Decouple inferior_ptid/inferior_thread(); dup ptids in thread list (PR 25412)

[deliverable/binutils-gdb.git] / bfd / elf32-hppa.c

diff --git a/bfd/elf32-hppa.c b/bfd/elf32-hppa.c
index f9629e4b119d370f13b2d5e21bbea1663f127d30..d131f1a0794a26a752d3aee72a8fb2719911e2b2 100644 (file)
--- a/bfd/elf32-hppa.c
+++ b/bfd/elf32-hppa.c
@@ -1,5 +1,5 @@
 /* BFD back-end for HP PA-RISC ELF files.
 /* BFD back-end for HP PA-RISC ELF files.

-   Copyright (C) 1990-2017 Free Software Foundation, Inc.
+   Copyright (C) 1990-2020 Free Software Foundation, Inc.

 
    Original code by
        Center for Software Science
 
    Original code by
        Center for Software Science


@@ -71,34 +71,38 @@
 
    Import stub to call shared library routine from normal object file
    (single sub-space version)
 
    Import stub to call shared library routine from normal object file
    (single sub-space version)

-   :           addil LR'lt_ptr+ltoff,%dp       ; get procedure entry point
-   :           ldw RR'lt_ptr+ltoff(%r1),%r21
+   :           addil LR'lt_ptr+ltoff,%dp       ; get PLT address
+   :           ldo RR'lt_ptr+ltoff(%r1),%r22   ; 
+   :           ldw 0(%r22),%r21                ; get procedure entry point

    :           bv %r0(%r21)
    :           bv %r0(%r21)

-   :           ldw RR'lt_ptr+ltoff+4(%r1),%r19 ; get new dlt value.
+   :           ldw 4(%r22),%r19                ; get new dlt value.

 
    Import stub to call shared library routine from shared library
    (single sub-space version)
 
    Import stub to call shared library routine from shared library
    (single sub-space version)

-   :           addil LR'ltoff,%r19             ; get procedure entry point
-   :           ldw RR'ltoff(%r1),%r21
+   :           addil LR'ltoff,%r19             ; get PLT address
+   :           ldo RR'ltoff(%r1),%r22
+   :           ldw 0(%r22),%r21                ; get procedure entry point

    :           bv %r0(%r21)
    :           bv %r0(%r21)

-   :           ldw RR'ltoff+4(%r1),%r19        ; get new dlt value.
+   :           ldw 4(%r22),%r19                ; get new dlt value.

 
    Import stub to call shared library routine from normal object file
    (multiple sub-space support)
 
    Import stub to call shared library routine from normal object file
    (multiple sub-space support)

-   :           addil LR'lt_ptr+ltoff,%dp       ; get procedure entry point
-   :           ldw RR'lt_ptr+ltoff(%r1),%r21
-   :           ldw RR'lt_ptr+ltoff+4(%r1),%r19 ; get new dlt value.
-   :           ldsid (%r21),%r1
+   :           addil LR'lt_ptr+ltoff,%dp       ; get PLT address
+   :           ldo RR'lt_ptr+ltoff(%r1),%r22   ; 
+   :           ldw 0(%r22),%r21                ; get procedure entry point
+   :           ldsid (%r21),%r1                ; get target sid
+   :           ldw 4(%r22),%r19                ; get new dlt value.

    :           mtsp %r1,%sr0
    :           be 0(%sr0,%r21)                 ; branch to target
    :           stw %rp,-24(%sp)                ; save rp
 
    Import stub to call shared library routine from shared library
    (multiple sub-space support)
    :           mtsp %r1,%sr0
    :           be 0(%sr0,%r21)                 ; branch to target
    :           stw %rp,-24(%sp)                ; save rp
 
    Import stub to call shared library routine from shared library
    (multiple sub-space support)

-   :           addil LR'ltoff,%r19             ; get procedure entry point
-   :           ldw RR'ltoff(%r1),%r21
-   :           ldw RR'ltoff+4(%r1),%r19        ; get new dlt value.
-   :           ldsid (%r21),%r1
+   :           addil LR'ltoff,%r19             ; get PLT address
+   :           ldo RR'ltoff(%r1),%r22
+   :           ldw 0(%r22),%r21                ; get procedure entry point
+   :           ldsid (%r21),%r1                ; get target sid
+   :           ldw 4(%r22),%r19                ; get new dlt value.

    :           mtsp %r1,%sr0
    :           be 0(%sr0,%r21)                 ; branch to target
    :           stw %rp,-24(%sp)                ; save rp
    :           mtsp %r1,%sr0
    :           be 0(%sr0,%r21)                 ; branch to target
    :           stw %rp,-24(%sp)                ; save rp


@@ -119,7 +123,7 @@
 /* Variable names follow a coding style.
    Please follow this (Apps Hungarian) style:
 
 /* Variable names follow a coding style.
    Please follow this (Apps Hungarian) style:
 

-   Structure/Variable                  Prefix
+   Structure/Variable                  Prefix

    elf_link_hash_table                 "etab"
    elf_link_hash_entry                 "eh"
 
    elf_link_hash_table                 "etab"
    elf_link_hash_entry                 "eh"
 


@@ -132,18 +136,21 @@
    bfd_hash_table containing stubs     "bstab"
    elf32_hppa_stub_hash_entry          "hsh"
 
    bfd_hash_table containing stubs     "bstab"
    elf32_hppa_stub_hash_entry          "hsh"
 

-   elf32_hppa_dyn_reloc_entry          "hdh"
-

    Always remember to use GNU Coding Style. */
 
 #define PLT_ENTRY_SIZE 8
 #define GOT_ENTRY_SIZE 4
    Always remember to use GNU Coding Style. */
 
 #define PLT_ENTRY_SIZE 8
 #define GOT_ENTRY_SIZE 4

