projects / deliverable / binutils-gdb.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Jakub Jelinek <jj@ultra.linux.cz>
[deliverable/binutils-gdb.git] / bfd / elf32-sparc.c
diff --git a/bfd/elf32-sparc.c b/bfd/elf32-sparc.c
index 7cc0048aded0634cbd2db34b6077171603323f39..f02702c919e3ec6371b30d6f973569724501e774 100644 (file)
--- a/bfd/elf32-sparc.c
+++ b/bfd/elf32-sparc.c
@@ -1,5 +1,5 @@
 /* SPARC-specific support for 32-bit ELF
 /* SPARC-specific support for 32-bit ELF
-   Copyright (C) 1993, 1994, 1995, 1996 Free Software Foundation, Inc.
+   Copyright (C) 1993, 94, 95, 96, 97, 98, 1999 Free Software Foundation, Inc.
 
 This file is part of BFD, the Binary File Descriptor library.
 
 
 This file is part of BFD, the Binary File Descriptor library.
 
@@ -51,13 +51,7 @@ static boolean elf32_sparc_object_p
 static void elf32_sparc_final_write_processing
   PARAMS ((bfd *, boolean));
 \f
 static void elf32_sparc_final_write_processing
   PARAMS ((bfd *, boolean));
 \f
-/* The howto table and associated functions.
-   ??? elf64-sparc.c has its own copy for the moment to ease transition
-   since some of the relocation values have changed.  At some point we'll
-   want elf64-sparc.c to switch over and use this table.
-   ??? Do we want to recognize (or flag as errors) some of the 64 bit entries
-   if the target is elf32-sparc.
-*/
+/* The relocation "howto" table.  */
 
 static bfd_reloc_status_type sparc_elf_notsupported_reloc
   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
 
 static bfd_reloc_status_type sparc_elf_notsupported_reloc
   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
