Update year range in copyright notice of binutils files

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

diff --git a/bfd/elf32-hppa.c b/bfd/elf32-hppa.c
index efab20fbd368249903b4487e1bab1fce02e0dbd3..44129c801388312615ccc9d981b2b477a83bf972 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-2018 Free Software Foundation, Inc.
+   Copyright (C) 1990-2023 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


@@ -136,12 +140,17 @@
 
 #define PLT_ENTRY_SIZE 8
 #define GOT_ENTRY_SIZE 4
 
 #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                 */


@@ -222,10 +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 elf_dyn_relocs *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.  */


@@ -281,9 +286,6 @@ struct elf32_hppa_link_hash_table
   /* Set if we need a .plt stub to support lazy dynamic linking.  */
   unsigned int need_plt_stub:1;
 
   /* Set if we need a .plt stub to support lazy dynamic linking.  */
   unsigned int need_plt_stub:1;
 

-  /* Small local sym cache.  */
-  struct sym_cache sym_cache;
-

   /* Data for LDM relocations.  */
   union
   {
   /* Data for LDM relocations.  */
   union
   {


@@ -294,8 +296,9 @@ struct elf32_hppa_link_hash_table
 
 /* Various hash macros and functions.  */
 #define hppa_link_hash_table(p) \
 
 /* Various hash macros and functions.  */
 #define hppa_link_hash_table(p) \

-  (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
-  == HPPA32_ELF_DATA ? ((struct elf32_hppa_link_hash_table *) ((p)->hash)) : NULL)
+  ((is_elf_hash_table ((p)->hash)                                      \
+    && elf_hash_table_id (elf_hash_table (p)) == HPPA32_ELF_DATA)      \
+   ? (struct elf32_hppa_link_hash_table *) (p)->hash : NULL)

 
 #define hppa_elf_hash_entry(ent) \
   ((struct elf32_hppa_link_hash_entry *)(ent))
 
 #define hppa_elf_hash_entry(ent) \
   ((struct elf32_hppa_link_hash_entry *)(ent))


@@ -381,7 +384,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;
     }


@@ -409,7 +411,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)


@@ -431,6 +433,7 @@ elf32_hppa_link_hash_table_create (bfd *abfd)
       return NULL;
     }
   htab->etab.root.hash_table_free = elf32_hppa_link_hash_table_free;
       return NULL;
     }
   htab->etab.root.hash_table_free = elf32_hppa_link_hash_table_free;

+  htab->etab.dt_pltgot_required = true;

 
   htab->text_segment_base = (bfd_vma) -1;
   htab->data_segment_base = (bfd_vma) -1;
 
   htab->text_segment_base = (bfd_vma) -1;
   htab->data_segment_base = (bfd_vma) -1;


@@ -521,7 +524,7 @@ hppa_get_stub_entry (const asection *input_section,
        return NULL;
 
       hsh_entry = hppa_stub_hash_lookup (&htab->bstab,
        return NULL;
 
       hsh_entry = hppa_stub_hash_lookup (&htab->bstab,

-                                         stub_name, FALSE, FALSE);
+                                         stub_name, false, false);

       if (hh != NULL)
        hh->hsh_cache = hsh_entry;
 
       if (hh != NULL)
        hh->hsh_cache = hsh_entry;
 


@@ -572,7 +575,7 @@ hppa_add_stub (const char *stub_name,
 
   /* Enter this entry into the linker stub hash table.  */
   hsh = hppa_stub_hash_lookup (&htab->bstab, stub_name,
 
   /* Enter this entry into the linker stub hash table.  */
   hsh = hppa_stub_hash_lookup (&htab->bstab, stub_name,

-                                     TRUE, FALSE);
+                                     true, false);

   if (hsh == NULL)
     {
       /* xgettext:c-format */
   if (hsh == NULL)
     {
       /* xgettext:c-format */


@@ -662,6 +665,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)           */


@@ -684,7 +691,7 @@ hppa_type_of_stub (asection *input_sec,
 #define LDW_R1_DLT     LDW_R1_DP
 #endif
 
 #define LDW_R1_DLT     LDW_R1_DP
 #endif
 

-static bfd_boolean
+static bool

 hppa_build_one_stub (struct bfd_hash_entry *bh, void *in_arg)
 {
   struct elf32_hppa_stub_hash_entry *hsh;
 hppa_build_one_stub (struct bfd_hash_entry *bh, void *in_arg)
 {
   struct elf32_hppa_stub_hash_entry *hsh;


@@ -705,7 +712,7 @@ hppa_build_one_stub (struct bfd_hash_entry *bh, void *in_arg)
 
   htab = hppa_link_hash_table (info);
   if (htab == NULL)
 
   htab = hppa_link_hash_table (info);
   if (htab == NULL)

-    return FALSE;
+    return false;

 
   stub_sec = hsh->stub_sec;
 
 
   stub_sec = hsh->stub_sec;
 


@@ -718,6 +725,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.


@@ -734,10 +750,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


@@ -756,7 +781,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:


@@ -776,45 +801,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


@@ -838,7 +867,7 @@ hppa_build_one_stub (struct bfd_hash_entry *bh, void *in_arg)
             (uint64_t) hsh->stub_offset,
             hsh->bh_root.string);
          bfd_set_error (bfd_error_bad_value);
             (uint64_t) hsh->stub_offset,
             hsh->bh_root.string);
          bfd_set_error (bfd_error_bad_value);

-         return FALSE;
+         return false;

        }
 
       val = hppa_field_adjust (sym_value, (bfd_signed_vma) -8, e_fsel) >> 2;
        }
 
       val = hppa_field_adjust (sym_value, (bfd_signed_vma) -8, e_fsel) >> 2;


@@ -858,16 +887,16 @@ 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:
       BFD_FAIL ();
       break;
 
     default:
       BFD_FAIL ();

-      return FALSE;
+      return false;

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

-  return TRUE;
+  return true;

 }
 
 #undef LDIL_R1
 }
 
 #undef LDIL_R1


@@ -894,7 +923,7 @@ hppa_build_one_stub (struct bfd_hash_entry *bh, void *in_arg)
 /* As above, but don't actually build the stub.  Just bump offset so
    we know stub section sizes.  */
 
 /* As above, but don't actually build the stub.  Just bump offset so
    we know stub section sizes.  */
 

-static bfd_boolean
+static bool

 hppa_size_one_stub (struct bfd_hash_entry *bh, void *in_arg)
 {
   struct elf32_hppa_stub_hash_entry *hsh;
 hppa_size_one_stub (struct bfd_hash_entry *bh, void *in_arg)
 {
   struct elf32_hppa_stub_hash_entry *hsh;


@@ -906,27 +935,27 @@ 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;

-  return TRUE;
+  return true;

 }
 
 /* Return nonzero if ABFD represents an HPPA ELF32 file.
    Additionally we set the default architecture and machine.  */
 
 }
 
 /* Return nonzero if ABFD represents an HPPA ELF32 file.
    Additionally we set the default architecture and machine.  */
 

-static bfd_boolean
+static bool

 elf32_hppa_object_p (bfd *abfd)
 {
   Elf_Internal_Ehdr * i_ehdrp;
 elf32_hppa_object_p (bfd *abfd)
 {
   Elf_Internal_Ehdr * i_ehdrp;


@@ -939,7 +968,7 @@ elf32_hppa_object_p (bfd *abfd)
         but the kernel produces corefiles with OSABI=SysV.  */
       if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_GNU &&
          i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_NONE) /* aka SYSV */
         but the kernel produces corefiles with OSABI=SysV.  */
       if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_GNU &&
          i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_NONE) /* aka SYSV */

-       return FALSE;
+       return false;

     }
   else if (strcmp (bfd_get_target (abfd), "elf32-hppa-netbsd") == 0)
     {
     }
   else if (strcmp (bfd_get_target (abfd), "elf32-hppa-netbsd") == 0)
     {


@@ -947,12 +976,12 @@ elf32_hppa_object_p (bfd *abfd)
         but the kernel produces corefiles with OSABI=SysV.  */
       if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_NETBSD &&
          i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_NONE) /* aka SYSV */
         but the kernel produces corefiles with OSABI=SysV.  */
       if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_NETBSD &&
          i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_NONE) /* aka SYSV */