+#define LONG_BRANCH_STUB_SIZE 8
+#define LONG_BRANCH_SHARED_STUB_SIZE 12
+#define IMPORT_STUB_SIZE 20
+#define IMPORT_SHARED_STUB_SIZE 32
+#define EXPORT_STUB_SIZE 24

 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
 
 static const bfd_byte plt_stub[] =
 {
 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
 
 static const bfd_byte plt_stub[] =
 {

-  0x0e, 0x80, 0x10, 0x96,  /* 1: ldw   0(%r20),%r22            */
-  0xea, 0xc0, 0xc0, 0x00,  /*    bv    %r0(%r22)               */
+  0x0e, 0x80, 0x10, 0x95,  /* 1: ldw   0(%r20),%r21            */
+  0xea, 0xa0, 0xc0, 0x00,  /*    bv    %r0(%r21)               */

   0x0e, 0x88, 0x10, 0x95,  /*    ldw   4(%r20),%r21            */
 #define PLT_STUB_ENTRY (3*4)
   0xea, 0x9f, 0x1f, 0xdd,  /*    b,l   1b,%r20                 */
   0x0e, 0x88, 0x10, 0x95,  /*    ldw   4(%r20),%r21            */
 #define PLT_STUB_ENTRY (3*4)
   0xea, 0x9f, 0x1f, 0xdd,  /*    b,l   1b,%r20                 */


@@ -162,6 +169,7 @@ static const bfd_byte plt_stub[] =
 #ifndef RELATIVE_DYNRELOCS
 #define RELATIVE_DYNRELOCS 0
 #define IS_ABSOLUTE_RELOC(r_type) 1
 #ifndef RELATIVE_DYNRELOCS
 #define RELATIVE_DYNRELOCS 0
 #define IS_ABSOLUTE_RELOC(r_type) 1

+#define pc_dynrelocs(hh) 0

 #endif
 
 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
 #endif
 
 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid


@@ -223,25 +231,6 @@ struct elf32_hppa_link_hash_entry
      symbol.  */
   struct elf32_hppa_stub_hash_entry *hsh_cache;
 
      symbol.  */
   struct elf32_hppa_stub_hash_entry *hsh_cache;
 

-  /* Used to count relocations for delayed sizing of relocation
-     sections.  */
-  struct elf32_hppa_dyn_reloc_entry
-  {
-    /* Next relocation in the chain.  */
-    struct elf32_hppa_dyn_reloc_entry *hdh_next;
-
-    /* The input section of the reloc.  */
-    asection *sec;
-
-    /* Number of relocs copied in this section.  */
-    bfd_size_type count;
-
-#if RELATIVE_DYNRELOCS
-  /* Number of relative relocs copied for the input section.  */
-    bfd_size_type relative_count;
-#endif
-  } *dyn_relocs;
-

   ENUM_BITFIELD (_tls_type) tls_type : 8;
 
   /* Set if this symbol is used by a plabel reloc.  */
   ENUM_BITFIELD (_tls_type) tls_type : 8;
 
   /* Set if this symbol is used by a plabel reloc.  */


@@ -397,7 +386,6 @@ hppa_link_hash_newfunc (struct bfd_hash_entry *entry,
       /* Initialize the local fields.  */
       hh = hppa_elf_hash_entry (entry);
       hh->hsh_cache = NULL;
       /* Initialize the local fields.  */
       hh = hppa_elf_hash_entry (entry);
       hh->hsh_cache = NULL;

-      hh->dyn_relocs = NULL;

       hh->plabel = 0;
       hh->tls_type = GOT_UNKNOWN;
     }
       hh->plabel = 0;
       hh->tls_type = GOT_UNKNOWN;
     }


@@ -425,7 +413,7 @@ static struct bfd_link_hash_table *
 elf32_hppa_link_hash_table_create (bfd *abfd)
 {
   struct elf32_hppa_link_hash_table *htab;
 elf32_hppa_link_hash_table_create (bfd *abfd)
 {
   struct elf32_hppa_link_hash_table *htab;

-  bfd_size_type amt = sizeof (*htab);
+  size_t amt = sizeof (*htab);

 
   htab = bfd_zmalloc (amt);
   if (htab == NULL)
 
   htab = bfd_zmalloc (amt);
   if (htab == NULL)


@@ -519,6 +507,8 @@ hppa_get_stub_entry (const asection *input_section,
      more than one stub used to reach say, printf, and we need to
      distinguish between them.  */
   id_sec = htab->stub_group[input_section->id].link_sec;
      more than one stub used to reach say, printf, and we need to
      distinguish between them.  */
   id_sec = htab->stub_group[input_section->id].link_sec;

+  if (id_sec == NULL)
+    return NULL;

 
   if (hh != NULL && hh->hsh_cache != NULL
       && hh->hsh_cache->hh == hh
 
   if (hh != NULL && hh->hsh_cache != NULL
       && hh->hsh_cache->hh == hh


@@ -590,7 +580,7 @@ hppa_add_stub (const char *stub_name,
   if (hsh == NULL)
     {
       /* xgettext:c-format */
   if (hsh == NULL)
     {
       /* xgettext:c-format */

-      _bfd_error_handler (_("%B: cannot create stub entry %s"),
+      _bfd_error_handler (_("%pB: cannot create stub entry %s"),

                          section->owner, stub_name);
       return NULL;
     }
                          section->owner, stub_name);
       return NULL;
     }


@@ -628,6 +618,9 @@ hppa_type_of_stub (asection *input_sec,
       return hppa_stub_import;
     }
 
       return hppa_stub_import;
     }
 

+  if (destination == (bfd_vma) -1)
+    return hppa_stub_none;
+

   /* Determine where the call point is.  */
   location = (input_sec->output_offset
              + input_sec->output_section->vma
   /* Determine where the call point is.  */
   location = (input_sec->output_offset
              + input_sec->output_section->vma


@@ -673,6 +666,10 @@ hppa_type_of_stub (asection *input_sec,
 #define ADDIL_R19      0x2a600000      /* addil LR'XXX,%r19,%r1        */
 #define LDW_R1_DP      0x483b0000      /* ldw   RR'XXX(%sr0,%r1),%dp   */
 
 #define ADDIL_R19      0x2a600000      /* addil LR'XXX,%r19,%r1        */
 #define LDW_R1_DP      0x483b0000      /* ldw   RR'XXX(%sr0,%r1),%dp   */
 

+#define LDO_R1_R22     0x34360000      /* ldo   RR'XXX(%r1),%r22       */
+#define LDW_R22_R21    0x0ec01095      /* ldw   0(%r22),%r21           */
+#define LDW_R22_R19    0x0ec81093      /* ldw   4(%r22),%r19           */
+

 #define LDSID_R21_R1   0x02a010a1      /* ldsid (%sr0,%r21),%r1        */
 #define MTSP_R1                0x00011820      /* mtsp  %r1,%sr0               */
 #define BE_SR0_R21     0xe2a00000      /* be    0(%sr0,%r21)           */
 #define LDSID_R21_R1   0x02a010a1      /* ldsid (%sr0,%r21),%r1        */
 #define MTSP_R1                0x00011820      /* mtsp  %r1,%sr0               */
 #define BE_SR0_R21     0xe2a00000      /* be    0(%sr0,%r21)           */


@@ -729,6 +726,15 @@ hppa_build_one_stub (struct bfd_hash_entry *bh, void *in_arg)
   switch (hsh->stub_type)
     {
     case hppa_stub_long_branch:
   switch (hsh->stub_type)
     {
     case hppa_stub_long_branch:

+      /* Fail if the target section could not be assigned to an output
+        section.  The user should fix his linker script.  */
+      if (hsh->target_section->output_section == NULL
+         && info->non_contiguous_regions)
+       info->callbacks->einfo (_("%F%P: Could not assign '%pA' to an output "
+                                 "section. Retry without "
+                                 "--enable-non-contiguous-regions.\n"),
+                               hsh->target_section);
+

       /* Create the long branch.  A long branch is formed with "ldil"
         loading the upper bits of the target address into a register,
         then branching with "be" which adds in the lower bits.
       /* Create the long branch.  A long branch is formed with "ldil"
         loading the upper bits of the target address into a register,
         then branching with "be" which adds in the lower bits.


@@ -745,10 +751,19 @@ hppa_build_one_stub (struct bfd_hash_entry *bh, void *in_arg)
       insn = hppa_rebuild_insn ((int) BE_SR4_R1, val, 17);
       bfd_put_32 (stub_bfd, insn, loc + 4);
 
       insn = hppa_rebuild_insn ((int) BE_SR4_R1, val, 17);
       bfd_put_32 (stub_bfd, insn, loc + 4);
 

-      size = 8;
+      size = LONG_BRANCH_STUB_SIZE;

       break;
 
     case hppa_stub_long_branch_shared:
       break;
 
     case hppa_stub_long_branch_shared:

+      /* Fail if the target section could not be assigned to an output
+        section.  The user should fix his linker script.  */
+      if (hsh->target_section->output_section == NULL
+         && info->non_contiguous_regions)
+       info->callbacks->einfo (_("%F%P: Could not assign %pA to an output "
+                                 "section. Retry without "
+                                 "--enable-non-contiguous-regions.\n"),
+                               hsh->target_section);
+

       /* Branches are relative.  This is where we are going to.  */
       sym_value = (hsh->target_value
                   + hsh->target_section->output_offset
       /* Branches are relative.  This is where we are going to.  */
       sym_value = (hsh->target_value
                   + hsh->target_section->output_offset


@@ -767,7 +782,7 @@ hppa_build_one_stub (struct bfd_hash_entry *bh, void *in_arg)
       val = hppa_field_adjust (sym_value, (bfd_signed_vma) -8, e_rrsel) >> 2;
       insn = hppa_rebuild_insn ((int) BE_SR4_R1, val, 17);
       bfd_put_32 (stub_bfd, insn, loc + 8);
       val = hppa_field_adjust (sym_value, (bfd_signed_vma) -8, e_rrsel) >> 2;
       insn = hppa_rebuild_insn ((int) BE_SR4_R1, val, 17);
       bfd_put_32 (stub_bfd, insn, loc + 8);

-      size = 12;
+      size = LONG_BRANCH_SHARED_STUB_SIZE;

       break;
 
     case hppa_stub_import:
       break;
 
     case hppa_stub_import:


@@ -787,45 +802,49 @@ hppa_build_one_stub (struct bfd_hash_entry *bh, void *in_arg)
       if (hsh->stub_type == hppa_stub_import_shared)
        insn = ADDIL_R19;
 #endif
       if (hsh->stub_type == hppa_stub_import_shared)
        insn = ADDIL_R19;
 #endif

+
+      /* Load function descriptor address into register %r22.  It is
+        sometimes needed for lazy binding.  */

       val = hppa_field_adjust (sym_value, 0, e_lrsel),
       insn = hppa_rebuild_insn ((int) insn, val, 21);
       bfd_put_32 (stub_bfd, insn, loc);
 
       val = hppa_field_adjust (sym_value, 0, e_lrsel),
       insn = hppa_rebuild_insn ((int) insn, val, 21);
       bfd_put_32 (stub_bfd, insn, loc);
 

-      /* It is critical to use lrsel/rrsel here because we are using
-        two different offsets (+0 and +4) from sym_value.  If we use
-        lsel/rsel then with unfortunate sym_values we will round
-        sym_value+4 up to the next 2k block leading to a mis-match
-        between the lsel and rsel value.  */

       val = hppa_field_adjust (sym_value, 0, e_rrsel);
       val = hppa_field_adjust (sym_value, 0, e_rrsel);

-      insn = hppa_rebuild_insn ((int) LDW_R1_R21, val, 14);
+      insn = hppa_rebuild_insn ((int) LDO_R1_R22, val, 14);

       bfd_put_32 (stub_bfd, insn, loc + 4);
 
       bfd_put_32 (stub_bfd, insn, loc + 4);
 

+      bfd_put_32 (stub_bfd, (bfd_vma) LDW_R22_R21, loc + 8);
+

       if (htab->multi_subspace)
        {
       if (htab->multi_subspace)
        {

-         val = hppa_field_adjust (sym_value, (bfd_signed_vma) 4, e_rrsel);
-         insn = hppa_rebuild_insn ((int) LDW_R1_DLT, val, 14);
-         bfd_put_32 (stub_bfd, insn, loc + 8);
-

          bfd_put_32 (stub_bfd, (bfd_vma) LDSID_R21_R1, loc + 12);
          bfd_put_32 (stub_bfd, (bfd_vma) LDSID_R21_R1, loc + 12);

-         bfd_put_32 (stub_bfd, (bfd_vma) MTSP_R1,      loc + 16);
-         bfd_put_32 (stub_bfd, (bfd_vma) BE_SR0_R21,   loc + 20);
-         bfd_put_32 (stub_bfd, (bfd_vma) STW_RP,       loc + 24);
+         bfd_put_32 (stub_bfd, (bfd_vma) LDW_R22_R19,  loc + 16);
+         bfd_put_32 (stub_bfd, (bfd_vma) MTSP_R1,      loc + 20);
+         bfd_put_32 (stub_bfd, (bfd_vma) BE_SR0_R21,   loc + 24);
+         bfd_put_32 (stub_bfd, (bfd_vma) STW_RP,       loc + 28);

 
 

-         size = 28;
+         size = IMPORT_SHARED_STUB_SIZE;

        }
       else
        {
        }
       else
        {

-         bfd_put_32 (stub_bfd, (bfd_vma) BV_R0_R21, loc + 8);
-         val = hppa_field_adjust (sym_value, (bfd_signed_vma) 4, e_rrsel);
-         insn = hppa_rebuild_insn ((int) LDW_R1_DLT, val, 14);
-         bfd_put_32 (stub_bfd, insn, loc + 12);
+         bfd_put_32 (stub_bfd, (bfd_vma) BV_R0_R21, loc + 12);
+         bfd_put_32 (stub_bfd, (bfd_vma) LDW_R22_R19, loc + 16);

 
 

-         size = 16;
+         size = IMPORT_STUB_SIZE;

        }
 
       break;
 
     case hppa_stub_export:
        }
 
       break;
 
     case hppa_stub_export:

+      /* Fail if the target section could not be assigned to an output
+        section.  The user should fix his linker script.  */
+      if (hsh->target_section->output_section == NULL
+         && info->non_contiguous_regions)
+       info->callbacks->einfo (_("%F%P: Could not assign %pA to an output "
+                                 "section. Retry without "
+                                 "--enable-non-contiguous-regions.\n"),
+                               hsh->target_section);
+

       /* Branches are relative.  This is where we are going to.  */
       sym_value = (hsh->target_value
                   + hsh->target_section->output_offset
       /* Branches are relative.  This is where we are going to.  */
       sym_value = (hsh->target_value
                   + hsh->target_section->output_offset


@@ -842,10 +861,11 @@ hppa_build_one_stub (struct bfd_hash_entry *bh, void *in_arg)
        {
          _bfd_error_handler
            /* xgettext:c-format */
        {
          _bfd_error_handler
            /* xgettext:c-format */

-           (_("%B(%A+%#Lx): cannot reach %s, recompile with -ffunction-sections"),
+           (_("%pB(%pA+%#" PRIx64 "): "
+              "cannot reach %s, recompile with -ffunction-sections"),

             hsh->target_section->owner,
             stub_sec,
             hsh->target_section->owner,
             stub_sec,

-            hsh->stub_offset,
+            (uint64_t) hsh->stub_offset,

             hsh->bh_root.string);
          bfd_set_error (bfd_error_bad_value);
          return FALSE;
             hsh->bh_root.string);
          bfd_set_error (bfd_error_bad_value);
          return FALSE;


@@ -858,7 +878,7 @@ hppa_build_one_stub (struct bfd_hash_entry *bh, void *in_arg)
        insn = hppa_rebuild_insn ((int) BL22_RP, val, 22);
       bfd_put_32 (stub_bfd, insn, loc);
 
        insn = hppa_rebuild_insn ((int) BL22_RP, val, 22);
       bfd_put_32 (stub_bfd, insn, loc);
 

-      bfd_put_32 (stub_bfd, (bfd_vma) NOP,         loc + 4);
+      bfd_put_32 (stub_bfd, (bfd_vma) NOP,        loc + 4);

       bfd_put_32 (stub_bfd, (bfd_vma) LDW_RP,      loc + 8);
       bfd_put_32 (stub_bfd, (bfd_vma) LDSID_RP_R1, loc + 12);
       bfd_put_32 (stub_bfd, (bfd_vma) MTSP_R1,     loc + 16);
       bfd_put_32 (stub_bfd, (bfd_vma) LDW_RP,      loc + 8);
       bfd_put_32 (stub_bfd, (bfd_vma) LDSID_RP_R1, loc + 12);
       bfd_put_32 (stub_bfd, (bfd_vma) MTSP_R1,     loc + 16);


@@ -868,7 +888,7 @@ hppa_build_one_stub (struct bfd_hash_entry *bh, void *in_arg)
       hsh->hh->eh.root.u.def.section = stub_sec;
       hsh->hh->eh.root.u.def.value = stub_sec->size;
 
       hsh->hh->eh.root.u.def.section = stub_sec;
       hsh->hh->eh.root.u.def.value = stub_sec->size;
 

-      size = 24;
+      size = EXPORT_STUB_SIZE;

       break;
 
     default:
       break;
 
     default:


@@ -916,17 +936,17 @@ hppa_size_one_stub (struct bfd_hash_entry *bh, void *in_arg)
   htab = in_arg;
 
   if (hsh->stub_type == hppa_stub_long_branch)
   htab = in_arg;
 
   if (hsh->stub_type == hppa_stub_long_branch)

-    size = 8;
+    size = LONG_BRANCH_STUB_SIZE;

   else if (hsh->stub_type == hppa_stub_long_branch_shared)
   else if (hsh->stub_type == hppa_stub_long_branch_shared)

-    size = 12;
+    size = LONG_BRANCH_SHARED_STUB_SIZE;

   else if (hsh->stub_type == hppa_stub_export)
   else if (hsh->stub_type == hppa_stub_export)

-    size = 24;
+    size = EXPORT_STUB_SIZE;

   else /* hppa_stub_import or hppa_stub_import_shared.  */
     {
       if (htab->multi_subspace)
   else /* hppa_stub_import or hppa_stub_import_shared.  */
     {
       if (htab->multi_subspace)

-       size = 28;
+       size = IMPORT_SHARED_STUB_SIZE;

       else
       else

-       size = 16;
+       size = IMPORT_STUB_SIZE;

     }
 
   hsh->stub_sec->size += size;
     }
 
   hsh->stub_sec->size += size;


@@ -1020,65 +1040,14 @@ elf32_hppa_copy_indirect_symbol (struct bfd_link_info *info,
   hh_dir = hppa_elf_hash_entry (eh_dir);
   hh_ind = hppa_elf_hash_entry (eh_ind);
 
   hh_dir = hppa_elf_hash_entry (eh_dir);
   hh_ind = hppa_elf_hash_entry (eh_ind);
 

-  if (hh_ind->dyn_relocs != NULL)
-    {
-      if (hh_dir->dyn_relocs != NULL)
-       {
-         struct elf32_hppa_dyn_reloc_entry **hdh_pp;
-         struct elf32_hppa_dyn_reloc_entry *hdh_p;
-
-         /* Add reloc counts against the indirect sym to the direct sym
-            list.  Merge any entries against the same section.  */
-         for (hdh_pp = &hh_ind->dyn_relocs; (hdh_p = *hdh_pp) != NULL; )
-           {
-             struct elf32_hppa_dyn_reloc_entry *hdh_q;
-
-             for (hdh_q = hh_dir->dyn_relocs;
-                  hdh_q != NULL;
-                  hdh_q = hdh_q->hdh_next)
-               if (hdh_q->sec == hdh_p->sec)
-                 {
-#if RELATIVE_DYNRELOCS
-                   hdh_q->relative_count += hdh_p->relative_count;
-#endif
-                   hdh_q->count += hdh_p->count;
-                   *hdh_pp = hdh_p->hdh_next;
-                   break;
-                 }
-             if (hdh_q == NULL)
-               hdh_pp = &hdh_p->hdh_next;
-           }
-         *hdh_pp = hh_dir->dyn_relocs;
-       }
-
-      hh_dir->dyn_relocs = hh_ind->dyn_relocs;
-      hh_ind->dyn_relocs = NULL;
-    }
-
-  if (ELIMINATE_COPY_RELOCS
-      && eh_ind->root.type != bfd_link_hash_indirect
-      && eh_dir->dynamic_adjusted)
+  if (eh_ind->root.type == bfd_link_hash_indirect)

     {
     {

-      /* If called to transfer flags for a weakdef during processing
-        of elf_adjust_dynamic_symbol, don't copy non_got_ref.
-        We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
-      if (eh_dir->versioned != versioned_hidden)
-       eh_dir->ref_dynamic |= eh_ind->ref_dynamic;
-      eh_dir->ref_regular |= eh_ind->ref_regular;
-      eh_dir->ref_regular_nonweak |= eh_ind->ref_regular_nonweak;
-      eh_dir->needs_plt |= eh_ind->needs_plt;
+      hh_dir->plabel |= hh_ind->plabel;
+      hh_dir->tls_type |= hh_ind->tls_type;
+      hh_ind->tls_type = GOT_UNKNOWN;

     }
     }

-  else
-    {
-      if (eh_ind->root.type == bfd_link_hash_indirect)
-       {
-         hh_dir->plabel |= hh_ind->plabel;
-         hh_dir->tls_type |= hh_ind->tls_type;
-         hh_ind->tls_type = GOT_UNKNOWN;
-       }

 
 

-      _bfd_elf_link_hash_copy_indirect (info, eh_dir, eh_ind);
-    }
+  _bfd_elf_link_hash_copy_indirect (info, eh_dir, eh_ind);

 }
 
 static int
 }
 
 static int


@@ -1173,10 +1142,6 @@ elf32_hppa_check_relocs (bfd *abfd,
          while (hh->eh.root.type == bfd_link_hash_indirect
                 || hh->eh.root.type == bfd_link_hash_warning)
            hh = hppa_elf_hash_entry (hh->eh.root.u.i.link);
          while (hh->eh.root.type == bfd_link_hash_indirect
                 || hh->eh.root.type == bfd_link_hash_warning)
            hh = hppa_elf_hash_entry (hh->eh.root.u.i.link);

-
-         /* PR15323, ref flags aren't set for references in the same
-            object.  */
-         hh->eh.root.non_ir_ref_regular = 1;

        }
 
       r_type = ELF32_R_TYPE (rela->r_info);
        }
 
       r_type = ELF32_R_TYPE (rela->r_info);


@@ -1274,7 +1239,7 @@ elf32_hppa_check_relocs (bfd *abfd,
            {
              _bfd_error_handler
                /* xgettext:c-format */
            {
              _bfd_error_handler
                /* xgettext:c-format */

-               (_("%B: relocation %s can not be used when making a shared object; recompile with -fPIC"),
+               (_("%pB: relocation %s can not be used when making a shared object; recompile with -fPIC"),

                 abfd,
                 elf_hppa_howto_table[r_type].name);
              bfd_set_error (bfd_error_bad_value);
                 abfd,
                 elf_hppa_howto_table[r_type].name);
              bfd_set_error (bfd_error_bad_value);


@@ -1302,9 +1267,7 @@ elf32_hppa_check_relocs (bfd *abfd,
          /* This relocation describes which C++ vtable entries are actually
             used.  Record for later use during GC.  */
        case R_PARISC_GNU_VTENTRY:
          /* This relocation describes which C++ vtable entries are actually
             used.  Record for later use during GC.  */
        case R_PARISC_GNU_VTENTRY:

-         BFD_ASSERT (hh != NULL);
-         if (hh != NULL
-             && !bfd_elf_gc_record_vtentry (abfd, sec, &hh->eh, rela->r_addend))
+         if (!bfd_elf_gc_record_vtentry (abfd, sec, &hh->eh, rela->r_addend))

            return FALSE;
          continue;
 
            return FALSE;
          continue;
 


@@ -1318,7 +1281,7 @@ elf32_hppa_check_relocs (bfd *abfd,
        case R_PARISC_TLS_IE21L:
        case R_PARISC_TLS_IE14R:
          if (bfd_link_dll (info))
        case R_PARISC_TLS_IE21L:
        case R_PARISC_TLS_IE14R:
          if (bfd_link_dll (info))

-            info->flags |= DF_STATIC_TLS;
+           info->flags |= DF_STATIC_TLS;

          need_entry = NEED_GOT;
          break;
 
          need_entry = NEED_GOT;
          break;
 


@@ -1426,7 +1389,7 @@ elf32_hppa_check_relocs (bfd *abfd,
          /* Flag this symbol as having a non-got, non-plt reference
             so that we generate copy relocs if it turns out to be
             dynamic.  */
          /* Flag this symbol as having a non-got, non-plt reference
             so that we generate copy relocs if it turns out to be
             dynamic.  */

-         if (hh != NULL && !bfd_link_pic (info))
+         if (hh != NULL)

            hh->eh.non_got_ref = 1;
 
          /* If we are creating a shared library then we need to copy
            hh->eh.non_got_ref = 1;
 
          /* If we are creating a shared library then we need to copy


@@ -1469,8 +1432,8 @@ elf32_hppa_check_relocs (bfd *abfd,
                  && (hh->eh.root.type == bfd_link_hash_defweak
                      || !hh->eh.def_regular)))
            {
                  && (hh->eh.root.type == bfd_link_hash_defweak
                      || !hh->eh.def_regular)))
            {

-             struct elf32_hppa_dyn_reloc_entry *hdh_p;
-             struct elf32_hppa_dyn_reloc_entry **hdh_head;
+             struct elf_dyn_relocs *hdh_p;
+             struct elf_dyn_relocs **hdh_head;

 
              /* Create a reloc section in dynobj and make room for
                 this reloc.  */
 
              /* Create a reloc section in dynobj and make room for
                 this reloc.  */


@@ -1490,7 +1453,7 @@ elf32_hppa_check_relocs (bfd *abfd,
                 relocations we need for this symbol.  */
              if (hh != NULL)
                {
                 relocations we need for this symbol.  */
              if (hh != NULL)
                {

-                 hdh_head = &hh->dyn_relocs;
+                 hdh_head = &hh->eh.dyn_relocs;

                }
              else
                {
                }
              else
                {


@@ -1511,7 +1474,7 @@ elf32_hppa_check_relocs (bfd *abfd,
                    sr = sec;
 
                  vpp = &elf_section_data (sr)->local_dynrel;
                    sr = sec;
 
                  vpp = &elf_section_data (sr)->local_dynrel;

-                 hdh_head = (struct elf32_hppa_dyn_reloc_entry **) vpp;
+                 hdh_head = (struct elf_dyn_relocs **) vpp;

                }
 
              hdh_p = *hdh_head;
                }
 
              hdh_p = *hdh_head;


@@ -1520,19 +1483,19 @@ elf32_hppa_check_relocs (bfd *abfd,
                  hdh_p = bfd_alloc (htab->etab.dynobj, sizeof *hdh_p);
                  if (hdh_p == NULL)
                    return FALSE;
                  hdh_p = bfd_alloc (htab->etab.dynobj, sizeof *hdh_p);
                  if (hdh_p == NULL)
                    return FALSE;

-                 hdh_p->hdh_next = *hdh_head;
+                 hdh_p->next = *hdh_head;

                  *hdh_head = hdh_p;
                  hdh_p->sec = sec;
                  hdh_p->count = 0;
 #if RELATIVE_DYNRELOCS
                  *hdh_head = hdh_p;
                  hdh_p->sec = sec;
                  hdh_p->count = 0;
 #if RELATIVE_DYNRELOCS

-                 hdh_p->relative_count = 0;
+                 hdh_p->pc_count = 0;

 #endif
                }
 
              hdh_p->count += 1;
 #if RELATIVE_DYNRELOCS
              if (!IS_ABSOLUTE_RELOC (rtype))
 #endif
                }
 
              hdh_p->count += 1;
 #if RELATIVE_DYNRELOCS
              if (!IS_ABSOLUTE_RELOC (rtype))

-               hdh_p->relative_count += 1;
+               hdh_p->pc_count += 1;

 #endif
            }
        }
 #endif
            }
        }


@@ -1655,23 +1618,22 @@ elf32_hppa_hide_symbol (struct bfd_link_info *info,
     }
 }
 
     }
 }
 

-/* Find any dynamic relocs that apply to read-only sections.  */
+/* Return true if we have dynamic relocs against H or any of its weak
+   aliases, that apply to read-only sections.  Cannot be used after
+   size_dynamic_sections.  */

 
 

-static asection *
-readonly_dynrelocs (struct elf_link_hash_entry *eh)
+static bfd_boolean
+alias_readonly_dynrelocs (struct elf_link_hash_entry *eh)

 {
 {

-  struct elf32_hppa_link_hash_entry *hh;
-  struct elf32_hppa_dyn_reloc_entry *hdh_p;
-
-  hh = hppa_elf_hash_entry (eh);
-  for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->hdh_next)
+  struct elf32_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);
+  do

     {
     {

-      asection *sec = hdh_p->sec->output_section;
+      if (_bfd_elf_readonly_dynrelocs (&hh->eh))
+       return TRUE;
+      hh = hppa_elf_hash_entry (hh->eh.u.alias);
+    } while (hh != NULL && &hh->eh != eh);

 
 

-      if (sec != NULL && (sec->flags & SEC_READONLY) != 0)
-       return hdh_p->sec;
-    }
-  return NULL;
+  return FALSE;

 }
 
 /* Adjust a symbol defined by a dynamic object and referenced by a
 }
 
 /* Adjust a symbol defined by a dynamic object and referenced by a


@@ -1692,30 +1654,12 @@ elf32_hppa_adjust_dynamic_symbol (struct bfd_link_info *info,
   if (eh->type == STT_FUNC
       || eh->needs_plt)
     {
   if (eh->type == STT_FUNC
       || eh->needs_plt)
     {

-      /* After adjust_dynamic_symbol, non_got_ref set in the non-pic
-        case means that dyn_relocs for this symbol should be
-        discarded;  We either want the symbol to remain undefined, or
-        we have a local definition of some sort.  The "local
-        definition" for non-function symbols may be due to creating a
-        local definition in .dynbss.
-        Unlike other targets, elf32-hppa.c does not define a function
-        symbol in a non-pic executable on PLT stub code, so we don't
-        have a local definition in that case.  dyn_relocs therefore
-        should not be discarded for function symbols, generally.
-        However we should discard dyn_relocs if we've decided that an
-        undefined function symbol is local, for example due to
-        non-default visibility, or UNDEFWEAK_NO_DYNAMIC_RELOC is
-        true for an undefined weak symbol.  */

       bfd_boolean local = (SYMBOL_CALLS_LOCAL (info, eh)
                           || UNDEFWEAK_NO_DYNAMIC_RELOC (info, eh));
       bfd_boolean local = (SYMBOL_CALLS_LOCAL (info, eh)
                           || UNDEFWEAK_NO_DYNAMIC_RELOC (info, eh));

-      /* Prior to adjust_dynamic_symbol, non_got_ref set means that
-        check_relocs set up some dyn_relocs for this symbol.
-        The !non_got_ref term here is saying that if we didn't have
-        any dyn_relocs set up by check_relocs, then we don't want
-        relocate_section looking for them.
-        FIXME: Get rid of the inversion, so non_got_ref set after
-        dyn_relocs means we do have dyn_relocs.  */
-      eh->non_got_ref = local || !eh->non_got_ref;
+      /* Discard dyn_relocs when non-pic if we've decided that a
+        function symbol is local.  */
+      if (!bfd_link_pic (info) && local)
+       eh->dyn_relocs = NULL;

 
       /* If the symbol is used by a plabel, we must allocate a PLT slot.
         The refcounts are not reliable when it has been hidden since
 
       /* If the symbol is used by a plabel, we must allocate a PLT slot.
         The refcounts are not reliable when it has been hidden since


@@ -1739,24 +1683,33 @@ elf32_hppa_adjust_dynamic_symbol (struct bfd_link_info *info,
          eh->needs_plt = 0;
        }
 
          eh->needs_plt = 0;
        }
 

+      /* Unlike other targets, elf32-hppa.c does not define a function
+        symbol in a non-pic executable on PLT stub code, so we don't
+        have a local definition in that case.  ie. dyn_relocs can't
+        be discarded.  */
+

       /* Function symbols can't have copy relocs.  */
       return TRUE;
     }
   else
     eh->plt.offset = (bfd_vma) -1;
 
       /* Function symbols can't have copy relocs.  */
       return TRUE;
     }
   else
     eh->plt.offset = (bfd_vma) -1;
 

+  htab = hppa_link_hash_table (info);
+  if (htab == NULL)
+    return FALSE;
+

   /* If this is a weak symbol, and there is a real definition, the
      processor independent code will have arranged for us to see the
      real definition first, and we can just use the same value.  */
   /* If this is a weak symbol, and there is a real definition, the
      processor independent code will have arranged for us to see the
      real definition first, and we can just use the same value.  */

-  if (eh->u.weakdef != NULL)
+  if (eh->is_weakalias)

     {
     {

-      if (eh->u.weakdef->root.type != bfd_link_hash_defined
-         && eh->u.weakdef->root.type != bfd_link_hash_defweak)
-       abort ();
-      eh->root.u.def.section = eh->u.weakdef->root.u.def.section;
-      eh->root.u.def.value = eh->u.weakdef->root.u.def.value;
-      if (ELIMINATE_COPY_RELOCS)
-       eh->non_got_ref = eh->u.weakdef->non_got_ref;
+      struct elf_link_hash_entry *def = weakdef (eh);
+      BFD_ASSERT (def->root.type == bfd_link_hash_defined);
+      eh->root.u.def.section = def->root.u.def.section;
+      eh->root.u.def.value = def->root.u.def.value;
+      if (def->root.u.def.section == htab->etab.sdynbss
+         || def->root.u.def.section == htab->etab.sdynrelro)
+       eh->dyn_relocs = NULL;

       return TRUE;
     }
 
       return TRUE;
     }
 


@@ -1773,26 +1726,17 @@ elf32_hppa_adjust_dynamic_symbol (struct bfd_link_info *info,
   /* If there are no references to this symbol that do not use the
      GOT, we don't need to generate a copy reloc.  */
   if (!eh->non_got_ref)
   /* If there are no references to this symbol that do not use the
      GOT, we don't need to generate a copy reloc.  */
   if (!eh->non_got_ref)

-    {
-      eh->non_got_ref = 1;
-      return TRUE;
-    }
+    return TRUE;

 
   /* If -z nocopyreloc was given, we won't generate them either.  */
   if (info->nocopyreloc)
 
   /* If -z nocopyreloc was given, we won't generate them either.  */
   if (info->nocopyreloc)

-    {
-      eh->non_got_ref = 0;
-      return TRUE;
-    }
+    return TRUE;

 
 

+  /* If we don't find any dynamic relocs in read-only sections, then
+     we'll be keeping the dynamic relocs and avoiding the copy reloc.  */

   if (ELIMINATE_COPY_RELOCS
   if (ELIMINATE_COPY_RELOCS

-      && !readonly_dynrelocs (eh))
-    {
-      /* If we didn't find any dynamic relocs in read-only sections, then
-        we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
-      eh->non_got_ref = 0;
-      return TRUE;
-    }
+      && !alias_readonly_dynrelocs (eh))
+    return TRUE;

 
   /* We must allocate the symbol in our .dynbss section, which will
      become part of the .bss section of the executable.  There will be
 
   /* We must allocate the symbol in our .dynbss section, which will
      become part of the .bss section of the executable.  There will be


@@ -1803,14 +1747,6 @@ elf32_hppa_adjust_dynamic_symbol (struct bfd_link_info *info,
      determine the address it must put in the global offset table, so
      both the dynamic object and the regular object will refer to the
      same memory location for the variable.  */
      determine the address it must put in the global offset table, so
      both the dynamic object and the regular object will refer to the
      same memory location for the variable.  */

-
-  htab = hppa_link_hash_table (info);
-  if (htab == NULL)
-    return FALSE;
-
-  /* We must generate a COPY reloc to tell the dynamic linker to
-     copy the initial value out of the dynamic object and into the
-     runtime process image.  */

   if ((eh->root.u.def.section->flags & SEC_READONLY) != 0)
     {
       sec = htab->etab.sdynrelro;
   if ((eh->root.u.def.section->flags & SEC_READONLY) != 0)
     {
       sec = htab->etab.sdynrelro;


@@ -1823,10 +1759,15 @@ elf32_hppa_adjust_dynamic_symbol (struct bfd_link_info *info,
     }
   if ((eh->root.u.def.section->flags & SEC_ALLOC) != 0 && eh->size != 0)
     {
     }
   if ((eh->root.u.def.section->flags & SEC_ALLOC) != 0 && eh->size != 0)
     {

+      /* We must generate a COPY reloc to tell the dynamic linker to
+        copy the initial value out of the dynamic object and into the
+        runtime process image.  */

       srel->size += sizeof (Elf32_External_Rela);
       eh->needs_copy = 1;
     }
 
       srel->size += sizeof (Elf32_External_Rela);
       eh->needs_copy = 1;
     }
 

+  /* We no longer want dyn_relocs.  */
+  eh->dyn_relocs = NULL;

   return _bfd_elf_adjust_dynamic_copy (info, eh, sec);
 }
 
   return _bfd_elf_adjust_dynamic_copy (info, eh, sec);
 }
 


@@ -1928,18 +1869,19 @@ got_entries_needed (int tls_type)
 }
 
 /* Calculate size of relocs needed for symbol given its TLS_TYPE and
 }
 
 /* Calculate size of relocs needed for symbol given its TLS_TYPE and

-   NEEDed GOT entries.  KNOWN says a TPREL offset can be calculated
-   at link time.  */
+   NEEDed GOT entries.  TPREL_KNOWN says a TPREL offset can be
+   calculated at link time.  DTPREL_KNOWN says the same for a DTPREL
+   offset.  */

 
 static inline unsigned int
 
 static inline unsigned int

-got_relocs_needed (int tls_type, unsigned int need, bfd_boolean known)
+got_relocs_needed (int tls_type, unsigned int need,
+                  bfd_boolean dtprel_known, bfd_boolean tprel_known)

 {
   /* All the entries we allocated need relocs.
 {
   /* All the entries we allocated need relocs.

-     Except IE in executable with a local symbol.  We could also omit
-     the DTPOFF reloc on the second word of a GD entry under the same
-     condition as that for IE, but ld.so might want to differentiate
-     LD and GD entries at some stage.  */
-  if ((tls_type & GOT_TLS_IE) != 0 && known)
+     Except for GD and IE with local symbols.  */
+  if ((tls_type & GOT_TLS_GD) != 0 && dtprel_known)
+    need -= GOT_ENTRY_SIZE;
+  if ((tls_type & GOT_TLS_IE) != 0 && tprel_known)

     need -= GOT_ENTRY_SIZE;
   return need * sizeof (Elf32_External_Rela) / GOT_ENTRY_SIZE;
 }
     need -= GOT_ENTRY_SIZE;
   return need * sizeof (Elf32_External_Rela) / GOT_ENTRY_SIZE;
 }


@@ -1954,7 +1896,7 @@ allocate_dynrelocs (struct elf_link_hash_entry *eh, void *inf)
   struct elf32_hppa_link_hash_table *htab;
   asection *sec;
   struct elf32_hppa_link_hash_entry *hh;
   struct elf32_hppa_link_hash_table *htab;
   asection *sec;
   struct elf32_hppa_link_hash_entry *hh;

-  struct elf32_hppa_dyn_reloc_entry *hdh_p;
+  struct elf_dyn_relocs *hdh_p;

 
   if (eh->root.type == bfd_link_hash_indirect)
     return TRUE;
 
   if (eh->root.type == bfd_link_hash_indirect)
     return TRUE;


@@ -1993,15 +1935,16 @@ allocate_dynrelocs (struct elf_link_hash_entry *eh, void *inf)
       need = got_entries_needed (hh->tls_type);
       sec->size += need;
       if (htab->etab.dynamic_sections_created
       need = got_entries_needed (hh->tls_type);
       sec->size += need;
       if (htab->etab.dynamic_sections_created

-         && (bfd_link_pic (info)
+         && (bfd_link_dll (info)
+             || (bfd_link_pic (info) && (hh->tls_type & GOT_NORMAL) != 0)

              || (eh->dynindx != -1
                  && !SYMBOL_REFERENCES_LOCAL (info, eh)))
          && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, eh))
        {
              || (eh->dynindx != -1
                  && !SYMBOL_REFERENCES_LOCAL (info, eh)))
          && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, eh))
        {

-         bfd_boolean tprel_known = (bfd_link_executable (info)
-                                    && SYMBOL_REFERENCES_LOCAL (info, eh));
+         bfd_boolean local = SYMBOL_REFERENCES_LOCAL (info, eh);

          htab->etab.srelgot->size
          htab->etab.srelgot->size

-           += got_relocs_needed (hh->tls_type, need, tprel_known);
+           += got_relocs_needed (hh->tls_type, need, local,
+                                 local && bfd_link_executable (info));

        }
     }
   else
        }
     }
   else


@@ -2009,9 +1952,15 @@ allocate_dynrelocs (struct elf_link_hash_entry *eh, void *inf)
 
   /* If no dynamic sections we can't have dynamic relocs.  */
   if (!htab->etab.dynamic_sections_created)
 
   /* If no dynamic sections we can't have dynamic relocs.  */
   if (!htab->etab.dynamic_sections_created)

-    hh->dyn_relocs = NULL;
+    eh->dyn_relocs = NULL;
+
+  /* Discard relocs on undefined syms with non-default visibility.  */
+  else if ((eh->root.type == bfd_link_hash_undefined
+           && ELF_ST_VISIBILITY (eh->other) != STV_DEFAULT)
+          || UNDEFWEAK_NO_DYNAMIC_RELOC (info, eh))
+    eh->dyn_relocs = NULL;

 
 

-  if (hh->dyn_relocs == NULL)
+  if (eh->dyn_relocs == NULL)

     return TRUE;
 
   /* If this is a -Bsymbolic shared link, then we need to discard all
     return TRUE;
 
   /* If this is a -Bsymbolic shared link, then we need to discard all


@@ -2021,30 +1970,24 @@ allocate_dynrelocs (struct elf_link_hash_entry *eh, void *inf)
      changes.  */
   if (bfd_link_pic (info))
     {
      changes.  */
   if (bfd_link_pic (info))
     {

-      /* Discard relocs on undefined syms with non-default visibility.  */
-      if ((eh->root.type == bfd_link_hash_undefined
-          && ELF_ST_VISIBILITY (eh->other) != STV_DEFAULT)
-         || UNDEFWEAK_NO_DYNAMIC_RELOC (info, eh))
-       hh->dyn_relocs = NULL;
-

 #if RELATIVE_DYNRELOCS
 #if RELATIVE_DYNRELOCS

-      else if (SYMBOL_CALLS_LOCAL (info, eh))
+      if (SYMBOL_CALLS_LOCAL (info, eh))

        {
        {

-         struct elf32_hppa_dyn_reloc_entry **hdh_pp;
+         struct elf_dyn_relocs **hdh_pp;

 
 

-         for (hdh_pp = &hh->dyn_relocs; (hdh_p = *hdh_pp) != NULL; )
+         for (hdh_pp = &eh->dyn_relocs; (hdh_p = *hdh_pp) != NULL; )

            {
            {

-             hdh_p->count -= hdh_p->relative_count;
-             hdh_p->relative_count = 0;
+             hdh_p->count -= hdh_p->pc_count;
+             hdh_p->pc_count = 0;

              if (hdh_p->count == 0)
              if (hdh_p->count == 0)

-               *hdh_pp = hdh_p->hdh_next;
+               *hdh_pp = hdh_p->next;

              else
              else

-               hdh_pp = &hdh_p->hdh_next;
+               hdh_pp = &hdh_p->next;

            }
        }
 #endif
 
            }
        }
 #endif
 

-      if (hh->dyn_relocs != NULL)
+      if (eh->dyn_relocs != NULL)

        {
          if (!ensure_undef_dynamic (info, eh))
            return FALSE;
        {
          if (!ensure_undef_dynamic (info, eh))
            return FALSE;


@@ -2056,21 +1999,22 @@ allocate_dynrelocs (struct elf_link_hash_entry *eh, void *inf)
         symbols which turn out to need copy relocs or are not
         dynamic.  */
 
         symbols which turn out to need copy relocs or are not
         dynamic.  */
 

-      if (!eh->non_got_ref
-         && !eh->def_regular)
+      if (eh->dynamic_adjusted
+         && !eh->def_regular
+         && !ELF_COMMON_DEF_P (eh))

        {
          if (!ensure_undef_dynamic (info, eh))
            return FALSE;
 
          if (eh->dynindx == -1)
        {
          if (!ensure_undef_dynamic (info, eh))
            return FALSE;
 
          if (eh->dynindx == -1)

-           hh->dyn_relocs = NULL;
+           eh->dyn_relocs = NULL;

        }
       else
        }
       else

-       hh->dyn_relocs = NULL;
+       eh->dyn_relocs = NULL;

     }
 
   /* Finally, allocate space.  */
     }
 
   /* Finally, allocate space.  */

-  for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->hdh_next)
+  for (hdh_p = eh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->next)

     {
       asection *sreloc = elf_section_data (hdh_p->sec)->sreloc;
       sreloc->size += hdh_p->count * sizeof (Elf32_External_Rela);
     {
       asection *sreloc = elf_section_data (hdh_p->sec)->sreloc;
       sreloc->size += hdh_p->count * sizeof (Elf32_External_Rela);


@@ -2098,33 +2042,6 @@ clobber_millicode_symbols (struct elf_link_hash_entry *eh,
   return TRUE;
 }
 
   return TRUE;
 }
 

-/* Set DF_TEXTREL if we find any dynamic relocs that apply to
-   read-only sections.  */
-
-static bfd_boolean
-maybe_set_textrel (struct elf_link_hash_entry *eh, void *inf)
-{
-  asection *sec;
-
-  if (eh->root.type == bfd_link_hash_indirect)
-    return TRUE;
-
-  sec = readonly_dynrelocs (eh);
-  if (sec != NULL)
-    {
-      struct bfd_link_info *info = (struct bfd_link_info *) inf;
-
-      info->flags |= DF_TEXTREL;
-      info->callbacks->minfo
-       (_("%B: dynamic relocation in read-only section `%A'\n"),
-        sec->owner, sec);
-
-      /* Not an error, just cut short the traversal.  */
-      return FALSE;
-    }
-  return TRUE;
-}
-

 /* Set the sizes of the dynamic sections.  */
 
 static bfd_boolean
 /* Set the sizes of the dynamic sections.  */
 
 static bfd_boolean


@@ -2181,12 +2098,12 @@ elf32_hppa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
 
       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
        {
 
       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
        {

-         struct elf32_hppa_dyn_reloc_entry *hdh_p;
+         struct elf_dyn_relocs *hdh_p;

 
 

-         for (hdh_p = ((struct elf32_hppa_dyn_reloc_entry *)
+         for (hdh_p = ((struct elf_dyn_relocs *)

                    elf_section_data (sec)->local_dynrel);
               hdh_p != NULL;
                    elf_section_data (sec)->local_dynrel);
               hdh_p != NULL;

-              hdh_p = hdh_p->hdh_next)
+              hdh_p = hdh_p->next)

            {
              if (!bfd_is_abs_section (hdh_p->sec)
                  && bfd_is_abs_section (hdh_p->sec->output_section))
            {
              if (!bfd_is_abs_section (hdh_p->sec)
                  && bfd_is_abs_section (hdh_p->sec->output_section))


@@ -2225,12 +2142,12 @@ elf32_hppa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
              *local_got = sec->size;
              need = got_entries_needed (*local_tls_type);
              sec->size += need;
              *local_got = sec->size;
              need = got_entries_needed (*local_tls_type);
              sec->size += need;

-             if (bfd_link_pic (info))
-               {
-                 bfd_boolean tprel_known = bfd_link_executable (info);
-                 htab->etab.srelgot->size
-                   += got_relocs_needed (*local_tls_type, need, tprel_known);
-               }
+             if (bfd_link_dll (info)
+                 || (bfd_link_pic (info)
+                     && (*local_tls_type & GOT_NORMAL) != 0))
+               htab->etab.srelgot->size
+                 += got_relocs_needed (*local_tls_type, need, TRUE,
+                                       bfd_link_executable (info));

            }
          else
            *local_got = (bfd_vma) -1;
            }
          else
            *local_got = (bfd_vma) -1;


@@ -2268,7 +2185,7 @@ elf32_hppa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
   if (htab->tls_ldm_got.refcount > 0)
     {
       /* Allocate 2 got entries and 1 dynamic reloc for
   if (htab->tls_ldm_got.refcount > 0)
     {
       /* Allocate 2 got entries and 1 dynamic reloc for

-         R_PARISC_TLS_DTPMOD32 relocs.  */
+        R_PARISC_TLS_DTPMOD32 relocs.  */

       htab->tls_ldm_got.offset = htab->etab.sgot->size;
       htab->etab.sgot->size += (GOT_ENTRY_SIZE * 2);
       htab->etab.srelgot->size += sizeof (Elf32_External_Rela);
       htab->tls_ldm_got.offset = htab->etab.sgot->size;
       htab->etab.sgot->size += (GOT_ENTRY_SIZE * 2);
       htab->etab.srelgot->size += sizeof (Elf32_External_Rela);


@@ -2301,12 +2218,13 @@ elf32_hppa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
              /* Make space for the plt stub at the end of the .plt
                 section.  We want this stub right at the end, up
                 against the .got section.  */
              /* Make space for the plt stub at the end of the .plt
                 section.  We want this stub right at the end, up
                 against the .got section.  */

-             int gotalign = bfd_section_alignment (dynobj, htab->etab.sgot);
-             int pltalign = bfd_section_alignment (dynobj, sec);
+             int gotalign = bfd_section_alignment (htab->etab.sgot);
+             int pltalign = bfd_section_alignment (sec);
+             int align = gotalign > 3 ? gotalign : 3;

              bfd_size_type mask;
 
              bfd_size_type mask;
 

-             if (gotalign > pltalign)
-               (void) bfd_set_section_alignment (dynobj, sec, gotalign);
+             if (align > pltalign)
+               bfd_set_section_alignment (sec, align);

              mask = ((bfd_size_type) 1 << gotalign) - 1;
              sec->size = (sec->size + sizeof (plt_stub) + mask) & ~mask;
            }
              mask = ((bfd_size_type) 1 << gotalign) - 1;
              sec->size = (sec->size + sizeof (plt_stub) + mask) & ~mask;
            }


@@ -2315,7 +2233,7 @@ elf32_hppa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
               || sec == htab->etab.sdynbss
               || sec == htab->etab.sdynrelro)
        ;
               || sec == htab->etab.sdynbss
               || sec == htab->etab.sdynrelro)
        ;

-      else if (CONST_STRNEQ (bfd_get_section_name (dynobj, sec), ".rela"))
+      else if (CONST_STRNEQ (bfd_section_name (sec), ".rela"))

        {
          if (sec->size != 0)
            {
        {
          if (sec->size != 0)
            {


@@ -2401,7 +2319,8 @@ elf32_hppa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
          /* If any dynamic relocs apply to a read-only section,
             then we need a DT_TEXTREL entry.  */
          if ((info->flags & DF_TEXTREL) == 0)
          /* If any dynamic relocs apply to a read-only section,
             then we need a DT_TEXTREL entry.  */
          if ((info->flags & DF_TEXTREL) == 0)

-           elf_link_hash_traverse (&htab->etab, maybe_set_textrel, info);
+           elf_link_hash_traverse (&htab->etab,
+                                   _bfd_elf_maybe_set_textrel, info);

 
          if ((info->flags & DF_TEXTREL) != 0)
            {
 
          if ((info->flags & DF_TEXTREL) != 0)
            {


@@ -2429,7 +2348,7 @@ elf32_hppa_setup_section_lists (bfd *output_bfd, struct bfd_link_info *info)
   unsigned int top_id, top_index;
   asection *section;
   asection **input_list, **list;
   unsigned int top_id, top_index;
   asection *section;
   asection **input_list, **list;

-  bfd_size_type amt;
+  size_t amt;

   struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info);
 
   if (htab == NULL)
   struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info);
 
   if (htab == NULL)


@@ -2618,7 +2537,7 @@ get_local_syms (bfd *output_bfd, bfd *input_bfd, struct bfd_link_info *info)
   /* We want to read in symbol extension records only once.  To do this
      we need to read in the local symbols in parallel and save them for
      later use; so hold pointers to the local symbols in an array.  */
   /* We want to read in symbol extension records only once.  To do this
      we need to read in the local symbols in parallel and save them for
      later use; so hold pointers to the local symbols in an array.  */

-  bfd_size_type amt = sizeof (Elf_Internal_Sym *) * htab->bfd_count;
+  size_t amt = sizeof (Elf_Internal_Sym *) * htab->bfd_count;

   all_local_syms = bfd_zmalloc (amt);
   htab->all_local_syms = all_local_syms;
   if (all_local_syms == NULL)
   all_local_syms = bfd_zmalloc (amt);
   htab->all_local_syms = all_local_syms;
   if (all_local_syms == NULL)


@@ -2714,7 +2633,7 @@ get_local_syms (bfd *output_bfd, bfd *input_bfd, struct bfd_link_info *info)
                  else
                    {
                      /* xgettext:c-format */
                  else
                    {
                      /* xgettext:c-format */

-                     _bfd_error_handler (_("%B: duplicate export stub %s"),
+                     _bfd_error_handler (_("%pB: duplicate export stub %s"),

                                          input_bfd, stub_name);
                    }
                }
                                          input_bfd, stub_name);
                    }
                }


@@ -2826,6 +2745,9 @@ elf32_hppa_size_stubs
              /* If there aren't any relocs, then there's nothing more
                 to do.  */
              if ((section->flags & SEC_RELOC) == 0
              /* If there aren't any relocs, then there's nothing more
                 to do.  */
              if ((section->flags & SEC_RELOC) == 0

+                 || (section->flags & SEC_ALLOC) == 0
+                 || (section->flags & SEC_LOAD) == 0
+                 || (section->flags & SEC_CODE) == 0

                  || section->reloc_count == 0)
                continue;
 
                  || section->reloc_count == 0)
                continue;
 


@@ -2879,7 +2801,7 @@ elf32_hppa_size_stubs
                     section.  */
                  sym_sec = NULL;
                  sym_value = 0;
                     section.  */
                  sym_sec = NULL;
                  sym_value = 0;

-                 destination = 0;
+                 destination = -1;

                  hh = NULL;
                  if (r_indx < symtab_hdr->sh_info)
                    {
                  hh = NULL;
                  if (r_indx < symtab_hdr->sh_info)
                    {


@@ -3069,9 +2991,9 @@ elf32_hppa_set_gp (bfd *abfd, struct bfd_link_info *info)
            {
              if (strcmp (bfd_get_target (abfd), "elf32-hppa-netbsd") != 0)
                {
            {
              if (strcmp (bfd_get_target (abfd), "elf32-hppa-netbsd") != 0)
                {

-                 /* We know we don't have a .plt.  If .got is large,
+                 /* We know we don't have a .plt.  If .got is large,

                     offset our LTP.  */
                     offset our LTP.  */

-                 if (sec->size > 0x2000)
+                 if (sec->size > 0x2000)

                    gp_val = 0x2000;
                }
            }
                    gp_val = 0x2000;
                }
            }


@@ -3188,7 +3110,7 @@ elf32_hppa_final_link (bfd *abfd, struct bfd_link_info *info)
   /* Do not attempt to sort non-regular files.  This is here
      especially for configure scripts and kernel builds which run
      tests with "ld [...] -o /dev/null".  */
   /* Do not attempt to sort non-regular files.  This is here
      especially for configure scripts and kernel builds which run
      tests with "ld [...] -o /dev/null".  */

-  if (stat (abfd->filename, &buf) != 0
+  if (stat (bfd_get_filename (abfd), &buf) != 0

       || !S_ISREG(buf.st_mode))
     return TRUE;
 
       || !S_ISREG(buf.st_mode))
     return TRUE;
 


@@ -3240,7 +3162,7 @@ final_link_relocate (asection *input_section,
                     struct elf32_hppa_link_hash_entry *hh,
                     struct bfd_link_info *info)
 {
                     struct elf32_hppa_link_hash_entry *hh,
                     struct bfd_link_info *info)
 {

-  int insn;
+  unsigned int insn;

   unsigned int r_type = ELF32_R_TYPE (rela->r_info);
   unsigned int orig_r_type = r_type;
   reloc_howto_type *howto = elf_hppa_howto_table + r_type;
   unsigned int r_type = ELF32_R_TYPE (rela->r_info);
   unsigned int orig_r_type = r_type;
   reloc_howto_type *howto = elf_hppa_howto_table + r_type;


@@ -3309,7 +3231,7 @@ final_link_relocate (asection *input_section,
                  || hh->eh.root.type == bfd_link_hash_defweak)))
        {
          hsh = hppa_get_stub_entry (input_section, sym_sec,
                  || hh->eh.root.type == bfd_link_hash_defweak)))
        {
          hsh = hppa_get_stub_entry (input_section, sym_sec,

-                                           hh, rela, htab);
+                                    hh, rela, htab);

          if (hsh != NULL)
            {
              value = (hsh->stub_offset
          if (hsh != NULL)
            {
              value = (hsh->stub_offset


@@ -3359,7 +3281,7 @@ final_link_relocate (asection *input_section,
              /* GCC sometimes uses a register other than r19 for the
                 operation, so we must convert any addil instruction
                 that uses this relocation.  */
              /* GCC sometimes uses a register other than r19 for the
                 operation, so we must convert any addil instruction
                 that uses this relocation.  */

-             if ((insn & 0xfc000000) == ((int) OP_ADDIL << 26))
+             if ((insn & 0xfc000000) == OP_ADDIL << 26)

                insn = ADDIL_DP;
              else
                /* We must have a ldil instruction.  It's too hard to find
                insn = ADDIL_DP;
              else
                /* We must have a ldil instruction.  It's too hard to find


@@ -3367,10 +3289,11 @@ final_link_relocate (asection *input_section,
                   error.  */
                _bfd_error_handler
                  /* xgettext:c-format */
                   error.  */
                _bfd_error_handler
                  /* xgettext:c-format */

-                 (_("%B(%A+%#Lx): %s fixup for insn %#x is not supported in a non-shared link"),
+                 (_("%pB(%pA+%#" PRIx64 "): %s fixup for insn %#x "
+                    "is not supported in a non-shared link"),

                   input_bfd,
                   input_section,
                   input_bfd,
                   input_section,

-                  offset,
+                  (uint64_t) offset,

                   howto->name,
                   insn);
            }
                   howto->name,
                   insn);
            }


@@ -3392,8 +3315,8 @@ final_link_relocate (asection *input_section,
         instance: "extern int foo" with foo defined as "const int foo".  */
       if (sym_sec == NULL || (sym_sec->flags & SEC_CODE) != 0)
        {
         instance: "extern int foo" with foo defined as "const int foo".  */
       if (sym_sec == NULL || (sym_sec->flags & SEC_CODE) != 0)
        {

-         if ((insn & ((0x3f << 26) | (0x1f << 21)))
-             == (((int) OP_ADDIL << 26) | (27 << 21)))
+         if ((insn & ((0x3fu << 26) | (0x1f << 21)))
+             == ((OP_ADDIL << 26) | (27 << 21)))

            {
              insn &= ~ (0x1f << 21);
            }
            {
              insn &= ~ (0x1f << 21);
            }


@@ -3508,7 +3431,7 @@ final_link_relocate (asection *input_section,
       if (value + addend + max_branch_offset >= 2*max_branch_offset)
        {
          hsh = hppa_get_stub_entry (input_section, sym_sec,
       if (value + addend + max_branch_offset >= 2*max_branch_offset)
        {
          hsh = hppa_get_stub_entry (input_section, sym_sec,

-                                           hh, rela, htab);
+                                    hh, rela, htab);

          if (hsh == NULL)
            return bfd_reloc_undefined;
 
          if (hsh == NULL)
            return bfd_reloc_undefined;
 


@@ -3533,10 +3456,11 @@ final_link_relocate (asection *input_section,
     {
       _bfd_error_handler
        /* xgettext:c-format */
     {
       _bfd_error_handler
        /* xgettext:c-format */

-       (_("%B(%A+%#Lx): cannot reach %s, recompile with -ffunction-sections"),
+       (_("%pB(%pA+%#" PRIx64 "): cannot reach %s, "
+          "recompile with -ffunction-sections"),

         input_bfd,
         input_section,
         input_bfd,
         input_section,

-        offset,
+        (uint64_t) offset,

         hsh->bh_root.string);
       bfd_set_error (bfd_error_bad_value);
       return bfd_reloc_notsupported;
         hsh->bh_root.string);
       bfd_set_error (bfd_error_bad_value);
       return bfd_reloc_notsupported;


@@ -3799,7 +3723,7 @@ elf32_hppa_relocate_section (bfd *output_bfd,
                                                         bfd_link_pic (info),
                                                         &hh->eh))
                    {
                                                         bfd_link_pic (info),
                                                         &hh->eh))
                    {

-                     /* In a non-shared link, adjust_dynamic_symbols
+                     /* In a non-shared link, adjust_dynamic_symbol

                         isn't called for symbols forced local.  We
                         need to write out the plt entry here.  */
                      if ((off & 1) != 0)
                         isn't called for symbols forced local.  We
                         need to write out the plt entry here.  */
                      if ((off & 1) != 0)


@@ -3897,25 +3821,13 @@ elf32_hppa_relocate_section (bfd *output_bfd,
          if ((input_section->flags & SEC_ALLOC) == 0)
            break;
 
          if ((input_section->flags & SEC_ALLOC) == 0)
            break;
 

-         /* The reloc types handled here and this conditional
-            expression must match the code in ..check_relocs and
-            allocate_dynrelocs.  ie. We need exactly the same condition
-            as in ..check_relocs, with some extra conditions (dynindx
-            test in this case) to cater for relocs removed by
-            allocate_dynrelocs.  */
-         if ((bfd_link_pic (info)
-              && !(hh != NULL
-                   && ((hh->eh.root.type == bfd_link_hash_undefined
-                        && ELF_ST_VISIBILITY (hh->eh.other) != STV_DEFAULT)
-                       || UNDEFWEAK_NO_DYNAMIC_RELOC (info, &hh->eh)))
-              && (IS_ABSOLUTE_RELOC (r_type)
-                  || !SYMBOL_CALLS_LOCAL (info, &hh->eh)))
-             || (ELIMINATE_COPY_RELOCS
-                 && !bfd_link_pic (info)
-                 && hh != NULL
-                 && hh->eh.dynindx != -1
-                 && !hh->eh.non_got_ref
-                 && !hh->eh.def_regular))
+         if (bfd_link_pic (info)
+             ? ((hh == NULL
+                 || hh->eh.dyn_relocs != NULL)
+                && ((hh != NULL && pc_dynrelocs (hh))
+                    || IS_ABSOLUTE_RELOC (r_type)))
+             : (hh != NULL
+                && hh->eh.dyn_relocs != NULL))

            {
              Elf_Internal_Rela outrel;
              bfd_boolean skip;
            {
              Elf_Internal_Rela outrel;
              bfd_boolean skip;


@@ -4079,12 +3991,12 @@ elf32_hppa_relocate_section (bfd *output_bfd,
                bfd_byte *loc = NULL;
                int cur_off = off;
 
                bfd_byte *loc = NULL;
                int cur_off = off;
 

-               /* The GOT entries have not been initialized yet.  Do it
-                  now, and emit any relocations.  If both an IE GOT and a
-                  GD GOT are necessary, we emit the GD first.  */
+               /* The GOT entries have not been initialized yet.  Do it
+                  now, and emit any relocations.  If both an IE GOT and a
+                  GD GOT are necessary, we emit the GD first.  */

 
                if (indx != 0
 
                if (indx != 0

-                   || (bfd_link_pic (info)
+                   || (bfd_link_dll (info)

                        && (hh == NULL
                            || !UNDEFWEAK_NO_DYNAMIC_RELOC (info, &hh->eh))))
                  {
                        && (hh == NULL
                            || !UNDEFWEAK_NO_DYNAMIC_RELOC (info, &hh->eh))))
                  {


@@ -4108,29 +4020,32 @@ elf32_hppa_relocate_section (bfd *output_bfd,
                        bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
                        htab->etab.srelgot->reloc_count++;
                        loc += sizeof (Elf32_External_Rela);
                        bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
                        htab->etab.srelgot->reloc_count++;
                        loc += sizeof (Elf32_External_Rela);

+                       bfd_put_32 (output_bfd, 0,
+                                   htab->etab.sgot->contents + cur_off);
+                     }
+                   else
+                     /* If we are not emitting relocations for a
+                        general dynamic reference, then we must be in a
+                        static link or an executable link with the
+                        symbol binding locally.  Mark it as belonging
+                        to module 1, the executable.  */
+                     bfd_put_32 (output_bfd, 1,
+                                 htab->etab.sgot->contents + cur_off);
+
+                   if (indx != 0)
+                     {

                        outrel.r_info
                          = ELF32_R_INFO (indx, R_PARISC_TLS_DTPOFF32);
                        outrel.r_offset += 4;
                        bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
                        htab->etab.srelgot->reloc_count++;
                        loc += sizeof (Elf32_External_Rela);
                        outrel.r_info
                          = ELF32_R_INFO (indx, R_PARISC_TLS_DTPOFF32);
                        outrel.r_offset += 4;
                        bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
                        htab->etab.srelgot->reloc_count++;
                        loc += sizeof (Elf32_External_Rela);

-                       bfd_put_32 (output_bfd, 0,
-                                   htab->etab.sgot->contents + cur_off);

                        bfd_put_32 (output_bfd, 0,
                                    htab->etab.sgot->contents + cur_off + 4);
                      }
                    else
                        bfd_put_32 (output_bfd, 0,
                                    htab->etab.sgot->contents + cur_off + 4);
                      }
                    else

-                     {
-                       /* If we are not emitting relocations for a
-                          general dynamic reference, then we must be in a
-                          static link or an executable link with the
-                          symbol binding locally.  Mark it as belonging
-                          to module 1, the executable.  */
-                       bfd_put_32 (output_bfd, 1,
-                                   htab->etab.sgot->contents + cur_off);
-                       bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
-                                   htab->etab.sgot->contents + cur_off + 4);
-                     }
+                     bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
+                                 htab->etab.sgot->contents + cur_off + 4);

                    cur_off += 8;
                  }
 
                    cur_off += 8;
                  }
 


@@ -4186,9 +4101,9 @@ elf32_hppa_relocate_section (bfd *output_bfd,
                    if (sym_name == NULL)
                      return FALSE;
                    if (*sym_name == '\0')
                    if (sym_name == NULL)
                      return FALSE;
                    if (*sym_name == '\0')

-                     sym_name = bfd_section_name (input_bfd, sym_sec);
+                     sym_name = bfd_section_name (sym_sec);

                    _bfd_error_handler
                    _bfd_error_handler

-                     (_("%B:%s has both normal and TLS relocs"),
+                     (_("%pB:%s has both normal and TLS relocs"),

                       input_bfd, sym_name);
                  }
                bfd_set_error (bfd_error_bad_value);
                       input_bfd, sym_name);
                  }
                bfd_set_error (bfd_error_bad_value);


@@ -4196,8 +4111,8 @@ elf32_hppa_relocate_section (bfd *output_bfd,
              }
 
            if ((tls_type & GOT_TLS_GD)
              }
 
            if ((tls_type & GOT_TLS_GD)

-               && r_type != R_PARISC_TLS_GD21L
-               && r_type != R_PARISC_TLS_GD14R)
+               && r_type != R_PARISC_TLS_GD21L
+               && r_type != R_PARISC_TLS_GD14R)

              off += 2 * GOT_ENTRY_SIZE;
 
            /* Add the base of the GOT to the relocation value.  */
              off += 2 * GOT_ENTRY_SIZE;
 
            /* Add the base of the GOT to the relocation value.  */


@@ -4236,7 +4151,7 @@ elf32_hppa_relocate_section (bfd *output_bfd,
          if (sym_name == NULL)
            return FALSE;
          if (*sym_name == '\0')
          if (sym_name == NULL)
            return FALSE;
          if (*sym_name == '\0')

-           sym_name = bfd_section_name (input_bfd, sym_sec);
+           sym_name = bfd_section_name (sym_sec);

        }
 
       howto = elf_hppa_howto_table + r_type;
        }
 
       howto = elf_hppa_howto_table + r_type;


@@ -4247,10 +4162,10 @@ elf32_hppa_relocate_section (bfd *output_bfd,
            {
              _bfd_error_handler
                /* xgettext:c-format */
            {
              _bfd_error_handler
                /* xgettext:c-format */

-               (_("%B(%A+%#Lx): cannot handle %s for %s"),
+               (_("%pB(%pA+%#" PRIx64 "): cannot handle %s for %s"),

                 input_bfd,
                 input_section,
                 input_bfd,
                 input_section,

-                rela->r_offset,
+                (uint64_t) rela->r_offset,

                 howto->name,
                 sym_name);
              bfd_set_error (bfd_error_bad_value);
                 howto->name,
                 sym_name);
              bfd_set_error (bfd_error_bad_value);


@@ -4431,7 +4346,7 @@ elf32_hppa_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
       case R_PARISC_TLS_DTPMOD32:
       case R_PARISC_TLS_DTPOFF32:
       case R_PARISC_TLS_TPREL32:
       case R_PARISC_TLS_DTPMOD32:
       case R_PARISC_TLS_DTPOFF32:
       case R_PARISC_TLS_TPREL32:

-        return reloc_class_normal;
+       return reloc_class_normal;

     }
 
   if (ELF32_R_SYM (rela->r_info) == STN_UNDEF)
     }
 
   if (ELF32_R_SYM (rela->r_info) == STN_UNDEF)