@@ -98,42 +92,44 @@ reloc_howto_type _bfd_sparc_elf_howto_table[] =
   HOWTO(R_SPARC_PCPLT10,   0,0,00,false,0,complain_overflow_dont,    sparc_elf_notsupported_reloc,  "R_SPARC_PCPLT10",  false,0,0x00000000,true),
   HOWTO(R_SPARC_10,        0,2,10,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_10",      false,0,0x000003ff,true),
   HOWTO(R_SPARC_11,        0,2,11,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_11",      false,0,0x000007ff,true),
   HOWTO(R_SPARC_PCPLT10,   0,0,00,false,0,complain_overflow_dont,    sparc_elf_notsupported_reloc,  "R_SPARC_PCPLT10",  false,0,0x00000000,true),
   HOWTO(R_SPARC_10,        0,2,10,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_10",      false,0,0x000003ff,true),
   HOWTO(R_SPARC_11,        0,2,11,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_11",      false,0,0x000007ff,true),
-  /* ??? If we need to handle R_SPARC_64 then we need (figuratively)
-     --enable-64-bit-bfd.  That causes objdump to print address as 64 bits
-     which we really don't want on an elf32-sparc system.  There may be other
-     consequences which we may not want (at least not until it's proven they're
-     necessary) so for now these are only enabled ifdef BFD64.  */
-#ifdef BFD64
-  HOWTO(R_SPARC_64,        0,4,00,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_64",      false,0,~ (bfd_vma) 0, true),
-  /* ??? These don't make sense except in 64 bit systems so they're disabled
-     ifndef BFD64 too (for now).  */
-  HOWTO(R_SPARC_OLO10,     0,2,10,false,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_OLO10",   false,0,0x000003ff,true),
-  HOWTO(R_SPARC_HH22,     42,2,22,false,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_HH22",    false,0,0x003fffff,true),
-  HOWTO(R_SPARC_HM10,     32,2,10,false,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_HM10",    false,0,0x000003ff,true),
-  HOWTO(R_SPARC_LM22,     10,2,22,false,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_LM22",    false,0,0x003fffff,true),
-  HOWTO(R_SPARC_PC_HH22,  42,2,22,true, 0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_HH22",    false,0,0x003fffff,true),
-  HOWTO(R_SPARC_PC_HM10,  32,2,10,true, 0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_HM10",    false,0,0x000003ff,true),
-  HOWTO(R_SPARC_PC_LM22,  10,2,22,true, 0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_LM22",    false,0,0x003fffff,true),
-#else
-  HOWTO(R_SPARC_64,      0,0,00,false,0,complain_overflow_dont,      sparc_elf_notsupported_reloc,  "R_SPARC_64",      false,0,0x00000000,true),
-  HOWTO(R_SPARC_OLO10,      0,0,00,false,0,complain_overflow_dont,   sparc_elf_notsupported_reloc,  "R_SPARC_OLO10",   false,0,0x00000000,true),
+  /* These are for sparc64 in a 64 bit environment.
+     Values need to be here because the table is indexed by reloc number.  */
+  HOWTO(R_SPARC_64,        0,0,00,false,0,complain_overflow_dont,    sparc_elf_notsupported_reloc,  "R_SPARC_64",      false,0,0x00000000,true),
+  HOWTO(R_SPARC_OLO10,     0,0,00,false,0,complain_overflow_dont,    sparc_elf_notsupported_reloc,  "R_SPARC_OLO10",   false,0,0x00000000,true),
   HOWTO(R_SPARC_HH22,      0,0,00,false,0,complain_overflow_dont,    sparc_elf_notsupported_reloc,  "R_SPARC_HH22",    false,0,0x00000000,true),
   HOWTO(R_SPARC_HM10,      0,0,00,false,0,complain_overflow_dont,    sparc_elf_notsupported_reloc,  "R_SPARC_HM10",    false,0,0x00000000,true),
   HOWTO(R_SPARC_LM22,      0,0,00,false,0,complain_overflow_dont,    sparc_elf_notsupported_reloc,  "R_SPARC_LM22",    false,0,0x00000000,true),
   HOWTO(R_SPARC_HH22,      0,0,00,false,0,complain_overflow_dont,    sparc_elf_notsupported_reloc,  "R_SPARC_HH22",    false,0,0x00000000,true),
   HOWTO(R_SPARC_HM10,      0,0,00,false,0,complain_overflow_dont,    sparc_elf_notsupported_reloc,  "R_SPARC_HM10",    false,0,0x00000000,true),
   HOWTO(R_SPARC_LM22,      0,0,00,false,0,complain_overflow_dont,    sparc_elf_notsupported_reloc,  "R_SPARC_LM22",    false,0,0x00000000,true),
-  HOWTO(R_SPARC_PC_HH22,      0,0,00,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc,  "R_SPARC_PC_HH22", false,0,0x00000000,true),
-  HOWTO(R_SPARC_PC_HM10,      0,0,00,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc,  "R_SPARC_PC_HM10", false,0,0x00000000,true),
-  HOWTO(R_SPARC_PC_LM22,      0,0,00,false,0,complain_overflow_dont, sparc_elf_notsupported_reloc,  "R_SPARC_PC_LM22", false,0,0x00000000,true),
-#endif
+  HOWTO(R_SPARC_PC_HH22,   0,0,00,false,0,complain_overflow_dont,    sparc_elf_notsupported_reloc,  "R_SPARC_PC_HH22", false,0,0x00000000,true),
+  HOWTO(R_SPARC_PC_HM10,   0,0,00,false,0,complain_overflow_dont,    sparc_elf_notsupported_reloc,  "R_SPARC_PC_HM10", false,0,0x00000000,true),
+  HOWTO(R_SPARC_PC_LM22,   0,0,00,false,0,complain_overflow_dont,    sparc_elf_notsupported_reloc,  "R_SPARC_PC_LM22", false,0,0x00000000,true),
+  /* End sparc64 in 64 bit environment values.
+     The following are for sparc64 in a 32 bit environment.  */
   HOWTO(R_SPARC_WDISP16,   2,2,16,true, 0,complain_overflow_signed,  sparc_elf_wdisp16_reloc,"R_SPARC_WDISP16", false,0,0x00000000,true),
   HOWTO(R_SPARC_WDISP16,   2,2,16,true, 0,complain_overflow_signed,  sparc_elf_wdisp16_reloc,"R_SPARC_WDISP16", false,0,0x00000000,true),
-  HOWTO(R_SPARC_WDISP19,   2,2,22,true, 0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_WDISP19", false,0,0x0007ffff,true),
-  HOWTO(R_SPARC_GLOB_JMP,  0,0,00,false,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_GLOB_JMP",false,0,0x00000000,true),
+  HOWTO(R_SPARC_WDISP19,   2,2,19,true, 0,complain_overflow_signed,  bfd_elf_generic_reloc,  "R_SPARC_WDISP19", false,0,0x0007ffff,true),
+  HOWTO(R_SPARC_UNUSED_42, 0,0, 0,false,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_UNUSED_42",false,0,0x00000000,true),
   HOWTO(R_SPARC_7,         0,2, 7,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_7",       false,0,0x0000007f,true),
   HOWTO(R_SPARC_5,         0,2, 5,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_5",       false,0,0x0000001f,true),
   HOWTO(R_SPARC_6,         0,2, 6,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_6",       false,0,0x0000003f,true),
   HOWTO(R_SPARC_7,         0,2, 7,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_7",       false,0,0x0000007f,true),
   HOWTO(R_SPARC_5,         0,2, 5,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_5",       false,0,0x0000001f,true),
   HOWTO(R_SPARC_6,         0,2, 6,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_6",       false,0,0x0000003f,true),
+  HOWTO(R_SPARC_NONE,      0,0, 0,false,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_NONE",    false,0,0x00000000,true),
+  HOWTO(R_SPARC_NONE,      0,0, 0,false,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_NONE",    false,0,0x00000000,true),
+  HOWTO(R_SPARC_NONE,      0,0, 0,false,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_NONE",    false,0,0x00000000,true),
+  HOWTO(R_SPARC_NONE,      0,0, 0,false,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_NONE",    false,0,0x00000000,true),
+  HOWTO(R_SPARC_NONE,      0,0, 0,false,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_NONE",    false,0,0x00000000,true),
+  HOWTO(R_SPARC_NONE,      0,0, 0,false,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_NONE",    false,0,0x00000000,true),
+  HOWTO(R_SPARC_NONE,      0,0, 0,false,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_NONE",    false,0,0x00000000,true),
+  HOWTO(R_SPARC_NONE,      0,0, 0,false,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_NONE",    false,0,0x00000000,true),
+  HOWTO(R_SPARC_NONE,      0,0, 0,false,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_NONE",    false,0,0x00000000,true),
+  HOWTO(R_SPARC_NONE,      0,0, 0,false,0,complain_overflow_dont,    bfd_elf_generic_reloc,  "R_SPARC_NONE",    false,0,0x00000000,true),
+  HOWTO(R_SPARC_REV32,      0,2,32,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc,  "R_SPARC_REV32",      false,0,0xffffffff,true),
 };
 };
+static reloc_howto_type elf32_sparc_vtinherit_howto =
+  HOWTO (R_SPARC_GNU_VTINHERIT, 0,2,0,false,0,complain_overflow_dont, NULL, "R_SPARC_GNU_VTINHERIT", false,0, 0, false);
+static reloc_howto_type elf32_sparc_vtentry_howto =
+  HOWTO (R_SPARC_GNU_VTENTRY, 0,2,0,false,0,complain_overflow_dont, _bfd_elf_rel_vtable_reloc_fn,"R_SPARC_GNU_VTENTRY", false,0,0, false);
+
 
 struct elf_reloc_map {
 
 struct elf_reloc_map {
-  unsigned char bfd_reloc_val;
+  bfd_reloc_code_real_type bfd_reloc_val;
   unsigned char elf_reloc_val;
 };
 
   unsigned char elf_reloc_val;
 };
 
@@ -143,9 +139,7 @@ static CONST struct elf_reloc_map sparc_reloc_map[] =
   { BFD_RELOC_16, R_SPARC_16, },
   { BFD_RELOC_8, R_SPARC_8 },
   { BFD_RELOC_8_PCREL, R_SPARC_DISP8 },
   { BFD_RELOC_16, R_SPARC_16, },
   { BFD_RELOC_8, R_SPARC_8 },
   { BFD_RELOC_8_PCREL, R_SPARC_DISP8 },
-  /* ??? This might cause us to need separate functions in elf{32,64}-sparc.c
-     (we could still have just one table), but is this reloc ever used?  */
-  { BFD_RELOC_CTOR, R_SPARC_32 }, /* @@ Assumes 32 bits.  */
+  { BFD_RELOC_CTOR, R_SPARC_32 },
   { BFD_RELOC_32, R_SPARC_32 },
   { BFD_RELOC_32_PCREL, R_SPARC_DISP32 },
   { BFD_RELOC_HI22, R_SPARC_HI22 },
   { BFD_RELOC_32, R_SPARC_32 },
   { BFD_RELOC_32_PCREL, R_SPARC_DISP32 },
   { BFD_RELOC_HI22, R_SPARC_HI22 },
@@ -178,10 +172,12 @@ static CONST struct elf_reloc_map sparc_reloc_map[] =
   {BFD_RELOC_SPARC_PC_LM22, R_SPARC_PC_LM22},
   {BFD_RELOC_SPARC_WDISP16, R_SPARC_WDISP16},
   {BFD_RELOC_SPARC_WDISP19, R_SPARC_WDISP19},
   {BFD_RELOC_SPARC_PC_LM22, R_SPARC_PC_LM22},
   {BFD_RELOC_SPARC_WDISP16, R_SPARC_WDISP16},
   {BFD_RELOC_SPARC_WDISP19, R_SPARC_WDISP19},
-  {BFD_RELOC_SPARC_GLOB_JMP, R_SPARC_GLOB_JMP},
   {BFD_RELOC_SPARC_7, R_SPARC_7},
   {BFD_RELOC_SPARC_5, R_SPARC_5},
   {BFD_RELOC_SPARC_6, R_SPARC_6},
   {BFD_RELOC_SPARC_7, R_SPARC_7},
   {BFD_RELOC_SPARC_5, R_SPARC_5},
   {BFD_RELOC_SPARC_6, R_SPARC_6},
+  {BFD_RELOC_SPARC_REV32, R_SPARC_REV32 },
+  {BFD_RELOC_VTABLE_INHERIT, R_SPARC_GNU_VTINHERIT},
+  {BFD_RELOC_VTABLE_ENTRY, R_SPARC_GNU_VTENTRY},
 };
 
 static reloc_howto_type *
 };
 
 static reloc_howto_type *
@@ -190,12 +186,24 @@ elf32_sparc_reloc_type_lookup (abfd, code)
      bfd_reloc_code_real_type code;
 {
   unsigned int i;
      bfd_reloc_code_real_type code;
 {
   unsigned int i;
-  for (i = 0; i < sizeof (sparc_reloc_map) / sizeof (struct elf_reloc_map); i++)
+  
+  switch (code)
     {
     {
-      if (sparc_reloc_map[i].bfd_reloc_val == code)
-       return &_bfd_sparc_elf_howto_table[(int) sparc_reloc_map[i].elf_reloc_val];
+    case BFD_RELOC_VTABLE_INHERIT:
+      return &elf32_sparc_vtinherit_howto;
+
+    case BFD_RELOC_VTABLE_ENTRY:
+      return &elf32_sparc_vtentry_howto;
+
+    default:
+      for (i = 0; i < sizeof (sparc_reloc_map) / sizeof (struct elf_reloc_map); i++)
+        {
+          if (sparc_reloc_map[i].bfd_reloc_val == code)
+           return &_bfd_sparc_elf_howto_table[(int) sparc_reloc_map[i].elf_reloc_val];
+        }
     }
     }
-  return 0;
+    bfd_set_error (bfd_error_bad_value);
+    return NULL;
 }
 
 /* We need to use ELF32_R_TYPE so we have our own copy of this function,
 }
 
 /* We need to use ELF32_R_TYPE so we have our own copy of this function,
@@ -207,8 +215,20 @@ elf32_sparc_info_to_howto (abfd, cache_ptr, dst)
      arelent *cache_ptr;
      Elf_Internal_Rela *dst;
 {
      arelent *cache_ptr;
      Elf_Internal_Rela *dst;
 {
-  BFD_ASSERT (ELF32_R_TYPE(dst->r_info) < (unsigned int) R_SPARC_max);
-  cache_ptr->howto = &_bfd_sparc_elf_howto_table[ELF32_R_TYPE(dst->r_info)];
+  switch (ELF32_R_TYPE(dst->r_info))
+    {
+    case R_SPARC_GNU_VTINHERIT:
+      cache_ptr->howto = &elf32_sparc_vtinherit_howto;
+      break;
+
+    case R_SPARC_GNU_VTENTRY:
+      cache_ptr->howto = &elf32_sparc_vtentry_howto;
+      break;
+
+    default:
+      BFD_ASSERT (ELF32_R_TYPE(dst->r_info) < (unsigned int) R_SPARC_max_std);
+      cache_ptr->howto = &_bfd_sparc_elf_howto_table[ELF32_R_TYPE(dst->r_info)];
+    }
 }
 \f
 /* For unsupported relocs.  */
 }
 \f
 /* For unsupported relocs.  */
@@ -276,10 +296,10 @@ sparc_elf_wdisp16_reloc (abfd,
                 + input_section->output_offset);
   relocation -= reloc_entry->address;
 
                 + input_section->output_offset);
   relocation -= reloc_entry->address;
 
-  x = bfd_get_32 (abfd, (char *) data + reloc_entry->address);
+  x = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
   x |= ((((relocation >> 2) & 0xc000) << 6)
        | ((relocation >> 2) & 0x3fff));
   x |= ((((relocation >> 2) & 0xc000) << 6)
        | ((relocation >> 2) & 0x3fff));
-  bfd_put_32 (abfd, x, (char *) data + reloc_entry->address);
+  bfd_put_32 (abfd, x, (bfd_byte *) data + reloc_entry->address);
 
   if ((bfd_signed_vma) relocation < - 0x40000
       || (bfd_signed_vma) relocation > 0x3ffff)
 
   if ((bfd_signed_vma) relocation < - 0x40000
       || (bfd_signed_vma) relocation > 0x3ffff)
@@ -403,12 +423,12 @@ elf32_sparc_check_relocs (abfd, info, sec, relocs)
 
          if (h != NULL)
            {
 
          if (h != NULL)
            {
-             if (h->got_offset != (bfd_vma) -1)
+             if (h->got.offset != (bfd_vma) -1)
                {
                  /* We have already allocated space in the .got.  */
                  break;
                }
                {
                  /* We have already allocated space in the .got.  */
                  break;
                }
-             h->got_offset = sgot->_raw_size;
+             h->got.offset = sgot->_raw_size;
 
              /* Make sure this symbol is output as a dynamic symbol.  */
              if (h->dynindx == -1)
 
              /* Make sure this symbol is output as a dynamic symbol.  */
              if (h->dynindx == -1)
@@ -472,10 +492,11 @@ elf32_sparc_check_relocs (abfd, info, sec, relocs)
 
          if (h == NULL)
            {
 
          if (h == NULL)
            {
-             /* It does not make sense to have a procedure linkage
-                 table entry for a local symbol.  */
-             bfd_set_error (bfd_error_bad_value);
-             return false;
+             /* The Solaris native assembler will generate a WPLT30
+                 reloc for a local symbol if you assemble a call from
+                 one section to another when using -K pic.  We treat
+                 it as WDISP30.  */
+             break;
            }
 
          /* Make sure this symbol is output as a dynamic symbol.  */
            }
 
          /* Make sure this symbol is output as a dynamic symbol.  */
@@ -502,7 +523,18 @@ elf32_sparc_check_relocs (abfd, info, sec, relocs)
        case R_SPARC_WDISP22:
        case R_SPARC_WDISP19:
        case R_SPARC_WDISP16:
        case R_SPARC_WDISP22:
        case R_SPARC_WDISP19:
        case R_SPARC_WDISP16:
-         if (h == NULL)
+         /* If we are linking with -Bsymbolic, we do not need to copy
+             a PC relative reloc against a global symbol which is
+             defined in an object we are including in the link (i.e.,
+             DEF_REGULAR is set).  FIXME: At this point we have not
+             seen all the input files, so it is possible that
+             DEF_REGULAR is not set now but will be set later (it is
+             never cleared).  This needs to be handled as in
+             elf32-i386.c.  */
+         if (h == NULL
+             || (info->symbolic
+                 && (h->elf_link_hash_flags
+                     & ELF_LINK_HASH_DEF_REGULAR) != 0))
            break;
          /* Fall through.  */
        case R_SPARC_8:
            break;
          /* Fall through.  */
        case R_SPARC_8:
@@ -555,6 +587,16 @@ elf32_sparc_check_relocs (abfd, info, sec, relocs)
 
          break;
 
 
          break;
 
+        case R_SPARC_GNU_VTINHERIT:
+          if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
+            return false;
+          break;
+
+        case R_SPARC_GNU_VTENTRY:
+          if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
+            return false;
+          break;
+
        default:
          break;
        }
        default:
          break;
        }
@@ -563,6 +605,111 @@ elf32_sparc_check_relocs (abfd, info, sec, relocs)
   return true;
 }
 
   return true;
 }
 
+static asection *
+elf32_sparc_gc_mark_hook (abfd, info, rel, h, sym)
+       bfd *abfd;
+       struct bfd_link_info *info;
+       Elf_Internal_Rela *rel;
+       struct elf_link_hash_entry *h;
+       Elf_Internal_Sym *sym;
+{
+
+  if (h != NULL)
+    {
+      switch (ELF32_R_TYPE (rel->r_info))
+      {
+      case R_SPARC_GNU_VTINHERIT:
+      case R_SPARC_GNU_VTENTRY:
+        break;
+
+      default:
+        switch (h->root.type)
+          {
+          case bfd_link_hash_defined:
+          case bfd_link_hash_defweak:
+            return h->root.u.def.section;
+
+          case bfd_link_hash_common:
+            return h->root.u.c.p->section;
+          }
+       }
+     }
+   else
+     {
+       if (!(elf_bad_symtab (abfd)
+           && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
+         && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
+                && sym->st_shndx != SHN_COMMON))
+          {
+            return bfd_section_from_elf_index (abfd, sym->st_shndx);
+          }
+      }
+
+  return NULL;
+}
+
+/* Update the got entry reference counts for the section being removed.  */
+static boolean
+elf32_sparc_gc_sweep_hook (abfd, info, sec, relocs)
+     bfd *abfd;
+     struct bfd_link_info *info;
+     asection *sec;
+     const Elf_Internal_Rela *relocs;
+{
+
+  Elf_Internal_Shdr *symtab_hdr;
+  struct elf_link_hash_entry **sym_hashes;
+  bfd_signed_vma *local_got_refcounts;
+  const Elf_Internal_Rela *rel, *relend;
+  unsigned long r_symndx;
+  struct elf_link_hash_entry *h;
+
+  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+  sym_hashes = elf_sym_hashes (abfd);
+  local_got_refcounts = elf_local_got_refcounts (abfd);
+
+  relend = relocs + sec->reloc_count;
+  for (rel = relocs; rel < relend; rel++)
+    switch (ELF32_R_TYPE (rel->r_info))
+      {
+      case R_SPARC_GOT10:
+      case R_SPARC_GOT13:
+      case R_SPARC_GOT22:
+       r_symndx = ELF32_R_SYM (rel->r_info);
+       if (r_symndx >= symtab_hdr->sh_info)
+         {
+           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
+           if (h->got.refcount > 0)
+             h->got.refcount--;
+         }
+       else
+         {
+           if (local_got_refcounts[r_symndx] > 0)
+             local_got_refcounts[r_symndx]--;
+         }
+        break;
+
+      case R_SPARC_PLT32:
+      case R_SPARC_HIPLT22:
+      case R_SPARC_LOPLT10:
+      case R_SPARC_PCPLT32:
+      case R_SPARC_PCPLT10:
+       r_symndx = ELF32_R_SYM (rel->r_info);
+       if (r_symndx >= symtab_hdr->sh_info)
+         {
+           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
+           if (h->plt.refcount > 0)
+             h->plt.refcount--;
+         }
+       break;
+
+      default:
+       break;
+      }
+
+  return true;
+}
+
 /* Adjust a symbol defined by a dynamic object and referenced by a
    regular object.  The current definition is in some section of the
    dynamic object, but we're not including those sections.  We have to
 /* Adjust a symbol defined by a dynamic object and referenced by a
    regular object.  The current definition is in some section of the
    dynamic object, but we're not including those sections.  We have to
@@ -593,18 +740,34 @@ elf32_sparc_adjust_dynamic_symbol (info, h)
 
   /* If this is a function, put it in the procedure linkage table.  We
      will fill in the contents of the procedure linkage table later
 
   /* If this is a function, put it in the procedure linkage table.  We
      will fill in the contents of the procedure linkage table later
-     (although we could actually do it here).  */
+     (although we could actually do it here).  The STT_NOTYPE
+     condition is a hack specifically for the Oracle libraries
+     delivered for Solaris; for some inexplicable reason, they define
+     some of their functions as STT_NOTYPE when they really should be
+     STT_FUNC.  */
   if (h->type == STT_FUNC
   if (h->type == STT_FUNC
-      || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
+      || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0
+      || (h->type == STT_NOTYPE
+         && (h->root.type == bfd_link_hash_defined
+             || h->root.type == bfd_link_hash_defweak)
+         && (h->root.u.def.section->flags & SEC_CODE) != 0))
     {
     {
-      if (! elf_hash_table (info)->dynamic_sections_created)
+      if (! elf_hash_table (info)->dynamic_sections_created
+         || ((!info->shared || info->symbolic || h->dynindx == -1)
+             && (h->elf_link_hash_flags
+                 & ELF_LINK_HASH_DEF_REGULAR) != 0))
        {
          /* This case can occur if we saw a WPLT30 reloc in an input
        {
          /* This case can occur if we saw a WPLT30 reloc in an input
-             file, but none of the input files were dynamic objects.
-             In such a case, we don't actually need to build a
-             procedure linkage table, and we can just do a WDISP30
-             reloc instead.  */
-         BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
+            file, but none of the input files were dynamic objects.
+            Or, when linking the main application or a -Bsymbolic
+            shared library against PIC code.  Or when a global symbol
+            has been made private, e.g. via versioning.
+
+            In these cases we know what value the symbol will resolve
+            to, so we don't actually need to build a procedure linkage
+            table, and we can just do a WDISP30 reloc instead.  */
+
+         h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
          return true;
        }
 
          return true;
        }
 
@@ -622,19 +785,19 @@ elf32_sparc_adjust_dynamic_symbol (info, h)
          return false;
        }
 
          return false;
        }
 
-      /* If this symbol is not defined in a regular file, and we are
-        not generating a shared library, then set the symbol to this
-        location in the .plt.  This is required to make function
-        pointers compare as equal between the normal executable and
-        the shared library.  */
-      if (! info->shared
-         && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
-       {
-         h->root.u.def.section = s;
-         h->root.u.def.value = s->_raw_size;
-       }
+     /* If this symbol is not defined in a regular file, and we are
+       not generating a shared library, then set the symbol to this
+       location in the .plt.  This is required to make function
+       pointers compare as equal between the normal executable and
+       the shared library.  */
+     if (! info->shared
+       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
+      {
+       h->root.u.def.section = s;
+       h->root.u.def.value = s->_raw_size;
+      }
 
 
-      h->plt_offset = s->_raw_size;
+      h->plt.offset = s->_raw_size;
 
       /* Make room for this entry.  */
       s->_raw_size += PLT_ENTRY_SIZE;
 
       /* Make room for this entry.  */
       s->_raw_size += PLT_ENTRY_SIZE;
@@ -683,14 +846,11 @@ elf32_sparc_adjust_dynamic_symbol (info, h)
   s = bfd_get_section_by_name (dynobj, ".dynbss");
   BFD_ASSERT (s != NULL);
 
   s = bfd_get_section_by_name (dynobj, ".dynbss");
   BFD_ASSERT (s != NULL);
 
-  /* If the symbol is currently defined in the .bss section of the
-     dynamic object, then it is OK to simply initialize it to zero.
-     If the symbol is in some other section, we must generate a
-     R_SPARC_COPY reloc to tell the dynamic linker to copy the initial
-     value out of the dynamic object and into the runtime process
-     image.  We need to remember the offset into the .rel.bss section
-     we are going to use.  */
-  if ((h->root.u.def.section->flags & SEC_LOAD) != 0)
+  /* We must generate a R_SPARC_COPY reloc to tell the dynamic linker
+     to copy the initial value out of the dynamic object and into the
+     runtime process image.  We need to remember the offset into the
+     .rel.bss section we are going to use.  */
+  if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
     {
       asection *srel;
 
     {
       asection *srel;
 
@@ -805,13 +965,17 @@ elf32_sparc_size_dynamic_sections (output_bfd, info)
            }
          else
            {
            }
          else
            {
+             const char *outname;
              asection *target;
 
              /* If this relocation section applies to a read only
                 section, then we probably need a DT_TEXTREL entry.  */
              asection *target;
 
              /* If this relocation section applies to a read only
                 section, then we probably need a DT_TEXTREL entry.  */
-             target = bfd_get_section_by_name (output_bfd, name + 5);
+             outname = bfd_get_section_name (output_bfd,
+                                             s->output_section);
+             target = bfd_get_section_by_name (output_bfd, outname + 5);
              if (target != NULL
              if (target != NULL
-                 && (target->flags & SEC_READONLY) != 0)
+                 && (target->flags & SEC_READONLY) != 0
+                 && (target->flags & SEC_ALLOC) != 0)
                reltext = true;
 
              if (strcmp (name, ".rela.plt") == 0)
                reltext = true;
 
              if (strcmp (name, ".rela.plt") == 0)
@@ -831,15 +995,7 @@ elf32_sparc_size_dynamic_sections (output_bfd, info)
 
       if (strip)
        {
 
       if (strip)
        {
-         asection **spp;
-
-         for (spp = &s->output_section->owner->sections;
-              *spp != s->output_section;
-              spp = &(*spp)->next)
-           ;
-         *spp = s->output_section->next;
-         --s->output_section->owner->section_count;
-
+         _bfd_strip_section_from_output (s);
          continue;
        }
 
          continue;
        }
 
@@ -862,12 +1018,10 @@ elf32_sparc_size_dynamic_sections (output_bfd, info)
            return false;
        }
 
            return false;
        }
 
-      if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0))
-       return false;
-
       if (relplt)
        {
       if (relplt)
        {
-         if (! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
+         if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0)
+             || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
              || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
              || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
            return false;
              || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
              || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
            return false;
@@ -887,26 +1041,33 @@ elf32_sparc_size_dynamic_sections (output_bfd, info)
     }
 
   /* If we are generating a shared library, we generate a section
     }
 
   /* If we are generating a shared library, we generate a section
-     symbol for each output section.  These are local symbols, which
-     means that they must come first in the dynamic symbol table.
-     That means we must increment the dynamic symbol index of every
-     other dynamic symbol.  */
+     symbol for each output section for which we might need to copy
+     relocs.  These are local symbols, which means that they must come
+     first in the dynamic symbol table.  That means we must increment
+     the dynamic symbol index of every other dynamic symbol.  */
   if (info->shared)
     {
   if (info->shared)
     {
-      int c, i;
+      int c;
 
 
-      c = bfd_count_sections (output_bfd);
-      elf_link_hash_traverse (elf_hash_table (info),
-                             elf32_sparc_adjust_dynindx,
-                             (PTR) &c);
-      elf_hash_table (info)->dynsymcount += c;
-
-      for (i = 1, s = output_bfd->sections; s != NULL; s = s->next, i++)
+      c = 0;
+      for (s = output_bfd->sections; s != NULL; s = s->next)
        {
        {
-         elf_section_data (s)->dynindx = i;
+         if ((s->flags & SEC_LINKER_CREATED) != 0
+             || (s->flags & SEC_ALLOC) == 0)
+           continue;
+
+         elf_section_data (s)->dynindx = c + 1;
+
          /* These symbols will have no names, so we don't need to
              fiddle with dynstr_index.  */
          /* These symbols will have no names, so we don't need to
              fiddle with dynstr_index.  */
+
+         ++c;
        }
        }
+
+      elf_link_hash_traverse (elf_hash_table (info),
+                             elf32_sparc_adjust_dynindx,
+                             (PTR) &c);
+      elf_hash_table (info)->dynsymcount += c;
     }
 
   return true;
     }
 
   return true;
@@ -980,7 +1141,12 @@ elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section,
       bfd_reloc_status_type r;
 
       r_type = ELF32_R_TYPE (rel->r_info);
       bfd_reloc_status_type r;
 
       r_type = ELF32_R_TYPE (rel->r_info);
-      if (r_type < 0 || r_type >= (int) R_SPARC_max)
+
+      if (r_type == R_SPARC_GNU_VTINHERIT 
+          || r_type == R_SPARC_GNU_VTENTRY)
+        continue;
+
+      if (r_type < 0 || r_type >= (int) R_SPARC_max_std)
        {
          bfd_set_error (bfd_error_bad_value);
          return false;
        {
          bfd_set_error (bfd_error_bad_value);
          return false;
@@ -1031,17 +1197,17 @@ elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section,
            {
              sec = h->root.u.def.section;
              if ((r_type == R_SPARC_WPLT30
            {
              sec = h->root.u.def.section;
              if ((r_type == R_SPARC_WPLT30
-                  && h->plt_offset != (bfd_vma) -1)
+                  && h->plt.offset != (bfd_vma) -1)
                  || ((r_type == R_SPARC_GOT10
                       || r_type == R_SPARC_GOT13
                       || r_type == R_SPARC_GOT22)
                      && elf_hash_table (info)->dynamic_sections_created
                      && (! info->shared
                  || ((r_type == R_SPARC_GOT10
                       || r_type == R_SPARC_GOT13
                       || r_type == R_SPARC_GOT22)
                      && elf_hash_table (info)->dynamic_sections_created
                      && (! info->shared
-                         || ! info->symbolic
+                         || (! info->symbolic && h->dynindx != -1)
                          || (h->elf_link_hash_flags
                              & ELF_LINK_HASH_DEF_REGULAR) == 0))
                  || (info->shared
                          || (h->elf_link_hash_flags
                              & ELF_LINK_HASH_DEF_REGULAR) == 0))
                  || (info->shared
-                     && (! info->symbolic
+                     && ((! info->symbolic && h->dynindx != -1)
                          || (h->elf_link_hash_flags
                              & ELF_LINK_HASH_DEF_REGULAR) == 0)
                      && (r_type == R_SPARC_8
                          || (h->elf_link_hash_flags
                              & ELF_LINK_HASH_DEF_REGULAR) == 0)
                      && (r_type == R_SPARC_8
@@ -1076,7 +1242,7 @@ elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section,
            }
          else if (h->root.type == bfd_link_hash_undefweak)
            relocation = 0;
            }
          else if (h->root.type == bfd_link_hash_undefweak)
            relocation = 0;
-         else if (info->shared && !info->symbolic)
+         else if (info->shared && !info->symbolic && !info->no_undefined)
            relocation = 0;
          else
            {
            relocation = 0;
          else
            {
@@ -1105,20 +1271,21 @@ elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section,
            {
              bfd_vma off;
 
            {
              bfd_vma off;
 
-             off = h->got_offset;
+             off = h->got.offset;
              BFD_ASSERT (off != (bfd_vma) -1);
 
              if (! elf_hash_table (info)->dynamic_sections_created
                  || (info->shared
              BFD_ASSERT (off != (bfd_vma) -1);
 
              if (! elf_hash_table (info)->dynamic_sections_created
                  || (info->shared
-                     && info->symbolic
+                     && (info->symbolic || h->dynindx == -1)
                      && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
                {
                  /* This is actually a static link, or it is a
                      -Bsymbolic link and the symbol is defined
                      && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
                {
                  /* This is actually a static link, or it is a
                      -Bsymbolic link and the symbol is defined
-                     locally.  We must initialize this entry in the
-                     global offset table.  Since the offset must
-                     always be a multiple of 4, we use the least
-                     significant bit to record whether we have
+                     locally, or the symbol was forced to be local
+                     because of a version file.  We must initialize
+                     this entry in the global offset table.  Since the
+                     offset must always be a multiple of 4, we use the
+                     least significant bit to record whether we have
                      initialized it already.
 
                     When doing a dynamic link, we create a .rela.got
                      initialized it already.
 
                     When doing a dynamic link, we create a .rela.got
@@ -1130,7 +1297,7 @@ elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section,
                    {
                      bfd_put_32 (output_bfd, relocation,
                                  sgot->contents + off);
                    {
                      bfd_put_32 (output_bfd, relocation,
                                  sgot->contents + off);
-                     h->got_offset |= 1;
+                     h->got.offset |= 1;
                    }
                }
 
                    }
                }
 
@@ -1187,9 +1354,15 @@ elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section,
        case R_SPARC_WPLT30:
          /* Relocation is to the entry for this symbol in the
              procedure linkage table.  */
        case R_SPARC_WPLT30:
          /* Relocation is to the entry for this symbol in the
              procedure linkage table.  */
-         BFD_ASSERT (h != NULL);
 
 
-         if (h->plt_offset == (bfd_vma) -1)
+         /* The Solaris native assembler will generate a WPLT30 reloc
+            for a local symbol if you assemble a call from one
+            section to another when using -K pic.  We treat it as
+            WDISP30.  */
+         if (h == NULL)
+           break;
+
+         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
            {
              /* We didn't make a PLT entry for this symbol.  This
                  happens when statically linking PIC code, or when
@@ -1205,7 +1378,7 @@ elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section,
 
          relocation = (splt->output_section->vma
                        + splt->output_offset
 
          relocation = (splt->output_section->vma
                        + splt->output_offset
-                       + h->plt_offset);
+                       + h->plt.offset);
          break;
 
        case R_SPARC_PC10:
          break;
 
        case R_SPARC_PC10:
@@ -1221,7 +1394,10 @@ elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section,
        case R_SPARC_WDISP22:
        case R_SPARC_WDISP19:
        case R_SPARC_WDISP16:
        case R_SPARC_WDISP22:
        case R_SPARC_WDISP19:
        case R_SPARC_WDISP16:
-         if (h == NULL)
+         if (h == NULL
+             || (info->symbolic
+                 && (h->elf_link_hash_flags
+                     & ELF_LINK_HASH_DEF_REGULAR) != 0))
            break;
          /* Fall through.  */
        case R_SPARC_8:
            break;
          /* Fall through.  */
        case R_SPARC_8:
@@ -1235,6 +1411,7 @@ elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section,
          if (info->shared)
            {
              Elf_Internal_Rela outrel;
          if (info->shared)
            {
              Elf_Internal_Rela outrel;
+             boolean skip;
 
              /* When generating a shared object, these relocations
                  are copied into the output file to be resolved at run
 
              /* When generating a shared object, these relocations
                  are copied into the output file to be resolved at run
@@ -1260,13 +1437,35 @@ elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section,
                  BFD_ASSERT (sreloc != NULL);
                }
 
                  BFD_ASSERT (sreloc != NULL);
                }
 
-             outrel.r_offset = (rel->r_offset
-                                + input_section->output_section->vma
-                                + input_section->output_offset);
-             if (h != NULL
-                 && (! info->symbolic
-                     || (h->elf_link_hash_flags
-                         & ELF_LINK_HASH_DEF_REGULAR) == 0))
+             skip = false;
+
+             if (elf_section_data (input_section)->stab_info == NULL)
+               outrel.r_offset = rel->r_offset;
+             else
+               {
+                 bfd_vma off;
+
+                 off = (_bfd_stab_section_offset
+                        (output_bfd, &elf_hash_table (info)->stab_info,
+                         input_section,
+                         &elf_section_data (input_section)->stab_info,
+                         rel->r_offset));
+                 if (off == (bfd_vma) -1)
+                   skip = true;
+                 outrel.r_offset = off;
+               }
+
+             outrel.r_offset += (input_section->output_section->vma
+                                 + input_section->output_offset);
+
+             if (skip)
+               memset (&outrel, 0, sizeof outrel);
+             /* h->dynindx may be -1 if the symbol was marked to
+                 become local.  */
+             else if (h != NULL
+                      && ((! info->symbolic && h->dynindx != -1)
+                          || (h->elf_link_hash_flags
+                              & ELF_LINK_HASH_DEF_REGULAR) == 0))
                {
                  BFD_ASSERT (h->dynindx != -1);
                  outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
                {
                  BFD_ASSERT (h->dynindx != -1);
                  outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
@@ -1305,12 +1504,30 @@ elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section,
 
                          osec = sec->output_section;
                          indx = elf_section_data (osec)->dynindx;
 
                          osec = sec->output_section;
                          indx = elf_section_data (osec)->dynindx;
+
+                         /* FIXME: we really should be able to link non-pic
+                            shared libraries.  */
                          if (indx == 0)
                          if (indx == 0)
-                           abort ();
+                           {
+                             BFD_FAIL ();
+                             (*_bfd_error_handler)
+                               (_("%s: probably compiled without -fPIC?"),
+                                bfd_get_filename (input_bfd));
+                             bfd_set_error (bfd_error_bad_value);
+                             return false;
+                           }
                        }
 
                      outrel.r_info = ELF32_R_INFO (indx, r_type);
                        }
 
                      outrel.r_info = ELF32_R_INFO (indx, r_type);
-                     outrel.r_addend = relocation + rel->r_addend;
+
+                     /* For non-RELATIVE dynamic relocations, we keep the
+                        same symbol, and so generally the same addend.  But
+                        we do need to adjust those relocations referencing
+                        sections.  */
+                     outrel.r_addend = rel->r_addend;
+                     if (r_symndx < symtab_hdr->sh_info
+                         && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
+                       outrel.r_addend += sec->output_offset+sym->st_value;
                    }
                }
 
                    }
                }
 
@@ -1321,19 +1538,20 @@ elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section,
              ++sreloc->reloc_count;
 
              /* This reloc will be computed at runtime, so there's no
              ++sreloc->reloc_count;
 
              /* This reloc will be computed at runtime, so there's no
-                 need to do anything now.  */
-             continue;
+                 need to do anything now, unless this is a RELATIVE
+                 reloc in an unallocated section.  */
+             if (skip
+                 || (input_section->flags & SEC_ALLOC) != 0
+                 || ELF32_R_TYPE (outrel.r_info) != R_SPARC_RELATIVE)
+               continue;
            }
            }
+         break;
 
        default:
          break;
        }
 
 
        default:
          break;
        }
 
-      if (r_type != R_SPARC_WDISP16)
-       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
-                                     contents, rel->r_offset,
-                                     relocation, rel->r_addend);
-      else
+      if (r_type == R_SPARC_WDISP16)
        {
          bfd_vma x;
 
        {
          bfd_vma x;
 
@@ -1353,6 +1571,22 @@ elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section,
          else
            r = bfd_reloc_ok;
        }
          else
            r = bfd_reloc_ok;
        }
+      else if (r_type == R_SPARC_REV32)
+       {
+         bfd_vma x;
+
+         relocation = relocation + rel->r_addend;
+
+         x = bfd_get_32 (input_bfd, contents + rel->r_offset);
+         x = x + relocation;
+         bfd_putl32 (/*input_bfd,*/ x, contents + rel->r_offset);
+         r = bfd_reloc_ok;
+       }
+      else
+       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
+                                     contents, rel->r_offset,
+                                     relocation, rel->r_addend);
+
 
       if (r != bfd_reloc_ok)
        {
 
       if (r != bfd_reloc_ok)
        {
@@ -1404,7 +1638,7 @@ elf32_sparc_finish_dynamic_symbol (output_bfd, info, h, sym)
 
   dynobj = elf_hash_table (info)->dynobj;
 
 
   dynobj = elf_hash_table (info)->dynobj;
 
-  if (h->plt_offset != (bfd_vma) -1)
+  if (h->plt.offset != (bfd_vma) -1)
     {
       asection *splt;
       asection *srela;
     {
       asection *splt;
       asection *srela;
@@ -1421,24 +1655,24 @@ elf32_sparc_finish_dynamic_symbol (output_bfd, info, h, sym)
 
       /* Fill in the entry in the procedure linkage table.  */
       bfd_put_32 (output_bfd,
 
       /* Fill in the entry in the procedure linkage table.  */
       bfd_put_32 (output_bfd,
-                 PLT_ENTRY_WORD0 + h->plt_offset,
-                 splt->contents + h->plt_offset);
+                 PLT_ENTRY_WORD0 + h->plt.offset,
+                 splt->contents + h->plt.offset);
       bfd_put_32 (output_bfd,
                  (PLT_ENTRY_WORD1
       bfd_put_32 (output_bfd,
                  (PLT_ENTRY_WORD1
-                  + (((- (h->plt_offset + 4)) >> 2) & 0x3fffff)),
-                 splt->contents + h->plt_offset + 4);
+                  + (((- (h->plt.offset + 4)) >> 2) & 0x3fffff)),
+                 splt->contents + h->plt.offset + 4);
       bfd_put_32 (output_bfd, PLT_ENTRY_WORD2,
       bfd_put_32 (output_bfd, PLT_ENTRY_WORD2,
-                 splt->contents + h->plt_offset + 8);
+                 splt->contents + h->plt.offset + 8);
 
       /* Fill in the entry in the .rela.plt section.  */
       rela.r_offset = (splt->output_section->vma
                       + splt->output_offset
 
       /* Fill in the entry in the .rela.plt section.  */
       rela.r_offset = (splt->output_section->vma
                       + splt->output_offset
-                      + h->plt_offset);
+                      + h->plt.offset);
       rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_JMP_SLOT);
       rela.r_addend = 0;
       bfd_elf32_swap_reloca_out (output_bfd, &rela,
                                 ((Elf32_External_Rela *) srela->contents
       rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_JMP_SLOT);
       rela.r_addend = 0;
       bfd_elf32_swap_reloca_out (output_bfd, &rela,
                                 ((Elf32_External_Rela *) srela->contents
-                                 + h->plt_offset / PLT_ENTRY_SIZE - 4));
+                                 + h->plt.offset / PLT_ENTRY_SIZE - 4));
 
       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
        {
 
       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
        {
@@ -1448,7 +1682,7 @@ elf32_sparc_finish_dynamic_symbol (output_bfd, info, h, sym)
        }
     }
 
        }
     }
 
-  if (h->got_offset != (bfd_vma) -1)
+  if (h->got.offset != (bfd_vma) -1)
     {
       asection *sgot;
       asection *srela;
     {
       asection *sgot;
       asection *srela;
@@ -1457,27 +1691,26 @@ elf32_sparc_finish_dynamic_symbol (output_bfd, info, h, sym)
       /* This symbol has an entry in the global offset table.  Set it
          up.  */
 
       /* This symbol has an entry in the global offset table.  Set it
          up.  */
 
-      BFD_ASSERT (h->dynindx != -1);
-
       sgot = bfd_get_section_by_name (dynobj, ".got");
       srela = bfd_get_section_by_name (dynobj, ".rela.got");
       BFD_ASSERT (sgot != NULL && srela != NULL);
 
       rela.r_offset = (sgot->output_section->vma
                       + sgot->output_offset
       sgot = bfd_get_section_by_name (dynobj, ".got");
       srela = bfd_get_section_by_name (dynobj, ".rela.got");
       BFD_ASSERT (sgot != NULL && srela != NULL);
 
       rela.r_offset = (sgot->output_section->vma
                       + sgot->output_offset
-                      + (h->got_offset &~ 1));
+                      + (h->got.offset &~ 1));
 
       /* If this is a -Bsymbolic link, and the symbol is defined
 
       /* If this is a -Bsymbolic link, and the symbol is defined
-        locally, we just want to emit a RELATIVE reloc.  The entry in
-        the global offset table will already have been initialized in
-        the relocate_section function.  */
+        locally, we just want to emit a RELATIVE reloc.  Likewise if
+        the symbol was forced to be local because of a version file.
+        The entry in the global offset table will already have been
+        initialized in the relocate_section function.  */
       if (info->shared
       if (info->shared
-         && info->symbolic
+         && (info->symbolic || h->dynindx == -1)
          && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
        rela.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
       else
        {
          && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
        rela.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
       else
        {
-         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got_offset);
+         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
          rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_GLOB_DAT);
        }
 
          rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_GLOB_DAT);
        }
 
@@ -1619,6 +1852,7 @@ elf32_sparc_finish_dynamic_sections (output_bfd, info)
       asection *sdynsym;
       asection *s;
       Elf_Internal_Sym sym;
       asection *sdynsym;
       asection *s;
       Elf_Internal_Sym sym;
+      int c;
 
       /* Set up the section symbols for the output sections.  */
 
 
       /* Set up the section symbols for the output sections.  */
 
@@ -1630,10 +1864,14 @@ elf32_sparc_finish_dynamic_sections (output_bfd, info)
       sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
       sym.st_other = 0;
 
       sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
       sym.st_other = 0;
 
+      c = 0;
       for (s = output_bfd->sections; s != NULL; s = s->next)
        {
          int indx;
 
       for (s = output_bfd->sections; s != NULL; s = s->next)
        {
          int indx;
 
+         if (elf_section_data (s)->dynindx == 0)
+           continue;
+
          sym.st_value = s->vma;
 
          indx = elf_section_data (s)->this_idx;
          sym.st_value = s->vma;
 
          indx = elf_section_data (s)->this_idx;
@@ -1644,12 +1882,13 @@ elf32_sparc_finish_dynamic_sections (output_bfd, info)
                                     (PTR) (((Elf32_External_Sym *)
                                             sdynsym->contents)
                                            + elf_section_data (s)->dynindx));
                                     (PTR) (((Elf32_External_Sym *)
                                             sdynsym->contents)
                                            + elf_section_data (s)->dynindx));
+
+         ++c;
        }
 
       /* Set the sh_info field of the output .dynsym section to the
          index of the first global symbol.  */
        }
 
       /* Set the sh_info field of the output .dynsym section to the
          index of the first global symbol.  */
-      elf_section_data (sdynsym->output_section)->this_hdr.sh_info =
-       bfd_count_sections (output_bfd) + 1;
+      elf_section_data (sdynsym->output_section)->this_hdr.sh_info = c + 1;
     }
 
   return true;
     }
 
   return true;
@@ -1671,6 +1910,7 @@ elf32_sparc_merge_private_bfd_data (ibfd, obfd)
      bfd *obfd;
 {
   boolean error;
      bfd *obfd;
 {
   boolean error;
+  static int previous_ibfd_e_flags = -1;
 
   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
 
   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
@@ -1692,7 +1932,7 @@ elf32_sparc_merge_private_bfd_data (ibfd, obfd)
     {
       error = true;
       (*_bfd_error_handler)
     {
       error = true;
       (*_bfd_error_handler)
-       ("%s: compiled for a v8plus system and target is v8",
+       (_("%s: compiled for a v8plus system and target is v8"),
         bfd_get_filename (ibfd));
     }
   /* If the output machine is v9, we can't allow v9+vis input files.  */
         bfd_get_filename (ibfd));
     }
   /* If the output machine is v9, we can't allow v9+vis input files.  */
@@ -1701,7 +1941,7 @@ elf32_sparc_merge_private_bfd_data (ibfd, obfd)
     {
       error = true;
       (*_bfd_error_handler)
     {
       error = true;
       (*_bfd_error_handler)
-       ("%s: compiled for a v8plusa system and target is v8plus",
+       (_("%s: compiled for a v8plusa system and target is v8plus"),
         bfd_get_filename (ibfd));
     }
 #else
         bfd_get_filename (ibfd));
     }
 #else
@@ -1709,13 +1949,24 @@ elf32_sparc_merge_private_bfd_data (ibfd, obfd)
     {
       error = true;
       (*_bfd_error_handler)
     {
       error = true;
       (*_bfd_error_handler)
-       ("%s: compiled for a 64 bit system and target is 32 bit",
+       (_("%s: compiled for a 64 bit system and target is 32 bit"),
         bfd_get_filename (ibfd));
     }
   else if (bfd_get_mach (obfd) < bfd_get_mach (ibfd))
     bfd_set_arch_mach (obfd, bfd_arch_sparc, bfd_get_mach (ibfd));
 #endif
 
         bfd_get_filename (ibfd));
     }
   else if (bfd_get_mach (obfd) < bfd_get_mach (ibfd))
     bfd_set_arch_mach (obfd, bfd_arch_sparc, bfd_get_mach (ibfd));
 #endif
 
+  if (((elf_elfheader (ibfd)->e_flags & EF_SPARC_LEDATA)
+       != previous_ibfd_e_flags)
+      && previous_ibfd_e_flags >= 0)
+    {
+      (*_bfd_error_handler)
+       (_("%s: linking little endian files with big endian files"),
+        bfd_get_filename (ibfd));
+      error = true;
+    }
+  previous_ibfd_e_flags = elf_elfheader (ibfd)->e_flags & EF_SPARC_LEDATA;
+
   if (error)
     {
       bfd_set_error (bfd_error_bad_value);
   if (error)
     {
       bfd_set_error (bfd_error_bad_value);
@@ -1742,6 +1993,9 @@ elf32_sparc_object_p (abfd)
       else
        return false;
     }
       else
        return false;
     }
+  else if (elf_elfheader (abfd)->e_flags & EF_SPARC_LEDATA)
+    return bfd_default_set_arch_mach (abfd, bfd_arch_sparc,
+                                      bfd_mach_sparc_sparclite_le);
   else
     return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc);
 }
   else
     return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, bfd_mach_sparc);
 }
@@ -1768,8 +2022,13 @@ elf32_sparc_final_write_processing (abfd, linker)
       elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK;
       elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS | EF_SPARC_SUN_US1;
       break;
       elf_elfheader (abfd)->e_flags &=~ EF_SPARC_32PLUS_MASK;
       elf_elfheader (abfd)->e_flags |= EF_SPARC_32PLUS | EF_SPARC_SUN_US1;
       break;
+    case bfd_mach_sparc_sparclite_le :
+      elf_elfheader (abfd)->e_machine = EM_SPARC;
+      elf_elfheader (abfd)->e_flags |= EF_SPARC_LEDATA;
+      break;
     default :
       abort ();
     default :
       abort ();
+      break;
     }
 }
 \f
     }
 }
 \f
@@ -1799,8 +2058,14 @@ elf32_sparc_final_write_processing (abfd, linker)
 #define elf_backend_object_p           elf32_sparc_object_p
 #define elf_backend_final_write_processing \
                                        elf32_sparc_final_write_processing
 #define elf_backend_object_p           elf32_sparc_object_p
 #define elf_backend_final_write_processing \
                                        elf32_sparc_final_write_processing
+#define elf_backend_gc_mark_hook        elf32_sparc_gc_mark_hook
+#define elf_backend_gc_sweep_hook       elf32_sparc_gc_sweep_hook
+
+#define elf_backend_can_gc_sections 1
 #define elf_backend_want_got_plt 0
 #define elf_backend_plt_readonly 0
 #define elf_backend_want_plt_sym 1
 #define elf_backend_want_got_plt 0
 #define elf_backend_plt_readonly 0
 #define elf_backend_want_plt_sym 1
+#define elf_backend_got_header_size 4
+#define elf_backend_plt_header_size (4*PLT_ENTRY_SIZE)
 
 #include "elf32-target.h"
 
 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.036866 seconds and 4 git commands to generate.