-       return FALSE;
+       return false;

     }
   else
     {
       if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_HPUX)
     }
   else
     {
       if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_HPUX)

-       return FALSE;
+       return false;

     }
 
   flags = i_ehdrp->e_flags;
     }
 
   flags = i_ehdrp->e_flags;


@@ -967,13 +996,13 @@ elf32_hppa_object_p (bfd *abfd)
     case EFA_PARISC_2_0 | EF_PARISC_WIDE:
       return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 25);
     }
     case EFA_PARISC_2_0 | EF_PARISC_WIDE:
       return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 25);
     }

-  return TRUE;
+  return true;

 }
 
 /* Create the .plt and .got sections, and set up our hash table
    short-cuts to various dynamic sections.  */
 
 }
 
 /* Create the .plt and .got sections, and set up our hash table
    short-cuts to various dynamic sections.  */
 

-static bfd_boolean
+static bool

 elf32_hppa_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
 {
   struct elf32_hppa_link_hash_table *htab;
 elf32_hppa_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
 {
   struct elf32_hppa_link_hash_table *htab;


@@ -982,13 +1011,13 @@ elf32_hppa_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
   /* Don't try to create the .plt and .got twice.  */
   htab = hppa_link_hash_table (info);
   if (htab == NULL)
   /* Don't try to create the .plt and .got twice.  */
   htab = hppa_link_hash_table (info);
   if (htab == NULL)

-    return FALSE;
+    return false;

   if (htab->etab.splt != NULL)
   if (htab->etab.splt != NULL)

-    return TRUE;
+    return true;

 
   /* Call the generic code to do most of the work.  */
   if (! _bfd_elf_create_dynamic_sections (abfd, info))
 
   /* Call the generic code to do most of the work.  */
   if (! _bfd_elf_create_dynamic_sections (abfd, info))

-    return FALSE;
+    return false;

 
   /* hppa-linux needs _GLOBAL_OFFSET_TABLE_ to be visible from the main
      application, because __canonicalize_funcptr_for_compare needs it.  */
 
   /* hppa-linux needs _GLOBAL_OFFSET_TABLE_ to be visible from the main
      application, because __canonicalize_funcptr_for_compare needs it.  */


@@ -1010,42 +1039,6 @@ 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
-      && eh_ind->root.type == bfd_link_hash_indirect)
-    {
-      if (hh_dir->dyn_relocs != NULL)
-       {
-         struct elf_dyn_relocs **hdh_pp;
-         struct elf_dyn_relocs *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 elf_dyn_relocs *hdh_q;
-
-             for (hdh_q = hh_dir->dyn_relocs;
-                  hdh_q != NULL;
-                  hdh_q = hdh_q->next)
-               if (hdh_q->sec == hdh_p->sec)
-                 {
-#if RELATIVE_DYNRELOCS
-                   hdh_q->pc_count += hdh_p->pc_count;
-#endif
-                   hdh_q->count += hdh_p->count;
-                   *hdh_pp = hdh_p->next;
-                   break;
-                 }
-             if (hdh_q == NULL)
-               hdh_pp = &hdh_p->next;
-           }
-         *hdh_pp = hh_dir->dyn_relocs;
-       }
-
-      hh_dir->dyn_relocs = hh_ind->dyn_relocs;
-      hh_ind->dyn_relocs = NULL;
-    }
-

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


@@ -1101,7 +1094,7 @@ hppa32_elf_local_refcounts (bfd *abfd)
    table, and dynamic reloc sections.  At this point we haven't
    necessarily read all the input files.  */
 
    table, and dynamic reloc sections.  At this point we haven't
    necessarily read all the input files.  */
 

-static bfd_boolean
+static bool

 elf32_hppa_check_relocs (bfd *abfd,
                         struct bfd_link_info *info,
                         asection *sec,
 elf32_hppa_check_relocs (bfd *abfd,
                         struct bfd_link_info *info,
                         asection *sec,


@@ -1115,11 +1108,11 @@ elf32_hppa_check_relocs (bfd *abfd,
   asection *sreloc;
 
   if (bfd_link_relocatable (info))
   asection *sreloc;
 
   if (bfd_link_relocatable (info))

-    return TRUE;
+    return true;

 
   htab = hppa_link_hash_table (info);
   if (htab == NULL)
 
   htab = hppa_link_hash_table (info);
   if (htab == NULL)

-    return FALSE;
+    return false;

   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
   eh_syms = elf_sym_hashes (abfd);
   sreloc = NULL;
   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
   eh_syms = elf_sym_hashes (abfd);
   sreloc = NULL;


@@ -1249,7 +1242,7 @@ elf32_hppa_check_relocs (bfd *abfd,
                 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);

-             return FALSE;
+             return false;

            }
          /* Fall through.  */
 
            }
          /* Fall through.  */
 


@@ -1267,16 +1260,14 @@ elf32_hppa_check_relocs (bfd *abfd,
             Reconstruct it for later use during GC.  */
        case R_PARISC_GNU_VTINHERIT:
          if (!bfd_elf_gc_record_vtinherit (abfd, sec, &hh->eh, rela->r_offset))
             Reconstruct it for later use during GC.  */
        case R_PARISC_GNU_VTINHERIT:
          if (!bfd_elf_gc_record_vtinherit (abfd, sec, &hh->eh, rela->r_offset))

-           return FALSE;
+           return false;

          continue;
 
          /* This relocation describes which C++ vtable entries are actually
             used.  Record for later use during GC.  */
        case R_PARISC_GNU_VTENTRY:
          continue;
 
          /* 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))
-           return FALSE;
+         if (!bfd_elf_gc_record_vtentry (abfd, sec, &hh->eh, rela->r_addend))
+           return false;

          continue;
 
        case R_PARISC_TLS_GD21L:
          continue;
 
        case R_PARISC_TLS_GD21L:


@@ -1325,7 +1316,7 @@ elf32_hppa_check_relocs (bfd *abfd,
          if (htab->etab.sgot == NULL)
            {
              if (!elf32_hppa_create_dynamic_sections (htab->etab.dynobj, info))
          if (htab->etab.sgot == NULL)
            {
              if (!elf32_hppa_create_dynamic_sections (htab->etab.dynobj, info))

-               return FALSE;
+               return false;

            }
 
          if (hh != NULL)
            }
 
          if (hh != NULL)


@@ -1343,7 +1334,7 @@ elf32_hppa_check_relocs (bfd *abfd,
              /* This is a global offset table entry for a local symbol.  */
              local_got_refcounts = hppa32_elf_local_refcounts (abfd);
              if (local_got_refcounts == NULL)
              /* This is a global offset table entry for a local symbol.  */
              local_got_refcounts = hppa32_elf_local_refcounts (abfd);
              if (local_got_refcounts == NULL)

-               return FALSE;
+               return false;

              if (tls_type == GOT_TLS_LDM)
                htab->tls_ldm_got.refcount += 1;
              else
              if (tls_type == GOT_TLS_LDM)
                htab->tls_ldm_got.refcount += 1;
              else


@@ -1383,7 +1374,7 @@ elf32_hppa_check_relocs (bfd *abfd,
 
                  local_got_refcounts = hppa32_elf_local_refcounts (abfd);
                  if (local_got_refcounts == NULL)
 
                  local_got_refcounts = hppa32_elf_local_refcounts (abfd);
                  if (local_got_refcounts == NULL)

-                   return FALSE;
+                   return false;

                  local_plt_refcounts = (local_got_refcounts
                                         + symtab_hdr->sh_info);
                  local_plt_refcounts[r_symndx] += 1;
                  local_plt_refcounts = (local_got_refcounts
                                         + symtab_hdr->sh_info);
                  local_plt_refcounts[r_symndx] += 1;


@@ -1448,12 +1439,12 @@ elf32_hppa_check_relocs (bfd *abfd,
              if (sreloc == NULL)
                {
                  sreloc = _bfd_elf_make_dynamic_reloc_section
              if (sreloc == NULL)
                {
                  sreloc = _bfd_elf_make_dynamic_reloc_section

-                   (sec, htab->etab.dynobj, 2, abfd, /*rela?*/ TRUE);
+                   (sec, htab->etab.dynobj, 2, abfd, /*rela?*/ true);

 
                  if (sreloc == NULL)
                    {
                      bfd_set_error (bfd_error_bad_value);
 
                  if (sreloc == NULL)
                    {
                      bfd_set_error (bfd_error_bad_value);

-                     return FALSE;
+                     return false;

                    }
                }
 
                    }
                }
 


@@ -1461,7 +1452,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
                {


@@ -1472,10 +1463,10 @@ elf32_hppa_check_relocs (bfd *abfd,
                  void *vpp;
                  Elf_Internal_Sym *isym;
 
                  void *vpp;
                  Elf_Internal_Sym *isym;
 

-                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
+                 isym = bfd_sym_from_r_symndx (&htab->etab.sym_cache,

                                                abfd, r_symndx);
                  if (isym == NULL)
                                                abfd, r_symndx);
                  if (isym == NULL)

-                   return FALSE;
+                   return false;

 
                  sr = bfd_section_from_elf_index (abfd, isym->st_shndx);
                  if (sr == NULL)
 
                  sr = bfd_section_from_elf_index (abfd, isym->st_shndx);
                  if (sr == NULL)


@@ -1490,7 +1481,7 @@ elf32_hppa_check_relocs (bfd *abfd,
                {
                  hdh_p = bfd_alloc (htab->etab.dynobj, sizeof *hdh_p);
                  if (hdh_p == NULL)
                {
                  hdh_p = bfd_alloc (htab->etab.dynobj, sizeof *hdh_p);
                  if (hdh_p == NULL)

-                   return FALSE;
+                   return false;

                  hdh_p->next = *hdh_head;
                  *hdh_head = hdh_p;
                  hdh_p->sec = sec;
                  hdh_p->next = *hdh_head;
                  *hdh_head = hdh_p;
                  hdh_p->sec = sec;


@@ -1509,7 +1500,7 @@ elf32_hppa_check_relocs (bfd *abfd,
        }
     }
 
        }
     }
 

-  return TRUE;
+  return true;

 }
 
 /* Return the section that should be marked against garbage collection
 }
 
 /* Return the section that should be marked against garbage collection


@@ -1535,7 +1526,7 @@ elf32_hppa_gc_mark_hook (asection *sec,
 
 /* Support for core dump NOTE sections.  */
 
 
 /* Support for core dump NOTE sections.  */
 

-static bfd_boolean
+static bool

 elf32_hppa_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
 {
   int offset;
 elf32_hppa_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
 {
   int offset;


@@ -1544,7 +1535,7 @@ elf32_hppa_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
   switch (note->descsz)
     {
       default:
   switch (note->descsz)
     {
       default:

-       return FALSE;
+       return false;

 
       case 396:                /* Linux/hppa */
        /* pr_cursig */
 
       case 396:                /* Linux/hppa */
        /* pr_cursig */


@@ -1565,13 +1556,13 @@ elf32_hppa_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
                                          size, note->descpos + offset);
 }
 
                                          size, note->descpos + offset);
 }
 

-static bfd_boolean
+static bool

 elf32_hppa_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
 {
   switch (note->descsz)
     {
       default:
 elf32_hppa_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
 {
   switch (note->descsz)
     {
       default:

-       return FALSE;
+       return false;

 
       case 124:                /* Linux/hppa elf_prpsinfo.  */
        elf_tdata (abfd)->core->program
 
       case 124:                /* Linux/hppa elf_prpsinfo.  */
        elf_tdata (abfd)->core->program


@@ -1591,7 +1582,7 @@ elf32_hppa_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
       command[n - 1] = '\0';
   }
 
       command[n - 1] = '\0';
   }
 

-  return TRUE;
+  return true;

 }
 
 /* Our own version of hide_symbol, so that we can keep plt entries for
 }
 
 /* Our own version of hide_symbol, so that we can keep plt entries for


@@ -1600,7 +1591,7 @@ elf32_hppa_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
 static void
 elf32_hppa_hide_symbol (struct bfd_link_info *info,
                        struct elf_link_hash_entry *eh,
 static void
 elf32_hppa_hide_symbol (struct bfd_link_info *info,
                        struct elf_link_hash_entry *eh,

-                       bfd_boolean force_local)
+                       bool force_local)

 {
   if (force_local)
     {
 {
   if (force_local)
     {


@@ -1626,41 +1617,22 @@ elf32_hppa_hide_symbol (struct bfd_link_info *info,
     }
 }
 
     }
 }
 

-/* Find any dynamic relocs that apply to read-only sections.  */
-
-static asection *
-readonly_dynrelocs (struct elf_link_hash_entry *eh)
-{
-  struct elf32_hppa_link_hash_entry *hh;
-  struct elf_dyn_relocs *hdh_p;
-
-  hh = hppa_elf_hash_entry (eh);
-  for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->next)
-    {
-      asection *sec = hdh_p->sec->output_section;
-
-      if (sec != NULL && (sec->flags & SEC_READONLY) != 0)
-       return hdh_p->sec;
-    }
-  return NULL;
-}
-

 /* 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.  */
 
 /* 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 bfd_boolean
+static bool

 alias_readonly_dynrelocs (struct elf_link_hash_entry *eh)
 {
   struct elf32_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);
   do
     {
 alias_readonly_dynrelocs (struct elf_link_hash_entry *eh)
 {
   struct elf32_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);
   do
     {

-      if (readonly_dynrelocs (&hh->eh))
-       return TRUE;
+      if (_bfd_elf_readonly_dynrelocs (&hh->eh))
+       return true;

       hh = hppa_elf_hash_entry (hh->eh.u.alias);
     } while (hh != NULL && &hh->eh != eh);
 
       hh = hppa_elf_hash_entry (hh->eh.u.alias);
     } while (hh != NULL && &hh->eh != eh);
 

-  return FALSE;
+  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


@@ -1669,7 +1641,7 @@ alias_readonly_dynrelocs (struct elf_link_hash_entry *eh)
    change the definition to something the rest of the link can
    understand.  */
 
    change the definition to something the rest of the link can
    understand.  */
 

-static bfd_boolean
+static bool

 elf32_hppa_adjust_dynamic_symbol (struct bfd_link_info *info,
                                  struct elf_link_hash_entry *eh)
 {
 elf32_hppa_adjust_dynamic_symbol (struct bfd_link_info *info,
                                  struct elf_link_hash_entry *eh)
 {


@@ -1681,12 +1653,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)
     {

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

       /* Discard dyn_relocs when non-pic if we've decided that a
         function symbol is local.  */
       if (!bfd_link_pic (info) && local)
       /* Discard dyn_relocs when non-pic if we've decided that a
         function symbol is local.  */
       if (!bfd_link_pic (info) && local)

-       hppa_elf_hash_entry (eh)->dyn_relocs = NULL;
+       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


@@ -1716,14 +1688,14 @@ elf32_hppa_adjust_dynamic_symbol (struct bfd_link_info *info,
         be discarded.  */
 
       /* Function symbols can't have copy relocs.  */
         be discarded.  */
 
       /* Function symbols can't have copy relocs.  */

-      return TRUE;
+      return true;

     }
   else
     eh->plt.offset = (bfd_vma) -1;
 
   htab = hppa_link_hash_table (info);
   if (htab == NULL)
     }
   else
     eh->plt.offset = (bfd_vma) -1;
 
   htab = hppa_link_hash_table (info);
   if (htab == NULL)

-    return FALSE;
+    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
 
   /* If this is a weak symbol, and there is a real definition, the
      processor independent code will have arranged for us to see the


@@ -1736,8 +1708,8 @@ elf32_hppa_adjust_dynamic_symbol (struct bfd_link_info *info,
       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->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)

-       hppa_elf_hash_entry (eh)->dyn_relocs = NULL;
-      return TRUE;
+       eh->dyn_relocs = NULL;
+      return true;

     }
 
   /* This is a reference to a symbol defined by a dynamic object which
     }
 
   /* This is a reference to a symbol defined by a dynamic object which


@@ -1748,22 +1720,22 @@ elf32_hppa_adjust_dynamic_symbol (struct bfd_link_info *info,
      For such cases we need not do anything here; the relocations will
      be handled correctly by relocate_section.  */
   if (bfd_link_pic (info))
      For such cases we need not do anything here; the relocations will
      be handled correctly by relocate_section.  */
   if (bfd_link_pic (info))

-    return TRUE;
+    return true;

 
   /* 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)

-    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)

-    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
       && !alias_readonly_dynrelocs (eh))
 
   /* 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
       && !alias_readonly_dynrelocs (eh))

-    return TRUE;
+    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


@@ -1794,13 +1766,13 @@ elf32_hppa_adjust_dynamic_symbol (struct bfd_link_info *info,
     }
 
   /* We no longer want dyn_relocs.  */
     }
 
   /* We no longer want dyn_relocs.  */

-  hppa_elf_hash_entry (eh)->dyn_relocs = NULL;
+  eh->dyn_relocs = NULL;

   return _bfd_elf_adjust_dynamic_copy (info, eh, sec);
 }
 
 /* If EH is undefined, make it dynamic if that makes sense.  */
 
   return _bfd_elf_adjust_dynamic_copy (info, eh, sec);
 }
 
 /* If EH is undefined, make it dynamic if that makes sense.  */
 

-static bfd_boolean
+static bool

 ensure_undef_dynamic (struct bfd_link_info *info,
                      struct elf_link_hash_entry *eh)
 {
 ensure_undef_dynamic (struct bfd_link_info *info,
                      struct elf_link_hash_entry *eh)
 {


@@ -1815,13 +1787,13 @@ ensure_undef_dynamic (struct bfd_link_info *info,
       && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, eh)
       && ELF_ST_VISIBILITY (eh->other) == STV_DEFAULT)
     return bfd_elf_link_record_dynamic_symbol (info, eh);
       && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, eh)
       && ELF_ST_VISIBILITY (eh->other) == STV_DEFAULT)
     return bfd_elf_link_record_dynamic_symbol (info, eh);

-  return TRUE;
+  return true;

 }
 
 /* Allocate space in the .plt for entries that won't have relocations.
    ie. plabel entries.  */
 
 }
 
 /* Allocate space in the .plt for entries that won't have relocations.
    ie. plabel entries.  */
 

-static bfd_boolean
+static bool

 allocate_plt_static (struct elf_link_hash_entry *eh, void *inf)
 {
   struct bfd_link_info *info;
 allocate_plt_static (struct elf_link_hash_entry *eh, void *inf)
 {
   struct bfd_link_info *info;


@@ -1830,19 +1802,19 @@ allocate_plt_static (struct elf_link_hash_entry *eh, void *inf)
   asection *sec;
 
   if (eh->root.type == bfd_link_hash_indirect)
   asection *sec;
 
   if (eh->root.type == bfd_link_hash_indirect)

-    return TRUE;
+    return true;

 
   info = (struct bfd_link_info *) inf;
   hh = hppa_elf_hash_entry (eh);
   htab = hppa_link_hash_table (info);
   if (htab == NULL)
 
   info = (struct bfd_link_info *) inf;
   hh = hppa_elf_hash_entry (eh);
   htab = hppa_link_hash_table (info);
   if (htab == NULL)

-    return FALSE;
+    return false;

 
   if (htab->etab.dynamic_sections_created
       && eh->plt.refcount > 0)
     {
       if (!ensure_undef_dynamic (info, eh))
 
   if (htab->etab.dynamic_sections_created
       && eh->plt.refcount > 0)
     {
       if (!ensure_undef_dynamic (info, eh))

-       return FALSE;
+       return false;

 
       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), eh))
        {
 
       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), eh))
        {


@@ -1876,7 +1848,7 @@ allocate_plt_static (struct elf_link_hash_entry *eh, void *inf)
       eh->needs_plt = 0;
     }
 
       eh->needs_plt = 0;
     }
 

-  return TRUE;
+  return true;

 }
 
 /* Calculate size of GOT entries for symbol given its TLS_TYPE.  */
 }
 
 /* Calculate size of GOT entries for symbol given its TLS_TYPE.  */


@@ -1902,7 +1874,7 @@ got_entries_needed (int tls_type)
 
 static inline unsigned int
 got_relocs_needed (int tls_type, unsigned int need,
 
 static inline unsigned int
 got_relocs_needed (int tls_type, unsigned int need,

-                  bfd_boolean dtprel_known, bfd_boolean tprel_known)
+                  bool dtprel_known, bool tprel_known)

 {
   /* All the entries we allocated need relocs.
      Except for GD and IE with local symbols.  */
 {
   /* All the entries we allocated need relocs.
      Except for GD and IE with local symbols.  */


@@ -1916,7 +1888,7 @@ got_relocs_needed (int tls_type, unsigned int need,
 /* Allocate space in .plt, .got and associated reloc sections for
    global syms.  */
 
 /* Allocate space in .plt, .got and associated reloc sections for
    global syms.  */
 

-static bfd_boolean
+static bool

 allocate_dynrelocs (struct elf_link_hash_entry *eh, void *inf)
 {
   struct bfd_link_info *info;
 allocate_dynrelocs (struct elf_link_hash_entry *eh, void *inf)
 {
   struct bfd_link_info *info;


@@ -1926,12 +1898,12 @@ allocate_dynrelocs (struct elf_link_hash_entry *eh, void *inf)
   struct elf_dyn_relocs *hdh_p;
 
   if (eh->root.type == bfd_link_hash_indirect)
   struct elf_dyn_relocs *hdh_p;
 
   if (eh->root.type == bfd_link_hash_indirect)

-    return TRUE;
+    return true;

 
   info = inf;
   htab = hppa_link_hash_table (info);
   if (htab == NULL)
 
   info = inf;
   htab = hppa_link_hash_table (info);
   if (htab == NULL)

-    return FALSE;
+    return false;

 
   hh = hppa_elf_hash_entry (eh);
 
 
   hh = hppa_elf_hash_entry (eh);
 


@@ -1955,7 +1927,7 @@ allocate_dynrelocs (struct elf_link_hash_entry *eh, void *inf)
       unsigned int need;
 
       if (!ensure_undef_dynamic (info, eh))
       unsigned int need;
 
       if (!ensure_undef_dynamic (info, eh))

-       return FALSE;
+       return false;

 
       sec = htab->etab.sgot;
       eh->got.offset = sec->size;
 
       sec = htab->etab.sgot;
       eh->got.offset = sec->size;


@@ -1968,7 +1940,7 @@ allocate_dynrelocs (struct elf_link_hash_entry *eh, void *inf)
                  && !SYMBOL_REFERENCES_LOCAL (info, eh)))
          && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, eh))
        {
                  && !SYMBOL_REFERENCES_LOCAL (info, eh)))
          && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, eh))
        {

-         bfd_boolean local = SYMBOL_REFERENCES_LOCAL (info, eh);
+         bool local = SYMBOL_REFERENCES_LOCAL (info, eh);

          htab->etab.srelgot->size
            += got_relocs_needed (hh->tls_type, need, local,
                                  local && bfd_link_executable (info));
          htab->etab.srelgot->size
            += got_relocs_needed (hh->tls_type, need, local,
                                  local && bfd_link_executable (info));


@@ -1979,16 +1951,16 @@ 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))
 
   /* 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))

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

 
 

-  if (hh->dyn_relocs == NULL)
-    return TRUE;
+  if (eh->dyn_relocs == NULL)
+    return true;

 
   /* If this is a -Bsymbolic shared link, then we need to discard all
      space allocated for dynamic pc-relative relocs against symbols
 
   /* If this is a -Bsymbolic shared link, then we need to discard all
      space allocated for dynamic pc-relative relocs against symbols


@@ -2002,7 +1974,7 @@ allocate_dynrelocs (struct elf_link_hash_entry *eh, void *inf)
        {
          struct elf_dyn_relocs **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->pc_count;
              hdh_p->pc_count = 0;
            {
              hdh_p->count -= hdh_p->pc_count;
              hdh_p->pc_count = 0;


@@ -2014,10 +1986,10 @@ allocate_dynrelocs (struct elf_link_hash_entry *eh, void *inf)
        }
 #endif
 
        }
 #endif
 

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

        {
          if (!ensure_undef_dynamic (info, eh))
        {
          if (!ensure_undef_dynamic (info, eh))

-           return FALSE;
+           return false;

        }
     }
   else if (ELIMINATE_COPY_RELOCS)
        }
     }
   else if (ELIMINATE_COPY_RELOCS)


@@ -2031,23 +2003,23 @@ allocate_dynrelocs (struct elf_link_hash_entry *eh, void *inf)
          && !ELF_COMMON_DEF_P (eh))
        {
          if (!ensure_undef_dynamic (info, eh))
          && !ELF_COMMON_DEF_P (eh))
        {
          if (!ensure_undef_dynamic (info, eh))

-           return FALSE;
+           return false;

 
          if (eh->dynindx == -1)
 
          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->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);
     }
 

-  return TRUE;
+  return true;

 }
 
 /* This function is called via elf_link_hash_traverse to force
 }
 
 /* This function is called via elf_link_hash_traverse to force


@@ -2057,48 +2029,19 @@ allocate_dynrelocs (struct elf_link_hash_entry *eh, void *inf)
    for all dynamic symbols.  Arguably, this is a bug in
    elf_adjust_dynamic_symbol.  */
 
    for all dynamic symbols.  Arguably, this is a bug in
    elf_adjust_dynamic_symbol.  */
 

-static bfd_boolean
+static bool

 clobber_millicode_symbols (struct elf_link_hash_entry *eh,
 clobber_millicode_symbols (struct elf_link_hash_entry *eh,

-                          struct bfd_link_info *info)
+                          void *info)

 {
   if (eh->type == STT_PARISC_MILLI
       && !eh->forced_local)
 {
   if (eh->type == STT_PARISC_MILLI
       && !eh->forced_local)

-    {
-      elf32_hppa_hide_symbol (info, eh, 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
-       (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
-        sec->owner, eh->root.root.string, sec);
-
-      /* Not an error, just cut short the traversal.  */
-      return FALSE;
-    }
-  return TRUE;
+    elf32_hppa_hide_symbol ((struct bfd_link_info *) info, eh, true);
+  return true;

 }
 
 /* Set the sizes of the dynamic sections.  */
 
 }
 
 /* Set the sizes of the dynamic sections.  */
 

-static bfd_boolean
+static bool

 elf32_hppa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
                                  struct bfd_link_info *info)
 {
 elf32_hppa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
                                  struct bfd_link_info *info)
 {


@@ -2106,11 +2049,11 @@ elf32_hppa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
   bfd *dynobj;
   bfd *ibfd;
   asection *sec;
   bfd *dynobj;
   bfd *ibfd;
   asection *sec;

-  bfd_boolean relocs;
+  bool relocs;

 
   htab = hppa_link_hash_table (info);
   if (htab == NULL)
 
   htab = hppa_link_hash_table (info);
   if (htab == NULL)

-    return FALSE;
+    return false;

 
   dynobj = htab->etab.dynobj;
   if (dynobj == NULL)
 
   dynobj = htab->etab.dynobj;
   if (dynobj == NULL)


@@ -2200,7 +2143,7 @@ elf32_hppa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
                  || (bfd_link_pic (info)
                      && (*local_tls_type & GOT_NORMAL) != 0))
                htab->etab.srelgot->size
                  || (bfd_link_pic (info)
                      && (*local_tls_type & GOT_NORMAL) != 0))
                htab->etab.srelgot->size

-                 += got_relocs_needed (*local_tls_type, need, TRUE,
+                 += got_relocs_needed (*local_tls_type, need, true,

                                        bfd_link_executable (info));
            }
          else
                                        bfd_link_executable (info));
            }
          else


@@ -2259,7 +2202,7 @@ elf32_hppa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
   /* The check_relocs and adjust_dynamic_symbol entry points have
      determined the sizes of the various dynamic sections.  Allocate
      memory for them.  */
   /* The check_relocs and adjust_dynamic_symbol entry points have
      determined the sizes of the various dynamic sections.  Allocate
      memory for them.  */

-  relocs = FALSE;
+  relocs = false;

   for (sec = dynobj->sections; sec != NULL; sec = sec->next)
     {
       if ((sec->flags & SEC_LINKER_CREATED) == 0)
   for (sec = dynobj->sections; sec != NULL; sec = sec->next)
     {
       if ((sec->flags & SEC_LINKER_CREATED) == 0)


@@ -2272,12 +2215,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;
            }


@@ -2286,14 +2230,14 @@ 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 (startswith (bfd_section_name (sec), ".rela"))

        {
          if (sec->size != 0)
            {
              /* Remember whether there are any reloc sections other
                 than .rela.plt.  */
              if (sec != htab->etab.srelplt)
        {
          if (sec->size != 0)
            {
              /* Remember whether there are any reloc sections other
                 than .rela.plt.  */
              if (sec != htab->etab.srelplt)

-               relocs = TRUE;
+               relocs = true;

 
              /* We use the reloc_count field as a counter if we need
                 to copy relocs into the output file.  */
 
              /* We use the reloc_count field as a counter if we need
                 to copy relocs into the output file.  */


@@ -2328,62 +2272,10 @@ elf32_hppa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
         we may not fill in all the reloc sections.  */
       sec->contents = bfd_zalloc (dynobj, sec->size);
       if (sec->contents == NULL)
         we may not fill in all the reloc sections.  */
       sec->contents = bfd_zalloc (dynobj, sec->size);
       if (sec->contents == NULL)

-       return FALSE;
+       return false;

     }
 
     }
 

-  if (htab->etab.dynamic_sections_created)
-    {
-      /* Like IA-64 and HPPA64, always create a DT_PLTGOT.  It
-        actually has nothing to do with the PLT, it is how we
-        communicate the LTP value of a load module to the dynamic
-        linker.  */
-#define add_dynamic_entry(TAG, VAL) \
-  _bfd_elf_add_dynamic_entry (info, TAG, VAL)
-
-      if (!add_dynamic_entry (DT_PLTGOT, 0))
-       return FALSE;
-
-      /* Add some entries to the .dynamic section.  We fill in the
-        values later, in elf32_hppa_finish_dynamic_sections, but we
-        must add the entries now so that we get the correct size for
-        the .dynamic section.  The DT_DEBUG entry is filled in by the
-        dynamic linker and used by the debugger.  */
-      if (bfd_link_executable (info))
-       {
-         if (!add_dynamic_entry (DT_DEBUG, 0))
-           return FALSE;
-       }
-
-      if (htab->etab.srelplt->size != 0)
-       {
-         if (!add_dynamic_entry (DT_PLTRELSZ, 0)
-             || !add_dynamic_entry (DT_PLTREL, DT_RELA)
-             || !add_dynamic_entry (DT_JMPREL, 0))
-           return FALSE;
-       }
-
-      if (relocs)
-       {
-         if (!add_dynamic_entry (DT_RELA, 0)
-             || !add_dynamic_entry (DT_RELASZ, 0)
-             || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
-           return FALSE;
-
-         /* 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);
-
-         if ((info->flags & DF_TEXTREL) != 0)
-           {
-             if (!add_dynamic_entry (DT_TEXTREL, 0))
-               return FALSE;
-           }
-       }
-    }
-#undef add_dynamic_entry
-
-  return TRUE;
+  return _bfd_elf_add_dynamic_tags (output_bfd, info, relocs);

 }
 
 /* External entry points for sizing and building linker stubs.  */
 }
 
 /* External entry points for sizing and building linker stubs.  */


@@ -2400,7 +2292,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)


@@ -2501,7 +2393,7 @@ elf32_hppa_next_input_section (struct bfd_link_info *info, asection *isec)
 static void
 group_sections (struct elf32_hppa_link_hash_table *htab,
                bfd_size_type stub_group_size,
 static void
 group_sections (struct elf32_hppa_link_hash_table *htab,
                bfd_size_type stub_group_size,

-               bfd_boolean stubs_always_before_branch)
+               bool stubs_always_before_branch)

 {
   asection **list = htab->input_list + htab->top_index;
   do
 {
   asection **list = htab->input_list + htab->top_index;
   do


@@ -2514,7 +2406,7 @@ group_sections (struct elf32_hppa_link_hash_table *htab,
          asection *curr;
          asection *prev;
          bfd_size_type total;
          asection *curr;
          asection *prev;
          bfd_size_type total;

-         bfd_boolean big_sec;
+         bool big_sec;

 
          curr = tail;
          total = tail->size;
 
          curr = tail;
          total = tail->size;


@@ -2589,7 +2481,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)


@@ -2669,7 +2561,7 @@ get_local_syms (bfd *output_bfd, bfd *input_bfd, struct bfd_link_info *info)
                  stub_name = hh_name (hh);
                  hsh = hppa_stub_hash_lookup (&htab->bstab,
                                                      stub_name,
                  stub_name = hh_name (hh);
                  hsh = hppa_stub_hash_lookup (&htab->bstab,
                                                      stub_name,

-                                                     FALSE, FALSE);
+                                                     false, false);

                  if (hsh == NULL)
                    {
                      hsh = hppa_add_stub (stub_name, sec, htab);
                  if (hsh == NULL)
                    {
                      hsh = hppa_add_stub (stub_name, sec, htab);


@@ -2702,20 +2594,20 @@ get_local_syms (bfd *output_bfd, bfd *input_bfd, struct bfd_link_info *info)
    PC-relative calls to a target that is unreachable with a "bl"
    instruction.  */
 
    PC-relative calls to a target that is unreachable with a "bl"
    instruction.  */
 

-bfd_boolean
+bool

 elf32_hppa_size_stubs
   (bfd *output_bfd, bfd *stub_bfd, struct bfd_link_info *info,
 elf32_hppa_size_stubs
   (bfd *output_bfd, bfd *stub_bfd, struct bfd_link_info *info,

-   bfd_boolean multi_subspace, bfd_signed_vma group_size,
+   bool multi_subspace, bfd_signed_vma group_size,

    asection * (*add_stub_section) (const char *, asection *),
    void (*layout_sections_again) (void))
 {
   bfd_size_type stub_group_size;
    asection * (*add_stub_section) (const char *, asection *),
    void (*layout_sections_again) (void))
 {
   bfd_size_type stub_group_size;

-  bfd_boolean stubs_always_before_branch;
-  bfd_boolean stub_changed;
+  bool stubs_always_before_branch;
+  bool stub_changed;

   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)

-    return FALSE;
+    return false;

 
   /* Stash our params away.  */
   htab->stub_bfd = stub_bfd;
 
   /* Stash our params away.  */
   htab->stub_bfd = stub_bfd;


@@ -2755,14 +2647,14 @@ elf32_hppa_size_stubs
     default:
       if (htab->all_local_syms)
        goto error_ret_free_local;
     default:
       if (htab->all_local_syms)
        goto error_ret_free_local;

-      return FALSE;
+      return false;

 
     case 0:
 
     case 0:

-      stub_changed = FALSE;
+      stub_changed = false;

       break;
 
     case 1:
       break;
 
     case 1:

-      stub_changed = TRUE;
+      stub_changed = true;

       break;
     }
 
       break;
     }
 


@@ -2933,7 +2825,7 @@ elf32_hppa_size_stubs
 
                  hsh = hppa_stub_hash_lookup (&htab->bstab,
                                                      stub_name,
 
                  hsh = hppa_stub_hash_lookup (&htab->bstab,
                                                      stub_name,

-                                                     FALSE, FALSE);
+                                                     false, false);

                  if (hsh != NULL)
                    {
                      /* The proper stub has already been created.  */
                  if (hsh != NULL)
                    {
                      /* The proper stub has already been created.  */


@@ -2959,7 +2851,7 @@ elf32_hppa_size_stubs
                        hsh->stub_type = hppa_stub_long_branch_shared;
                    }
                  hsh->hh = hh;
                        hsh->stub_type = hppa_stub_long_branch_shared;
                    }
                  hsh->hh = hh;

-                 stub_changed = TRUE;
+                 stub_changed = true;

                }
 
              /* We're done with the internal relocs, free them.  */
                }
 
              /* We're done with the internal relocs, free them.  */


@@ -2983,28 +2875,28 @@ elf32_hppa_size_stubs
 
       /* Ask the linker to do its stuff.  */
       (*htab->layout_sections_again) ();
 
       /* Ask the linker to do its stuff.  */
       (*htab->layout_sections_again) ();

-      stub_changed = FALSE;
+      stub_changed = false;

     }
 
   free (htab->all_local_syms);
     }
 
   free (htab->all_local_syms);

-  return TRUE;
+  return true;

 
  error_ret_free_local:
   free (htab->all_local_syms);
 
  error_ret_free_local:
   free (htab->all_local_syms);

-  return FALSE;
+  return false;

 }
 
 /* For a final link, this function is called after we have sized the
    stubs to provide a value for __gp.  */
 
 }
 
 /* For a final link, this function is called after we have sized the
    stubs to provide a value for __gp.  */
 

-bfd_boolean
+bool

 elf32_hppa_set_gp (bfd *abfd, struct bfd_link_info *info)
 {
   struct bfd_link_hash_entry *h;
   asection *sec = NULL;
   bfd_vma gp_val = 0;
 
 elf32_hppa_set_gp (bfd *abfd, struct bfd_link_info *info)
 {
   struct bfd_link_hash_entry *h;
   asection *sec = NULL;
   bfd_vma gp_val = 0;
 

-  h = bfd_link_hash_lookup (info->hash, "$global$", FALSE, FALSE, FALSE);
+  h = bfd_link_hash_lookup (info->hash, "$global$", false, false, false);

 
   if (h != NULL
       && (h->type == bfd_link_hash_defined
 
   if (h != NULL
       && (h->type == bfd_link_hash_defined


@@ -3074,7 +2966,7 @@ elf32_hppa_set_gp (bfd *abfd, struct bfd_link_info *info)
 
       elf_gp (abfd) = gp_val;
     }
 
       elf_gp (abfd) = gp_val;
     }

-  return TRUE;
+  return true;

 }
 
 /* Build all the stubs associated with the current output file.  The
 }
 
 /* Build all the stubs associated with the current output file.  The


@@ -3083,7 +2975,7 @@ elf32_hppa_set_gp (bfd *abfd, struct bfd_link_info *info)
    functions here.  This function is called via hppaelf_finish in the
    linker.  */
 
    functions here.  This function is called via hppaelf_finish in the
    linker.  */
 

-bfd_boolean
+bool

 elf32_hppa_build_stubs (struct bfd_link_info *info)
 {
   asection *stub_sec;
 elf32_hppa_build_stubs (struct bfd_link_info *info)
 {
   asection *stub_sec;


@@ -3092,7 +2984,7 @@ elf32_hppa_build_stubs (struct bfd_link_info *info)
 
   htab = hppa_link_hash_table (info);
   if (htab == NULL)
 
   htab = hppa_link_hash_table (info);
   if (htab == NULL)

-    return FALSE;
+    return false;

 
   for (stub_sec = htab->stub_bfd->sections;
        stub_sec != NULL;
 
   for (stub_sec = htab->stub_bfd->sections;
        stub_sec != NULL;


@@ -3103,7 +2995,7 @@ elf32_hppa_build_stubs (struct bfd_link_info *info)
        /* Allocate memory to hold the linker stubs.  */
        stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size);
        if (stub_sec->contents == NULL)
        /* Allocate memory to hold the linker stubs.  */
        stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size);
        if (stub_sec->contents == NULL)

-         return FALSE;
+         return false;

        stub_sec->size = 0;
       }
 
        stub_sec->size = 0;
       }
 


@@ -3111,7 +3003,7 @@ elf32_hppa_build_stubs (struct bfd_link_info *info)
   table = &htab->bstab;
   bfd_hash_traverse (table, hppa_build_one_stub, info);
 
   table = &htab->bstab;
   bfd_hash_traverse (table, hppa_build_one_stub, info);
 

-  return TRUE;
+  return true;

 }
 
 /* Return the base vma address which should be subtracted from the real
 }
 
 /* Return the base vma address which should be subtracted from the real


@@ -3145,26 +3037,26 @@ tpoff (struct bfd_link_info *info, bfd_vma address)
 
 /* Perform a final link.  */
 
 
 /* Perform a final link.  */
 

-static bfd_boolean
+static bool

 elf32_hppa_final_link (bfd *abfd, struct bfd_link_info *info)
 {
   struct stat buf;
 
   /* Invoke the regular ELF linker to do all the work.  */
   if (!bfd_elf_final_link (abfd, info))
 elf32_hppa_final_link (bfd *abfd, struct bfd_link_info *info)
 {
   struct stat buf;
 
   /* Invoke the regular ELF linker to do all the work.  */
   if (!bfd_elf_final_link (abfd, info))

-    return FALSE;
+    return false;

 
   /* If we're producing a final executable, sort the contents of the
      unwind section.  */
   if (bfd_link_relocatable (info))
 
   /* If we're producing a final executable, sort the contents of the
      unwind section.  */
   if (bfd_link_relocatable (info))

-    return TRUE;
+    return true;

 
   /* 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))
       || !S_ISREG(buf.st_mode))

-    return TRUE;
+    return true;

 
   return elf_hppa_sort_unwind (abfd);
 }
 
   return elf_hppa_sort_unwind (abfd);
 }


@@ -3214,7 +3106,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;


@@ -3333,7 +3225,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,8 +3259,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);
            }


@@ -3549,7 +3441,7 @@ final_link_relocate (asection *input_section,
 
 /* Relocate an HPPA ELF section.  */
 
 
 /* Relocate an HPPA ELF section.  */
 

-static bfd_boolean
+static int

 elf32_hppa_relocate_section (bfd *output_bfd,
                             struct bfd_link_info *info,
                             bfd *input_bfd,
 elf32_hppa_relocate_section (bfd *output_bfd,
                             struct bfd_link_info *info,
                             bfd *input_bfd,


@@ -3569,7 +3461,7 @@ elf32_hppa_relocate_section (bfd *output_bfd,
 
   htab = hppa_link_hash_table (info);
   if (htab == NULL)
 
   htab = hppa_link_hash_table (info);
   if (htab == NULL)

-    return FALSE;
+    return false;

 
   local_got_offsets = elf_local_got_offsets (input_bfd);
 
 
   local_got_offsets = elf_local_got_offsets (input_bfd);
 


@@ -3586,14 +3478,14 @@ elf32_hppa_relocate_section (bfd *output_bfd,
       bfd_vma relocation;
       bfd_reloc_status_type rstatus;
       const char *sym_name;
       bfd_vma relocation;
       bfd_reloc_status_type rstatus;
       const char *sym_name;

-      bfd_boolean plabel;
-      bfd_boolean warned_undef;
+      bool plabel;
+      bool warned_undef;

 
       r_type = ELF32_R_TYPE (rela->r_info);
       if (r_type >= (unsigned int) R_PARISC_UNIMPLEMENTED)
        {
          bfd_set_error (bfd_error_bad_value);
 
       r_type = ELF32_R_TYPE (rela->r_info);
       if (r_type >= (unsigned int) R_PARISC_UNIMPLEMENTED)
        {
          bfd_set_error (bfd_error_bad_value);

-         return FALSE;
+         return false;

        }
       if (r_type == (unsigned int) R_PARISC_GNU_VTENTRY
          || r_type == (unsigned int) R_PARISC_GNU_VTINHERIT)
        }
       if (r_type == (unsigned int) R_PARISC_GNU_VTENTRY
          || r_type == (unsigned int) R_PARISC_GNU_VTINHERIT)


@@ -3603,7 +3495,7 @@ elf32_hppa_relocate_section (bfd *output_bfd,
       hh = NULL;
       sym = NULL;
       sym_sec = NULL;
       hh = NULL;
       sym = NULL;
       sym_sec = NULL;

-      warned_undef = FALSE;
+      warned_undef = false;

       if (r_symndx < symtab_hdr->sh_info)
        {
          /* This is a local symbol, h defaults to NULL.  */
       if (r_symndx < symtab_hdr->sh_info)
        {
          /* This is a local symbol, h defaults to NULL.  */


@@ -3614,7 +3506,7 @@ elf32_hppa_relocate_section (bfd *output_bfd,
       else
        {
          struct elf_link_hash_entry *eh;
       else
        {
          struct elf_link_hash_entry *eh;

-         bfd_boolean unresolved_reloc, ignored;
+         bool unresolved_reloc, ignored;

          struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
 
          RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rela,
          struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
 
          RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rela,


@@ -3635,8 +3527,8 @@ elf32_hppa_relocate_section (bfd *output_bfd,
                {
                  (*info->callbacks->undefined_symbol)
                    (info, eh_name (eh), input_bfd,
                {
                  (*info->callbacks->undefined_symbol)
                    (info, eh_name (eh), input_bfd,

-                    input_section, rela->r_offset, FALSE);
-                 warned_undef = TRUE;
+                    input_section, rela->r_offset, false);
+                 warned_undef = true;

                }
            }
          hh = hppa_elf_hash_entry (eh);
                }
            }
          hh = hppa_elf_hash_entry (eh);


@@ -3662,14 +3554,14 @@ elf32_hppa_relocate_section (bfd *output_bfd,
        case R_PARISC_DLTIND21L:
          {
            bfd_vma off;
        case R_PARISC_DLTIND21L:
          {
            bfd_vma off;

-           bfd_boolean do_got = FALSE;
-           bfd_boolean reloc = bfd_link_pic (info);
+           bool do_got = false;
+           bool reloc = bfd_link_pic (info);

 
            /* Relocation is to the entry for this symbol in the
               global offset table.  */
            if (hh != NULL)
              {
 
            /* Relocation is to the entry for this symbol in the
               global offset table.  */
            if (hh != NULL)
              {

-               bfd_boolean dyn;
+               bool dyn;

 
                off = hh->eh.got.offset;
                dyn = htab->etab.dynamic_sections_created;
 
                off = hh->eh.got.offset;
                dyn = htab->etab.dynamic_sections_created;


@@ -3693,7 +3585,7 @@ elf32_hppa_relocate_section (bfd *output_bfd,
                    else
                      {
                        hh->eh.got.offset |= 1;
                    else
                      {
                        hh->eh.got.offset |= 1;

-                       do_got = TRUE;
+                       do_got = true;

                      }
                  }
              }
                      }
                  }
              }


@@ -3713,7 +3605,7 @@ elf32_hppa_relocate_section (bfd *output_bfd,
                else
                  {
                    local_got_offsets[r_symndx] |= 1;
                else
                  {
                    local_got_offsets[r_symndx] |= 1;

-                   do_got = TRUE;
+                   do_got = true;

                  }
              }
 
                  }
              }
 


@@ -3765,7 +3657,7 @@ elf32_hppa_relocate_section (bfd *output_bfd,
          if (htab->etab.dynamic_sections_created)
            {
              bfd_vma off;
          if (htab->etab.dynamic_sections_created)
            {
              bfd_vma off;

-             bfd_boolean do_plt = 0;
+             bool do_plt = 0;

              /* If we have a global symbol with a PLT slot, then
                 redirect this relocation to it.  */
              if (hh != NULL)
              /* If we have a global symbol with a PLT slot, then
                 redirect this relocation to it.  */
              if (hh != NULL)


@@ -3875,14 +3767,14 @@ elf32_hppa_relocate_section (bfd *output_bfd,
 
          if (bfd_link_pic (info)
              ? ((hh == NULL
 
          if (bfd_link_pic (info)
              ? ((hh == NULL

-                 || hh->dyn_relocs != NULL)
+                 || hh->eh.dyn_relocs != NULL)

                 && ((hh != NULL && pc_dynrelocs (hh))
                     || IS_ABSOLUTE_RELOC (r_type)))
              : (hh != NULL
                 && ((hh != NULL && pc_dynrelocs (hh))
                     || IS_ABSOLUTE_RELOC (r_type)))
              : (hh != NULL

-                && hh->dyn_relocs != NULL))
+                && hh->eh.dyn_relocs != NULL))

            {
              Elf_Internal_Rela outrel;
            {
              Elf_Internal_Rela outrel;

-             bfd_boolean skip;
+             bool skip;

              asection *sreloc;
              bfd_byte *loc;
 
              asection *sreloc;
              bfd_byte *loc;
 


@@ -4038,7 +3930,7 @@ elf32_hppa_relocate_section (bfd *output_bfd,
              off &= ~1;
            else
              {
              off &= ~1;
            else
              {

-               bfd_boolean need_relocs = FALSE;
+               bool need_relocs = false;

                Elf_Internal_Rela outrel;
                bfd_byte *loc = NULL;
                int cur_off = off;
                Elf_Internal_Rela outrel;
                bfd_byte *loc = NULL;
                int cur_off = off;


@@ -4052,7 +3944,7 @@ elf32_hppa_relocate_section (bfd *output_bfd,
                        && (hh == NULL
                            || !UNDEFWEAK_NO_DYNAMIC_RELOC (info, &hh->eh))))
                  {
                        && (hh == NULL
                            || !UNDEFWEAK_NO_DYNAMIC_RELOC (info, &hh->eh))))
                  {

-                   need_relocs = TRUE;
+                   need_relocs = true;

                    loc = htab->etab.srelgot->contents;
                    loc += (htab->etab.srelgot->reloc_count
                            * sizeof (Elf32_External_Rela));
                    loc = htab->etab.srelgot->contents;
                    loc += (htab->etab.srelgot->reloc_count
                            * sizeof (Elf32_External_Rela));


@@ -4142,24 +4034,24 @@ elf32_hppa_relocate_section (bfd *output_bfd,
                else
                  {
                    Elf_Internal_Sym *isym
                else
                  {
                    Elf_Internal_Sym *isym

-                     = bfd_sym_from_r_symndx (&htab->sym_cache,
+                     = bfd_sym_from_r_symndx (&htab->etab.sym_cache,

                                               input_bfd, r_symndx);
                    if (isym == NULL)
                                               input_bfd, r_symndx);
                    if (isym == NULL)

-                     return FALSE;
+                     return false;

                    sym_name
                      = bfd_elf_string_from_elf_section (input_bfd,
                                                         symtab_hdr->sh_link,
                                                         isym->st_name);
                    if (sym_name == NULL)
                    sym_name
                      = bfd_elf_string_from_elf_section (input_bfd,
                                                         symtab_hdr->sh_link,
                                                         isym->st_name);
                    if (sym_name == NULL)

-                     return FALSE;
+                     return false;

                    if (*sym_name == '\0')
                    if (*sym_name == '\0')

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

                    _bfd_error_handler
                      (_("%pB:%s has both normal and TLS relocs"),
                       input_bfd, sym_name);
                  }
                bfd_set_error (bfd_error_bad_value);
                    _bfd_error_handler
                      (_("%pB:%s has both normal and TLS relocs"),
                       input_bfd, sym_name);
                  }
                bfd_set_error (bfd_error_bad_value);

-               return FALSE;
+               return false;

              }
 
            if ((tls_type & GOT_TLS_GD)
              }
 
            if ((tls_type & GOT_TLS_GD)


@@ -4201,9 +4093,9 @@ elf32_hppa_relocate_section (bfd *output_bfd,
                                                      symtab_hdr->sh_link,
                                                      sym->st_name);
          if (sym_name == NULL)
                                                      symtab_hdr->sh_link,
                                                      sym->st_name);
          if (sym_name == NULL)

-           return FALSE;
+           return false;

          if (*sym_name == '\0')
          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;


@@ -4221,7 +4113,7 @@ elf32_hppa_relocate_section (bfd *output_bfd,
                 howto->name,
                 sym_name);
              bfd_set_error (bfd_error_bad_value);
                 howto->name,
                 sym_name);
              bfd_set_error (bfd_error_bad_value);

-             return FALSE;
+             return false;

            }
        }
       else
            }
        }
       else


@@ -4230,13 +4122,13 @@ elf32_hppa_relocate_section (bfd *output_bfd,
           (bfd_vma) 0, input_bfd, input_section, rela->r_offset);
     }
 
           (bfd_vma) 0, input_bfd, input_section, rela->r_offset);
     }
 

-  return TRUE;
+  return true;

 }
 
 /* Finish up dynamic symbol handling.  We set the contents of various
    dynamic sections here.  */
 
 }
 
 /* Finish up dynamic symbol handling.  We set the contents of various
    dynamic sections here.  */
 

-static bfd_boolean
+static bool

 elf32_hppa_finish_dynamic_symbol (bfd *output_bfd,
                                  struct bfd_link_info *info,
                                  struct elf_link_hash_entry *eh,
 elf32_hppa_finish_dynamic_symbol (bfd *output_bfd,
                                  struct bfd_link_info *info,
                                  struct elf_link_hash_entry *eh,


@@ -4248,7 +4140,7 @@ elf32_hppa_finish_dynamic_symbol (bfd *output_bfd,
 
   htab = hppa_link_hash_table (info);
   if (htab == NULL)
 
   htab = hppa_link_hash_table (info);
   if (htab == NULL)

-    return FALSE;
+    return false;

 
   if (eh->plt.offset != (bfd_vma) -1)
     {
 
   if (eh->plt.offset != (bfd_vma) -1)
     {


@@ -4307,8 +4199,8 @@ elf32_hppa_finish_dynamic_symbol (bfd *output_bfd,
       && (hppa_elf_hash_entry (eh)->tls_type & GOT_NORMAL) != 0
       && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, eh))
     {
       && (hppa_elf_hash_entry (eh)->tls_type & GOT_NORMAL) != 0
       && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, eh))
     {

-      bfd_boolean is_dyn = (eh->dynindx != -1
-                           && !SYMBOL_REFERENCES_LOCAL (info, eh));
+      bool is_dyn = (eh->dynindx != -1
+                    && !SYMBOL_REFERENCES_LOCAL (info, eh));

 
       if (is_dyn || bfd_link_pic (info))
        {
 
       if (is_dyn || bfd_link_pic (info))
        {


@@ -4379,7 +4271,7 @@ elf32_hppa_finish_dynamic_symbol (bfd *output_bfd,
       sym->st_shndx = SHN_ABS;
     }
 
       sym->st_shndx = SHN_ABS;
     }
 

-  return TRUE;
+  return true;

 }
 
 /* Used to decide how to sort relocs in an optimal manner for the
 }
 
 /* Used to decide how to sort relocs in an optimal manner for the


@@ -4417,7 +4309,7 @@ elf32_hppa_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
 
 /* Finish up the dynamic sections.  */
 
 
 /* Finish up the dynamic sections.  */
 

-static bfd_boolean
+static bool

 elf32_hppa_finish_dynamic_sections (bfd *output_bfd,
                                    struct bfd_link_info *info)
 {
 elf32_hppa_finish_dynamic_sections (bfd *output_bfd,
                                    struct bfd_link_info *info)
 {


@@ -4428,7 +4320,7 @@ elf32_hppa_finish_dynamic_sections (bfd *output_bfd,
 
   htab = hppa_link_hash_table (info);
   if (htab == NULL)
 
   htab = hppa_link_hash_table (info);
   if (htab == NULL)

-    return FALSE;
+    return false;

 
   dynobj = htab->etab.dynobj;
 
 
   dynobj = htab->etab.dynobj;
 


@@ -4436,7 +4328,7 @@ elf32_hppa_finish_dynamic_sections (bfd *output_bfd,
   /* A broken linker script might have discarded the dynamic sections.
      Catch this here so that we do not seg-fault later on.  */
   if (sgot != NULL && bfd_is_abs_section (sgot->output_section))
   /* A broken linker script might have discarded the dynamic sections.
      Catch this here so that we do not seg-fault later on.  */
   if (sgot != NULL && bfd_is_abs_section (sgot->output_section))

-    return FALSE;
+    return false;

 
   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
 
 
   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
 


@@ -4519,12 +4411,12 @@ elf32_hppa_finish_dynamic_sections (bfd *output_bfd,
            {
              _bfd_error_handler
                (_(".got section not immediately after .plt section"));
            {
              _bfd_error_handler
                (_(".got section not immediately after .plt section"));

-             return FALSE;
+             return false;

            }
        }
     }
 
            }
        }
     }
 

-  return TRUE;
+  return true;

 }
 
 /* Called when writing out an object file to decide the type of a
 }
 
 /* Called when writing out an object file to decide the type of a