Use bool in bfd

	* sysdep.h: POISON_BFD_BOOLEAN: Define.
	* aix5ppc-core.c, * aout-cris.c, * aout-ns32k.c, * aout-target.h,
	* aoutx.h, * arc-got.h, * archive.c, * archive64.c, * archures.c,
	* bfd-in.h, * bfd.c, * bfdwin.c, * binary.c, * cache.c,
	* coff-alpha.c, * coff-arm.c, * coff-arm.h, * coff-bfd.c,
	* coff-bfd.h, * coff-go32.c, * coff-i386.c, * coff-ia64.c,
	* coff-mcore.c, * coff-mips.c, * coff-rs6000.c, * coff-sh.c,
	* coff-stgo32.c, * coff-tic30.c, * coff-tic4x.c, * coff-tic54x.c,
	* coff-x86_64.c, * coff-z80.c, * coff-z8k.c, * coff64-rs6000.c,
	* coffcode.h, * coffgen.c, * cofflink.c, * compress.c,
	* corefile.c, * cpu-aarch64.c, * cpu-aarch64.h, * cpu-alpha.c,
	* cpu-arc.c, * cpu-arm.c, * cpu-arm.h, * cpu-avr.c, * cpu-bfin.c,
	* cpu-bpf.c, * cpu-cr16.c, * cpu-cris.c, * cpu-crx.c,
	* cpu-csky.c, * cpu-d10v.c, * cpu-d30v.c, * cpu-dlx.c,
	* cpu-epiphany.c, * cpu-fr30.c, * cpu-frv.c, * cpu-ft32.c,
	* cpu-h8300.c, * cpu-hppa.c, * cpu-i386.c, * cpu-ia64.c,
	* cpu-iamcu.c, * cpu-ip2k.c, * cpu-iq2000.c, * cpu-k1om.c,
	* cpu-l1om.c, * cpu-lm32.c, * cpu-m10200.c, * cpu-m10300.c,
	* cpu-m32c.c, * cpu-m32r.c, * cpu-m68hc11.c, * cpu-m68hc12.c,
	* cpu-m68k.c, * cpu-m9s12x.c, * cpu-m9s12xg.c, * cpu-mcore.c,
	* cpu-mep.c, * cpu-metag.c, * cpu-microblaze.c, * cpu-mips.c,
	* cpu-mmix.c, * cpu-moxie.c, * cpu-msp430.c, * cpu-mt.c,
	* cpu-nds32.c, * cpu-nfp.c, * cpu-nios2.c, * cpu-ns32k.c,
	* cpu-or1k.c, * cpu-pdp11.c, * cpu-pj.c, * cpu-powerpc.c,
	* cpu-pru.c, * cpu-riscv.c, * cpu-rl78.c, * cpu-rs6000.c,
	* cpu-rx.c, * cpu-s12z.c, * cpu-s390.c, * cpu-score.c,
	* cpu-sh.c, * cpu-sparc.c, * cpu-spu.c, * cpu-tic30.c,
	* cpu-tic4x.c, * cpu-tic54x.c, * cpu-tic6x.c, * cpu-tilegx.c,
	* cpu-tilepro.c, * cpu-v850.c, * cpu-v850_rh850.c, * cpu-vax.c,
	* cpu-visium.c, * cpu-wasm32.c, * cpu-xc16x.c, * cpu-xgate.c,
	* cpu-xstormy16.c, * cpu-xtensa.c, * cpu-z80.c, * cpu-z8k.c,
	* dwarf1.c, * dwarf2.c, * ecoff-bfd.h, * ecoff.c, * ecofflink.c,
	* elf-attrs.c, * elf-bfd.h, * elf-eh-frame.c, * elf-hppa.h,
	* elf-ifunc.c, * elf-m10200.c, * elf-m10300.c, * elf-nacl.c,
	* elf-nacl.h, * elf-properties.c, * elf-s390-common.c,
	* elf-s390.h, * elf-strtab.c, * elf-vxworks.c, * elf-vxworks.h,
	* elf.c, * elf32-am33lin.c, * elf32-arc.c, * elf32-arm.c,
	* elf32-arm.h, * elf32-avr.c, * elf32-avr.h, * elf32-bfin.c,
	* elf32-bfin.h, * elf32-cr16.c, * elf32-cr16.h, * elf32-cris.c,
	* elf32-crx.c, * elf32-csky.c, * elf32-csky.h, * elf32-d10v.c,
	* elf32-d30v.c, * elf32-dlx.c, * elf32-epiphany.c,
	* elf32-fr30.c, * elf32-frv.c, * elf32-ft32.c, * elf32-gen.c,
	* elf32-h8300.c, * elf32-hppa.c, * elf32-hppa.h, * elf32-i386.c,
	* elf32-ip2k.c, * elf32-iq2000.c, * elf32-lm32.c, * elf32-m32c.c,
	* elf32-m32r.c, * elf32-m68hc11.c, * elf32-m68hc12.c,
	* elf32-m68hc1x.c, * elf32-m68hc1x.h, * elf32-m68k.c,
	* elf32-m68k.h, * elf32-mcore.c, * elf32-mep.c, * elf32-metag.c,
	* elf32-metag.h, * elf32-microblaze.c, * elf32-mips.c,
	* elf32-moxie.c, * elf32-msp430.c, * elf32-mt.c, * elf32-nds32.c,
	* elf32-nios2.c, * elf32-nios2.h, * elf32-or1k.c, * elf32-pj.c,
	* elf32-ppc.c, * elf32-ppc.h, * elf32-pru.c, * elf32-rl78.c,
	* elf32-rx.c, * elf32-s12z.c, * elf32-s390.c, * elf32-score.c,
	* elf32-score.h, * elf32-score7.c, * elf32-sh-relocs.h,
	* elf32-sh.c, * elf32-sparc.c, * elf32-spu.c, * elf32-spu.h,
	* elf32-tic6x.c, * elf32-tic6x.h, * elf32-tilegx.c,
	* elf32-tilepro.c, * elf32-v850.c, * elf32-v850.h,
	* elf32-vax.c, * elf32-visium.c, * elf32-wasm32.c,
	* elf32-xc16x.c, * elf32-xgate.c, * elf32-xstormy16.c,
	* elf32-xtensa.c, * elf32-z80.c, * elf64-alpha.c, * elf64-bpf.c,
	* elf64-gen.c, * elf64-hppa.c, * elf64-ia64-vms.c,
	* elf64-mips.c, * elf64-mmix.c, * elf64-nfp.c, * elf64-ppc.c,
	* elf64-ppc.h, * elf64-s390.c, * elf64-sparc.c,
	* elf64-tilegx.c, * elf64-x86-64.c, * elfcode.h,
	* elfcore.h, * elflink.c, * elfn32-mips.c, * elfnn-aarch64.c,
	* elfnn-ia64.c, * elfnn-riscv.c, * elfxx-aarch64.c,
	* elfxx-aarch64.h, * elfxx-ia64.c, * elfxx-ia64.h,
	* elfxx-mips.c, * elfxx-mips.h, * elfxx-riscv.c, * elfxx-riscv.h,
	* elfxx-sparc.c, * elfxx-sparc.h, * elfxx-target.h,
	* elfxx-tilegx.c, * elfxx-tilegx.h, * elfxx-x86.c, * elfxx-x86.h,
	* format.c, * genlink.h, * hash.c, * i386aout.c, * i386lynx.c,
	* i386msdos.c, * ihex.c, * libaout.h, * libbfd-in.h,
	* libbfd.c, * libcoff-in.h, * libecoff.h, * libpei.h,
	* libxcoff.h, * linker.c, * mach-o-aarch64.c, * mach-o-arm.c,
	* mach-o-i386.c, * mach-o-x86-64.c, * mach-o.c, * mach-o.h,
	* merge.c, * mmo.c, * netbsd.h, * opncls.c, * pc532-mach.c,
	* pdp11.c, * pe-arm.c, * pe-i386.c, * pe-mcore.c, * pe-sh.c,
	* pe-x86_64.c, * peXXigen.c, * pef.c, * pei-arm.c, * pei-i386.c,
	* pei-ia64.c, * pei-mcore.c, * pei-sh.c, * pei-x86_64.c,
	* peicode.h, * plugin.c, * plugin.h, * ppcboot.c, * reloc.c,
	* reloc16.c, * rs6000-core.c, * section.c, * simple.c, * som.c,
	* som.h, * srec.c, * stabs.c, * syms.c, * targets.c, * tekhex.c,
	* verilog.c, * vms-alpha.c, * vms-lib.c, * vms-misc.c, * vms.h,
	* wasm-module.c, * xcofflink.c, * xcofflink.h, * xsym.c,
	* xsym.h: Replace bfd_boolean with bool, FALSE with false, and
	TRUE with true throughout.
	* bfd-in2.h: Regenerate.
	* libbfd.h: Regenerate.
	* libcoff.h: Regenerate.

1 files changed, 887 insertions, 887 deletions

diff --git a/bfd/elflink.c b/bfd/elflink.c
index c7102e6..ce1407f 100644
--- a/bfd/elflink.c
+++ b/bfd/elflink.c
@@ -45,7 +45,7 @@
 struct elf_info_failed
 {
   struct bfd_link_info *info;
-  bfd_boolean failed;
+  bool failed;
 };
 
 /* This structure is used to pass information to
@@ -58,16 +58,16 @@ struct elf_find_verdep_info
   /* The number of dependencies.  */
   unsigned int vers;
   /* Whether we had a failure.  */
-  bfd_boolean failed;
+  bool failed;
 };
 
-static bfd_boolean _bfd_elf_fix_symbol_flags
+static bool _bfd_elf_fix_symbol_flags
   (struct elf_link_hash_entry *, struct elf_info_failed *);
 
 asection *
 _bfd_elf_section_for_symbol (struct elf_reloc_cookie *cookie,
 			     unsigned long r_symndx,
-			     bfd_boolean discard)
+			     bool discard)
 {
   if (r_symndx >= cookie->locsymcount
       || ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL)
@@ -117,7 +117,7 @@ _bfd_elf_define_linkage_sym (bfd *abfd,
   struct bfd_link_hash_entry *bh;
   const struct elf_backend_data *bed;
 
-  h = elf_link_hash_lookup (elf_hash_table (info), name, FALSE, FALSE, FALSE);
+  h = elf_link_hash_lookup (elf_hash_table (info), name, false, false, false);
   if (h != NULL)
     {
       /* Zap symbol defined in an as-needed lib that wasn't linked.
@@ -132,7 +132,7 @@ _bfd_elf_define_linkage_sym (bfd *abfd,
 
   bed = get_elf_backend_data (abfd);
   if (!_bfd_generic_link_add_one_symbol (info, abfd, name, BSF_GLOBAL,
-					 sec, 0, NULL, FALSE, bed->collect,
+					 sec, 0, NULL, false, bed->collect,
 					 &bh))
     return NULL;
   h = (struct elf_link_hash_entry *) bh;
@@ -144,11 +144,11 @@ _bfd_elf_define_linkage_sym (bfd *abfd,
   if (ELF_ST_VISIBILITY (h->other) != STV_INTERNAL)
     h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN;
 
-  (*bed->elf_backend_hide_symbol) (info, h, TRUE);
+  (*bed->elf_backend_hide_symbol) (info, h, true);
   return h;
 }
 
-bfd_boolean
+bool
 _bfd_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
 {
   flagword flags;
@@ -159,7 +159,7 @@ _bfd_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
 
   /* This function may be called more than once.  */
   if (htab->sgot != NULL)
-    return TRUE;
+    return true;
 
   flags = bed->dynamic_sec_flags;
 
@@ -170,13 +170,13 @@ _bfd_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
 					   | SEC_READONLY));
   if (s == NULL
       || !bfd_set_section_alignment (s, bed->s->log_file_align))
-    return FALSE;
+    return false;
   htab->srelgot = s;
 
   s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
   if (s == NULL
       || !bfd_set_section_alignment (s, bed->s->log_file_align))
-    return FALSE;
+    return false;
   htab->sgot = s;
 
   if (bed->want_got_plt)
@@ -184,7 +184,7 @@ _bfd_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
       s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", flags);
       if (s == NULL
 	  || !bfd_set_section_alignment (s, bed->s->log_file_align))
-	return FALSE;
+	return false;
       htab->sgotplt = s;
     }
 
@@ -201,14 +201,14 @@ _bfd_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
 				       "_GLOBAL_OFFSET_TABLE_");
       elf_hash_table (info)->hgot = h;
       if (h == NULL)
-	return FALSE;
+	return false;
     }
 
-  return TRUE;
+  return true;
 }
 
 /* Create a strtab to hold the dynamic symbol names.  */
-static bfd_boolean
+static bool
 _bfd_elf_link_create_dynstrtab (bfd *abfd, struct bfd_link_info *info)
 {
   struct elf_link_hash_table *hash_table;
@@ -243,9 +243,9 @@ _bfd_elf_link_create_dynstrtab (bfd *abfd, struct bfd_link_info *info)
     {
       hash_table->dynstr = _bfd_elf_strtab_init ();
       if (hash_table->dynstr == NULL)
-	return FALSE;
+	return false;
     }
-  return TRUE;
+  return true;
 }
 
 /* Create some sections which will be filled in with dynamic linking
@@ -255,7 +255,7 @@ _bfd_elf_link_create_dynstrtab (bfd *abfd, struct bfd_link_info *info)
    addresses are assigned to the output sections.  We work out the
    actual contents and size of these sections later.  */
 
-bfd_boolean
+bool
 _bfd_elf_link_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
 {
   flagword flags;
@@ -264,13 +264,13 @@ _bfd_elf_link_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
   struct elf_link_hash_entry *h;
 
   if (! is_elf_hash_table (info->hash))
-    return FALSE;
+    return false;
 
   if (elf_hash_table (info)->dynamic_sections_created)
-    return TRUE;
+    return true;
 
   if (!_bfd_elf_link_create_dynstrtab (abfd, info))
-    return FALSE;
+    return false;
 
   abfd = elf_hash_table (info)->dynobj;
   bed = get_elf_backend_data (abfd);
@@ -284,7 +284,7 @@ _bfd_elf_link_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
       s = bfd_make_section_anyway_with_flags (abfd, ".interp",
 					      flags | SEC_READONLY);
       if (s == NULL)
-	return FALSE;
+	return false;
     }
 
   /* Create sections to hold version informations.  These are removed
@@ -293,36 +293,36 @@ _bfd_elf_link_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
 					  flags | SEC_READONLY);
   if (s == NULL
       || !bfd_set_section_alignment (s, bed->s->log_file_align))
-    return FALSE;
+    return false;
 
   s = bfd_make_section_anyway_with_flags (abfd, ".gnu.version",
 					  flags | SEC_READONLY);
   if (s == NULL
       || !bfd_set_section_alignment (s, 1))
-    return FALSE;
+    return false;
 
   s = bfd_make_section_anyway_with_flags (abfd, ".gnu.version_r",
 					  flags | SEC_READONLY);
   if (s == NULL
       || !bfd_set_section_alignment (s, bed->s->log_file_align))
-    return FALSE;
+    return false;
 
   s = bfd_make_section_anyway_with_flags (abfd, ".dynsym",
 					  flags | SEC_READONLY);
   if (s == NULL
       || !bfd_set_section_alignment (s, bed->s->log_file_align))
-    return FALSE;
+    return false;
   elf_hash_table (info)->dynsym = s;
 
   s = bfd_make_section_anyway_with_flags (abfd, ".dynstr",
 					  flags | SEC_READONLY);
   if (s == NULL)
-    return FALSE;
+    return false;
 
   s = bfd_make_section_anyway_with_flags (abfd, ".dynamic", flags);
   if (s == NULL
       || !bfd_set_section_alignment (s, bed->s->log_file_align))
-    return FALSE;
+    return false;
 
   /* The special symbol _DYNAMIC is always set to the start of the
      .dynamic section.  We could set _DYNAMIC in a linker script, but we
@@ -333,7 +333,7 @@ _bfd_elf_link_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
   h = _bfd_elf_define_linkage_sym (abfd, info, s, "_DYNAMIC");
   elf_hash_table (info)->hdynamic = h;
   if (h == NULL)
-    return FALSE;
+    return false;
 
   if (info->emit_hash)
     {
@@ -341,7 +341,7 @@ _bfd_elf_link_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
 					      flags | SEC_READONLY);
       if (s == NULL
 	  || !bfd_set_section_alignment (s, bed->s->log_file_align))
-	return FALSE;
+	return false;
       elf_section_data (s)->this_hdr.sh_entsize = bed->s->sizeof_hash_entry;
     }
 
@@ -351,7 +351,7 @@ _bfd_elf_link_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
 					      flags | SEC_READONLY);
       if (s == NULL
 	  || !bfd_set_section_alignment (s, bed->s->log_file_align))
-	return FALSE;
+	return false;
       /* For 64-bit ELF, .gnu.hash is a non-uniform entity size section:
 	 4 32-bit words followed by variable count of 64-bit words, then
 	 variable count of 32-bit words.  */
@@ -366,16 +366,16 @@ _bfd_elf_link_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
      the .got and .plt sections.  */
   if (bed->elf_backend_create_dynamic_sections == NULL
       || ! (*bed->elf_backend_create_dynamic_sections) (abfd, info))
-    return FALSE;
+    return false;
 
-  elf_hash_table (info)->dynamic_sections_created = TRUE;
+  elf_hash_table (info)->dynamic_sections_created = true;
 
-  return TRUE;
+  return true;
 }
 
 /* Create dynamic sections when linking against a dynamic object.  */
 
-bfd_boolean
+bool
 _bfd_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
 {
   flagword flags, pltflags;
@@ -402,7 +402,7 @@ _bfd_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
   s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags);
   if (s == NULL
       || !bfd_set_section_alignment (s, bed->plt_alignment))
-    return FALSE;
+    return false;
   htab->splt = s;
 
   /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
@@ -413,7 +413,7 @@ _bfd_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
 				       "_PROCEDURE_LINKAGE_TABLE_");
       elf_hash_table (info)->hplt = h;
       if (h == NULL)
-	return FALSE;
+	return false;
     }
 
   s = bfd_make_section_anyway_with_flags (abfd,
@@ -422,11 +422,11 @@ _bfd_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
 					  flags | SEC_READONLY);
   if (s == NULL
       || !bfd_set_section_alignment (s, bed->s->log_file_align))
-    return FALSE;
+    return false;
   htab->srelplt = s;
 
   if (! _bfd_elf_create_got_section (abfd, info))
-    return FALSE;
+    return false;
 
   if (bed->want_dynbss)
     {
@@ -439,7 +439,7 @@ _bfd_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
       s = bfd_make_section_anyway_with_flags (abfd, ".dynbss",
 					      SEC_ALLOC | SEC_LINKER_CREATED);
       if (s == NULL)
-	return FALSE;
+	return false;
       htab->sdynbss = s;
 
       if (bed->want_dynrelro)
@@ -450,7 +450,7 @@ _bfd_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
 	  s = bfd_make_section_anyway_with_flags (abfd, ".data.rel.ro",
 						  flags);
 	  if (s == NULL)
-	    return FALSE;
+	    return false;
 	  htab->sdynrelro = s;
 	}
 
@@ -473,7 +473,7 @@ _bfd_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
 						  flags | SEC_READONLY);
 	  if (s == NULL
 	      || !bfd_set_section_alignment (s, bed->s->log_file_align))
-	    return FALSE;
+	    return false;
 	  htab->srelbss = s;
 
 	  if (bed->want_dynrelro)
@@ -484,13 +484,13 @@ _bfd_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
 		    flags | SEC_READONLY));
 	      if (s == NULL
 		  || !bfd_set_section_alignment (s, bed->s->log_file_align))
-		return FALSE;
+		return false;
 	      htab->sreldynrelro = s;
 	    }
 	}
     }
 
-  return TRUE;
+  return true;
 }
 
 /* Record a new dynamic symbol.  We record the dynamic symbols as we
@@ -501,7 +501,7 @@ _bfd_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
    symbol should be in the dynamic symbol table, but only if there is
    one.  */
 
-bfd_boolean
+bool
 bfd_elf_link_record_dynamic_symbol (struct bfd_link_info *info,
 				    struct elf_link_hash_entry *h)
 {
@@ -519,7 +519,7 @@ bfd_elf_link_record_dynamic_symbol (struct bfd_link_info *info,
 	  if (h->root.u.def.section != NULL
 	      && h->root.u.def.section->owner != NULL
 	      && (h->root.u.def.section->owner->flags & BFD_PLUGIN) != 0)
-	    return TRUE;
+	    return true;
 	}
 
       /* XXX: The ABI draft says the linker must turn hidden and
@@ -542,7 +542,7 @@ bfd_elf_link_record_dynamic_symbol (struct bfd_link_info *info,
 		  || (h->root.type == bfd_link_hash_common
 		      && h->root.u.c.p->section->owner != NULL
 		      && h->root.u.c.p->section->owner->no_export))
-		return TRUE;
+		return true;
 	    }
 
 	default:
@@ -558,7 +558,7 @@ bfd_elf_link_record_dynamic_symbol (struct bfd_link_info *info,
 	  /* Create a strtab to hold the dynamic symbol names.  */
 	  elf_hash_table (info)->dynstr = dynstr = _bfd_elf_strtab_init ();
 	  if (dynstr == NULL)
-	    return FALSE;
+	    return false;
 	}
 
       /* We don't put any version information in the dynamic string
@@ -579,11 +579,11 @@ bfd_elf_link_record_dynamic_symbol (struct bfd_link_info *info,
 	*p = ELF_VER_CHR;
 
       if (indx == (size_t) -1)
-	return FALSE;
+	return false;
       h->dynstr_index = indx;
     }
 
-  return TRUE;
+  return true;
 }
 
 /* Mark a symbol dynamic.  */
@@ -619,22 +619,22 @@ bfd_elf_link_mark_dynamic_symbol (struct bfd_link_info *info,
 /* Record an assignment to a symbol made by a linker script.  We need
    this in case some dynamic object refers to this symbol.  */
 
-bfd_boolean
+bool
 bfd_elf_record_link_assignment (bfd *output_bfd,
 				struct bfd_link_info *info,
 				const char *name,
-				bfd_boolean provide,
-				bfd_boolean hidden)
+				bool provide,
+				bool hidden)
 {
   struct elf_link_hash_entry *h, *hv;
   struct elf_link_hash_table *htab;
   const struct elf_backend_data *bed;
 
   if (!is_elf_hash_table (info->hash))
-    return TRUE;
+    return true;
 
   htab = elf_hash_table (info);
-  h = elf_link_hash_lookup (htab, name, !provide, TRUE, FALSE);
+  h = elf_link_hash_lookup (htab, name, !provide, true, false);
   if (h == NULL)
     return provide;
 
@@ -696,7 +696,7 @@ bfd_elf_record_link_assignment (bfd *output_bfd,
       break;
     default:
       BFD_FAIL ();
-      return FALSE;
+      return false;
     }
 
   /* If this symbol is being provided by the linker script, and it is
@@ -725,7 +725,7 @@ bfd_elf_record_link_assignment (bfd *output_bfd,
       bed = get_elf_backend_data (output_bfd);
       if (ELF_ST_VISIBILITY (h->other) != STV_INTERNAL)
 	h->other = (h->other & ~ELF_ST_VISIBILITY (-1)) | STV_HIDDEN;
-      (*bed->elf_backend_hide_symbol) (info, h, TRUE);
+      (*bed->elf_backend_hide_symbol) (info, h, true);
     }
 
   /* STV_HIDDEN and STV_INTERNAL symbols must be STB_LOCAL in shared objects
@@ -744,7 +744,7 @@ bfd_elf_record_link_assignment (bfd *output_bfd,
       && h->dynindx == -1)
     {
       if (! bfd_elf_link_record_dynamic_symbol (info, h))
-	return FALSE;
+	return false;
 
       /* If this is a weak defined symbol, and we know a corresponding
 	 real symbol from the same dynamic object, make sure the real
@@ -755,11 +755,11 @@ bfd_elf_record_link_assignment (bfd *output_bfd,
 
 	  if (def->dynindx == -1
 	      && !bfd_elf_link_record_dynamic_symbol (info, def))
-	    return FALSE;
+	    return false;
 	}
     }
 
-  return TRUE;
+  return true;
 }
 
 /* Record a new local dynamic symbol.  Returns 0 on failure, 1 on
@@ -829,7 +829,7 @@ bfd_elf_link_record_local_dynamic_symbol (struct bfd_link_info *info,
 	return 0;
     }
 
-  dynstr_index = _bfd_elf_strtab_add (dynstr, name, FALSE);
+  dynstr_index = _bfd_elf_strtab_add (dynstr, name, false);
   if (dynstr_index == (size_t) -1)
     return 0;
   entry->isym.st_name = dynstr_index;
@@ -870,43 +870,43 @@ _bfd_elf_link_lookup_local_dynindx (struct bfd_link_info *info,
    them are removed because they are marked as local.  This is called
    via elf_link_hash_traverse.  */
 
-static bfd_boolean
+static bool
 elf_link_renumber_hash_table_dynsyms (struct elf_link_hash_entry *h,
 				      void *data)
 {
   size_t *count = (size_t *) data;
 
   if (h->forced_local)
-    return TRUE;
+    return true;
 
   if (h->dynindx != -1)
     h->dynindx = ++(*count);
 
-  return TRUE;
+  return true;
 }
 
 
 /* Like elf_link_renumber_hash_table_dynsyms, but just number symbols with
    STB_LOCAL binding.  */
 
-static bfd_boolean
+static bool
 elf_link_renumber_local_hash_table_dynsyms (struct elf_link_hash_entry *h,
 					    void *data)
 {
   size_t *count = (size_t *) data;
 
   if (!h->forced_local)
-    return TRUE;
+    return true;
 
   if (h->dynindx != -1)
     h->dynindx = ++(*count);
 
-  return TRUE;
+  return true;
 }
 
 /* Return true if the dynamic symbol for a given section should be
    omitted when creating a shared library.  */
-bfd_boolean
+bool
 _bfd_elf_omit_section_dynsym_default (bfd *output_bfd ATTRIBUTE_UNUSED,
 				      struct bfd_link_info *info,
 				      asection *p)
@@ -932,17 +932,17 @@ _bfd_elf_omit_section_dynsym_default (bfd *output_bfd ATTRIBUTE_UNUSED,
       /* There shouldn't be section relative relocations
 	 against any other section.  */
     default:
-      return TRUE;
+      return true;
     }
 }
 
-bfd_boolean
+bool
 _bfd_elf_omit_section_dynsym_all
     (bfd *output_bfd ATTRIBUTE_UNUSED,
      struct bfd_link_info *info ATTRIBUTE_UNUSED,
      asection *p ATTRIBUTE_UNUSED)
 {
-  return TRUE;
+  return true;
 }
 
 /* Assign dynsym indices.  In a shared library we generate a section
@@ -960,7 +960,7 @@ _bfd_elf_link_renumber_dynsyms (bfd *output_bfd,
 				unsigned long *section_sym_count)
 {
   unsigned long dynsymcount = 0;
-  bfd_boolean do_sec = section_sym_count != NULL;
+  bool do_sec = section_sym_count != NULL;
 
   if (bfd_link_pic (info)
       || elf_hash_table (info)->is_relocatable_executable)
@@ -1014,7 +1014,7 @@ _bfd_elf_link_renumber_dynsyms (bfd *output_bfd,
 static void
 elf_merge_st_other (bfd *abfd, struct elf_link_hash_entry *h,
 		    unsigned int st_other, asection *sec,
-		    bfd_boolean definition, bfd_boolean dynamic)
+		    bool definition, bool dynamic)
 {
   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
 
@@ -1053,7 +1053,7 @@ elf_merge_st_other (bfd *abfd, struct elf_link_hash_entry *h,
    to change.  By OK to change, we mean that we shouldn't warn if the
    type or size does change.  */
 
-static bfd_boolean
+static bool
 _bfd_elf_merge_symbol (bfd *abfd,
 		       struct bfd_link_info *info,
 		       const char *name,
@@ -1062,13 +1062,13 @@ _bfd_elf_merge_symbol (bfd *abfd,
 		       bfd_vma *pvalue,
 		       struct elf_link_hash_entry **sym_hash,
 		       bfd **poldbfd,
-		       bfd_boolean *pold_weak,
+		       bool *pold_weak,
 		       unsigned int *pold_alignment,
-		       bfd_boolean *skip,
+		       bool *skip,
 		       bfd **override,
-		       bfd_boolean *type_change_ok,
-		       bfd_boolean *size_change_ok,
-		       bfd_boolean *matched)
+		       bool *type_change_ok,
+		       bool *size_change_ok,
+		       bool *matched)
 {
   asection *sec, *oldsec;
   struct elf_link_hash_entry *h;
@@ -1076,25 +1076,25 @@ _bfd_elf_merge_symbol (bfd *abfd,
   struct elf_link_hash_entry *flip;
   int bind;
   bfd *oldbfd;
-  bfd_boolean newdyn, olddyn, olddef, newdef, newdyncommon, olddyncommon;
-  bfd_boolean newweak, oldweak, newfunc, oldfunc;
+  bool newdyn, olddyn, olddef, newdef, newdyncommon, olddyncommon;
+  bool newweak, oldweak, newfunc, oldfunc;
   const struct elf_backend_data *bed;
   char *new_version;
-  bfd_boolean default_sym = *matched;
+  bool default_sym = *matched;
 
-  *skip = FALSE;
+  *skip = false;
   *override = NULL;
 
   sec = *psec;
   bind = ELF_ST_BIND (sym->st_info);
 
   if (! bfd_is_und_section (sec))
-    h = elf_link_hash_lookup (elf_hash_table (info), name, TRUE, FALSE, FALSE);
+    h = elf_link_hash_lookup (elf_hash_table (info), name, true, false, false);
   else
     h = ((struct elf_link_hash_entry *)
-	 bfd_wrapped_link_hash_lookup (abfd, info, name, TRUE, FALSE, FALSE));
+	 bfd_wrapped_link_hash_lookup (abfd, info, name, true, false, false));
   if (h == NULL)
-    return FALSE;
+    return false;
   *sym_hash = h;
 
   bed = get_elf_backend_data (abfd);
@@ -1133,19 +1133,19 @@ _bfd_elf_merge_symbol (bfd *abfd,
   if (!*matched)
     {
       if (hi == h || h->root.type == bfd_link_hash_new)
-	*matched = TRUE;
+	*matched = true;
       else
 	{
 	  /* OLD_HIDDEN is true if the existing symbol is only visible
 	     to the symbol with the same symbol version.  NEW_HIDDEN is
 	     true if the new symbol is only visible to the symbol with
 	     the same symbol version.  */
-	  bfd_boolean old_hidden = h->versioned == versioned_hidden;
-	  bfd_boolean new_hidden = hi->versioned == versioned_hidden;
+	  bool old_hidden = h->versioned == versioned_hidden;
+	  bool new_hidden = hi->versioned == versioned_hidden;
 	  if (!old_hidden && !new_hidden)
 	    /* The new symbol matches the existing symbol if both
 	       aren't hidden.  */
-	    *matched = TRUE;
+	    *matched = true;
 	  else
 	    {
 	      /* OLD_VERSION is the symbol version of the existing
@@ -1249,7 +1249,7 @@ _bfd_elf_merge_symbol (bfd *abfd,
   if (h->root.type == bfd_link_hash_new)
     {
       h->non_elf = 0;
-      return TRUE;
+      return true;
     }
 
   /* In cases involving weak versioned symbols, we may wind up trying
@@ -1262,9 +1262,9 @@ _bfd_elf_merge_symbol (bfd *abfd,
       && (newweak || oldweak)
       && ((abfd->flags & DYNAMIC) == 0
 	  || !h->def_regular))
-    return TRUE;
+    return true;
 
-  olddyn = FALSE;
+  olddyn = false;
   if (oldbfd != NULL)
     olddyn = (oldbfd->flags & DYNAMIC) != 0;
   else if (oldsec != NULL)
@@ -1280,8 +1280,8 @@ _bfd_elf_merge_symbol (bfd *abfd,
       && (oldbfd->flags & BFD_PLUGIN) != (abfd->flags & BFD_PLUGIN)
       && newdyn != olddyn)
     {
-      h->root.non_ir_ref_dynamic = TRUE;
-      hi->root.non_ir_ref_dynamic = TRUE;
+      h->root.non_ir_ref_dynamic = true;
+      hi->root.non_ir_ref_dynamic = true;
     }
 
   /* NEWDEF and OLDDEF indicate whether the new or old symbol,
@@ -1317,8 +1317,8 @@ _bfd_elf_merge_symbol (bfd *abfd,
       if (newdyn
 	  && !olddyn)
 	{
-	  *skip = TRUE;
-	  return TRUE;
+	  *skip = true;
+	  return true;
 	}
 
       /* When adding a symbol from a regular object file after we have
@@ -1329,7 +1329,7 @@ _bfd_elf_merge_symbol (bfd *abfd,
 	  && olddyn)
 	{
 	  h = hi;
-	  (*bed->elf_backend_hide_symbol) (info, h, TRUE);
+	  (*bed->elf_backend_hide_symbol) (info, h, true);
 	  h->forced_local = 0;
 	  h->ref_dynamic = 0;
 	  h->def_dynamic = 0;
@@ -1344,7 +1344,7 @@ _bfd_elf_merge_symbol (bfd *abfd,
 	      h->root.type = bfd_link_hash_new;
 	      h->root.u.undef.abfd = NULL;
 	    }
-	  return TRUE;
+	  return true;
 	}
     }
 
@@ -1358,7 +1358,7 @@ _bfd_elf_merge_symbol (bfd *abfd,
       && (ELF_ST_TYPE (sym->st_info) == STT_TLS || h->type == STT_TLS))
     {
       bfd *ntbfd, *tbfd;
-      bfd_boolean ntdef, tdef;
+      bool ntdef, tdef;
       asection *ntsec, *tsec;
 
       if (h->type == STT_TLS)
@@ -1406,7 +1406,7 @@ _bfd_elf_merge_symbol (bfd *abfd,
 	   h->root.root.string, tbfd, ntbfd, ntsec);
 
       bfd_set_error (bfd_error_bad_value);
-      return FALSE;
+      return false;
     }
 
   /* If the old symbol has non-default visibility, we ignore the new
@@ -1415,7 +1415,7 @@ _bfd_elf_merge_symbol (bfd *abfd,
       && ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
       && !bfd_is_und_section (sec))
     {
-      *skip = TRUE;
+      *skip = true;
       /* Make sure this symbol is dynamic.  */
       h->ref_dynamic = 1;
       hi->ref_dynamic = 1;
@@ -1426,7 +1426,7 @@ _bfd_elf_merge_symbol (bfd *abfd,
       if (ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
 	return bfd_elf_link_record_dynamic_symbol (info, h);
       else
-	return TRUE;
+	return true;
     }
   else if (!newdyn
 	   && ELF_ST_VISIBILITY (sym->st_other) != STV_DEFAULT
@@ -1452,7 +1452,7 @@ _bfd_elf_merge_symbol (bfd *abfd,
 		{
 		  /* If the new symbol is hidden or internal, completely undo
 		     any dynamic link state.  */
-		  (*bed->elf_backend_hide_symbol) (info, h, TRUE);
+		  (*bed->elf_backend_hide_symbol) (info, h, true);
 		  h->forced_local = 0;
 		  h->ref_dynamic = 0;
 		}
@@ -1492,7 +1492,7 @@ _bfd_elf_merge_symbol (bfd *abfd,
 	{
 	  /* If the new symbol is hidden or internal, completely undo
 	     any dynamic link state.  */
-	  (*bed->elf_backend_hide_symbol) (info, h, TRUE);
+	  (*bed->elf_backend_hide_symbol) (info, h, true);
 	  h->forced_local = 0;
 	  h->ref_dynamic = 0;
 	}
@@ -1502,7 +1502,7 @@ _bfd_elf_merge_symbol (bfd *abfd,
       /* FIXME: Should we check type and size for protected symbol?  */
       h->size = 0;
       h->type = 0;
-      return TRUE;
+      return true;
     }
 
   /* If a new weak symbol definition comes from a regular file and the
@@ -1522,13 +1522,13 @@ _bfd_elf_merge_symbol (bfd *abfd,
      we warn properly when dynamic library symbols are overridden.  */
 
   if (newdef && !newdyn && (olddyn || h->root.ldscript_def))
-    newweak = FALSE;
+    newweak = false;
   if (olddef && newdyn)
-    oldweak = FALSE;
+    oldweak = false;
 
   /* Allow changes between different types of function symbol.  */
   if (newfunc && oldfunc)
-    *type_change_ok = TRUE;
+    *type_change_ok = true;
 
   /* It's OK to change the type if either the existing symbol or the
      new symbol is weak.  A type change is also OK if the old symbol
@@ -1538,14 +1538,14 @@ _bfd_elf_merge_symbol (bfd *abfd,
       || newweak
       || (newdef
 	  && h->root.type == bfd_link_hash_undefined))
-    *type_change_ok = TRUE;
+    *type_change_ok = true;
 
   /* It's OK to change the size if either the existing symbol or the
      new symbol is weak, or if the old symbol is undefined.  */
 
   if (*type_change_ok
       || h->root.type == bfd_link_hash_undefined)
-    *size_change_ok = TRUE;
+    *size_change_ok = true;
 
   /* NEWDYNCOMMON and OLDDYNCOMMON indicate whether the new or old
      symbol, respectively, appears to be a common symbol in a dynamic
@@ -1577,9 +1577,9 @@ _bfd_elf_merge_symbol (bfd *abfd,
       && (sec->flags & SEC_LOAD) == 0
       && sym->st_size > 0
       && !newfunc)
-    newdyncommon = TRUE;
+    newdyncommon = true;
   else
-    newdyncommon = FALSE;
+    newdyncommon = false;
 
   if (olddyn
       && olddef
@@ -1589,16 +1589,16 @@ _bfd_elf_merge_symbol (bfd *abfd,
       && (h->root.u.def.section->flags & SEC_LOAD) == 0
       && h->size > 0
       && !oldfunc)
-    olddyncommon = TRUE;
+    olddyncommon = true;
   else
-    olddyncommon = FALSE;
+    olddyncommon = false;
 
   /* We now know everything about the old and new symbols.  We ask the
      backend to check if we can merge them.  */
   if (bed->merge_symbol != NULL)
     {
       if (!bed->merge_symbol (h, sym, psec, newdef, olddef, oldbfd, oldsec))
-	return FALSE;
+	return false;
       sec = *psec;
     }
 
@@ -1613,8 +1613,8 @@ _bfd_elf_merge_symbol (bfd *abfd,
       /* Handle a multiple definition.  */
       (*info->callbacks->multiple_definition) (info, &h->root,
 					       abfd, sec, *pvalue);
-      *skip = TRUE;
-      return TRUE;
+      *skip = true;
+      return true;
     }
 
   /* If both the old and the new symbols look like common symbols in a
@@ -1636,7 +1636,7 @@ _bfd_elf_merge_symbol (bfd *abfd,
       if (sym->st_size > h->size)
 	h->size = sym->st_size;
 
-      *size_change_ok = TRUE;
+      *size_change_ok = true;
     }
 
   /* If we are looking at a dynamic object, and we have found a
@@ -1660,11 +1660,11 @@ _bfd_elf_merge_symbol (bfd *abfd,
 	      && (newweak || newfunc))))
     {
       *override = abfd;
-      newdef = FALSE;
-      newdyncommon = FALSE;
+      newdef = false;
+      newdyncommon = false;
 
       *psec = sec = bfd_und_section_ptr;
-      *size_change_ok = TRUE;
+      *size_change_ok = true;
 
       /* If we get here when the old symbol is a common symbol, then
 	 we are explicitly letting it override a weak symbol or
@@ -1673,7 +1673,7 @@ _bfd_elf_merge_symbol (bfd *abfd,
 	 change warning may still be appropriate.  */
 
       if (h->root.type == bfd_link_hash_common)
-	*type_change_ok = TRUE;
+	*type_change_ok = true;
     }
 
   /* Handle the special case of an old common symbol merging with a
@@ -1686,11 +1686,11 @@ _bfd_elf_merge_symbol (bfd *abfd,
       && h->root.type == bfd_link_hash_common)
     {
       *override = oldbfd;
-      newdef = FALSE;
-      newdyncommon = FALSE;
+      newdef = false;
+      newdyncommon = false;
       *pvalue = sym->st_size;
       *psec = sec = bed->common_section (oldsec);
-      *size_change_ok = TRUE;
+      *size_change_ok = true;
     }
 
   /* Skip weak definitions of symbols that are already defined.  */
@@ -1701,8 +1701,8 @@ _bfd_elf_merge_symbol (bfd *abfd,
 	    && (oldbfd->flags & BFD_PLUGIN) != 0
 	    && (abfd->flags & BFD_PLUGIN) == 0))
 	{
-	  newdef = FALSE;
-	  *skip = TRUE;
+	  newdef = false;
+	  *skip = true;
 	}
 
       /* Merge st_other.  If the symbol already has a dynamic index,
@@ -1714,7 +1714,7 @@ _bfd_elf_merge_symbol (bfd *abfd,
 	  {
 	  case STV_INTERNAL:
 	  case STV_HIDDEN:
-	    (*bed->elf_backend_hide_symbol) (info, h, TRUE);
+	    (*bed->elf_backend_hide_symbol) (info, h, true);
 	    break;
 	  }
     }
@@ -1744,10 +1744,10 @@ _bfd_elf_merge_symbol (bfd *abfd,
 
       h->root.type = bfd_link_hash_undefined;
       h->root.u.undef.abfd = h->root.u.def.section->owner;
-      *size_change_ok = TRUE;
+      *size_change_ok = true;
 
-      olddef = FALSE;
-      olddyncommon = FALSE;
+      olddef = false;
+      olddyncommon = false;
 
       /* We again permit a type change when a common symbol may be
 	 overriding a function.  */
@@ -1762,7 +1762,7 @@ _bfd_elf_merge_symbol (bfd *abfd,
 	      h->def_dynamic = 0;
 	      h->type = STT_NOTYPE;
 	    }
-	  *type_change_ok = TRUE;
+	  *type_change_ok = true;
 	}
 
       if (hi->root.type == bfd_link_hash_indirect)
@@ -1801,14 +1801,14 @@ _bfd_elf_merge_symbol (bfd *abfd,
       BFD_ASSERT (pold_alignment);
       *pold_alignment = h->root.u.def.section->alignment_power;
 
-      olddef = FALSE;
-      olddyncommon = FALSE;
+      olddef = false;
+      olddyncommon = false;
 
       h->root.type = bfd_link_hash_undefined;
       h->root.u.undef.abfd = h->root.u.def.section->owner;
 
-      *size_change_ok = TRUE;
-      *type_change_ok = TRUE;
+      *size_change_ok = true;
+      *type_change_ok = true;
 
       if (hi->root.type == bfd_link_hash_indirect)
 	flip = hi;
@@ -1833,7 +1833,7 @@ _bfd_elf_merge_symbol (bfd *abfd,
 	}
     }
 
-  return TRUE;
+  return true;
 }
 
 /* This function is called to create an indirect symbol from the
@@ -1841,7 +1841,7 @@ _bfd_elf_merge_symbol (bfd *abfd,
    symbol is described by H, NAME, SYM, SEC, and VALUE.  We
    set DYNSYM if the new indirect symbol is dynamic.  */
 
-static bfd_boolean
+static bool
 _bfd_elf_add_default_symbol (bfd *abfd,
 			     struct bfd_link_info *info,
 			     struct elf_link_hash_entry *h,
@@ -1850,25 +1850,25 @@ _bfd_elf_add_default_symbol (bfd *abfd,
 			     asection *sec,
 			     bfd_vma value,
 			     bfd **poldbfd,
-			     bfd_boolean *dynsym)
+			     bool *dynsym)
 {
-  bfd_boolean type_change_ok;
-  bfd_boolean size_change_ok;
-  bfd_boolean skip;
+  bool type_change_ok;
+  bool size_change_ok;
+  bool skip;
   char *shortname;
   struct elf_link_hash_entry *hi;
   struct bfd_link_hash_entry *bh;
   const struct elf_backend_data *bed;
-  bfd_boolean collect;
-  bfd_boolean dynamic;
+  bool collect;
+  bool dynamic;
   bfd *override;
   char *p;
   size_t len, shortlen;
   asection *tmp_sec;
-  bfd_boolean matched;
+  bool matched;
 
   if (h->versioned == unversioned || h->versioned == versioned_hidden)
-    return TRUE;
+    return true;
 
   /* If this symbol has a version, and it is the default version, we
      create an indirect symbol from the default name to the fully
@@ -1880,14 +1880,14 @@ _bfd_elf_add_default_symbol (bfd *abfd,
       if (p == NULL)
 	{
 	  h->versioned = unversioned;
-	  return TRUE;
+	  return true;
 	}
       else
 	{
 	  if (p[1] != ELF_VER_CHR)
 	    {
 	      h->versioned = versioned_hidden;
-	      return TRUE;
+	      return true;
 	    }
 	  else
 	    h->versioned = versioned;
@@ -1898,7 +1898,7 @@ _bfd_elf_add_default_symbol (bfd *abfd,
       /* PR ld/19073: We may see an unversioned definition after the
 	 default version.  */
       if (p == NULL)
-	return TRUE;
+	return true;
     }
 
   bed = get_elf_backend_data (abfd);
@@ -1908,7 +1908,7 @@ _bfd_elf_add_default_symbol (bfd *abfd,
   shortlen = p - name;
   shortname = (char *) bfd_hash_allocate (&info->hash->table, shortlen + 1);
   if (shortname == NULL)
-    return FALSE;
+    return false;
   memcpy (shortname, name, shortlen);
   shortname[shortlen] = '\0';
 
@@ -1916,14 +1916,14 @@ _bfd_elf_add_default_symbol (bfd *abfd,
      symbol with this name.  For the purposes of the merge, act as
      though we were defining the symbol we just defined, although we
      actually going to define an indirect symbol.  */
-  type_change_ok = FALSE;
-  size_change_ok = FALSE;
-  matched = TRUE;
+  type_change_ok = false;
+  size_change_ok = false;
+  matched = true;
   tmp_sec = sec;
   if (!_bfd_elf_merge_symbol (abfd, info, shortname, sym, &tmp_sec, &value,
 			      &hi, poldbfd, NULL, NULL, &skip, &override,
 			      &type_change_ok, &size_change_ok, &matched))
-    return FALSE;
+    return false;
 
   if (skip)
     goto nondefault;
@@ -1937,14 +1937,14 @@ _bfd_elf_add_default_symbol (bfd *abfd,
 	 command line rather than via --version-script.  */
       if (hi->verinfo.vertree == NULL && info->version_info != NULL)
 	{
-	  bfd_boolean hide;
+	  bool hide;
 
 	  hi->verinfo.vertree
 	    = bfd_find_version_for_sym (info->version_info,
 					hi->root.root.string, &hide);
 	  if (hi->verinfo.vertree != NULL && hide)
 	    {
-	      (*bed->elf_backend_hide_symbol) (info, hi, TRUE);
+	      (*bed->elf_backend_hide_symbol) (info, hi, true);
 	      goto nondefault;
 	    }
 	}
@@ -1972,8 +1972,8 @@ _bfd_elf_add_default_symbol (bfd *abfd,
 	  if (! (_bfd_generic_link_add_one_symbol
 		 (info, abfd, shortname, BSF_INDIRECT,
 		  bfd_ind_section_ptr,
-		  0, name, FALSE, collect, &bh)))
-	    return FALSE;
+		  0, name, false, collect, &bh)))
+	    return false;
 	  hi = (struct elf_link_hash_entry *) bh;
 	}
     }
@@ -2011,7 +2011,7 @@ _bfd_elf_add_default_symbol (bfd *abfd,
 	      || hi->def_regular)
 	    {
 	      if (! bfd_elf_link_record_dynamic_symbol (info, hi))
-		return FALSE;
+		return false;
 	    }
 	}
 
@@ -2037,7 +2037,7 @@ _bfd_elf_add_default_symbol (bfd *abfd,
 
       /* If we first saw a reference to SHORTNAME with non-default
 	 visibility, merge that visibility to the @@VER symbol.  */
-      elf_merge_st_other (abfd, ht, hi->other, sec, TRUE, dynamic);
+      elf_merge_st_other (abfd, ht, hi->other, sec, true, dynamic);
 
       /* A reference to the SHORTNAME symbol from a dynamic library
 	 will be satisfied by the versioned symbol at runtime.  In
@@ -2054,12 +2054,12 @@ _bfd_elf_add_default_symbol (bfd *abfd,
 	      if (! bfd_link_executable (info)
 		  || hi->def_dynamic
 		  || hi->ref_dynamic)
-		*dynsym = TRUE;
+		*dynsym = true;
 	    }
 	  else
 	    {
 	      if (hi->ref_regular)
-		*dynsym = TRUE;
+		*dynsym = true;
 	    }
 	}
     }
@@ -2071,18 +2071,18 @@ _bfd_elf_add_default_symbol (bfd *abfd,
   len = strlen (name);
   shortname = (char *) bfd_hash_allocate (&info->hash->table, len);
   if (shortname == NULL)
-    return FALSE;
+    return false;
   memcpy (shortname, name, shortlen);
   memcpy (shortname + shortlen, p + 1, len - shortlen);
 
   /* Once again, merge with any existing symbol.  */
-  type_change_ok = FALSE;
-  size_change_ok = FALSE;
+  type_change_ok = false;
+  size_change_ok = false;
   tmp_sec = sec;
   if (!_bfd_elf_merge_symbol (abfd, info, shortname, sym, &tmp_sec, &value,
 			      &hi, poldbfd, NULL, NULL, &skip, &override,
 			      &type_change_ok, &size_change_ok, &matched))
-    return FALSE;
+    return false;
 
   if (skip)
     {
@@ -2102,7 +2102,7 @@ _bfd_elf_add_default_symbol (bfd *abfd,
 	  hi->root.u.i.link = &h->root;
 	}
       else
-	return TRUE;
+	return true;
     }
   else if (override)
     {
@@ -2115,15 +2115,15 @@ _bfd_elf_add_default_symbol (bfd *abfd,
 	  /* xgettext:c-format */
 	  (_("%pB: unexpected redefinition of indirect versioned symbol `%s'"),
 	   abfd, shortname);
-      return TRUE;
+      return true;
     }
   else
     {
       bh = &hi->root;
       if (! (_bfd_generic_link_add_one_symbol
 	     (info, abfd, shortname, BSF_INDIRECT,
-	      bfd_ind_section_ptr, 0, name, FALSE, collect, &bh)))
-	return FALSE;
+	      bfd_ind_section_ptr, 0, name, false, collect, &bh)))
+	return false;
       hi = (struct elf_link_hash_entry *) bh;
     }
 
@@ -2139,7 +2139,7 @@ _bfd_elf_add_default_symbol (bfd *abfd,
       /* If we first saw a reference to @VER symbol with
 	 non-default visibility, merge that visibility to the
 	 @@VER symbol.  */
-      elf_merge_st_other (abfd, h, hi->other, sec, TRUE, dynamic);
+      elf_merge_st_other (abfd, h, hi->other, sec, true, dynamic);
 
       /* See if the new flags lead us to realize that the symbol
 	 must be dynamic.  */
@@ -2149,34 +2149,34 @@ _bfd_elf_add_default_symbol (bfd *abfd,
 	    {
 	      if (! bfd_link_executable (info)
 		  || hi->ref_dynamic)
-		*dynsym = TRUE;
+		*dynsym = true;
 	    }
 	  else
 	    {
 	      if (hi->ref_regular)
-		*dynsym = TRUE;
+		*dynsym = true;
 	    }
 	}
     }
 
-  return TRUE;
+  return true;
 }
 
 /* This routine is used to export all defined symbols into the dynamic
    symbol table.  It is called via elf_link_hash_traverse.  */
 
-static bfd_boolean
+static bool
 _bfd_elf_export_symbol (struct elf_link_hash_entry *h, void *data)
 {
   struct elf_info_failed *eif = (struct elf_info_failed *) data;
 
   /* Ignore indirect symbols.  These are added by the versioning code.  */
   if (h->root.type == bfd_link_hash_indirect)
-    return TRUE;
+    return true;
 
   /* Ignore this if we won't export it.  */
   if (!eif->info->export_dynamic && !h->dynamic)
-    return TRUE;
+    return true;
 
   if (h->dynindx == -1
       && (h->def_regular || h->ref_regular)
@@ -2185,12 +2185,12 @@ _bfd_elf_export_symbol (struct elf_link_hash_entry *h, void *data)
     {
       if (! bfd_elf_link_record_dynamic_symbol (eif->info, h))
 	{
-	  eif->failed = TRUE;
-	  return FALSE;
+	  eif->failed = true;
+	  return false;
 	}
     }
 
-  return TRUE;
+  return true;
 }
 
 /* Look through the symbols which are defined in other shared
@@ -2198,7 +2198,7 @@ _bfd_elf_export_symbol (struct elf_link_hash_entry *h, void *data)
    dependencies.  This will be put into the .gnu.version_r section.
    This function is called via elf_link_hash_traverse.  */
 
-static bfd_boolean
+static bool
 _bfd_elf_link_find_version_dependencies (struct elf_link_hash_entry *h,
 					 void *data)
 {
@@ -2215,7 +2215,7 @@ _bfd_elf_link_find_version_dependencies (struct elf_link_hash_entry *h,
       || h->verinfo.verdef == NULL
       || (elf_dyn_lib_class (h->verinfo.verdef->vd_bfd)
 	  & (DYN_AS_NEEDED | DYN_DT_NEEDED | DYN_NO_NEEDED)))
-    return TRUE;
+    return true;
 
   /* See if we already know about this version.  */
   for (t = elf_tdata (rinfo->info->output_bfd)->verref;
@@ -2227,7 +2227,7 @@ _bfd_elf_link_find_version_dependencies (struct elf_link_hash_entry *h,
 
       for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
 	if (a->vna_nodename == h->verinfo.verdef->vd_nodename)
-	  return TRUE;
+	  return true;
 
       break;
     }
@@ -2240,8 +2240,8 @@ _bfd_elf_link_find_version_dependencies (struct elf_link_hash_entry *h,
       t = (Elf_Internal_Verneed *) bfd_zalloc (rinfo->info->output_bfd, amt);
       if (t == NULL)
 	{
-	  rinfo->failed = TRUE;
-	  return FALSE;
+	  rinfo->failed = true;
+	  return false;
 	}
 
       t->vn_bfd = h->verinfo.verdef->vd_bfd;
@@ -2253,8 +2253,8 @@ _bfd_elf_link_find_version_dependencies (struct elf_link_hash_entry *h,
   a = (Elf_Internal_Vernaux *) bfd_zalloc (rinfo->info->output_bfd, amt);
   if (a == NULL)
     {
-      rinfo->failed = TRUE;
-      return FALSE;
+      rinfo->failed = true;
+      return false;
     }
 
   /* Note that we are copying a string pointer here, and testing it
@@ -2273,18 +2273,18 @@ _bfd_elf_link_find_version_dependencies (struct elf_link_hash_entry *h,
 
   t->vn_auxptr = a;
 
-  return TRUE;
+  return true;
 }
 
 /* Return TRUE and set *HIDE to TRUE if the versioned symbol is
    hidden.  Set *T_P to NULL if there is no match.  */
 
-static bfd_boolean
+static bool
 _bfd_elf_link_hide_versioned_symbol (struct bfd_link_info *info,
 				     struct elf_link_hash_entry *h,
 				     const char *version_p,
 				     struct bfd_elf_version_tree **t_p,
-				     bfd_boolean *hide)
+				     bool *hide)
 {
   struct bfd_elf_version_tree *t;
 
@@ -2300,14 +2300,14 @@ _bfd_elf_link_hide_versioned_symbol (struct bfd_link_info *info,
 	  len = version_p - h->root.root.string;
 	  alc = (char *) bfd_malloc (len);
 	  if (alc == NULL)
-	    return FALSE;
+	    return false;
 	  memcpy (alc, h->root.root.string, len - 1);
 	  alc[len - 1] = '\0';
 	  if (alc[len - 2] == ELF_VER_CHR)
 	    alc[len - 2] = '\0';
 
 	  h->verinfo.vertree = t;
-	  t->used = TRUE;
+	  t->used = true;
 	  d = NULL;
 
 	  if (t->globals.list != NULL)
@@ -2321,7 +2321,7 @@ _bfd_elf_link_hide_versioned_symbol (struct bfd_link_info *info,
 	      if (d != NULL
 		  && h->dynindx != -1
 		  && ! info->export_dynamic)
-		*hide = TRUE;
+		*hide = true;
 	    }
 
 	  free (alc);
@@ -2331,23 +2331,23 @@ _bfd_elf_link_hide_versioned_symbol (struct bfd_link_info *info,
 
   *t_p = t;
 
-  return TRUE;
+  return true;
 }
 
 /* Return TRUE if the symbol H is hidden by version script.  */
 
-bfd_boolean
+bool
 _bfd_elf_link_hide_sym_by_version (struct bfd_link_info *info,
 				   struct elf_link_hash_entry *h)
 {
   const char *p;
-  bfd_boolean hide = FALSE;
+  bool hide = false;
   const struct elf_backend_data *bed
     = get_elf_backend_data (info->output_bfd);
 
   /* Version script only hides symbols defined in regular objects.  */
   if (!h->def_regular && !ELF_COMMON_DEF_P (h))
-    return TRUE;
+    return true;
 
   p = strchr (h->root.root.string, ELF_VER_CHR);
   if (p != NULL && h->verinfo.vertree == NULL)
@@ -2363,8 +2363,8 @@ _bfd_elf_link_hide_sym_by_version (struct bfd_link_info *info,
 	  && hide)
 	{
 	  if (hide)
-	    (*bed->elf_backend_hide_symbol) (info, h, TRUE);
-	  return TRUE;
+	    (*bed->elf_backend_hide_symbol) (info, h, true);
+	  return true;
 	}
     }
 
@@ -2377,12 +2377,12 @@ _bfd_elf_link_hide_sym_by_version (struct bfd_link_info *info,
 				    h->root.root.string, &hide);
       if (h->verinfo.vertree != NULL && hide)
 	{
-	  (*bed->elf_backend_hide_symbol) (info, h, TRUE);
-	  return TRUE;
+	  (*bed->elf_backend_hide_symbol) (info, h, true);
+	  return true;
 	}
     }
 
-  return FALSE;
+  return false;
 }
 
 /* Figure out appropriate versions for all the symbols.  We may not
@@ -2390,7 +2390,7 @@ _bfd_elf_link_hide_sym_by_version (struct bfd_link_info *info,
    files, so until that point we don't know which symbols should be
    local.  This function is called via elf_link_hash_traverse.  */
 
-static bfd_boolean
+static bool
 _bfd_elf_link_assign_sym_version (struct elf_link_hash_entry *h, void *data)
 {
   struct elf_info_failed *sinfo;
@@ -2398,19 +2398,19 @@ _bfd_elf_link_assign_sym_version (struct elf_link_hash_entry *h, void *data)
   const struct elf_backend_data *bed;
   struct elf_info_failed eif;
   char *p;
-  bfd_boolean hide;
+  bool hide;
 
   sinfo = (struct elf_info_failed *) data;
   info = sinfo->info;
 
   /* Fix the symbol flags.  */
-  eif.failed = FALSE;
+  eif.failed = false;
   eif.info = info;
   if (! _bfd_elf_fix_symbol_flags (h, &eif))
     {
       if (eif.failed)
-	sinfo->failed = TRUE;
-      return FALSE;
+	sinfo->failed = true;
+      return false;
     }
 
   bed = get_elf_backend_data (info->output_bfd);
@@ -2423,11 +2423,11 @@ _bfd_elf_link_assign_sym_version (struct elf_link_hash_entry *h, void *data)
       if ((h->root.type == bfd_link_hash_defined
 	   || h->root.type == bfd_link_hash_defweak)
 	  && discarded_section (h->root.u.def.section))
-	(*bed->elf_backend_hide_symbol) (info, h, TRUE);
-      return TRUE;
+	(*bed->elf_backend_hide_symbol) (info, h, true);
+      return true;
     }
 
-  hide = FALSE;
+  hide = false;
   p = strchr (h->root.root.string, ELF_VER_CHR);
   if (p != NULL && h->verinfo.vertree == NULL)
     {
@@ -2439,16 +2439,16 @@ _bfd_elf_link_assign_sym_version (struct elf_link_hash_entry *h, void *data)
 
       /* If there is no version string, we can just return out.  */
       if (*p == '\0')
-	return TRUE;
+	return true;
 
       if (!_bfd_elf_link_hide_versioned_symbol (info, h, p, &t, &hide))
 	{
-	  sinfo->failed = TRUE;
-	  return FALSE;
+	  sinfo->failed = true;
+	  return false;
 	}
 
       if (hide)
-	(*bed->elf_backend_hide_symbol) (info, h, TRUE);
+	(*bed->elf_backend_hide_symbol) (info, h, true);
 
       /* If we are building an application, we need to create a
 	 version node for this version.  */
@@ -2460,19 +2460,19 @@ _bfd_elf_link_assign_sym_version (struct elf_link_hash_entry *h, void *data)
 	  /* If we aren't going to export this symbol, we don't need
 	     to worry about it.  */
 	  if (h->dynindx == -1)
-	    return TRUE;
+	    return true;
 
 	  t = (struct bfd_elf_version_tree *) bfd_zalloc (info->output_bfd,
 							  sizeof *t);
 	  if (t == NULL)
 	    {
-	      sinfo->failed = TRUE;
-	      return FALSE;
+	      sinfo->failed = true;
+	      return false;
 	    }
 
 	  t->name = p;
 	  t->name_indx = (unsigned int) -1;
-	  t->used = TRUE;
+	  t->used = true;
 
 	  version_index = 1;
 	  /* Don't count anonymous version tag.  */
@@ -2498,8 +2498,8 @@ _bfd_elf_link_assign_sym_version (struct elf_link_hash_entry *h, void *data)
 	    (_("%pB: version node not found for symbol %s"),
 	     info->output_bfd, h->root.root.string);
 	  bfd_set_error (bfd_error_bad_value);
-	  sinfo->failed = TRUE;
-	  return FALSE;
+	  sinfo->failed = true;
+	  return false;
 	}
     }
 
@@ -2513,10 +2513,10 @@ _bfd_elf_link_assign_sym_version (struct elf_link_hash_entry *h, void *data)
 	= bfd_find_version_for_sym (sinfo->info->version_info,
 				    h->root.root.string, &hide);
       if (h->verinfo.vertree != NULL && hide)
-	(*bed->elf_backend_hide_symbol) (info, h, TRUE);
+	(*bed->elf_backend_hide_symbol) (info, h, true);
     }
 
-  return TRUE;
+  return true;
 }
 
 /* Read and swap the relocs from the section indicated by SHDR.  This
@@ -2528,7 +2528,7 @@ _bfd_elf_link_assign_sym_version (struct elf_link_hash_entry *h, void *data)
 
    Returns FALSE if something goes wrong.  */
 
-static bfd_boolean
+static bool
 elf_link_read_relocs_from_section (bfd *abfd,
 				   asection *sec,
 				   Elf_Internal_Shdr *shdr,
@@ -2545,11 +2545,11 @@ elf_link_read_relocs_from_section (bfd *abfd,
 
   /* Position ourselves at the start of the section.  */
   if (bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0)
-    return FALSE;
+    return false;
 
   /* Read the relocations.  */
   if (bfd_bread (external_relocs, shdr->sh_size, abfd) != shdr->sh_size)
-    return FALSE;
+    return false;
 
   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
   nsyms = NUM_SHDR_ENTRIES (symtab_hdr);
@@ -2564,7 +2564,7 @@ elf_link_read_relocs_from_section (bfd *abfd,
   else
     {
       bfd_set_error (bfd_error_wrong_format);
-      return FALSE;
+      return false;
     }
 
   erela = (const bfd_byte *) external_relocs;
@@ -2591,7 +2591,7 @@ elf_link_read_relocs_from_section (bfd *abfd,
 		 abfd, (uint64_t) r_symndx, (unsigned long) nsyms,
 		 (uint64_t) irela->r_offset, sec);
 	      bfd_set_error (bfd_error_bad_value);
-	      return FALSE;
+	      return false;
 	    }
 	}
       else if (r_symndx != STN_UNDEF)
@@ -2604,13 +2604,13 @@ elf_link_read_relocs_from_section (bfd *abfd,
 	     abfd, (uint64_t) r_symndx,
 	     (uint64_t) irela->r_offset, sec);
 	  bfd_set_error (bfd_error_bad_value);
-	  return FALSE;
+	  return false;
 	}
       irela += bed->s->int_rels_per_ext_rel;
       erela += shdr->sh_entsize;
     }
 
-  return TRUE;
+  return true;
 }
 
 /* Read and swap the relocs for a section O.  They may have been
@@ -2628,7 +2628,7 @@ _bfd_elf_link_read_relocs (bfd *abfd,
 			   asection *o,
 			   void *external_relocs,
 			   Elf_Internal_Rela *internal_relocs,
-			   bfd_boolean keep_memory)
+			   bool keep_memory)
 {
   void *alloc1 = NULL;
   Elf_Internal_Rela *alloc2 = NULL;
@@ -2715,7 +2715,7 @@ _bfd_elf_link_read_relocs (bfd *abfd,
 /* Compute the size of, and allocate space for, REL_HDR which is the
    section header for a section containing relocations for O.  */
 
-static bfd_boolean
+static bool
 _bfd_elf_link_size_reloc_section (bfd *abfd,
 				  struct bfd_elf_section_reloc_data *reldata)
 {
@@ -2730,7 +2730,7 @@ _bfd_elf_link_size_reloc_section (bfd *abfd,
      we zero the allocated space.  */
   rel_hdr->contents = (unsigned char *) bfd_zalloc (abfd, rel_hdr->sh_size);
   if (rel_hdr->contents == NULL && rel_hdr->sh_size != 0)
-    return FALSE;
+    return false;
 
   if (reldata->hashes == NULL && reldata->count)
     {
@@ -2739,19 +2739,19 @@ _bfd_elf_link_size_reloc_section (bfd *abfd,
       p = ((struct elf_link_hash_entry **)
 	   bfd_zmalloc (reldata->count * sizeof (*p)));
       if (p == NULL)
-	return FALSE;
+	return false;
 
       reldata->hashes = p;
     }
 
-  return TRUE;
+  return true;
 }
 
 /* Copy the relocations indicated by the INTERNAL_RELOCS (which
    originated from the section given by INPUT_REL_HDR) to the
    OUTPUT_BFD.  */
 
-bfd_boolean
+bool
 _bfd_elf_link_output_relocs (bfd *output_bfd,
 			     asection *input_section,
 			     Elf_Internal_Shdr *input_rel_hdr,
@@ -2790,7 +2790,7 @@ _bfd_elf_link_output_relocs (bfd *output_bfd,
 	(_("%pB: relocation size mismatch in %pB section %pA"),
 	 output_bfd, input_section->owner, input_section);
       bfd_set_error (bfd_error_wrong_format);
-      return FALSE;
+      return false;
     }
 
   erel = output_reldata->hdr->contents;
@@ -2809,12 +2809,12 @@ _bfd_elf_link_output_relocs (bfd *output_bfd,
      relocations.  */
   output_reldata->count += NUM_SHDR_ENTRIES (input_rel_hdr);
 
-  return TRUE;
+  return true;
 }
 
 /* Make weak undefined symbols in PIE dynamic.  */
 
-bfd_boolean
+bool
 _bfd_elf_link_hash_fixup_symbol (struct bfd_link_info *info,
 				 struct elf_link_hash_entry *h)
 {
@@ -2823,7 +2823,7 @@ _bfd_elf_link_hash_fixup_symbol (struct bfd_link_info *info,
       && h->root.type == bfd_link_hash_undefweak)
     return bfd_elf_link_record_dynamic_symbol (info, h);
 
-  return TRUE;
+  return true;
 }
 
 /* Fix up the flags for a symbol.  This handles various cases which
@@ -2832,7 +2832,7 @@ _bfd_elf_link_hash_fixup_symbol (struct bfd_link_info *info,
    assign_sym_version, which is unnecessary but perhaps more robust in
    the face of future changes.  */
 
-static bfd_boolean
+static bool
 _bfd_elf_fix_symbol_flags (struct elf_link_hash_entry *h,
 			   struct elf_info_failed *eif)
 {
@@ -2872,8 +2872,8 @@ _bfd_elf_fix_symbol_flags (struct elf_link_hash_entry *h,
 	{
 	  if (! bfd_elf_link_record_dynamic_symbol (eif->info, h))
 	    {
-	      eif->failed = TRUE;
-	      return FALSE;
+	      eif->failed = true;
+	      return false;
 	    }
 	}
     }
@@ -2900,7 +2900,7 @@ _bfd_elf_fix_symbol_flags (struct elf_link_hash_entry *h,
   bed = get_elf_backend_data (elf_hash_table (eif->info)->dynobj);
   if (bed->elf_backend_fixup_symbol
       && !(*bed->elf_backend_fixup_symbol) (eif->info, h))
-    return FALSE;
+    return false;
 
   /* If this is a final link, and the symbol was defined as a common
      symbol in a regular object file, and there was no definition in
@@ -2916,13 +2916,13 @@ _bfd_elf_fix_symbol_flags (struct elf_link_hash_entry *h,
 
   /* Symbols defined in discarded sections shouldn't be dynamic.  */
   if (h->root.type == bfd_link_hash_undefined && h->indx == -3)
-    (*bed->elf_backend_hide_symbol) (eif->info, h, TRUE);
+    (*bed->elf_backend_hide_symbol) (eif->info, h, true);
 
   /* If a weak undefined symbol has non-default visibility, we also
      hide it from the dynamic linker.  */
   else if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
 	   && h->root.type == bfd_link_hash_undefweak)
-    (*bed->elf_backend_hide_symbol) (eif->info, h, TRUE);
+    (*bed->elf_backend_hide_symbol) (eif->info, h, true);
 
   /* A hidden versioned symbol in executable should be forced local if
      it is is locally defined, not referenced by shared library and not
@@ -2933,7 +2933,7 @@ _bfd_elf_fix_symbol_flags (struct elf_link_hash_entry *h,
 	   && !h->dynamic
 	   && !h->ref_dynamic
 	   && h->def_regular)
-    (*bed->elf_backend_hide_symbol) (eif->info, h, TRUE);
+    (*bed->elf_backend_hide_symbol) (eif->info, h, true);
 
   /* If -Bsymbolic was used (which means to bind references to global
      symbols to the definition within the shared object), and this
@@ -2948,7 +2948,7 @@ _bfd_elf_fix_symbol_flags (struct elf_link_hash_entry *h,
 	       || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
 	   && h->def_regular)
     {
-      bfd_boolean force_local;
+      bool force_local;
 
       force_local = (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
 		     || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN);
@@ -2990,14 +2990,14 @@ _bfd_elf_fix_symbol_flags (struct elf_link_hash_entry *h,
 	}
     }
 
-  return TRUE;
+  return true;
 }
 
 /* Make the backend pick a good value for a dynamic symbol.  This is
    called via elf_link_hash_traverse, and also calls itself
    recursively.  */
 
-static bfd_boolean
+static bool
 _bfd_elf_adjust_dynamic_symbol (struct elf_link_hash_entry *h, void *data)
 {
   struct elf_info_failed *eif = (struct elf_info_failed *) data;
@@ -3005,15 +3005,15 @@ _bfd_elf_adjust_dynamic_symbol (struct elf_link_hash_entry *h, void *data)
   const struct elf_backend_data *bed;
 
   if (! is_elf_hash_table (eif->info->hash))
-    return FALSE;
+    return false;
 
   /* Ignore indirect symbols.  These are added by the versioning code.  */
   if (h->root.type == bfd_link_hash_indirect)
-    return TRUE;
+    return true;
 
   /* Fix the symbol flags.  */
   if (! _bfd_elf_fix_symbol_flags (h, eif))
-    return FALSE;
+    return false;
 
   htab = elf_hash_table (eif->info);
   bed = get_elf_backend_data (htab->dynobj);
@@ -3021,7 +3021,7 @@ _bfd_elf_adjust_dynamic_symbol (struct elf_link_hash_entry *h, void *data)
   if (h->root.type == bfd_link_hash_undefweak)
     {
       if (eif->info->dynamic_undefined_weak == 0)
-	(*bed->elf_backend_hide_symbol) (eif->info, h, TRUE);
+	(*bed->elf_backend_hide_symbol) (eif->info, h, true);
       else if (eif->info->dynamic_undefined_weak > 0
 	       && h->ref_regular
 	       && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
@@ -3030,8 +3030,8 @@ _bfd_elf_adjust_dynamic_symbol (struct elf_link_hash_entry *h, void *data)
 	{
 	  if (!bfd_elf_link_record_dynamic_symbol (eif->info, h))
 	    {
-	      eif->failed = TRUE;
-	      return FALSE;
+	      eif->failed = true;
+	      return false;
 	    }
 	}
     }
@@ -3051,13 +3051,13 @@ _bfd_elf_adjust_dynamic_symbol (struct elf_link_hash_entry *h, void *data)
 	      && (!h->is_weakalias || weakdef (h)->dynindx == -1))))
     {
       h->plt = elf_hash_table (eif->info)->init_plt_offset;
-      return TRUE;
+      return true;
     }
 
   /* If we've already adjusted this symbol, don't do it again.  This
      can happen via a recursive call.  */
   if (h->dynamic_adjusted)
-    return TRUE;
+    return true;
 
   /* Don't look at this symbol again.  Note that we must set this
      after checking the above conditions, because we may look at a
@@ -3104,7 +3104,7 @@ _bfd_elf_adjust_dynamic_symbol (struct elf_link_hash_entry *h, void *data)
       /* Ensure that the backend adjust_dynamic_symbol function sees
 	 the strong alias before H by recursively calling ourselves.  */
       if (!_bfd_elf_adjust_dynamic_symbol (def, eif))
-	return FALSE;
+	return false;
     }
 
   /* If a symbol has no type and no size and does not require a PLT
@@ -3121,17 +3121,17 @@ _bfd_elf_adjust_dynamic_symbol (struct elf_link_hash_entry *h, void *data)
 
   if (! (*bed->elf_backend_adjust_dynamic_symbol) (eif->info, h))
     {
-      eif->failed = TRUE;
-      return FALSE;
+      eif->failed = true;
+      return false;
     }
 
-  return TRUE;
+  return true;
 }
 
 /* Adjust the dynamic symbol, H, for copy in the dynamic bss section,
    DYNBSS.  */
 
-bfd_boolean
+bool
 _bfd_elf_adjust_dynamic_copy (struct bfd_link_info *info,
 			      struct elf_link_hash_entry *h,
 			      asection *dynbss)
@@ -3157,7 +3157,7 @@ _bfd_elf_adjust_dynamic_copy (struct bfd_link_info *info,
     {
       /* Adjust the section alignment if needed.  */
       if (!bfd_set_section_alignment (dynbss, power_of_two))
-	return FALSE;
+	return false;
     }
 
   /* We make sure that the symbol will be aligned properly.  */
@@ -3179,13 +3179,13 @@ _bfd_elf_adjust_dynamic_copy (struct bfd_link_info *info,
       (_("%P: copy reloc against protected `%pT' is dangerous\n"),
        h->root.root.string);
 
-  return TRUE;
+  return true;
 }
 
 /* Adjust all external symbols pointing into SEC_MERGE sections
    to reflect the object merging within the sections.  */
 
-static bfd_boolean
+static bool
 _bfd_elf_link_sec_merge_syms (struct elf_link_hash_entry *h, void *data)
 {
   asection *sec;
@@ -3204,24 +3204,24 @@ _bfd_elf_link_sec_merge_syms (struct elf_link_hash_entry *h, void *data)
 				    h->root.u.def.value);
     }
 
-  return TRUE;
+  return true;
 }
 
 /* Returns false if the symbol referred to by H should be considered
    to resolve local to the current module, and true if it should be
    considered to bind dynamically.  */
 
-bfd_boolean
+bool
 _bfd_elf_dynamic_symbol_p (struct elf_link_hash_entry *h,
 			   struct bfd_link_info *info,
-			   bfd_boolean not_local_protected)
+			   bool not_local_protected)
 {
-  bfd_boolean binding_stays_local_p;
+  bool binding_stays_local_p;
   const struct elf_backend_data *bed;
   struct elf_link_hash_table *hash_table;
 
   if (h == NULL)
-    return FALSE;
+    return false;
 
   while (h->root.type == bfd_link_hash_indirect
 	 || h->root.type == bfd_link_hash_warning)
@@ -3229,9 +3229,9 @@ _bfd_elf_dynamic_symbol_p (struct elf_link_hash_entry *h,
 
   /* If it was forced local, then clearly it's not dynamic.  */
   if (h->dynindx == -1)
-    return FALSE;
+    return false;
   if (h->forced_local)
-    return FALSE;
+    return false;
 
   /* Identify the cases where name binding rules say that a
      visible symbol resolves locally.  */
@@ -3242,12 +3242,12 @@ _bfd_elf_dynamic_symbol_p (struct elf_link_hash_entry *h,
     {
     case STV_INTERNAL:
     case STV_HIDDEN:
-      return FALSE;
+      return false;
 
     case STV_PROTECTED:
       hash_table = elf_hash_table (info);
       if (!is_elf_hash_table (hash_table))
-	return FALSE;
+	return false;
 
       bed = get_elf_backend_data (hash_table->dynobj);
 
@@ -3255,7 +3255,7 @@ _bfd_elf_dynamic_symbol_p (struct elf_link_hash_entry *h,
 	 that these symbols perhaps be resolved dynamically, even though
 	 we should be resolving them to the current module.  */
       if (!not_local_protected || !bed->is_function_type (h->type))
-	binding_stays_local_p = TRUE;
+	binding_stays_local_p = true;
       break;
 
     default:
@@ -3264,7 +3264,7 @@ _bfd_elf_dynamic_symbol_p (struct elf_link_hash_entry *h,
 
   /* If it isn't defined locally, then clearly it's dynamic.  */
   if (!h->def_regular && !ELF_COMMON_DEF_P (h))
-    return TRUE;
+    return true;
 
   /* Otherwise, the symbol is dynamic if binding rules don't tell
      us that it remains local.  */
@@ -3284,26 +3284,26 @@ _bfd_elf_dynamic_symbol_p (struct elf_link_hash_entry *h,
    treatment of undefined weak symbols.  For those that do not make
    undefined weak symbols dynamic, both functions may return false.  */
 
-bfd_boolean
+bool
 _bfd_elf_symbol_refs_local_p (struct elf_link_hash_entry *h,
 			      struct bfd_link_info *info,
-			      bfd_boolean local_protected)
+			      bool local_protected)
 {
   const struct elf_backend_data *bed;
   struct elf_link_hash_table *hash_table;
 
   /* If it's a local sym, of course we resolve locally.  */
   if (h == NULL)
-    return TRUE;
+    return true;
 
   /* STV_HIDDEN or STV_INTERNAL ones must be local.  */
   if (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN
       || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL)
-    return TRUE;
+    return true;
 
   /* Forced local symbols resolve locally.  */
   if (h->forced_local)
-    return TRUE;
+    return true;
 
   /* Common symbols that become definitions don't get the DEF_REGULAR
      flag set, so test it first, and don't bail out.  */
@@ -3312,26 +3312,26 @@ _bfd_elf_symbol_refs_local_p (struct elf_link_hash_entry *h,
   /* If we don't have a definition in a regular file, then we can't
      resolve locally.  The sym is either undefined or dynamic.  */
   else if (!h->def_regular)
-    return FALSE;
+    return false;
 
   /* Non-dynamic symbols resolve locally.  */
   if (h->dynindx == -1)
-    return TRUE;
+    return true;
 
   /* At this point, we know the symbol is defined and dynamic.  In an
      executable it must resolve locally, likewise when building symbolic
      shared libraries.  */
   if (bfd_link_executable (info) || SYMBOLIC_BIND (info, h))
-    return TRUE;
+    return true;
 
   /* Now deal with defined dynamic symbols in shared libraries.  Ones
      with default visibility might not resolve locally.  */
   if (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
-    return FALSE;
+    return false;
 
   hash_table = elf_hash_table (info);
   if (!is_elf_hash_table (hash_table))
-    return TRUE;
+    return true;
 
   bed = get_elf_backend_data (hash_table->dynobj);
 
@@ -3341,7 +3341,7 @@ _bfd_elf_symbol_refs_local_p (struct elf_link_hash_entry *h,
        || (info->extern_protected_data < 0
 	   && !bed->extern_protected_data))
       && !bed->is_function_type (h->type))
-    return TRUE;
+    return true;
 
   /* Function pointer equality tests may require that STV_PROTECTED
      symbols be treated as dynamic symbols.  If the address of a
@@ -3380,7 +3380,7 @@ _bfd_elf_tls_setup (bfd *obfd, struct bfd_link_info *info)
 }
 
 /* Return TRUE iff this is a non-common, definition of a non-function symbol.  */
-static bfd_boolean
+static bool
 is_global_data_symbol_definition (bfd *abfd ATTRIBUTE_UNUSED,
 				  Elf_Internal_Sym *sym)
 {
@@ -3389,21 +3389,21 @@ is_global_data_symbol_definition (bfd *abfd ATTRIBUTE_UNUSED,
   /* Local symbols do not count, but target specific ones might.  */
   if (ELF_ST_BIND (sym->st_info) != STB_GLOBAL
       && ELF_ST_BIND (sym->st_info) < STB_LOOS)
-    return FALSE;
+    return false;
 
   bed = get_elf_backend_data (abfd);
   /* Function symbols do not count.  */
   if (bed->is_function_type (ELF_ST_TYPE (sym->st_info)))
-    return FALSE;
+    return false;
 
   /* If the section is undefined, then so is the symbol.  */
   if (sym->st_shndx == SHN_UNDEF)
-    return FALSE;
+    return false;
 
   /* If the symbol is defined in the common section, then
      it is a common definition and so does not count.  */
   if (bed->common_definition (sym))
-    return FALSE;
+    return false;
 
   /* If the symbol is in a target specific section then we
      must rely upon the backend to tell us what it is.  */
@@ -3415,15 +3415,15 @@ is_global_data_symbol_definition (bfd *abfd ATTRIBUTE_UNUSED,
        Instead for now assume that the definition is not global,
        Even if this is wrong, at least the linker will behave
        in the same way that it used to do.  */
-    return FALSE;
+    return false;
 
-  return TRUE;
+  return true;
 }
 
 /* Search the symbol table of the archive element of the archive ABFD
    whose archive map contains a mention of SYMDEF, and determine if
    the symbol is defined in this element.  */
-static bfd_boolean
+static bool
 elf_link_is_defined_archive_symbol (bfd * abfd, carsym * symdef)
 {
   Elf_Internal_Shdr * hdr;
@@ -3433,14 +3433,14 @@ elf_link_is_defined_archive_symbol (bfd * abfd, carsym * symdef)
   Elf_Internal_Sym *isymbuf;
   Elf_Internal_Sym *isym;
   Elf_Internal_Sym *isymend;
-  bfd_boolean result;
+  bool result;
 
   abfd = _bfd_get_elt_at_filepos (abfd, symdef->file_offset);
   if (abfd == NULL)
-    return FALSE;
+    return false;
 
   if (! bfd_check_format (abfd, bfd_object))
-    return FALSE;
+    return false;
 
   /* Select the appropriate symbol table.  If we don't know if the
      object file is an IR object, give linker LTO plugin a chance to
@@ -3478,16 +3478,16 @@ elf_link_is_defined_archive_symbol (bfd * abfd, carsym * symdef)
     }
 
   if (extsymcount == 0)
-    return FALSE;
+    return false;
 
   /* Read in the symbol table.  */
   isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff,
 				  NULL, NULL, NULL);
   if (isymbuf == NULL)
-    return FALSE;
+    return false;
 
   /* Scan the symbol table looking for SYMDEF.  */
-  result = FALSE;
+  result = false;
   for (isym = isymbuf, isymend = isymbuf + extsymcount; isym < isymend; isym++)
     {
       const char *name;
@@ -3511,7 +3511,7 @@ elf_link_is_defined_archive_symbol (bfd * abfd, carsym * symdef)
 
 /* Add an entry to the .dynamic table.  */
 
-bfd_boolean
+bool
 _bfd_elf_add_dynamic_entry (struct bfd_link_info *info,
 			    bfd_vma tag,
 			    bfd_vma val)
@@ -3525,10 +3525,10 @@ _bfd_elf_add_dynamic_entry (struct bfd_link_info *info,
 
   hash_table = elf_hash_table (info);
   if (! is_elf_hash_table (hash_table))
-    return FALSE;
+    return false;
 
   if (tag == DT_RELA || tag == DT_REL)
-    hash_table->dynamic_relocs = TRUE;
+    hash_table->dynamic_relocs = true;
 
   bed = get_elf_backend_data (hash_table->dynobj);
   s = bfd_get_linker_section (hash_table->dynobj, ".dynamic");
@@ -3537,7 +3537,7 @@ _bfd_elf_add_dynamic_entry (struct bfd_link_info *info,
   newsize = s->size + bed->s->sizeof_dyn;
   newcontents = (bfd_byte *) bfd_realloc (s->contents, newsize);
   if (newcontents == NULL)
-    return FALSE;
+    return false;
 
   dyn.d_tag = tag;
   dyn.d_un.d_val = val;
@@ -3546,12 +3546,12 @@ _bfd_elf_add_dynamic_entry (struct bfd_link_info *info,
   s->size = newsize;
   s->contents = newcontents;
 
-  return TRUE;
+  return true;
 }
 
 /* Strip zero-sized dynamic sections.  */
 
-bfd_boolean
+bool
 _bfd_elf_strip_zero_sized_dynamic_sections (struct bfd_link_info *info)
 {
   struct elf_link_hash_table *hash_table;
@@ -3561,28 +3561,28 @@ _bfd_elf_strip_zero_sized_dynamic_sections (struct bfd_link_info *info)
   Elf_Internal_Dyn dyn;
   bfd_byte *extdyn, *next;
   void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
-  bfd_boolean strip_zero_sized;
-  bfd_boolean strip_zero_sized_plt;
+  bool strip_zero_sized;
+  bool strip_zero_sized_plt;
 
   if (bfd_link_relocatable (info))
-    return TRUE;
+    return true;
 
   hash_table = elf_hash_table (info);
   if (!is_elf_hash_table (hash_table))
-    return FALSE;
+    return false;
 
   if (!hash_table->dynobj)
-    return TRUE;
+    return true;
 
   sdynamic= bfd_get_linker_section (hash_table->dynobj, ".dynamic");
   if (!sdynamic)
-    return TRUE;
+    return true;
 
   bed = get_elf_backend_data (hash_table->dynobj);
   swap_dyn_in = bed->s->swap_dyn_in;
 
-  strip_zero_sized = FALSE;
-  strip_zero_sized_plt = FALSE;
+  strip_zero_sized = false;
+  strip_zero_sized_plt = false;
 
   /* Strip zero-sized dynamic sections.  */
   rela_dyn = bfd_get_section_by_name (info->output_bfd, ".rela.dyn");
@@ -3596,7 +3596,7 @@ _bfd_elf_strip_zero_sized_dynamic_sections (struct bfd_link_info *info)
       {
 	*pp = s->next;
 	info->output_bfd->section_count--;
-	strip_zero_sized = TRUE;
+	strip_zero_sized = true;
 	if (s == rela_dyn)
 	  s = rela_dyn;
 	if (s == rel_dyn)
@@ -3604,7 +3604,7 @@ _bfd_elf_strip_zero_sized_dynamic_sections (struct bfd_link_info *info)
 	else if (s == hash_table->splt->output_section)
 	  {
 	    s = hash_table->splt;
-	    strip_zero_sized_plt = TRUE;
+	    strip_zero_sized_plt = true;
 	  }
 	else
 	  s = hash_table->srelplt;
@@ -3644,7 +3644,7 @@ _bfd_elf_strip_zero_sized_dynamic_sections (struct bfd_link_info *info)
       return _bfd_elf_map_sections_to_segments (info->output_bfd, info);
     }
 
-  return TRUE;
+  return true;
 }
 
 /* Add a DT_NEEDED entry for this dynamic object.  Returns -1 on error,
@@ -3662,7 +3662,7 @@ bfd_elf_add_dt_needed_tag (bfd *abfd, struct bfd_link_info *info)
 
   hash_table = elf_hash_table (info);
   soname = elf_dt_name (abfd);
-  strindex = _bfd_elf_strtab_add (hash_table->dynstr, soname, FALSE);
+  strindex = _bfd_elf_strtab_add (hash_table->dynstr, soname, false);
   if (strindex == (size_t) -1)
     return -1;
 
@@ -3704,7 +3704,7 @@ bfd_elf_add_dt_needed_tag (bfd *abfd, struct bfd_link_info *info)
    (or the end of list if STOP is NULL), and needed by a library that
    will be loaded.  */
 
-static bfd_boolean
+static bool
 on_needed_list (const char *soname,
 		struct bfd_link_needed_list *needed,
 		struct bfd_link_needed_list *stop)
@@ -3720,9 +3720,9 @@ on_needed_list (const char *soname,
 	       the library.  Therefore search prior to the current
 	       LOOK, preventing possible infinite recursion.  */
 	    || on_needed_list (elf_dt_name (look->by), needed, look)))
-      return TRUE;
+      return true;
 
-  return FALSE;
+  return false;
 }
 
 /* Sort symbol by value, section, size, and type.  */
@@ -3784,20 +3784,20 @@ elf_sort_symbol (const void *arg1, const void *arg2)
 /* This function is used to adjust offsets into .dynstr for
    dynamic symbols.  This is called via elf_link_hash_traverse.  */
 
-static bfd_boolean
+static bool
 elf_adjust_dynstr_offsets (struct elf_link_hash_entry *h, void *data)
 {
   struct elf_strtab_hash *dynstr = (struct elf_strtab_hash *) data;
 
   if (h->dynindx != -1)
     h->dynstr_index = _bfd_elf_strtab_offset (dynstr, h->dynstr_index);
-  return TRUE;
+  return true;
 }
 
 /* Assign string offsets in .dynstr, update all structures referencing
    them.  */
 
-static bfd_boolean
+static bool
 elf_finalize_dynstr (bfd *output_bfd, struct bfd_link_info *info)
 {
   struct elf_link_hash_table *hash_table = elf_hash_table (info);
@@ -3924,14 +3924,14 @@ elf_finalize_dynstr (bfd *output_bfd, struct bfd_link_info *info)
       while (need.vn_next);
     }
 
-  return TRUE;
+  return true;
 }
 
 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT.
    The default is to only match when the INPUT and OUTPUT are exactly
    the same target.  */
 
-bfd_boolean
+bool
 _bfd_elf_default_relocs_compatible (const bfd_target *input,
 				    const bfd_target *output)
 {
@@ -3942,20 +3942,20 @@ _bfd_elf_default_relocs_compatible (const bfd_target *input,
    This version is used when different targets for the same architecture
    are virtually identical.  */
 
-bfd_boolean
+bool
 _bfd_elf_relocs_compatible (const bfd_target *input,
 			    const bfd_target *output)
 {
   const struct elf_backend_data *obed, *ibed;
 
   if (input == output)
-    return TRUE;
+    return true;
 
   ibed = xvec_get_elf_backend_data (input);
   obed = xvec_get_elf_backend_data (output);
 
   if (ibed->arch != obed->arch)
-    return FALSE;
+    return false;
 
   /* If both backends are using this function, deem them compatible.  */
   return ibed->relocs_compatible == obed->relocs_compatible;
@@ -3965,7 +3965,7 @@ _bfd_elf_relocs_compatible (const bfd_target *input,
    we are about to handle an as-needed lib, or have finished
    processing the lib.  */
 
-bfd_boolean
+bool
 _bfd_elf_notice_as_needed (bfd *ibfd,
 			   struct bfd_link_info *info,
 			   enum notice_asneeded_action act)
@@ -3975,7 +3975,7 @@ _bfd_elf_notice_as_needed (bfd *ibfd,
 
 /* Check relocations an ELF object file.  */
 
-bfd_boolean
+bool
 _bfd_elf_link_check_relocs (bfd *abfd, struct bfd_link_info *info)
 {
   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
@@ -4009,7 +4009,7 @@ _bfd_elf_link_check_relocs (bfd *abfd, struct bfd_link_info *info)
       for (o = abfd->sections; o != NULL; o = o->next)
 	{
 	  Elf_Internal_Rela *internal_relocs;
-	  bfd_boolean ok;
+	  bool ok;
 
 	  /* Don't check relocations in excluded sections.  Don't do
 	     anything special with non-loaded, non-alloced sections.
@@ -4031,7 +4031,7 @@ _bfd_elf_link_check_relocs (bfd *abfd, struct bfd_link_info *info)
 	  internal_relocs = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
 						       info->keep_memory);
 	  if (internal_relocs == NULL)
-	    return FALSE;
+	    return false;
 
 	  ok = (*bed->check_relocs) (abfd, info, o, internal_relocs);
 
@@ -4039,16 +4039,16 @@ _bfd_elf_link_check_relocs (bfd *abfd, struct bfd_link_info *info)
 	    free (internal_relocs);
 
 	  if (! ok)
-	    return FALSE;
+	    return false;
 	}
     }
 
-  return TRUE;
+  return true;
 }
 
 /* Add symbols from an ELF object file to the linker hash table.  */
 
-static bfd_boolean
+static bool
 elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
 {
   Elf_Internal_Ehdr *ehdr;
@@ -4057,7 +4057,7 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
   size_t extsymcount;
   size_t extsymoff;
   struct elf_link_hash_entry **sym_hash;
-  bfd_boolean dynamic;
+  bool dynamic;
   Elf_External_Versym *extversym = NULL;
   Elf_External_Versym *extversym_end = NULL;
   Elf_External_Versym *ever;
@@ -4068,7 +4068,7 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
   Elf_Internal_Sym *isym;
   Elf_Internal_Sym *isymend;
   const struct elf_backend_data *bed;
-  bfd_boolean add_needed;
+  bool add_needed;
   struct elf_link_hash_table *htab;
   void *alloc_mark = NULL;
   struct bfd_hash_entry **old_table = NULL;
@@ -4081,16 +4081,16 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
   void *old_strtab = NULL;
   size_t tabsize = 0;
   asection *s;
-  bfd_boolean just_syms;
+  bool just_syms;
 
   htab = elf_hash_table (info);
   bed = get_elf_backend_data (abfd);
 
   if ((abfd->flags & DYNAMIC) == 0)
-    dynamic = FALSE;
+    dynamic = false;
   else
     {
-      dynamic = TRUE;
+      dynamic = true;
 
       /* You can't use -r against a dynamic object.  Also, there's no
 	 hope of using a dynamic object which does not exactly match
@@ -4149,7 +4149,7 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
 	    {
 	      struct elf_link_hash_entry *h;
 
-	      h = elf_link_hash_lookup (htab, name, FALSE, FALSE, TRUE);
+	      h = elf_link_hash_lookup (htab, name, false, false, true);
 
 	      /* FIXME: What about bfd_link_hash_common?  */
 	      if (h != NULL
@@ -4170,7 +4170,7 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
 
 	  if (! (_bfd_generic_link_add_one_symbol
 		 (info, abfd, name, BSF_WARNING, s, 0, msg,
-		  FALSE, bed->collect, NULL)))
+		  false, bed->collect, NULL)))
 	    goto error_return;
 
 	  if (bfd_link_executable (info))
@@ -4189,7 +4189,7 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
   just_syms = ((s = abfd->sections) != NULL
 	       && s->sec_info_type == SEC_INFO_TYPE_JUST_SYMS);
 
-  add_needed = TRUE;
+  add_needed = true;
   if (! dynamic)
     {
       /* If we are creating a shared library, create all the dynamic
@@ -4421,14 +4421,14 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
 	   loaded_lib = loaded_lib->next)
 	{
 	  if (strcmp (elf_dt_name (loaded_lib->abfd), soname) == 0)
-	    return TRUE;
+	    return true;
 	}
 
       /* Create dynamic sections for backends that require that be done
 	 before setup_gnu_properties.  */
       if (add_needed
 	  && !_bfd_elf_link_create_dynamic_sections (abfd, info))
-	return FALSE;
+	return false;
 
       /* Save the DT_AUDIT entry for the linker emulation code. */
       elf_dt_audit (abfd) = audit;
@@ -4622,18 +4622,18 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
       const char *name;
       struct elf_link_hash_entry *h;
       struct elf_link_hash_entry *hi;
-      bfd_boolean definition;
-      bfd_boolean size_change_ok;
-      bfd_boolean type_change_ok;
-      bfd_boolean new_weak;
-      bfd_boolean old_weak;
+      bool definition;
+      bool size_change_ok;
+      bool type_change_ok;
+      bool new_weak;
+      bool old_weak;
       bfd *override;
-      bfd_boolean common;
-      bfd_boolean discarded;
+      bool common;
+      bool discarded;
       unsigned int old_alignment;
       unsigned int shindex;
       bfd *old_bfd;
-      bfd_boolean matched;
+      bool matched;
 
       override = NULL;
 
@@ -4645,9 +4645,9 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
 	{
 	  /* Treat common symbol as undefined for --no-define-common.  */
 	  isym->st_shndx = SHN_UNDEF;
-	  common = FALSE;
+	  common = false;
 	}
-      discarded = FALSE;
+      discarded = false;
 
       bind = ELF_ST_BIND (isym->st_info);
       switch (bind)
@@ -4716,7 +4716,7 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
 	      /* Symbols from discarded section are undefined.  We keep
 		 its visibility.  */
 	      sec = bfd_und_section_ptr;
-	      discarded = TRUE;
+	      discarded = true;
 	      isym->st_shndx = SHN_UNDEF;
 	    }
 	  else if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
@@ -4784,14 +4784,14 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
 
       if (bfd_is_und_section (sec)
 	  || bfd_is_com_section (sec))
-	definition = FALSE;
+	definition = false;
       else
-	definition = TRUE;
+	definition = true;
 
-      size_change_ok = FALSE;
+      size_change_ok = false;
       type_change_ok = bed->type_change_ok;
-      old_weak = FALSE;
-      matched = FALSE;
+      old_weak = false;
+      matched = false;
       old_alignment = 0;
       old_bfd = NULL;
       new_sec = sec;
@@ -4800,7 +4800,7 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
 	{
 	  Elf_Internal_Versym iver;
 	  unsigned int vernum = 0;
-	  bfd_boolean skip;
+	  bool skip;
 
 	  if (ever == NULL)
 	    {
@@ -4941,7 +4941,7 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
 	  /* Override a definition only if the new symbol matches the
 	     existing one.  */
 	  if (override && matched)
-	    definition = FALSE;
+	    definition = false;
 
 	  h = *sym_hash;
 	  while (h->root.type == bfd_link_hash_indirect
@@ -4956,7 +4956,7 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
 
       if (! (_bfd_generic_link_add_one_symbol
 	     (info, override ? override : abfd, name, flags, sec, value,
-	      NULL, FALSE, bed->collect,
+	      NULL, false, bed->collect,
 	      (struct bfd_link_hash_entry **) sym_hash)))
 	goto error_free_vers;
 
@@ -5025,7 +5025,7 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
 	     reference or definition we just found.  A dynamic symbol
 	     is one which is referenced or defined by both a regular
 	     object and a shared object.  */
-	  bfd_boolean dynsym = FALSE;
+	  bool dynsym = false;
 
 	  /* Plugin symbols aren't normal.  Don't set def/ref flags.  */
 	  if ((abfd->flags & BFD_PLUGIN) != 0)
@@ -5076,7 +5076,7 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
 	      if (bfd_link_dll (info)
 		  || h->def_dynamic
 		  || h->ref_dynamic)
-		dynsym = TRUE;
+		dynsym = true;
 	    }
 	  else
 	    {
@@ -5084,7 +5084,7 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
 		  || h->ref_regular
 		  || (h->is_weakalias
 		      && weakdef (h)->dynindx != -1))
-		dynsym = TRUE;
+		dynsym = true;
 	    }
 
 	  /* Check to see if we need to add an indirect symbol for
@@ -5220,11 +5220,11 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
 	  if (definition
 	      && (sec->flags & SEC_DEBUGGING)
 	      && !bfd_link_relocatable (info))
-	    dynsym = FALSE;
+	    dynsym = false;
 
 	  /* Nor should we make plugin symbols dynamic.  */
 	  if ((abfd->flags & BFD_PLUGIN) != 0)
-	    dynsym = FALSE;
+	    dynsym = false;
 
 	  if (definition)
 	    {
@@ -5271,8 +5271,8 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
 	      {
 	      case STV_INTERNAL:
 	      case STV_HIDDEN:
-		(*bed->elf_backend_hide_symbol) (info, h, TRUE);
-		dynsym = FALSE;
+		(*bed->elf_backend_hide_symbol) (info, h, true);
+		dynsym = false;
 		break;
 	      }
 
@@ -5318,8 +5318,8 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
 	      /* Create dynamic sections for backends that require
 		 that be done before setup_gnu_properties.  */
 	      if (!_bfd_elf_link_create_dynamic_sections (abfd, info))
-		return FALSE;
-	      add_needed = TRUE;
+		return false;
+	      add_needed = true;
 	    }
 	}
     }
@@ -5449,7 +5449,7 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
       objalloc_free_block ((struct objalloc *) htab->root.table.memory,
 			   alloc_mark);
       free (nondeflt_vers);
-      return TRUE;
+      return true;
     }
 
   if (old_tab != NULL)
@@ -5488,13 +5488,13 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
 
 	  hi = (struct elf_link_hash_entry *)
 	       bfd_link_hash_lookup (&htab->root, shortname,
-				     FALSE, FALSE, FALSE);
+				     false, false, false);
 	  if (hi != NULL
 	      && hi->root.type == h->root.type
 	      && hi->root.u.def.value == h->root.u.def.value
 	      && hi->root.u.def.section == h->root.u.def.section)
 	    {
-	      (*bed->elf_backend_hide_symbol) (info, hi, TRUE);
+	      (*bed->elf_backend_hide_symbol) (info, hi, true);
 	      hi->root.type = bfd_link_hash_indirect;
 	      hi->root.u.i.link = (struct bfd_link_hash_entry *) h;
 	      (*bed->elf_backend_copy_indirect_symbol) (info, h, hi);
@@ -5675,7 +5675,7 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
 
   if (bed->check_directives
       && !(*bed->check_directives) (abfd, info))
-    return FALSE;
+    return false;
 
   /* If this is a non-traditional link, try to optimize the handling
      of the .stab/.stabstr sections.  */
@@ -5728,7 +5728,7 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
       && (elf_dyn_lib_class (abfd) & DYN_DT_NEEDED) != 0)
     elf_dyn_lib_class (abfd) |= DYN_NO_NEEDED;
 
-  return TRUE;
+  return true;
 
  error_free_vers:
   free (old_tab);
@@ -5738,7 +5738,7 @@ elf_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
  error_free_sym:
   free (isymbuf);
  error_return:
-  return FALSE;
+  return false;
 }
 
 /* Return the linker hash table entry of a symbol that might be
@@ -5753,7 +5753,7 @@ _bfd_elf_archive_symbol_lookup (bfd *abfd,
   char *p, *copy;
   size_t len, first;
 
-  h = elf_link_hash_lookup (elf_hash_table (info), name, FALSE, FALSE, TRUE);
+  h = elf_link_hash_lookup (elf_hash_table (info), name, false, false, true);
   if (h != NULL)
     return h;
 
@@ -5776,14 +5776,14 @@ _bfd_elf_archive_symbol_lookup (bfd *abfd,
   memcpy (copy, name, first);
   memcpy (copy + first, name + first + 1, len - first);
 
-  h = elf_link_hash_lookup (elf_hash_table (info), copy, FALSE, FALSE, TRUE);
+  h = elf_link_hash_lookup (elf_hash_table (info), copy, false, false, true);
   if (h == NULL)
     {
       /* We also need to check references to the symbol without the
 	 version.  */
       copy[first - 1] = '\0';
       h = elf_link_hash_lookup (elf_hash_table (info), copy,
-				FALSE, FALSE, TRUE);
+				false, false, true);
     }
 
   bfd_release (abfd, copy);
@@ -5803,13 +5803,13 @@ _bfd_elf_archive_symbol_lookup (bfd *abfd,
    Unfortunately, we do have to make multiple passes over the symbol
    table until nothing further is resolved.  */
 
-static bfd_boolean
+static bool
 elf_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info)
 {
   symindex c;
   unsigned char *included = NULL;
   carsym *symdefs;
-  bfd_boolean loop;
+  bool loop;
   size_t amt;
   const struct elf_backend_data *bed;
   struct elf_link_hash_entry * (*archive_symbol_lookup)
@@ -5819,9 +5819,9 @@ elf_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info)
     {
       /* An empty archive is a special case.  */
       if (bfd_openr_next_archived_file (abfd, NULL) == NULL)
-	return TRUE;
+	return true;
       bfd_set_error (bfd_error_no_armap);
-      return FALSE;
+      return false;
     }
 
   /* Keep track of all symbols we know to be already defined, and all
@@ -5829,11 +5829,11 @@ elf_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info)
      second and subsequent passes.  */
   c = bfd_ardata (abfd)->symdef_count;
   if (c == 0)
-    return TRUE;
+    return true;
   amt = c * sizeof (*included);
   included = (unsigned char *) bfd_zmalloc (amt);
   if (included == NULL)
-    return FALSE;
+    return false;
 
   symdefs = bfd_ardata (abfd)->symdefs;
   bed = get_elf_backend_data (abfd);
@@ -5846,7 +5846,7 @@ elf_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info)
       carsym *symdef;
       carsym *symdefend;
 
-      loop = FALSE;
+      loop = false;
       last = -1;
 
       symdef = symdefs;
@@ -5862,7 +5862,7 @@ elf_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info)
 	    continue;
 	  if (symdef->file_offset == last)
 	    {
-	      included[i] = TRUE;
+	      included[i] = true;
 	      continue;
 	    }
 
@@ -5902,7 +5902,7 @@ elf_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info)
 	    {
 	      if (h->root.type != bfd_link_hash_undefweak)
 		/* Symbol must be defined.  Don't check it again.  */
-		included[i] = TRUE;
+		included[i] = true;
 	      continue;
 	    }
 
@@ -5930,14 +5930,14 @@ elf_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info)
 	     does not require another pass.  This isn't a bug, but it
 	     does make the code less efficient than it could be.  */
 	  if (undefs_tail != info->hash->undefs_tail)
-	    loop = TRUE;
+	    loop = true;
 
 	  /* Look backward to mark all symbols from this object file
 	     which we have already seen in this pass.  */
 	  mark = i;
 	  do
 	    {
-	      included[mark] = TRUE;
+	      included[mark] = true;
 	      if (mark == 0)
 		break;
 	      --mark;
@@ -5952,17 +5952,17 @@ elf_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info)
   while (loop);
 
   free (included);
-  return TRUE;
+  return true;
 
  error_return:
   free (included);
-  return FALSE;
+  return false;
 }
 
 /* Given an ELF BFD, add symbols to the global hash table as
    appropriate.  */
 
-bfd_boolean
+bool
 bfd_elf_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
 {
   switch (bfd_get_format (abfd))
@@ -5973,20 +5973,20 @@ bfd_elf_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
       return elf_link_add_archive_symbols (abfd, info);
     default:
       bfd_set_error (bfd_error_wrong_format);
-      return FALSE;
+      return false;
     }
 }
 
 struct hash_codes_info
 {
   unsigned long *hashcodes;
-  bfd_boolean error;
+  bool error;
 };
 
 /* This function will be called though elf_link_hash_traverse to store
    all hash value of the exported symbols in an array.  */
 
-static bfd_boolean
+static bool
 elf_collect_hash_codes (struct elf_link_hash_entry *h, void *data)
 {
   struct hash_codes_info *inf = (struct hash_codes_info *) data;
@@ -5996,7 +5996,7 @@ elf_collect_hash_codes (struct elf_link_hash_entry *h, void *data)
 
   /* Ignore indirect symbols.  These are added by the versioning code.  */
   if (h->dynindx == -1)
-    return TRUE;
+    return true;
 
   name = h->root.root.string;
   if (h->versioned >= versioned)
@@ -6007,8 +6007,8 @@ elf_collect_hash_codes (struct elf_link_hash_entry *h, void *data)
 	  alc = (char *) bfd_malloc (p - name + 1);
 	  if (alc == NULL)
 	    {
-	      inf->error = TRUE;
-	      return FALSE;
+	      inf->error = true;
+	      return false;
 	    }
 	  memcpy (alc, name, p - name);
 	  alc[p - name] = '\0';
@@ -6027,7 +6027,7 @@ elf_collect_hash_codes (struct elf_link_hash_entry *h, void *data)
   h->u.elf_hash_value = ha;
 
   free (alc);
-  return TRUE;
+  return true;
 }
 
 struct collect_gnu_hash_codes
@@ -6049,13 +6049,13 @@ struct collect_gnu_hash_codes
   long int local_indx;
   long int shift1, shift2;
   unsigned long int mask;
-  bfd_boolean error;
+  bool error;
 };
 
 /* This function will be called though elf_link_hash_traverse to store
    all hash value of the exported symbols in an array.  */
 
-static bfd_boolean
+static bool
 elf_collect_gnu_hash_codes (struct elf_link_hash_entry *h, void *data)
 {
   struct collect_gnu_hash_codes *s = (struct collect_gnu_hash_codes *) data;
@@ -6065,11 +6065,11 @@ elf_collect_gnu_hash_codes (struct elf_link_hash_entry *h, void *data)
 
   /* Ignore indirect symbols.  These are added by the versioning code.  */
   if (h->dynindx == -1)
-    return TRUE;
+    return true;
 
   /* Ignore also local symbols and undefined symbols.  */
   if (! (*s->bed->elf_hash_symbol) (h))
-    return TRUE;
+    return true;
 
   name = h->root.root.string;
   if (h->versioned >= versioned)
@@ -6080,8 +6080,8 @@ elf_collect_gnu_hash_codes (struct elf_link_hash_entry *h, void *data)
 	  alc = (char *) bfd_malloc (p - name + 1);
 	  if (alc == NULL)
 	    {
-	      s->error = TRUE;
-	      return FALSE;
+	      s->error = true;
+	      return false;
 	    }
 	  memcpy (alc, name, p - name);
 	  alc[p - name] = '\0';
@@ -6101,7 +6101,7 @@ elf_collect_gnu_hash_codes (struct elf_link_hash_entry *h, void *data)
     s->min_dynindx = h->dynindx;
 
   free (alc);
-  return TRUE;
+  return true;
 }
 
 /* This function will be called though elf_link_hash_traverse to do
@@ -6109,7 +6109,7 @@ elf_collect_gnu_hash_codes (struct elf_link_hash_entry *h, void *data)
    If using .MIPS.xhash, invoke record_xhash_symbol to add symbol index
    to the translation table.  */
 
-static bfd_boolean
+static bool
 elf_gnu_hash_process_symidx (struct elf_link_hash_entry *h, void *data)
 {
   struct collect_gnu_hash_codes *s = (struct collect_gnu_hash_codes *) data;
@@ -6118,7 +6118,7 @@ elf_gnu_hash_process_symidx (struct elf_link_hash_entry *h, void *data)
 
   /* Ignore indirect symbols.  */
   if (h->dynindx == -1)
-    return TRUE;
+    return true;
 
   /* Ignore also local symbols and undefined symbols.  */
   if (! (*s->bed->elf_hash_symbol) (h))
@@ -6133,7 +6133,7 @@ elf_gnu_hash_process_symidx (struct elf_link_hash_entry *h, void *data)
 	  else
 	    h->dynindx = s->local_indx++;
 	}
-      return TRUE;
+      return true;
     }
 
   bucket = s->hashval[h->dynindx] % s->bucketcount;
@@ -6157,12 +6157,12 @@ elf_gnu_hash_process_symidx (struct elf_link_hash_entry *h, void *data)
     }
   else
     h->dynindx = s->indx[bucket]++;
-  return TRUE;
+  return true;
 }
 
 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
 
-bfd_boolean
+bool
 _bfd_elf_hash_symbol (struct elf_link_hash_entry *h)
 {
   return !(h->forced_local
@@ -6332,7 +6332,7 @@ compute_bucket_count (struct bfd_link_info *info ATTRIBUTE_UNUSED,
 
 /* Size any SHT_GROUP section for ld -r.  */
 
-bfd_boolean
+bool
 _bfd_elf_size_group_sections (struct bfd_link_info *info)
 {
   bfd *ibfd;
@@ -6343,15 +6343,15 @@ _bfd_elf_size_group_sections (struct bfd_link_info *info)
 	&& (s = ibfd->sections) != NULL
 	&& s->sec_info_type != SEC_INFO_TYPE_JUST_SYMS
 	&& !_bfd_elf_fixup_group_sections (ibfd, bfd_abs_section_ptr))
-      return FALSE;
-  return TRUE;
+      return false;
+  return true;
 }
 
 /* Set a default stack segment size.  The value in INFO wins.  If it
    is unset, LEGACY_SYMBOL's value is used, and if that symbol is
    undefined it is initialized.  */
 
-bfd_boolean
+bool
 bfd_elf_stack_segment_size (bfd *output_bfd,
 			    struct bfd_link_info *info,
 			    const char *legacy_symbol,
@@ -6362,7 +6362,7 @@ bfd_elf_stack_segment_size (bfd *output_bfd,
   /* Look for legacy symbol.  */
   if (legacy_symbol)
     h = elf_link_hash_lookup (elf_hash_table (info), legacy_symbol,
-			      FALSE, FALSE, FALSE);
+			      false, false, false);
   if (h && (h->root.type == bfd_link_hash_defined
 	    || h->root.type == bfd_link_hash_defweak)
       && h->def_regular
@@ -6397,15 +6397,15 @@ bfd_elf_stack_segment_size (bfd *output_bfd,
 	    (info, output_bfd, legacy_symbol,
 	     BSF_GLOBAL, bfd_abs_section_ptr,
 	     info->stacksize >= 0 ? info->stacksize : 0,
-	     NULL, FALSE, get_elf_backend_data (output_bfd)->collect, &bh)))
-	return FALSE;
+	     NULL, false, get_elf_backend_data (output_bfd)->collect, &bh)))
+	return false;
 
       h = (struct elf_link_hash_entry *) bh;
       h->def_regular = 1;
       h->type = STT_OBJECT;
     }
 
-  return TRUE;
+  return true;
 }
 
 /* Sweep symbols in swept sections.  Called via elf_link_hash_traverse.  */
@@ -6414,10 +6414,10 @@ struct elf_gc_sweep_symbol_info
 {
   struct bfd_link_info *info;
   void (*hide_symbol) (struct bfd_link_info *, struct elf_link_hash_entry *,
-		       bfd_boolean);
+		       bool);
 };
 
-static bfd_boolean
+static bool
 elf_gc_sweep_symbol (struct elf_link_hash_entry *h, void *data)
 {
   if (!h->mark
@@ -6431,13 +6431,13 @@ elf_gc_sweep_symbol (struct elf_link_hash_entry *h, void *data)
       struct elf_gc_sweep_symbol_info *inf;
 
       inf = (struct elf_gc_sweep_symbol_info *) data;
-      (*inf->hide_symbol) (inf->info, h, TRUE);
+      (*inf->hide_symbol) (inf->info, h, true);
       h->def_regular = 0;
       h->ref_regular = 0;
       h->ref_regular_nonweak = 0;
     }
 
-  return TRUE;
+  return true;
 }
 
 /* Set up the sizes and contents of the ELF dynamic sections.  This is
@@ -6445,7 +6445,7 @@ elf_gc_sweep_symbol (struct elf_link_hash_entry *h, void *data)
    must set the sizes of the sections before the linker sets the
    addresses of the various sections.  */
 
-bfd_boolean
+bool
 bfd_elf_size_dynamic_sections (bfd *output_bfd,
 			       const char *soname,
 			       const char *rpath,
@@ -6462,7 +6462,7 @@ bfd_elf_size_dynamic_sections (bfd *output_bfd,
   *sinterpptr = NULL;
 
   if (!is_elf_hash_table (info->hash))
-    return TRUE;
+    return true;
 
   dynobj = elf_hash_table (info)->dynobj;
 
@@ -6483,21 +6483,21 @@ bfd_elf_size_dynamic_sections (bfd *output_bfd,
 	  struct elf_info_failed eif;
 
 	  eif.info = info;
-	  eif.failed = FALSE;
+	  eif.failed = false;
 	  elf_link_hash_traverse (elf_hash_table (info),
 				  _bfd_elf_export_symbol,
 				  &eif);
 	  if (eif.failed)
-	    return FALSE;
+	    return false;
 	}
 
       if (soname != NULL)
 	{
 	  soname_indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
-					     soname, TRUE);
+					     soname, true);
 	  if (soname_indx == (size_t) -1
 	      || !_bfd_elf_add_dynamic_entry (info, DT_SONAME, soname_indx))
-	    return FALSE;
+	    return false;
 	}
       else
 	soname_indx = (size_t) -1;
@@ -6521,7 +6521,7 @@ bfd_elf_size_dynamic_sections (bfd *output_bfd,
 
 	      newname = (char *) bfd_malloc (newlen);
 	      if (newname == NULL)
-		return FALSE;
+		return false;
 	      newname[0] = leading_char;
 	      memcpy (newname + (leading_char != '\0'), name, namelen);
 
@@ -6530,8 +6530,8 @@ bfd_elf_size_dynamic_sections (bfd *output_bfd,
 	      *p++ = ELF_VER_CHR;
 	      memcpy (p, verstr, verlen + 1);
 	      newh = elf_link_hash_lookup (elf_hash_table (info),
-					   newname, FALSE, FALSE,
-					   FALSE);
+					   newname, false, false,
+					   false);
 	      if (newh == NULL
 		  || (newh->root.type != bfd_link_hash_defined
 		      && newh->root.type != bfd_link_hash_defweak))
@@ -6540,8 +6540,8 @@ bfd_elf_size_dynamic_sections (bfd *output_bfd,
 		  *p++ = ELF_VER_CHR;
 		  memcpy (p, verstr, verlen + 1);
 		  newh = elf_link_hash_lookup (elf_hash_table (info),
-					       newname, FALSE, FALSE,
-					       FALSE);
+					       newname, false, false,
+					       false);
 		}
 	      free (newname);
 
@@ -6556,18 +6556,18 @@ bfd_elf_size_dynamic_sections (bfd *output_bfd,
 
       /* Attach all the symbols to their version information.  */
       asvinfo.info = info;
-      asvinfo.failed = FALSE;
+      asvinfo.failed = false;
 
       elf_link_hash_traverse (elf_hash_table (info),
 			      _bfd_elf_link_assign_sym_version,
 			      &asvinfo);
       if (asvinfo.failed)
-	return FALSE;
+	return false;
 
       if (!info->allow_undefined_version)
 	{
 	  /* Check if all global versions have a definition.  */
-	  bfd_boolean all_defined = TRUE;
+	  bool all_defined = true;
 	  for (t = info->version_info; t != NULL; t = t->next)
 	    for (d = t->globals.list; d != NULL; d = d->next)
 	      if (d->literal && !d->symver && !d->script)
@@ -6575,13 +6575,13 @@ bfd_elf_size_dynamic_sections (bfd *output_bfd,
 		  _bfd_error_handler
 		    (_("%s: undefined version: %s"),
 		     d->pattern, t->name);
-		  all_defined = FALSE;
+		  all_defined = false;
 		}
 
 	  if (!all_defined)
 	    {
 	      bfd_set_error (bfd_error_bad_value);
-	      return FALSE;
+	      return false;
 	    }
 	}
 
@@ -6644,7 +6644,7 @@ bfd_elf_size_dynamic_sections (bfd *output_bfd,
 	  s->size = size;
 	  s->contents = (unsigned char *) bfd_alloc (output_bfd, s->size);
 	  if (s->contents == NULL && s->size != 0)
-	    return FALSE;
+	    return false;
 
 	  /* Fill in the version definition section.  */
 
@@ -6681,9 +6681,9 @@ bfd_elf_size_dynamic_sections (bfd *output_bfd,
 	      name = lbasename (bfd_get_filename (output_bfd));
 	      def.vd_hash = bfd_elf_hash (name);
 	      indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
-					  name, FALSE);
+					  name, false);
 	      if (indx == (size_t) -1)
-		return FALSE;
+		return false;
 	      defaux.vda_name = indx;
 	    }
 	  defaux.vda_next = 0;
@@ -6697,9 +6697,9 @@ bfd_elf_size_dynamic_sections (bfd *output_bfd,
 	      bh = NULL;
 	      if (! (_bfd_generic_link_add_one_symbol
 		     (info, dynobj, name, BSF_GLOBAL, bfd_abs_section_ptr,
-		      0, NULL, FALSE,
+		      0, NULL, false,
 		      get_elf_backend_data (dynobj)->collect, &bh)))
-		return FALSE;
+		return false;
 	      h = (struct elf_link_hash_entry *) bh;
 	      h->non_elf = 0;
 	      h->def_regular = 1;
@@ -6707,7 +6707,7 @@ bfd_elf_size_dynamic_sections (bfd *output_bfd,
 	      h->verinfo.vertree = NULL;
 
 	      if (! bfd_elf_link_record_dynamic_symbol (info, h))
-		return FALSE;
+		return false;
 
 	      /* Create a duplicate of the base version with the same
 		 aux block, but different flags.  */
@@ -6744,9 +6744,9 @@ bfd_elf_size_dynamic_sections (bfd *output_bfd,
 	      bh = NULL;
 	      if (! (_bfd_generic_link_add_one_symbol
 		     (info, dynobj, t->name, BSF_GLOBAL, bfd_abs_section_ptr,
-		      0, NULL, FALSE,
+		      0, NULL, false,
 		      get_elf_backend_data (dynobj)->collect, &bh)))
-		return FALSE;
+		return false;
 	      h = (struct elf_link_hash_entry *) bh;
 	      h->non_elf = 0;
 	      h->def_regular = 1;
@@ -6754,7 +6754,7 @@ bfd_elf_size_dynamic_sections (bfd *output_bfd,
 	      h->verinfo.vertree = t;
 
 	      if (! bfd_elf_link_record_dynamic_symbol (info, h))
-		return FALSE;
+		return false;
 
 	      def.vd_version = VER_DEF_CURRENT;
 	      def.vd_flags = 0;
@@ -6850,13 +6850,13 @@ bfd_elf_size_dynamic_sections (bfd *output_bfd,
       sinfo.vers = elf_tdata (output_bfd)->cverdefs;
       if (sinfo.vers == 0)
 	sinfo.vers = 1;
-      sinfo.failed = FALSE;
+      sinfo.failed = false;
 
       elf_link_hash_traverse (elf_hash_table (info),
 			      _bfd_elf_link_find_version_dependencies,
 			      &sinfo);
       if (sinfo.failed)
-	return FALSE;
+	return false;
 
       if (elf_tdata (output_bfd)->verref == NULL)
 	s->flags |= SEC_EXCLUDE;
@@ -6885,7 +6885,7 @@ bfd_elf_size_dynamic_sections (bfd *output_bfd,
 	  s->size = size;
 	  s->contents = (unsigned char *) bfd_alloc (output_bfd, s->size);
 	  if (s->contents == NULL)
-	    return FALSE;
+	    return false;
 
 	  p = s->contents;
 	  for (vn = elf_tdata (output_bfd)->verref;
@@ -6907,9 +6907,9 @@ bfd_elf_size_dynamic_sections (bfd *output_bfd,
 					  ? elf_dt_name (vn->vn_bfd)
 					  : lbasename (bfd_get_filename
 						       (vn->vn_bfd)),
-					  FALSE);
+					  false);
 	      if (indx == (size_t) -1)
-		return FALSE;
+		return false;
 	      vn->vn_file = indx;
 	      vn->vn_aux = sizeof (Elf_External_Verneed);
 	      if (vn->vn_nextref == NULL)
@@ -6926,9 +6926,9 @@ bfd_elf_size_dynamic_sections (bfd *output_bfd,
 		{
 		  a->vna_hash = bfd_elf_hash (a->vna_nodename);
 		  indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
-					      a->vna_nodename, FALSE);
+					      a->vna_nodename, false);
 		  if (indx == (size_t) -1)
-		    return FALSE;
+		    return false;
 		  a->vna_name = indx;
 		  if (a->vna_nextptr == NULL)
 		    a->vna_next = 0;
@@ -6954,13 +6954,13 @@ bfd_elf_size_dynamic_sections (bfd *output_bfd,
 
   if (bfd_link_relocatable (info)
       && !_bfd_elf_size_group_sections (info))
-    return FALSE;
+    return false;
 
   /* The backend may have to create some sections regardless of whether
      we're dynamic or not.  */
   if (bed->elf_backend_always_size_sections
       && ! (*bed->elf_backend_always_size_sections) (output_bfd, info))
-    return FALSE;
+    return false;
 
   /* Determine any GNU_STACK segment requirements, after the backend
      has had a chance to set a default segment size.  */
@@ -7017,7 +7017,7 @@ bfd_elf_size_dynamic_sections (bfd *output_bfd,
       if (info->symbolic)
 	{
 	  if (!_bfd_elf_add_dynamic_entry (info, DT_SYMBOLIC, 0))
-	    return FALSE;
+	    return false;
 	  info->flags |= DF_SYMBOLIC;
 	}
 
@@ -7027,13 +7027,13 @@ bfd_elf_size_dynamic_sections (bfd *output_bfd,
 	  bfd_vma tag;
 
 	  indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, rpath,
-				      TRUE);
+				      true);
 	  if (indx == (size_t) -1)
-	    return FALSE;
+	    return false;
 
 	  tag = info->new_dtags ? DT_RUNPATH : DT_RPATH;
 	  if (!_bfd_elf_add_dynamic_entry (info, tag, indx))
-	    return FALSE;
+	    return false;
 	}
 
       if (filter_shlib != NULL)
@@ -7041,10 +7041,10 @@ bfd_elf_size_dynamic_sections (bfd *output_bfd,
 	  size_t indx;
 
 	  indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
-				      filter_shlib, TRUE);
+				      filter_shlib, true);
 	  if (indx == (size_t) -1
 	      || !_bfd_elf_add_dynamic_entry (info, DT_FILTER, indx))
-	    return FALSE;
+	    return false;
 	}
 
       if (auxiliary_filters != NULL)
@@ -7056,10 +7056,10 @@ bfd_elf_size_dynamic_sections (bfd *output_bfd,
 	      size_t indx;
 
 	      indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr,
-					  *p, TRUE);
+					  *p, true);
 	      if (indx == (size_t) -1
 		  || !_bfd_elf_add_dynamic_entry (info, DT_AUXILIARY, indx))
-		return FALSE;
+		return false;
 	    }
 	}
 
@@ -7068,10 +7068,10 @@ bfd_elf_size_dynamic_sections (bfd *output_bfd,
 	  size_t indx;
 
 	  indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, audit,
-				      TRUE);
+				      true);
 	  if (indx == (size_t) -1
 	      || !_bfd_elf_add_dynamic_entry (info, DT_AUDIT, indx))
-	    return FALSE;
+	    return false;
 	}
 
       if (depaudit != NULL)
@@ -7079,14 +7079,14 @@ bfd_elf_size_dynamic_sections (bfd *output_bfd,
 	  size_t indx;
 
 	  indx = _bfd_elf_strtab_add (elf_hash_table (info)->dynstr, depaudit,
-				      TRUE);
+				      true);
 	  if (indx == (size_t) -1
 	      || !_bfd_elf_add_dynamic_entry (info, DT_DEPAUDIT, indx))
-	    return FALSE;
+	    return false;
 	}
 
       eif.info = info;
-      eif.failed = FALSE;
+      eif.failed = false;
 
       /* Find all symbols which were defined in a dynamic object and make
 	 the backend pick a reasonable value for them.  */
@@ -7094,7 +7094,7 @@ bfd_elf_size_dynamic_sections (bfd *output_bfd,
 			      _bfd_elf_adjust_dynamic_symbol,
 			      &eif);
       if (eif.failed)
-	return FALSE;
+	return false;
 
       /* Add some entries to the .dynamic section.  We fill in some of the
 	 values later, in bfd_elf_final_link, but we must add the entries
@@ -7104,27 +7104,27 @@ bfd_elf_size_dynamic_sections (bfd *output_bfd,
 	 call then add the corresponding DT_INIT/DT_FINI entries.  */
       h = (info->init_function
 	   ? elf_link_hash_lookup (elf_hash_table (info),
-				   info->init_function, FALSE,
-				   FALSE, FALSE)
+				   info->init_function, false,
+				   false, false)
 	   : NULL);
       if (h != NULL
 	  && (h->ref_regular
 	      || h->def_regular))
 	{
 	  if (!_bfd_elf_add_dynamic_entry (info, DT_INIT, 0))
-	    return FALSE;
+	    return false;
 	}
       h = (info->fini_function
 	   ? elf_link_hash_lookup (elf_hash_table (info),
-				   info->fini_function, FALSE,
-				   FALSE, FALSE)
+				   info->fini_function, false,
+				   false, false)
 	   : NULL);
       if (h != NULL
 	  && (h->ref_regular
 	      || h->def_regular))
 	{
 	  if (!_bfd_elf_add_dynamic_entry (info, DT_FINI, 0))
-	    return FALSE;
+	    return false;
 	}
 
       s = bfd_get_section_by_name (output_bfd, ".preinit_array");
@@ -7151,26 +7151,26 @@ bfd_elf_size_dynamic_sections (bfd *output_bfd,
 		      }
 
 	      bfd_set_error (bfd_error_nonrepresentable_section);
-	      return FALSE;
+	      return false;
 	    }
 
 	  if (!_bfd_elf_add_dynamic_entry (info, DT_PREINIT_ARRAY, 0)
 	      || !_bfd_elf_add_dynamic_entry (info, DT_PREINIT_ARRAYSZ, 0))
-	    return FALSE;
+	    return false;
 	}
       s = bfd_get_section_by_name (output_bfd, ".init_array");
       if (s != NULL && s->linker_has_input)
 	{
 	  if (!_bfd_elf_add_dynamic_entry (info, DT_INIT_ARRAY, 0)
 	      || !_bfd_elf_add_dynamic_entry (info, DT_INIT_ARRAYSZ, 0))
-	    return FALSE;
+	    return false;
 	}
       s = bfd_get_section_by_name (output_bfd, ".fini_array");
       if (s != NULL && s->linker_has_input)
 	{
 	  if (!_bfd_elf_add_dynamic_entry (info, DT_FINI_ARRAY, 0)
 	      || !_bfd_elf_add_dynamic_entry (info, DT_FINI_ARRAYSZ, 0))
-	    return FALSE;
+	    return false;
 	}
 
       dynstr = bfd_get_linker_section (dynobj, ".dynstr");
@@ -7196,19 +7196,19 @@ bfd_elf_size_dynamic_sections (bfd *output_bfd,
 	      || (info->gnu_flags_1
 		  && !_bfd_elf_add_dynamic_entry (info, DT_GNU_FLAGS_1,
 						  info->gnu_flags_1)))
-	    return FALSE;
+	    return false;
 	}
     }
 
   if (! _bfd_elf_maybe_strip_eh_frame_hdr (info))
-    return FALSE;
+    return false;
 
   /* The backend must work out the sizes of all the other dynamic
      sections.  */
   if (dynobj != NULL
       && bed->elf_backend_size_dynamic_sections != NULL
       && ! (*bed->elf_backend_size_dynamic_sections) (output_bfd, info))
-    return FALSE;
+    return false;
 
   if (dynobj != NULL && elf_hash_table (info)->dynamic_sections_created)
     {
@@ -7218,18 +7218,18 @@ bfd_elf_size_dynamic_sections (bfd *output_bfd,
 
 	  if (!_bfd_elf_add_dynamic_entry (info, DT_VERDEF, 0)
 	      || !_bfd_elf_add_dynamic_entry (info, DT_VERDEFNUM, crefs))
-	    return FALSE;
+	    return false;
 	}
 
       if ((info->new_dtags && info->flags) || (info->flags & DF_STATIC_TLS))
 	{
 	  if (!_bfd_elf_add_dynamic_entry (info, DT_FLAGS, info->flags))
-	    return FALSE;
+	    return false;
 	}
       else if (info->flags & DF_BIND_NOW)
 	{
 	  if (!_bfd_elf_add_dynamic_entry (info, DT_BIND_NOW, 0))
-	    return FALSE;
+	    return false;
 	}
 
       if (info->flags_1)
@@ -7239,7 +7239,7 @@ bfd_elf_size_dynamic_sections (bfd *output_bfd,
 				| DF_1_NODELETE
 				| DF_1_NOOPEN);
 	  if (!_bfd_elf_add_dynamic_entry (info, DT_FLAGS_1, info->flags_1))
-	    return FALSE;
+	    return false;
 	}
 
       if (elf_tdata (output_bfd)->cverrefs)
@@ -7248,7 +7248,7 @@ bfd_elf_size_dynamic_sections (bfd *output_bfd,
 
 	  if (!_bfd_elf_add_dynamic_entry (info, DT_VERNEED, 0)
 	      || !_bfd_elf_add_dynamic_entry (info, DT_VERNEEDNUM, crefs))
-	    return FALSE;
+	    return false;
 	}
 
       if ((elf_tdata (output_bfd)->cverrefs == 0
@@ -7261,7 +7261,7 @@ bfd_elf_size_dynamic_sections (bfd *output_bfd,
 	  s->flags |= SEC_EXCLUDE;
 	}
     }
-  return TRUE;
+  return true;
 }
 
 /* Find the first non-excluded output section.  We'll use its
@@ -7318,7 +7318,7 @@ _bfd_elf_init_2_index_sections (bfd *output_bfd, struct bfd_link_info *info)
 #define GNU_HASH_SECTION_NAME(bed)			    \
   (bed)->record_xhash_symbol != NULL ? ".MIPS.xhash" : ".gnu.hash"
 
-bfd_boolean
+bool
 bfd_elf_size_dynsym_hash_dynstr (bfd *output_bfd, struct bfd_link_info *info)
 {
   const struct elf_backend_data *bed;
@@ -7326,7 +7326,7 @@ bfd_elf_size_dynsym_hash_dynstr (bfd *output_bfd, struct bfd_link_info *info)
   bfd_size_type dynsymcount = 0;
 
   if (!is_elf_hash_table (info->hash))
-    return TRUE;
+    return true;
 
   bed = get_elf_backend_data (output_bfd);
   (*bed->elf_backend_init_index_section) (output_bfd, info);
@@ -7363,10 +7363,10 @@ bfd_elf_size_dynsym_hash_dynstr (bfd *output_bfd, struct bfd_link_info *info)
 	  s->size = dynsymcount * sizeof (Elf_External_Versym);
 	  s->contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
 	  if (s->contents == NULL)
-	    return FALSE;
+	    return false;
 
 	  if (!_bfd_elf_add_dynamic_entry (info, DT_VERSYM, 0))
-	    return FALSE;
+	    return false;
 	}
 
       /* Set the size of the .dynsym and .hash sections.  We counted
@@ -7381,7 +7381,7 @@ bfd_elf_size_dynsym_hash_dynstr (bfd *output_bfd, struct bfd_link_info *info)
 
       s->contents = (unsigned char *) bfd_alloc (output_bfd, s->size);
       if (s->contents == NULL)
-	return FALSE;
+	return false;
 
       /* The first entry in .dynsym is a dummy symbol.  Clear all the
 	 section syms, in case we don't output them all.  */
@@ -7407,9 +7407,9 @@ bfd_elf_size_dynsym_hash_dynstr (bfd *output_bfd, struct bfd_link_info *info)
 	  amt = dynsymcount * sizeof (unsigned long int);
 	  hashcodes = (unsigned long int *) bfd_malloc (amt);
 	  if (hashcodes == NULL)
-	    return FALSE;
+	    return false;
 	  hashinf.hashcodes = hashcodes;
-	  hashinf.error = FALSE;
+	  hashinf.error = false;
 
 	  /* Put all hash values in HASHCODES.  */
 	  elf_link_hash_traverse (elf_hash_table (info),
@@ -7417,7 +7417,7 @@ bfd_elf_size_dynsym_hash_dynstr (bfd *output_bfd, struct bfd_link_info *info)
 	  if (hashinf.error)
 	    {
 	      free (hashcodes);
-	      return FALSE;
+	      return false;
 	    }
 
 	  nsyms = hashinf.hashcodes - hashcodes;
@@ -7426,7 +7426,7 @@ bfd_elf_size_dynsym_hash_dynstr (bfd *output_bfd, struct bfd_link_info *info)
 	  free (hashcodes);
 
 	  if (bucketcount == 0 && nsyms > 0)
-	    return FALSE;
+	    return false;
 
 	  elf_hash_table (info)->bucketcount = bucketcount;
 
@@ -7436,7 +7436,7 @@ bfd_elf_size_dynsym_hash_dynstr (bfd *output_bfd, struct bfd_link_info *info)
 	  s->size = ((2 + bucketcount + dynsymcount) * hash_entry_size);
 	  s->contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
 	  if (s->contents == NULL)
-	    return FALSE;
+	    return false;
 
 	  bfd_put (8 * hash_entry_size, output_bfd, bucketcount, s->contents);
 	  bfd_put (8 * hash_entry_size, output_bfd, dynsymcount,
@@ -7459,7 +7459,7 @@ bfd_elf_size_dynsym_hash_dynstr (bfd *output_bfd, struct bfd_link_info *info)
 	  amt = dynsymcount * 2 * sizeof (unsigned long int);
 	  cinfo.hashcodes = (long unsigned int *) bfd_malloc (amt);
 	  if (cinfo.hashcodes == NULL)
-	    return FALSE;
+	    return false;
 
 	  cinfo.hashval = cinfo.hashcodes + dynsymcount;
 	  cinfo.min_dynindx = -1;
@@ -7472,7 +7472,7 @@ bfd_elf_size_dynsym_hash_dynstr (bfd *output_bfd, struct bfd_link_info *info)
 	  if (cinfo.error)
 	    {
 	      free (cinfo.hashcodes);
-	      return FALSE;
+	      return false;
 	    }
 
 	  bucketcount
@@ -7481,7 +7481,7 @@ bfd_elf_size_dynsym_hash_dynstr (bfd *output_bfd, struct bfd_link_info *info)
 	  if (bucketcount == 0)
 	    {
 	      free (cinfo.hashcodes);
-	      return FALSE;
+	      return false;
 	    }
 
 	  s = bfd_get_linker_section (dynobj, GNU_HASH_SECTION_NAME (bed));
@@ -7495,7 +7495,7 @@ bfd_elf_size_dynsym_hash_dynstr (bfd *output_bfd, struct bfd_link_info *info)
 	      s->size = 5 * 4 + bed->s->arch_size / 8;
 	      contents = (unsigned char *) bfd_zalloc (output_bfd, s->size);
 	      if (contents == NULL)
-		return FALSE;
+		return false;
 	      s->contents = contents;
 	      /* 1 empty bucket.  */
 	      bfd_put_32 (output_bfd, 1, contents);
@@ -7544,7 +7544,7 @@ bfd_elf_size_dynsym_hash_dynstr (bfd *output_bfd, struct bfd_link_info *info)
 	      if (cinfo.bitmask == NULL)
 		{
 		  free (cinfo.hashcodes);
-		  return FALSE;
+		  return false;
 		}
 
 	      cinfo.counts = (long unsigned int *) (cinfo.bitmask + maskwords);
@@ -7576,7 +7576,7 @@ bfd_elf_size_dynsym_hash_dynstr (bfd *output_bfd, struct bfd_link_info *info)
 		{
 		  free (cinfo.bitmask);
 		  free (cinfo.hashcodes);
-		  return FALSE;
+		  return false;
 		}
 
 	      s->contents = contents;
@@ -7625,10 +7625,10 @@ bfd_elf_size_dynsym_hash_dynstr (bfd *output_bfd, struct bfd_link_info *info)
 
       for (dtagcount = 0; dtagcount <= info->spare_dynamic_tags; ++dtagcount)
 	if (!_bfd_elf_add_dynamic_entry (info, DT_NULL, 0))
-	  return FALSE;
+	  return false;
     }
 
-  return TRUE;
+  return true;
 }
 
 /* Make sure sec_info_type is cleared if sec_info is cleared too.  */
@@ -7643,14 +7643,14 @@ merge_sections_remove_hook (bfd *abfd ATTRIBUTE_UNUSED,
 
 /* Finish SHF_MERGE section merging.  */
 
-bfd_boolean
+bool
 _bfd_elf_merge_sections (bfd *obfd, struct bfd_link_info *info)
 {
   bfd *ibfd;
   asection *sec;
 
   if (!is_elf_hash_table (info->hash))
-    return FALSE;
+    return false;
 
   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
     if ((ibfd->flags & DYNAMIC) == 0
@@ -7667,7 +7667,7 @@ _bfd_elf_merge_sections (bfd *obfd, struct bfd_link_info *info)
 	    if (! _bfd_add_merge_section (obfd,
 					  &elf_hash_table (info)->merge_info,
 					  sec, &secdata->sec_info))
-	      return FALSE;
+	      return false;
 	    else if (secdata->sec_info)
 	      sec->sec_info_type = SEC_INFO_TYPE_MERGE;
 	  }
@@ -7675,7 +7675,7 @@ _bfd_elf_merge_sections (bfd *obfd, struct bfd_link_info *info)
   if (elf_hash_table (info)->merge_info != NULL)
     _bfd_merge_sections (obfd, info, elf_hash_table (info)->merge_info,
 			 merge_sections_remove_hook);
-  return TRUE;
+  return true;
 }
 
 /* Create an entry in an ELF linker hash table.  */
@@ -7807,7 +7807,7 @@ _bfd_elf_link_hash_copy_indirect (struct bfd_link_info *info,
 void
 _bfd_elf_link_hash_hide_symbol (struct bfd_link_info *info,
 				struct elf_link_hash_entry *h,
-				bfd_boolean force_local)
+				bool force_local)
 {
   /* STT_GNU_IFUNC symbol must go through PLT.  */
   if (h->type != STT_GNU_IFUNC)
@@ -7841,7 +7841,7 @@ _bfd_elf_link_hide_symbol (bfd *output_bfd,
 	= get_elf_backend_data (output_bfd);
       struct elf_link_hash_entry *eh
 	= (struct elf_link_hash_entry *) h;
-      bed->elf_backend_hide_symbol (info, eh, TRUE);
+      bed->elf_backend_hide_symbol (info, eh, true);
       eh->def_dynamic = 0;
       eh->ref_dynamic = 0;
       eh->dynamic_def = 0;
@@ -7851,7 +7851,7 @@ _bfd_elf_link_hide_symbol (bfd *output_bfd,
 /* Initialize an ELF linker hash table.  *TABLE has been zeroed by our
    caller.  */
 
-bfd_boolean
+bool
 _bfd_elf_link_hash_table_init
   (struct elf_link_hash_table *table,
    bfd *abfd,
@@ -7861,7 +7861,7 @@ _bfd_elf_link_hash_table_init
    unsigned int entsize,
    enum elf_target_id target_id)
 {
-  bfd_boolean ret;
+  bool ret;
   int can_refcount = get_elf_backend_data (abfd)->can_refcount;
 
   table->init_got_refcount.refcount = can_refcount - 1;
@@ -7990,7 +7990,7 @@ bfd_elf_get_dt_soname (bfd *abfd)
 /* Get the list of DT_NEEDED entries from a BFD.  This is a hook for
    the ELF linker emulation code.  */
 
-bfd_boolean
+bool
 bfd_elf_get_bfd_needed_list (bfd *abfd,
 			     struct bfd_link_needed_list **pneeded)
 {
@@ -8006,11 +8006,11 @@ bfd_elf_get_bfd_needed_list (bfd *abfd,
 
   if (bfd_get_flavour (abfd) != bfd_target_elf_flavour
       || bfd_get_format (abfd) != bfd_object)
-    return TRUE;
+    return true;
 
   s = bfd_get_section_by_name (abfd, ".dynamic");
   if (s == NULL || s->size == 0)
-    return TRUE;
+    return true;
 
   if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
     goto error_return;
@@ -8060,11 +8060,11 @@ bfd_elf_get_bfd_needed_list (bfd *abfd,
 
   free (dynbuf);
 
-  return TRUE;
+  return true;
 
  error_return:
   free (dynbuf);
-  return FALSE;
+  return false;
 }
 
 struct elf_symbuf_symbol
@@ -8187,7 +8187,7 @@ elf_create_symbuf (size_t symcount, Elf_Internal_Sym *isymbuf)
 /* Check if 2 sections define the same set of local and global
    symbols.  */
 
-static bfd_boolean
+static bool
 bfd_elf_match_symbols_in_sections (asection *sec1, asection *sec2,
 				   struct bfd_link_info *info)
 {
@@ -8201,8 +8201,8 @@ bfd_elf_match_symbols_in_sections (asection *sec1, asection *sec2,
   struct elf_symbol *symtable1 = NULL, *symtable2 = NULL;
   size_t count1, count2, sec_count1, sec_count2, i;
   unsigned int shndx1, shndx2;
-  bfd_boolean result;
-  bfd_boolean ignore_section_symbol_p;
+  bool result;
+  bool ignore_section_symbol_p;
 
   bfd1 = sec1->owner;
   bfd2 = sec2->owner;
@@ -8210,15 +8210,15 @@ bfd_elf_match_symbols_in_sections (asection *sec1, asection *sec2,
   /* Both sections have to be in ELF.  */
   if (bfd_get_flavour (bfd1) != bfd_target_elf_flavour
       || bfd_get_flavour (bfd2) != bfd_target_elf_flavour)
-    return FALSE;
+    return false;
 
   if (elf_section_type (sec1) != elf_section_type (sec2))
-    return FALSE;
+    return false;
 
   shndx1 = _bfd_elf_section_from_bfd_section (bfd1, sec1);
   shndx2 = _bfd_elf_section_from_bfd_section (bfd2, sec2);
   if (shndx1 == SHN_BAD || shndx2 == SHN_BAD)
-    return FALSE;
+    return false;
 
   bed1 = get_elf_backend_data (bfd1);
   bed2 = get_elf_backend_data (bfd2);
@@ -8228,9 +8228,9 @@ bfd_elf_match_symbols_in_sections (asection *sec1, asection *sec2,
   symcount2 = hdr2->sh_size / bed2->s->sizeof_sym;
 
   if (symcount1 == 0 || symcount2 == 0)
-    return FALSE;
+    return false;
 
-  result = FALSE;
+  result = false;
   isymbuf1 = NULL;
   isymbuf2 = NULL;
   ssymbuf1 = (struct elf_symbuf_head *) elf_tdata (bfd1)->symbuf;
@@ -8381,7 +8381,7 @@ bfd_elf_match_symbols_in_sections (asection *sec1, asection *sec2,
 	    || strcmp (symtable1 [i].name, symtable2 [i].name) != 0)
 	  goto done;
 
-      result = TRUE;
+      result = true;
       goto done;
     }
 
@@ -8433,7 +8433,7 @@ bfd_elf_match_symbols_in_sections (asection *sec1, asection *sec2,
 	|| strcmp (symtable1 [i].name, symtable2 [i].name) != 0)
       goto done;
 
-  result = TRUE;
+  result = true;
 
  done:
   free (symtable1);
@@ -8446,7 +8446,7 @@ bfd_elf_match_symbols_in_sections (asection *sec1, asection *sec2,
 
 /* Return TRUE if 2 section types are compatible.  */
 
-bfd_boolean
+bool
 _bfd_elf_match_sections_by_type (bfd *abfd, const asection *asec,
 				 bfd *bbfd, const asection *bsec)
 {
@@ -8454,7 +8454,7 @@ _bfd_elf_match_sections_by_type (bfd *abfd, const asection *asec,
       || bsec == NULL
       || abfd->xvec->flavour != bfd_target_elf_flavour
       || bbfd->xvec->flavour != bfd_target_elf_flavour)
-    return TRUE;
+    return true;
 
   return elf_section_type (asec) == elf_section_type (bsec);
 }
@@ -8546,9 +8546,9 @@ local_hash_newfunc (struct bfd_hash_entry *entry,
 
 struct elf_outext_info
 {
-  bfd_boolean failed;
-  bfd_boolean localsyms;
-  bfd_boolean file_sym_done;
+  bool failed;
+  bool localsyms;
+  bool file_sym_done;
   struct elf_final_link_info *flinfo;
 };
 
@@ -8623,7 +8623,7 @@ set_symbol_value (bfd *bfd_with_globals,
   h->root.u.def.section = bfd_abs_section_ptr;
 }
 
-static bfd_boolean
+static bool
 resolve_symbol (const char *name,
 		bfd *input_bfd,
 		struct elf_final_link_info *flinfo,
@@ -8663,15 +8663,15 @@ resolve_symbol (const char *name,
 	  printf ("Found symbol with value %8.8lx\n",
 		  (unsigned long) *result);
 #endif
-	  return TRUE;
+	  return true;
 	}
     }
 
   /* Hmm, haven't found it yet. perhaps it is a global.  */
   global_entry = bfd_link_hash_lookup (flinfo->info->hash, name,
-				       FALSE, FALSE, TRUE);
+				       false, false, true);
   if (!global_entry)
-    return FALSE;
+    return false;
 
   if (global_entry->type == bfd_link_hash_defined
       || global_entry->type == bfd_link_hash_defweak)
@@ -8683,17 +8683,17 @@ resolve_symbol (const char *name,
       printf ("Found GLOBAL symbol '%s' with value %8.8lx\n",
 	      global_entry->root.string, (unsigned long) *result);
 #endif
-      return TRUE;
+      return true;
     }
 
-  return FALSE;
+  return false;
 }
 
 /* Looks up NAME in SECTIONS.  If found sets RESULT to NAME's address (in
    bytes) and returns TRUE, otherwise returns FALSE.  Accepts pseudo-section
    names like "foo.end" which is the end address of section "foo".  */
 
-static bfd_boolean
+static bool
 resolve_section (const char *name,
 		 asection *sections,
 		 bfd_vma *result,
@@ -8706,7 +8706,7 @@ resolve_section (const char *name,
     if (strcmp (curr->name, name) == 0)
       {
 	*result = curr->vma;
-	return TRUE;
+	return true;
       }
 
   /* Hmm. still haven't found it. try pseudo-section names.  */
@@ -8723,14 +8723,14 @@ resolve_section (const char *name,
 	    {
 	      *result = (curr->vma
 			 + curr->size / bfd_octets_per_byte (abfd, curr));
-	      return TRUE;
+	      return true;
 	    }
 
 	  /* Insert more pseudo-section names here, if you like.  */
 	}
     }
 
-  return FALSE;
+  return false;
 }
 
 static void
@@ -8742,7 +8742,7 @@ undefined_reference (const char *reftype, const char *name)
   bfd_set_error (bfd_error_bad_value);
 }
 
-static bfd_boolean
+static bool
 eval_symbol (bfd_vma *result,
 	     const char **symp,
 	     bfd *input_bfd,
@@ -8759,7 +8759,7 @@ eval_symbol (bfd_vma *result,
   char symbuf[4096];
   const char *sym = *symp;
   const char *symend;
-  bfd_boolean symbol_is_section = FALSE;
+  bool symbol_is_section = false;
 
   len = strlen (sym);
   symend = sym + len;
@@ -8767,7 +8767,7 @@ eval_symbol (bfd_vma *result,
   if (len < 1 || len > sizeof (symbuf))
     {
       bfd_set_error (bfd_error_invalid_operation);
-      return FALSE;
+      return false;
     }
 
   switch (* sym)
@@ -8775,15 +8775,15 @@ eval_symbol (bfd_vma *result,
     case '.':
       *result = dot;
       *symp = sym + 1;
-      return TRUE;
+      return true;
 
     case '#':
       ++sym;
       *result = strtoul (sym, (char **) symp, 16);
-      return TRUE;
+      return true;
 
     case 'S':
-      symbol_is_section = TRUE;
+      symbol_is_section = true;
       /* Fall through.  */
     case 's':
       ++sym;
@@ -8793,7 +8793,7 @@ eval_symbol (bfd_vma *result,
       if (symend < sym || symlen + 1 > sizeof (symbuf))
 	{
 	  bfd_set_error (bfd_error_invalid_operation);
-	  return FALSE;
+	  return false;
 	}
 
       memcpy (symbuf, sym, symlen);
@@ -8812,7 +8812,7 @@ eval_symbol (bfd_vma *result,
 				  isymbuf, locsymcount))
 	    {
 	      undefined_reference ("section", symbuf);
-	      return FALSE;
+	      return false;
 	    }
 	}
       else
@@ -8823,11 +8823,11 @@ eval_symbol (bfd_vma *result,
 				   result, input_bfd))
 	    {
 	      undefined_reference ("symbol", symbuf);
-	      return FALSE;
+	      return false;
 	    }
 	}
 
-      return TRUE;
+      return true;
 
       /* All that remains are operators.  */
 
@@ -8840,12 +8840,12 @@ eval_symbol (bfd_vma *result,
       *symp = sym;						\
       if (!eval_symbol (&a, symp, input_bfd, flinfo, dot,	\
 			isymbuf, locsymcount, signed_p))	\
-	return FALSE;						\
+	return false;						\
       if (signed_p)						\
 	*result = op ((bfd_signed_vma) a);			\
       else							\
 	*result = op a;						\
-      return TRUE;						\
+      return true;						\
     }
 
 #define BINARY_OP_HEAD(op)					\
@@ -8857,17 +8857,17 @@ eval_symbol (bfd_vma *result,
       *symp = sym;						\
       if (!eval_symbol (&a, symp, input_bfd, flinfo, dot,	\
 			isymbuf, locsymcount, signed_p))	\
-	return FALSE;						\
+	return false;						\
       ++*symp;							\
       if (!eval_symbol (&b, symp, input_bfd, flinfo, dot,	\
 			isymbuf, locsymcount, signed_p))	\
-	return FALSE;
+	return false;
 #define BINARY_OP_TAIL(op)					\
       if (signed_p)						\
 	*result = ((bfd_signed_vma) a) op ((bfd_signed_vma) b);	\
       else							\
 	*result = a op b;					\
-      return TRUE;						\
+      return true;						\
     }
 #define BINARY_OP(op) BINARY_OP_HEAD(op) BINARY_OP_TAIL(op)
 
@@ -8877,7 +8877,7 @@ eval_symbol (bfd_vma *result,
       if (b >= sizeof (a) * CHAR_BIT)
 	{
 	  *result = 0;
-	  return TRUE;
+	  return true;
 	}
       signed_p = 0;
       BINARY_OP_TAIL (<<);
@@ -8885,7 +8885,7 @@ eval_symbol (bfd_vma *result,
       if (b >= sizeof (a) * CHAR_BIT)
 	{
 	  *result = signed_p && (bfd_signed_vma) a < 0 ? -1 : 0;
-	  return TRUE;
+	  return true;
 	}
       BINARY_OP_TAIL (>>);
       BINARY_OP (==);
@@ -8902,7 +8902,7 @@ eval_symbol (bfd_vma *result,
 	{
 	  _bfd_error_handler (_("division by zero"));
 	  bfd_set_error (bfd_error_bad_value);
-	  return FALSE;
+	  return false;
 	}
       BINARY_OP_TAIL (/);
       BINARY_OP_HEAD (%);
@@ -8910,7 +8910,7 @@ eval_symbol (bfd_vma *result,
 	{
 	  _bfd_error_handler (_("division by zero"));
 	  bfd_set_error (bfd_error_bad_value);
-	  return FALSE;
+	  return false;
 	}
       BINARY_OP_TAIL (%);
       BINARY_OP (^);
@@ -8924,7 +8924,7 @@ eval_symbol (bfd_vma *result,
 #undef BINARY_OP
       _bfd_error_handler (_("unknown operator '%c' in complex symbol"), * sym);
       bfd_set_error (bfd_error_invalid_operation);
-      return FALSE;
+      return false;
     }
 }
 
@@ -9202,11 +9202,11 @@ ext64b_r_offset (const void *p)
    referenced must be updated.  Update all the relocations found in
    RELDATA.  */
 
-static bfd_boolean
+static bool
 elf_link_adjust_relocs (bfd *abfd,
 			asection *sec,
 			struct bfd_elf_section_reloc_data *reldata,
-			bfd_boolean sort,
+			bool sort,
 			struct bfd_link_info *info)
 {
   unsigned int i;
@@ -9266,7 +9266,7 @@ elf_link_adjust_relocs (bfd *abfd,
 	  _bfd_error_handler (_("%pB:%pA: error: try relinking with --gc-keep-exported enabled"),
 			      abfd, sec);
 	  bfd_set_error (bfd_error_invalid_operation);
-	  return FALSE;
+	  return false;
 	}
       BFD_ASSERT ((*rel_hash)->indx >= 0);
 
@@ -9368,7 +9368,7 @@ elf_link_adjust_relocs (bfd *abfd,
 		{
 		  buf = bfd_malloc (buf_size);
 		  if (buf == NULL)
-		    return FALSE;
+		    return false;
 		}
 	      if (runlen < sortlen)
 		{
@@ -9390,7 +9390,7 @@ elf_link_adjust_relocs (bfd *abfd,
       reldata->hashes = NULL;
       free (buf);
     }
-  return TRUE;
+  return true;
 }
 
 struct elf_link_sort_rela
@@ -9476,7 +9476,7 @@ elf_link_sort_relocs (bfd *abfd, struct bfd_link_info *info, asection **psec)
   void (*swap_out) (bfd *, const Elf_Internal_Rela *, bfd_byte *);
   struct bfd_link_order *lo;
   bfd_vma r_sym_mask;
-  bfd_boolean use_rela;
+  bool use_rela;
 
   /* Find a dynamic reloc section.  */
   rela_dyn = bfd_get_section_by_name (abfd, ".rela.dyn");
@@ -9484,11 +9484,11 @@ elf_link_sort_relocs (bfd *abfd, struct bfd_link_info *info, asection **psec)
   if (rela_dyn != NULL && rela_dyn->size > 0
       && rel_dyn != NULL && rel_dyn->size > 0)
     {
-      bfd_boolean use_rela_initialised = FALSE;
+      bool use_rela_initialised = false;
 
       /* This is just here to stop gcc from complaining.
 	 Its initialization checking code is not perfect.  */
-      use_rela = TRUE;
+      use_rela = true;
 
       /* Both sections are present.  Examine the sizes
 	 of the indirect sections to help us choose.  */
@@ -9516,8 +9516,8 @@ elf_link_sort_relocs (bfd *abfd, struct bfd_link_info *info, asection **psec)
 		      }
 		    else
 		      {
-			use_rela = TRUE;
-			use_rela_initialised = TRUE;
+			use_rela = true;
+			use_rela_initialised = true;
 		      }
 		  }
 	      }
@@ -9534,8 +9534,8 @@ elf_link_sort_relocs (bfd *abfd, struct bfd_link_info *info, asection **psec)
 		  }
 		else
 		  {
-		    use_rela = FALSE;
-		    use_rela_initialised = TRUE;
+		    use_rela = false;
+		    use_rela_initialised = true;
 		  }
 	      }
 	    else
@@ -9573,8 +9573,8 @@ elf_link_sort_relocs (bfd *abfd, struct bfd_link_info *info, asection **psec)
 		      }
 		    else
 		      {
-			use_rela = TRUE;
-			use_rela_initialised = TRUE;
+			use_rela = true;
+			use_rela_initialised = true;
 		      }
 		  }
 	      }
@@ -9591,8 +9591,8 @@ elf_link_sort_relocs (bfd *abfd, struct bfd_link_info *info, asection **psec)
 		  }
 		else
 		  {
-		    use_rela = FALSE;
-		    use_rela_initialised = TRUE;
+		    use_rela = false;
+		    use_rela_initialised = true;
 		  }
 	      }
 	    else
@@ -9608,12 +9608,12 @@ elf_link_sort_relocs (bfd *abfd, struct bfd_link_info *info, asection **psec)
 
       if (! use_rela_initialised)
 	/* Make a guess.  */
-	use_rela = TRUE;
+	use_rela = true;
     }
   else if (rela_dyn != NULL && rela_dyn->size > 0)
-    use_rela = TRUE;
+    use_rela = true;
   else if (rel_dyn != NULL && rel_dyn->size > 0)
-    use_rela = FALSE;
+    use_rela = false;
   else
     return 0;
 
@@ -9839,7 +9839,7 @@ elf_link_output_symstrtab (void *finf,
 	      break;
 	    default:
 	      lh = (struct local_hash_entry *) bfd_hash_lookup
-		     (&flinfo->local_hash_table, name, TRUE, FALSE);
+		     (&flinfo->local_hash_table, name, true, false);
 	      if (lh == NULL)
 		return 0;
 	      if (lh->count)
@@ -9870,7 +9870,7 @@ elf_link_output_symstrtab (void *finf,
 	}
       elfsym->st_name
 	= (unsigned long) _bfd_elf_strtab_add (flinfo->symstrtab,
-					       versioned_name, FALSE);
+					       versioned_name, false);
       if (elfsym->st_name == (unsigned long) -1)
 	return 0;
     }
@@ -9903,7 +9903,7 @@ elf_link_output_symstrtab (void *finf,
 /* Swap symbols out to the symbol table and flush the output symbols to
    the file.  */
 
-static bfd_boolean
+static bool
 elf_link_swap_symbols_out (struct elf_final_link_info *flinfo)
 {
   struct elf_link_hash_table *hash_table = elf_hash_table (flinfo->info);
@@ -9913,10 +9913,10 @@ elf_link_swap_symbols_out (struct elf_final_link_info *flinfo)
   bfd_byte *symbuf;
   Elf_Internal_Shdr *hdr;
   file_ptr pos;
-  bfd_boolean ret;
+  bool ret;
 
   if (!hash_table->strtabcount)
-    return TRUE;
+    return true;
 
   BFD_ASSERT (elf_onesymtab (flinfo->output_bfd));
 
@@ -9925,7 +9925,7 @@ elf_link_swap_symbols_out (struct elf_final_link_info *flinfo)
   amt = bed->s->sizeof_sym * hash_table->strtabcount;
   symbuf = (bfd_byte *) bfd_malloc (amt);
   if (symbuf == NULL)
-    return FALSE;
+    return false;
 
   if (flinfo->symshndxbuf)
     {
@@ -9935,7 +9935,7 @@ elf_link_swap_symbols_out (struct elf_final_link_info *flinfo)
       if (flinfo->symshndxbuf == NULL)
 	{
 	  free (symbuf);
-	  return FALSE;
+	  return false;
 	}
     }
 
@@ -9971,10 +9971,10 @@ elf_link_swap_symbols_out (struct elf_final_link_info *flinfo)
       && bfd_bwrite (symbuf, amt, flinfo->output_bfd) == amt)
     {
       hdr->sh_size += amt;
-      ret = TRUE;
+      ret = true;
     }
   else
-    ret = FALSE;
+    ret = false;
 
   free (symbuf);
 
@@ -9986,7 +9986,7 @@ elf_link_swap_symbols_out (struct elf_final_link_info *flinfo)
 
 /* Return TRUE if the dynamic symbol SYM in ABFD is supported.  */
 
-static bfd_boolean
+static bool
 check_dynsym (bfd *abfd, Elf_Internal_Sym *sym)
 {
   if (sym->st_shndx >= (SHN_LORESERVE & 0xffff)
@@ -9999,9 +9999,9 @@ check_dynsym (bfd *abfd, Elf_Internal_Sym *sym)
 	(_("%pB: too many sections: %d (>= %d)"),
 	 abfd, bfd_count_sections (abfd), SHN_LORESERVE & 0xffff);
       bfd_set_error (bfd_error_nonrepresentable_section);
-      return FALSE;
+      return false;
     }
-  return TRUE;
+  return true;
 }
 
 /* For DSOs loaded in via a DT_NEEDED entry, emulate ld.so in
@@ -10010,7 +10010,7 @@ check_dynsym (bfd *abfd, Elf_Internal_Sym *sym)
    We also handle the case that a DSO references a hidden symbol
    which may be satisfied by a versioned symbol in another DSO.  */
 
-static bfd_boolean
+static bool
 elf_link_check_versioned_symbol (struct bfd_link_info *info,
 				 const struct elf_backend_data *bed,
 				 struct elf_link_hash_entry *h)
@@ -10019,7 +10019,7 @@ elf_link_check_versioned_symbol (struct bfd_link_info *info,
   struct elf_link_loaded_list *loaded;
 
   if (!is_elf_hash_table (info->hash))
-    return FALSE;
+    return false;
 
   /* Check indirect symbol.  */
   while (h->root.type == bfd_link_hash_indirect)
@@ -10037,7 +10037,7 @@ elf_link_check_versioned_symbol (struct bfd_link_info *info,
       if (abfd == NULL
 	  || (abfd->flags & DYNAMIC) == 0
 	  || (elf_dyn_lib_class (abfd) & DYN_DT_NEEDED) == 0)
-	return FALSE;
+	return false;
       break;
 
     case bfd_link_hash_defined:
@@ -10094,7 +10094,7 @@ elf_link_check_versioned_symbol (struct bfd_link_info *info,
       isymbuf = bfd_elf_get_elf_syms (input, hdr, extsymcount, extsymoff,
 				      NULL, NULL, NULL);
       if (isymbuf == NULL)
-	return FALSE;
+	return false;
 
       /* Read in any version definitions.  */
       versymhdr = &elf_tdata (input)->dynversym_hdr;
@@ -10104,7 +10104,7 @@ elf_link_check_versioned_symbol (struct bfd_link_info *info,
 				    versymhdr->sh_size)) == NULL)
 	{
 	  free (isymbuf);
-	  return FALSE;
+	  return false;
 	}
 
       ever = extversym + extsymoff;
@@ -10144,7 +10144,7 @@ elf_link_check_versioned_symbol (struct bfd_link_info *info,
 	      /* This is the base or first version.  We can use it.  */
 	      free (extversym);
 	      free (isymbuf);
-	      return TRUE;
+	      return true;
 	    }
 	}
 
@@ -10152,7 +10152,7 @@ elf_link_check_versioned_symbol (struct bfd_link_info *info,
       free (isymbuf);
     }
 
-  return FALSE;
+  return false;
 }
 
 /* Convert ELF common symbol TYPE.  */
@@ -10184,13 +10184,13 @@ elf_link_convert_common_type (struct bfd_link_info *info, int type)
    script.  The second time we output the symbols that are still
    global symbols.  */
 
-static bfd_boolean
+static bool
 elf_link_output_extsym (struct bfd_hash_entry *bh, void *data)
 {
   struct elf_link_hash_entry *h = (struct elf_link_hash_entry *) bh;
   struct elf_outext_info *eoinfo = (struct elf_outext_info *) data;
   struct elf_final_link_info *flinfo = eoinfo->flinfo;
-  bfd_boolean strip;
+  bool strip;
   Elf_Internal_Sym sym;
   asection *input_sec;
   const struct elf_backend_data *bed;
@@ -10202,19 +10202,19 @@ elf_link_output_extsym (struct bfd_hash_entry *bh, void *data)
     {
       h = (struct elf_link_hash_entry *) h->root.u.i.link;
       if (h->root.type == bfd_link_hash_new)
-	return TRUE;
+	return true;
     }
 
   /* Decide whether to output this symbol in this pass.  */
   if (eoinfo->localsyms)
     {
       if (!h->forced_local)
-	return TRUE;
+	return true;
     }
   else
     {
       if (h->forced_local)
-	return TRUE;
+	return true;
     }
 
   bed = get_elf_backend_data (flinfo->output_bfd);
@@ -10226,7 +10226,7 @@ elf_link_output_extsym (struct bfd_hash_entry *bh, void *data)
 	 references in regular files have already been handled unless
 	 they are in unreferenced sections which are removed by garbage
 	 collection).  */
-      bfd_boolean ignore_undef = FALSE;
+      bool ignore_undef = false;
 
       /* Some symbols may be special in that the fact that they're
 	 undefined can be safely ignored - let backend determine that.  */
@@ -10249,7 +10249,7 @@ elf_link_output_extsym (struct bfd_hash_entry *bh, void *data)
 
       /* Strip a global symbol defined in a discarded section.  */
       if (h->indx == -3)
-	return TRUE;
+	return true;
     }
 
   /* We should also warn if a forced local symbol is referenced from
@@ -10285,15 +10285,15 @@ elf_link_output_extsym (struct bfd_hash_entry *bh, void *data)
       _bfd_error_handler (msg, flinfo->output_bfd,
 			  h->root.root.string, def_bfd);
       bfd_set_error (bfd_error_bad_value);
-      eoinfo->failed = TRUE;
-      return FALSE;
+      eoinfo->failed = true;
+      return false;
     }
 
   /* We don't want to output symbols that have never been mentioned by
      a regular file, or that we have been told to strip.  However, if
      h->indx is set to -2, the symbol is used by a reloc and we must
      output it.  */
-  strip = FALSE;
+  strip = false;
   if (h->indx == -2)
     ;
   else if ((h->def_dynamic
@@ -10301,13 +10301,13 @@ elf_link_output_extsym (struct bfd_hash_entry *bh, void *data)
 	    || h->root.type == bfd_link_hash_new)
 	   && !h->def_regular
 	   && !h->ref_regular)
-    strip = TRUE;
+    strip = true;
   else if (flinfo->info->strip == strip_all)
-    strip = TRUE;
+    strip = true;
   else if (flinfo->info->strip == strip_some
 	   && bfd_hash_lookup (flinfo->info->keep_hash,
-			       h->root.root.string, FALSE, FALSE) == NULL)
-    strip = TRUE;
+			       h->root.root.string, false, false) == NULL)
+    strip = true;
   else if ((h->root.type == bfd_link_hash_defined
 	    || h->root.type == bfd_link_hash_defweak)
 	   && ((flinfo->info->strip_discarded
@@ -10315,12 +10315,12 @@ elf_link_output_extsym (struct bfd_hash_entry *bh, void *data)
 	       || ((h->root.u.def.section->flags & SEC_LINKER_CREATED) == 0
 		   && h->root.u.def.section->owner != NULL
 		   && (h->root.u.def.section->owner->flags & BFD_PLUGIN) != 0)))
-    strip = TRUE;
+    strip = true;
   else if ((h->root.type == bfd_link_hash_undefined
 	    || h->root.type == bfd_link_hash_undefweak)
 	   && h->root.u.undef.abfd != NULL
 	   && (h->root.u.undef.abfd->flags & BFD_PLUGIN) != 0)
-    strip = TRUE;
+    strip = true;
 
   type = h->type;
 
@@ -10332,7 +10332,7 @@ elf_link_output_extsym (struct bfd_hash_entry *bh, void *data)
       && h->dynindx == -1
       && type != STT_GNU_IFUNC
       && !h->forced_local)
-    return TRUE;
+    return true;
 
   sym.st_value = 0;
   sym.st_size = h->size;
@@ -10343,7 +10343,7 @@ elf_link_output_extsym (struct bfd_hash_entry *bh, void *data)
     case bfd_link_hash_new:
     case bfd_link_hash_warning:
       abort ();
-      return FALSE;
+      return false;
 
     case bfd_link_hash_undefined:
     case bfd_link_hash_undefweak:
@@ -10367,8 +10367,8 @@ elf_link_output_extsym (struct bfd_hash_entry *bh, void *data)
 		  (_("%pB: could not find output section %pA for input section %pA"),
 		   flinfo->output_bfd, input_sec->output_section, input_sec);
 		bfd_set_error (bfd_error_nonrepresentable_section);
-		eoinfo->failed = TRUE;
-		return FALSE;
+		eoinfo->failed = true;
+		return false;
 	      }
 
 	    /* ELF symbols in relocatable files are section relative,
@@ -10409,7 +10409,7 @@ elf_link_output_extsym (struct bfd_hash_entry *bh, void *data)
 	 foo is used with no version, then we add an indirect symbol
 	 foo which points to foo@@GNU_1.2.  We ignore these symbols,
 	 since the indirected symbol is already in the hash table.  */
-      return TRUE;
+      return true;
     }
 
   if (type == STT_COMMON || type == STT_OBJECT)
@@ -10467,8 +10467,8 @@ elf_link_output_extsym (struct bfd_hash_entry *bh, void *data)
       if (! ((*bed->elf_backend_finish_dynamic_symbol)
 	     (flinfo->output_bfd, flinfo->info, h, &sym)))
 	{
-	  eoinfo->failed = TRUE;
-	  return FALSE;
+	  eoinfo->failed = true;
+	  return false;
 	}
     }
 
@@ -10527,8 +10527,8 @@ elf_link_output_extsym (struct bfd_hash_entry *bh, void *data)
 	msg = _("%pB: hidden symbol `%s' isn't defined");
       _bfd_error_handler (msg, flinfo->output_bfd, h->root.root.string);
       bfd_set_error (bfd_error_bad_value);
-      eoinfo->failed = TRUE;
-      return FALSE;
+      eoinfo->failed = true;
+      return false;
     }
 
   /* If this symbol should be put in the .dynsym section, then put it
@@ -10558,8 +10558,8 @@ elf_link_output_extsym (struct bfd_hash_entry *bh, void *data)
 		/* xgettext:c-format */
 		(_("%pB: no symbol version section for versioned symbol `%s'"),
 		 flinfo->output_bfd, h->root.root.string);
-	      eoinfo->failed = TRUE;
-	      return FALSE;
+	      eoinfo->failed = true;
+	      return false;
 	    }
 	}
 
@@ -10568,8 +10568,8 @@ elf_link_output_extsym (struct bfd_hash_entry *bh, void *data)
 	      + h->dynindx * bed->s->sizeof_sym);
       if (!check_dynsym (flinfo->output_bfd, &sym))
 	{
-	  eoinfo->failed = TRUE;
-	  return FALSE;
+	  eoinfo->failed = true;
+	  return false;
 	}
 
       /* Inform the linker of the addition of this symbol.  */
@@ -10645,14 +10645,14 @@ elf_link_output_extsym (struct bfd_hash_entry *bh, void *data)
 	   /* PR 22319 Do not strip global undefined symbols marked as being needed.  */
 	   && (h->mark != 1 || ELF_ST_BIND (sym.st_info) != STB_GLOBAL)
 	   && !bfd_link_relocatable (flinfo->info))
-    return TRUE;
+    return true;
 
   /* Also strip others that we couldn't earlier due to dynamic symbol
      processing.  */
   if (strip)
-    return TRUE;
+    return true;
   if ((input_sec->flags & SEC_EXCLUDE) != 0)
-    return TRUE;
+    return true;
 
   /* Output a FILE symbol so that following locals are not associated
      with the wrong input file.  We need one for forced local symbols
@@ -10672,9 +10672,9 @@ elf_link_output_extsym (struct bfd_hash_entry *bh, void *data)
       fsym.st_shndx = SHN_ABS;
       if (!elf_link_output_symstrtab (eoinfo->flinfo, NULL, &fsym,
 				      bfd_und_section_ptr, NULL))
-	return FALSE;
+	return false;
 
-      eoinfo->file_sym_done = TRUE;
+      eoinfo->file_sym_done = true;
     }
 
   indx = bfd_get_symcount (flinfo->output_bfd);
@@ -10682,21 +10682,21 @@ elf_link_output_extsym (struct bfd_hash_entry *bh, void *data)
 				   input_sec, h);
   if (ret == 0)
     {
-      eoinfo->failed = TRUE;
-      return FALSE;
+      eoinfo->failed = true;
+      return false;
     }
   else if (ret == 1)
     h->indx = indx;
   else if (h->indx == -2)
     abort();
 
-  return TRUE;
+  return true;
 }
 
 /* Return TRUE if special handling is done for relocs in SEC against
    symbols defined in discarded sections.  */
 
-static bfd_boolean
+static bool
 elf_section_ignore_discarded_relocs (asection *sec)
 {
   const struct elf_backend_data *bed;
@@ -10706,7 +10706,7 @@ elf_section_ignore_discarded_relocs (asection *sec)
     case SEC_INFO_TYPE_STABS:
     case SEC_INFO_TYPE_EH_FRAME:
     case SEC_INFO_TYPE_EH_FRAME_ENTRY:
-      return TRUE;
+      return true;
     default:
       break;
     }
@@ -10714,9 +10714,9 @@ elf_section_ignore_discarded_relocs (asection *sec)
   bed = get_elf_backend_data (sec->owner);
   if (bed->elf_backend_ignore_discarded_relocs != NULL
       && (*bed->elf_backend_ignore_discarded_relocs) (sec))
-    return TRUE;
+    return true;
 
-  return FALSE;
+  return false;
 }
 
 /* Return a mask saying how ld should treat relocations in SEC against
@@ -10804,7 +10804,7 @@ _bfd_elf_check_kept_section (asection *sec, struct bfd_link_info *info)
    This is so that we only have to read the local symbols once, and
    don't have to keep them in memory.  */
 
-static bfd_boolean
+static bool
 elf_link_input_bfd (struct elf_final_link_info *flinfo, bfd *input_bfd)
 {
   int (*relocate_section)
@@ -10825,7 +10825,7 @@ elf_link_input_bfd (struct elf_final_link_info *flinfo, bfd *input_bfd)
   bfd_size_type address_size;
   bfd_vma r_type_mask;
   int r_sym_shift;
-  bfd_boolean have_file_sym = FALSE;
+  bool have_file_sym = false;
 
   output_bfd = flinfo->output_bfd;
   bed = get_elf_backend_data (output_bfd);
@@ -10835,7 +10835,7 @@ elf_link_input_bfd (struct elf_final_link_info *flinfo, bfd *input_bfd)
      we don't want the local symbols, and we don't want the section
      contents.  */
   if ((input_bfd->flags & DYNAMIC) != 0)
-    return TRUE;
+    return true;
 
   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
   if (elf_bad_symtab (input_bfd))
@@ -10868,7 +10868,7 @@ elf_link_input_bfd (struct elf_final_link_info *flinfo, bfd *input_bfd)
 				      flinfo->external_syms,
 				      flinfo->locsym_shndx);
       if (isymbuf == NULL)
-	return FALSE;
+	return false;
     }
 
   /* Find local symbol sections and adjust values of symbols in
@@ -10971,11 +10971,11 @@ elf_link_input_bfd (struct elf_final_link_info *flinfo, bfd *input_bfd)
       name = bfd_elf_string_from_elf_section (input_bfd, symtab_hdr->sh_link,
 					      isym->st_name);
       if (name == NULL)
-	return FALSE;
+	return false;
 
       /* See if we are discarding symbols with this name.  */
       if ((flinfo->info->strip == strip_some
-	   && (bfd_hash_lookup (flinfo->info->keep_hash, name, FALSE, FALSE)
+	   && (bfd_hash_lookup (flinfo->info->keep_hash, name, false, false)
 	       == NULL))
 	  || (((flinfo->info->discard == discard_sec_merge
 		&& (isec->flags & SEC_MERGE)
@@ -10990,7 +10990,7 @@ elf_link_input_bfd (struct elf_final_link_info *flinfo, bfd *input_bfd)
 	    /* -flto puts a temp file name here.  This means builds
 	       are not reproducible.  Discard the symbol.  */
 	    continue;
-	  have_file_sym = TRUE;
+	  have_file_sym = true;
 	  flinfo->filesym_count += 1;
 	}
       if (!have_file_sym)
@@ -11002,7 +11002,7 @@ elf_link_input_bfd (struct elf_final_link_info *flinfo, bfd *input_bfd)
 	     associated with a previous input file.  It's not the
 	     source file, but the best we can do.  */
 	  const char *filename;
-	  have_file_sym = TRUE;
+	  have_file_sym = true;
 	  flinfo->filesym_count += 1;
 	  memset (&osym, 0, sizeof (osym));
 	  osym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
@@ -11013,7 +11013,7 @@ elf_link_input_bfd (struct elf_final_link_info *flinfo, bfd *input_bfd)
 	    filename = lbasename (bfd_get_filename (input_bfd));
 	  if (!elf_link_output_symstrtab (flinfo, filename, &osym,
 					  bfd_abs_section_ptr, NULL))
-	    return FALSE;
+	    return false;
 	}
 
       osym = *isym;
@@ -11022,7 +11022,7 @@ elf_link_input_bfd (struct elf_final_link_info *flinfo, bfd *input_bfd)
       osym.st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
 							 isec->output_section);
       if (osym.st_shndx == SHN_BAD)
-	return FALSE;
+	return false;
 
       /* ELF symbols in relocatable files are section relative, but
 	 in executable files they are virtual addresses.  Note that
@@ -11049,7 +11049,7 @@ elf_link_input_bfd (struct elf_final_link_info *flinfo, bfd *input_bfd)
       indx = bfd_get_symcount (output_bfd);
       ret = elf_link_output_symstrtab (flinfo, name, &osym, isec, NULL);
       if (ret == 0)
-	return FALSE;
+	return false;
       else if (ret == 1)
 	*pindex = indx;
     }
@@ -11121,12 +11121,12 @@ elf_link_input_bfd (struct elf_final_link_info *flinfo, bfd *input_bfd)
 							  symtab_hdr->sh_link,
 							  sym.st_name);
 		  if (name == NULL)
-		    return FALSE;
+		    return false;
 
 		  sym.st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
 								    sec);
 		  if (sym.st_shndx == SHN_BAD)
-		    return FALSE;
+		    return false;
 
 		  sym.st_value += o->output_offset;
 
@@ -11134,7 +11134,7 @@ elf_link_input_bfd (struct elf_final_link_info *flinfo, bfd *input_bfd)
 		  ret = elf_link_output_symstrtab (flinfo, name, &sym, o,
 						   NULL);
 		  if (ret == 0)
-		    return FALSE;
+		    return false;
 		  else if (ret == 1)
 		    flinfo->indices[symndx] = indx;
 		  else
@@ -11175,7 +11175,7 @@ elf_link_input_bfd (struct elf_final_link_info *flinfo, bfd *input_bfd)
 	{
 	  contents = flinfo->contents;
 	  if (! bfd_get_full_section_contents (input_bfd, o, &contents))
-	    return FALSE;
+	    return false;
 	}
 
       if ((o->flags & SEC_RELOC) != 0)
@@ -11188,10 +11188,10 @@ elf_link_input_bfd (struct elf_final_link_info *flinfo, bfd *input_bfd)
 	  /* Get the swapped relocs.  */
 	  internal_relocs
 	    = _bfd_elf_link_read_relocs (input_bfd, o, flinfo->external_relocs,
-					 flinfo->internal_relocs, FALSE);
+					 flinfo->internal_relocs, false);
 	  if (internal_relocs == NULL
 	      && o->reloc_count > 0)
-	    return FALSE;
+	    return false;
 
 	  /* We need to reverse-copy input .ctors/.dtors sections if
 	     they are placed in .init_array/.finit_array for output.  */
@@ -11213,7 +11213,7 @@ elf_link_input_bfd (struct elf_final_link_info *flinfo, bfd *input_bfd)
 		       "multiple of address size"),
 		     input_bfd, o);
 		  bfd_set_error (bfd_error_bad_value);
-		  return FALSE;
+		  return false;
 		}
 	      o->flags |= SEC_ELF_REVERSE_COPY;
 	    }
@@ -11258,7 +11258,7 @@ elf_link_input_bfd (struct elf_final_link_info *flinfo, bfd *input_bfd)
 			   "that references a non-existent global symbol"),
 			 input_bfd, (uint64_t) rel->r_info, o);
 		      bfd_set_error (bfd_error_bad_value);
-		      return FALSE;
+		      return false;
 		    }
 
 		  while (h->root.type == bfd_link_hash_indirect
@@ -11322,7 +11322,7 @@ elf_link_input_bfd (struct elf_final_link_info *flinfo, bfd *input_bfd)
 #endif
 		  if (!eval_symbol (&val, &sym_name, input_bfd, flinfo, dot,
 				    isymbuf, locsymcount, s_type == STT_SRELC))
-		    return FALSE;
+		    return false;
 
 		  /* Symbol evaluated OK.  Update to absolute value.  */
 		  set_symbol_value (input_bfd, isymbuf, locsymcount,
@@ -11392,7 +11392,7 @@ elf_link_input_bfd (struct elf_final_link_info *flinfo, bfd *input_bfd)
 				     isymbuf,
 				     flinfo->sections);
 	  if (!ret)
-	    return FALSE;
+	    return false;
 
 	  if (ret == 2
 	      || bfd_link_relocatable (flinfo->info)
@@ -11405,12 +11405,12 @@ elf_link_input_bfd (struct elf_final_link_info *flinfo, bfd *input_bfd)
 	      struct elf_link_hash_entry **rel_hash_list, **rela_hash_list;
 	      Elf_Internal_Shdr *input_rel_hdr, *input_rela_hdr;
 	      unsigned int next_erel;
-	      bfd_boolean rela_normal;
+	      bool rela_normal;
 	      struct bfd_elf_section_data *esdi, *esdo;
 
 	      esdi = elf_section_data (o);
 	      esdo = elf_section_data (o->output_section);
-	      rela_normal = FALSE;
+	      rela_normal = false;
 
 	      /* Adjust the reloc addresses and symbol indices.  */
 
@@ -11521,7 +11521,7 @@ elf_link_input_bfd (struct elf_final_link_info *flinfo, bfd *input_bfd)
 		      else if (sec == NULL || sec->owner == NULL)
 			{
 			  bfd_set_error (bfd_error_bad_value);
-			  return FALSE;
+			  return false;
 			}
 		      else
 			{
@@ -11573,7 +11573,7 @@ elf_link_input_bfd (struct elf_final_link_info *flinfo, bfd *input_bfd)
 			    {
 			      /* You can't do ld -r -s.  */
 			      bfd_set_error (bfd_error_invalid_operation);
-			      return FALSE;
+			      return false;
 			    }
 
 			  /* This symbol was skipped earlier, but
@@ -11583,14 +11583,14 @@ elf_link_input_bfd (struct elf_final_link_info *flinfo, bfd *input_bfd)
 			  name = (bfd_elf_string_from_elf_section
 				  (input_bfd, shlink, sym.st_name));
 			  if (name == NULL)
-			    return FALSE;
+			    return false;
 
 			  osec = sec->output_section;
 			  sym.st_shndx =
 			    _bfd_elf_section_from_bfd_section (output_bfd,
 							       osec);
 			  if (sym.st_shndx == SHN_BAD)
-			    return FALSE;
+			    return false;
 
 			  sym.st_value += sec->output_offset;
 			  if (!bfd_link_relocatable (flinfo->info))
@@ -11617,7 +11617,7 @@ elf_link_input_bfd (struct elf_final_link_info *flinfo, bfd *input_bfd)
 							   &sym, sec,
 							   NULL);
 			  if (ret == 0)
-			    return FALSE;
+			    return false;
 			  else if (ret == 1)
 			    flinfo->indices[r_symndx] = indx;
 			  else
@@ -11639,7 +11639,7 @@ elf_link_input_bfd (struct elf_final_link_info *flinfo, bfd *input_bfd)
 						     input_rel_hdr,
 						     internal_relocs,
 						     rel_hash_list))
-		    return FALSE;
+		    return false;
 		  internal_relocs += (NUM_SHDR_ENTRIES (input_rel_hdr)
 				      * bed->s->int_rels_per_ext_rel);
 		  rel_hash_list += NUM_SHDR_ENTRIES (input_rel_hdr);
@@ -11652,7 +11652,7 @@ elf_link_input_bfd (struct elf_final_link_info *flinfo, bfd *input_bfd)
 						     input_rela_hdr,
 						     internal_relocs,
 						     rela_hash_list))
-		    return FALSE;
+		    return false;
 		}
 	    }
 	}
@@ -11671,18 +11671,18 @@ elf_link_input_bfd (struct elf_final_link_info *flinfo, bfd *input_bfd)
 		 (output_bfd,
 		  &elf_hash_table (flinfo->info)->stab_info,
 		  o, &elf_section_data (o)->sec_info, contents)))
-	    return FALSE;
+	    return false;
 	  break;
 	case SEC_INFO_TYPE_MERGE:
 	  if (! _bfd_write_merged_section (output_bfd, o,
 					   elf_section_data (o)->sec_info))
-	    return FALSE;
+	    return false;
 	  break;
 	case SEC_INFO_TYPE_EH_FRAME:
 	  {
 	    if (! _bfd_elf_write_section_eh_frame (output_bfd, flinfo->info,
 						   o, contents))
-	      return FALSE;
+	      return false;
 	  }
 	  break;
 	case SEC_INFO_TYPE_EH_FRAME_ENTRY:
@@ -11690,7 +11690,7 @@ elf_link_input_bfd (struct elf_final_link_info *flinfo, bfd *input_bfd)
 	    if (! _bfd_elf_write_section_eh_frame_entry (output_bfd,
 							 flinfo->info,
 							 o, contents))
-	      return FALSE;
+	      return false;
 	  }
 	  break;
 	default:
@@ -11713,7 +11713,7 @@ elf_link_input_bfd (struct elf_final_link_info *flinfo, bfd *input_bfd)
 							contents + todo,
 							offset,
 							address_size))
-			  return FALSE;
+			  return false;
 			if (todo == 0)
 			  break;
 			offset += address_size;
@@ -11724,14 +11724,14 @@ elf_link_input_bfd (struct elf_final_link_info *flinfo, bfd *input_bfd)
 						     o->output_section,
 						     contents,
 						     offset, todo))
-		  return FALSE;
+		  return false;
 	      }
 	  }
 	  break;
 	}
     }
 
-  return TRUE;
+  return true;
 }
 
 /* Generate a reloc when linking an ELF file.  This is a reloc
@@ -11739,7 +11739,7 @@ elf_link_input_bfd (struct elf_final_link_info *flinfo, bfd *input_bfd)
    is used to build constructor and destructor tables when linking
    with -Ur.  */
 
-static bfd_boolean
+static bool
 elf_reloc_link_order (bfd *output_bfd,
 		      struct bfd_link_info *info,
 		      asection *output_section,
@@ -11762,7 +11762,7 @@ elf_reloc_link_order (bfd *output_bfd,
   if (howto == NULL)
     {
       bfd_set_error (bfd_error_bad_value);
-      return FALSE;
+      return false;
     }
 
   addend = link_order->u.reloc.p->addend;
@@ -11794,7 +11794,7 @@ elf_reloc_link_order (bfd *output_bfd,
       h = ((struct elf_link_hash_entry *)
 	   bfd_wrapped_link_hash_lookup (output_bfd, info,
 					 link_order->u.reloc.p->u.name,
-					 FALSE, FALSE, TRUE));
+					 false, false, true));
       if (h != NULL
 	  && (h->root.type == bfd_link_hash_defined
 	      || h->root.type == bfd_link_hash_defweak))
@@ -11832,14 +11832,14 @@ elf_reloc_link_order (bfd *output_bfd,
       bfd_size_type size;
       bfd_reloc_status_type rstat;
       bfd_byte *buf;
-      bfd_boolean ok;
+      bool ok;
       const char *sym_name;
       bfd_size_type octets;
 
       size = (bfd_size_type) bfd_get_reloc_size (howto);
       buf = (bfd_byte *) bfd_zmalloc (size);
       if (buf == NULL && size != 0)
-	return FALSE;
+	return false;
       rstat = _bfd_relocate_contents (howto, output_bfd, addend, buf);
       switch (rstat)
 	{
@@ -11867,7 +11867,7 @@ elf_reloc_link_order (bfd *output_bfd,
 				     octets, size);
       free (buf);
       if (! ok)
-	return FALSE;
+	return false;
     }
 
   /* The address of a reloc is relative to the section in a
@@ -11904,16 +11904,16 @@ elf_reloc_link_order (bfd *output_bfd,
 
   ++reldata->count;
 
-  return TRUE;
+  return true;
 }
 
 /* Generate an import library in INFO->implib_bfd from symbols in ABFD.
    Returns TRUE upon success, FALSE otherwise.  */
 
-static bfd_boolean
+static bool
 elf_output_implib (bfd *abfd, struct bfd_link_info *info)
 {
-  bfd_boolean ret = FALSE;
+  bool ret = false;
   bfd *implib_bfd;
   const struct elf_backend_data *bed;
   flagword flags;
@@ -11930,14 +11930,14 @@ elf_output_implib (bfd *abfd, struct bfd_link_info *info)
   bed = get_elf_backend_data (abfd);
 
   if (!bfd_set_format (implib_bfd, bfd_object))
-    return FALSE;
+    return false;
 
   /* Use flag from executable but make it a relocatable object.  */
   flags = bfd_get_file_flags (abfd);
   flags &= ~HAS_RELOC;
   if (!bfd_set_start_address (implib_bfd, 0)
       || !bfd_set_file_flags (implib_bfd, flags & ~EXEC_P))
-    return FALSE;
+    return false;
 
   /* Copy architecture of output file to import library file.  */
   arch = bfd_get_arch (abfd);
@@ -11945,17 +11945,17 @@ elf_output_implib (bfd *abfd, struct bfd_link_info *info)
   if (!bfd_set_arch_mach (implib_bfd, arch, mach)
       && (abfd->target_defaulted
 	  || bfd_get_arch (abfd) != bfd_get_arch (implib_bfd)))
-    return FALSE;
+    return false;
 
   /* Get symbol table size.  */
   symsize = bfd_get_symtab_upper_bound (abfd);
   if (symsize < 0)
-    return FALSE;
+    return false;
 
   /* Read in the symbol table.  */
   sympp = (asymbol **) bfd_malloc (symsize);
   if (sympp == NULL)
-    return FALSE;
+    return false;
 
   symcount = bfd_canonicalize_symtab (abfd, sympp);
   if (symcount < 0)
@@ -12010,7 +12010,7 @@ elf_output_implib (bfd *abfd, struct bfd_link_info *info)
   if (!bfd_close (implib_bfd))
     goto free_sym_buf;
 
-  ret = TRUE;
+  ret = true;
 
  free_sym_buf:
   free (sympp);
@@ -12044,11 +12044,11 @@ elf_final_link_free (bfd *obfd, struct elf_final_link_info *flinfo)
 
 /* Do the final step of an ELF link.  */
 
-bfd_boolean
+bool
 bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
 {
-  bfd_boolean dynamic;
-  bfd_boolean emit_relocs;
+  bool dynamic;
+  bool emit_relocs;
   bfd *dynobj;
   struct elf_final_link_info flinfo;
   asection *o;
@@ -12065,7 +12065,7 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
   Elf_Internal_Shdr *symtab_shndx_hdr;
   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
   struct elf_outext_info eoinfo;
-  bfd_boolean merged;
+  bool merged;
   size_t relativecount = 0;
   asection *reldyn = 0;
   bfd_size_type amt;
@@ -12073,11 +12073,11 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
   bfd_vma attr_size = 0;
   const char *std_attrs_section;
   struct elf_link_hash_table *htab = elf_hash_table (info);
-  bfd_boolean sections_removed;
-  bfd_boolean ret;
+  bool sections_removed;
+  bool ret;
 
   if (!is_elf_hash_table (htab))
-    return FALSE;
+    return false;
 
   if (bfd_link_pic (info))
     abfd->flags |= DYNAMIC;
@@ -12093,7 +12093,7 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
   flinfo.output_bfd = abfd;
   flinfo.symstrtab = _bfd_elf_strtab_init ();
   if (flinfo.symstrtab == NULL)
-    return FALSE;
+    return false;
 
   if (! dynamic)
     {
@@ -12112,16 +12112,16 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
       && !bfd_hash_table_init (&flinfo.local_hash_table,
 			       local_hash_newfunc,
 			       sizeof (struct local_hash_entry)))
-    return FALSE;
+    return false;
 
   /* The object attributes have been merged.  Remove the input
      sections from the link, and set the contents of the output
      section.  */
-  sections_removed = FALSE;
+  sections_removed = false;
   std_attrs_section = get_elf_backend_data (abfd)->obj_attrs_section;
   for (o = abfd->sections; o != NULL; o = o->next)
     {
-      bfd_boolean remove_section = FALSE;
+      bool remove_section = false;
 
       if ((std_attrs_section && strcmp (o->name, std_attrs_section) == 0)
 	  || strcmp (o->name, ".gnu.attributes") == 0)
@@ -12145,19 +12145,19 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
 	  if (attr_size)
 	    attr_section = o;
 	  else
-	    remove_section = TRUE;
+	    remove_section = true;
 	}
       else if ((o->flags & SEC_GROUP) != 0 && o->size == 0)
 	{
 	  /* Remove empty group section from linker output.  */
-	  remove_section = TRUE;
+	  remove_section = true;
 	}
       if (remove_section)
 	{
 	  o->flags |= SEC_EXCLUDE;
 	  bfd_section_list_remove (abfd, o);
 	  abfd->section_count--;
-	  sections_removed = TRUE;
+	  sections_removed = true;
 	}
     }
   if (sections_removed)
@@ -12171,7 +12171,7 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
   max_internal_reloc_count = 0;
   max_sym_count = 0;
   max_sym_shndx_count = 0;
-  merged = FALSE;
+  merged = false;
   for (o = abfd->sections; o != NULL; o = o->next)
     {
       struct bfd_elf_section_data *esdo = elf_section_data (o);
@@ -12196,10 +12196,10 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
 		 link.  This will normally be every section.  We need
 		 to do this so that we can identify any sections which
 		 the linker has decided to not include.  */
-	      sec->linker_mark = TRUE;
+	      sec->linker_mark = true;
 
 	      if (sec->flags & SEC_MERGE)
-		merged = TRUE;
+		merged = true;
 
 	      if (sec->rawsize > max_contents_size)
 		max_contents_size = sec->rawsize;
@@ -12394,7 +12394,7 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
     {
       file_ptr off = elf_next_file_pos (abfd);
 
-      _bfd_elf_assign_file_position_for_section (symtab_hdr, off, TRUE);
+      _bfd_elf_assign_file_position_for_section (symtab_hdr, off, true);
 
       /* Note that at this point elf_next_file_pos (abfd) is
 	 incorrect.  We do not yet know the size of the .symtab section.
@@ -12419,7 +12419,7 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
 
       if (bfd_keep_unused_section_symbols (abfd) || emit_relocs)
 	{
-	  bfd_boolean name_local_sections
+	  bool name_local_sections
 	    = (bed->elf_backend_name_local_section_symbols
 	       && bed->elf_backend_name_local_section_symbols (abfd));
 	  const char *name = NULL;
@@ -12541,7 +12541,7 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
     }
 
   if (!_bfd_elf_fixup_eh_frame_hdr (info))
-    return FALSE;
+    return false;
 
   /* Since ELF permits relocations to be against local symbols, we
      must have the local symbols available when we do the relocations.
@@ -12564,7 +12564,7 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
      know how bad the memory loss will be.  */
 
   for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
-    sub->output_has_begun = FALSE;
+    sub->output_has_begun = false;
   for (o = abfd->sections; o != NULL; o = o->next)
     {
       for (p = o->map_head.link_order; p != NULL; p = p->next)
@@ -12578,7 +12578,7 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
 		{
 		  if (! elf_link_input_bfd (&flinfo, sub))
 		    goto error_return;
-		  sub->output_has_begun = TRUE;
+		  sub->output_has_begun = true;
 		}
 	    }
 	  else if (p->type == bfd_section_reloc_link_order
@@ -12639,7 +12639,7 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
 	  }
     }
 
-  ret = TRUE;
+  ret = true;
 
   /* Output any global symbols that got converted to local in a
      version script or due to symbol visibility.  We do this in a
@@ -12647,14 +12647,14 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
      prior to any global symbols.  FIXME: We should only do this if
      some global symbols were, in fact, converted to become local.
      FIXME: Will this work correctly with the Irix 5 linker?  */
-  eoinfo.failed = FALSE;
+  eoinfo.failed = false;
   eoinfo.flinfo = &flinfo;
-  eoinfo.localsyms = TRUE;
-  eoinfo.file_sym_done = FALSE;
+  eoinfo.localsyms = true;
+  eoinfo.file_sym_done = false;
   bfd_hash_traverse (&info->hash->table, elf_link_output_extsym, &eoinfo);
   if (eoinfo.failed)
     {
-      ret = FALSE;
+      ret = false;
       goto return_local_hash_table;
     }
 
@@ -12666,7 +12666,7 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
       if (! ((*bed->elf_backend_output_arch_local_syms)
 	     (abfd, info, &flinfo, elf_link_output_symstrtab)))
 	{
-	  ret = FALSE;
+	  ret = false;
 	  goto return_local_hash_table;
 	}
     }
@@ -12716,7 +12716,7 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
 	      sym.st_shndx = indx;
 	      if (! check_dynsym (abfd, &sym))
 		{
-		  ret = FALSE;
+		  ret = false;
 		  goto return_local_hash_table;
 		}
 	      sym.st_value = s->vma;
@@ -12757,7 +12757,7 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
 		    elf_section_data (s->output_section)->this_idx;
 		  if (! check_dynsym (abfd, &sym))
 		    {
-		      ret = FALSE;
+		      ret = false;
 		      goto return_local_hash_table;
 		    }
 		  sym.st_value = (s->output_section->vma
@@ -12777,13 +12777,13 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
     }
 
   /* We get the global symbols from the hash table.  */
-  eoinfo.failed = FALSE;
-  eoinfo.localsyms = FALSE;
+  eoinfo.failed = false;
+  eoinfo.localsyms = false;
   eoinfo.flinfo = &flinfo;
   bfd_hash_traverse (&info->hash->table, elf_link_output_extsym, &eoinfo);
   if (eoinfo.failed)
     {
-      ret = FALSE;
+      ret = false;
       goto return_local_hash_table;
     }
 
@@ -12795,7 +12795,7 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
       if (! ((*bed->elf_backend_output_arch_syms)
 	     (abfd, info, &flinfo, elf_link_output_symstrtab)))
 	{
-	  ret = FALSE;
+	  ret = false;
 	  goto return_local_hash_table;
 	}
     }
@@ -12806,7 +12806,7 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
   /* Swap out the .strtab section. */
   if (!elf_link_swap_symbols_out (&flinfo))
     {
-      ret = FALSE;
+      ret = false;
       goto return_local_hash_table;
     }
 
@@ -12831,12 +12831,12 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
 	      symtab_shndx_hdr->sh_size = amt;
 
 	      off = _bfd_elf_assign_file_position_for_section (symtab_shndx_hdr,
-							       off, TRUE);
+							       off, true);
 
 	      if (bfd_seek (abfd, symtab_shndx_hdr->sh_offset, SEEK_SET) != 0
 		  || (bfd_bwrite (flinfo.symshndxbuf, amt, abfd) != amt))
 		{
-		  ret = FALSE;
+		  ret = false;
 		  goto return_local_hash_table;
 		}
 	    }
@@ -12855,13 +12855,13 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
       symstrtab_hdr->sh_addralign = 1;
 
       off = _bfd_elf_assign_file_position_for_section (symstrtab_hdr,
-						       off, TRUE);
+						       off, true);
       elf_next_file_pos (abfd) = off;
 
       if (bfd_seek (abfd, symstrtab_hdr->sh_offset, SEEK_SET) != 0
 	  || ! _bfd_elf_strtab_emit (abfd, flinfo.symstrtab))
 	{
-	  ret = FALSE;
+	  ret = false;
 	  goto return_local_hash_table;
 	}
     }
@@ -12870,7 +12870,7 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
     {
       _bfd_error_handler (_("%pB: failed to generate import library"),
 			  info->out_implib_bfd);
-      ret = FALSE;
+      ret = false;
       goto return_local_hash_table;
     }
 
@@ -12878,7 +12878,7 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
   for (o = abfd->sections; o != NULL; o = o->next)
     {
       struct bfd_elf_section_data *esdo = elf_section_data (o);
-      bfd_boolean sort;
+      bool sort;
 
       if ((o->flags & SEC_RELOC) == 0)
 	continue;
@@ -12887,13 +12887,13 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
       if (esdo->rel.hdr != NULL
 	  && !elf_link_adjust_relocs (abfd, o, &esdo->rel, sort, info))
 	{
-	  ret = FALSE;
+	  ret = false;
 	  goto return_local_hash_table;
 	}
       if (esdo->rela.hdr != NULL
 	  && !elf_link_adjust_relocs (abfd, o, &esdo->rela, sort, info))
 	{
-	  ret = FALSE;
+	  ret = false;
 	  goto return_local_hash_table;
 	}
 
@@ -12955,7 +12955,7 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
 	      {
 		struct elf_link_hash_entry *h;
 
-		h = elf_link_hash_lookup (htab, name, FALSE, FALSE, TRUE);
+		h = elf_link_hash_lookup (htab, name, false, false, true);
 		if (h != NULL
 		    && (h->root.type == bfd_link_hash_defined
 			|| h->root.type == bfd_link_hash_defweak))
@@ -13187,7 +13187,7 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
 
   if (!info->resolve_section_groups)
     {
-      bfd_boolean failed = FALSE;
+      bool failed = false;
 
       BFD_ASSERT (bfd_link_relocatable (info));
       bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
@@ -13216,7 +13216,7 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
       if (contents == NULL)
 	{
 	  /* Bail out and fail.  */
-	  ret = FALSE;
+	  ret = false;
 	  goto return_local_hash_table;
 	}
       bfd_elf_set_obj_attr_contents (abfd, contents, attr_size);
@@ -13231,13 +13231,13 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info)
 
  error_return:
   elf_final_link_free (abfd, &flinfo);
-  ret = FALSE;
+  ret = false;
   goto return_local_hash_table;
 }
 
 /* Initialize COOKIE for input bfd ABFD.  */
 
-static bfd_boolean
+static bool
 init_reloc_cookie (struct elf_reloc_cookie *cookie,
 		   struct bfd_link_info *info, bfd *abfd)
 {
@@ -13275,12 +13275,12 @@ init_reloc_cookie (struct elf_reloc_cookie *cookie,
       if (cookie->locsyms == NULL)
 	{
 	  info->callbacks->einfo (_("%P%X: can not read symbols: %E\n"));
-	  return FALSE;
+	  return false;
 	}
       if (info->keep_memory)
 	symtab_hdr->contents = (bfd_byte *) cookie->locsyms;
     }
-  return TRUE;
+  return true;
 }
 
 /* Free the memory allocated by init_reloc_cookie, if appropriate.  */
@@ -13298,7 +13298,7 @@ fini_reloc_cookie (struct elf_reloc_cookie *cookie, bfd *abfd)
 /* Initialize the relocation information in COOKIE for input section SEC
    of input bfd ABFD.  */
 
-static bfd_boolean
+static bool
 init_reloc_cookie_rels (struct elf_reloc_cookie *cookie,
 			struct bfd_link_info *info, bfd *abfd,
 			asection *sec)
@@ -13313,12 +13313,12 @@ init_reloc_cookie_rels (struct elf_reloc_cookie *cookie,
       cookie->rels = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
 						info->keep_memory);
       if (cookie->rels == NULL)
-	return FALSE;
+	return false;
       cookie->rel = cookie->rels;
       cookie->relend = cookie->rels + sec->reloc_count;
     }
   cookie->rel = cookie->rels;
-  return TRUE;
+  return true;
 }
 
 /* Free the memory allocated by init_reloc_cookie_rels,
@@ -13334,7 +13334,7 @@ fini_reloc_cookie_rels (struct elf_reloc_cookie *cookie,
 
 /* Initialize the whole of COOKIE for input section SEC.  */
 
-static bfd_boolean
+static bool
 init_reloc_cookie_for_section (struct elf_reloc_cookie *cookie,
 			       struct bfd_link_info *info,
 			       asection *sec)
@@ -13343,12 +13343,12 @@ init_reloc_cookie_for_section (struct elf_reloc_cookie *cookie,
     goto error1;
   if (!init_reloc_cookie_rels (cookie, info, sec->owner, sec))
     goto error2;
-  return TRUE;
+  return true;
 
  error2:
   fini_reloc_cookie (cookie, sec->owner);
  error1:
-  return FALSE;
+  return false;
 }
 
 /* Free the memory allocated by init_reloc_cookie_for_section,
@@ -13431,7 +13431,7 @@ asection *
 _bfd_elf_gc_mark_rsec (struct bfd_link_info *info, asection *sec,
 		       elf_gc_mark_hook_fn gc_mark_hook,
 		       struct elf_reloc_cookie *cookie,
-		       bfd_boolean *start_stop)
+		       bool *start_stop)
 {
   unsigned long r_symndx;
   struct elf_link_hash_entry *h, *hw;
@@ -13443,7 +13443,7 @@ _bfd_elf_gc_mark_rsec (struct bfd_link_info *info, asection *sec,
   if (r_symndx >= cookie->locsymcount
       || ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL)
     {
-      bfd_boolean was_marked;
+      bool was_marked;
 
       h = cookie->sym_hashes[r_symndx - cookie->extsymoff];
       if (h == NULL)
@@ -13480,7 +13480,7 @@ _bfd_elf_gc_mark_rsec (struct bfd_link_info *info, asection *sec,
 	  else if (start_stop != NULL)
 	    {
 	      asection *s = h->u2.start_stop_section;
-	      *start_stop = TRUE;
+	      *start_stop = true;
 	      return s;
 	    }
 	}
@@ -13496,14 +13496,14 @@ _bfd_elf_gc_mark_rsec (struct bfd_link_info *info, asection *sec,
    a section we've decided to keep.  Mark the section that contains
    the relocation symbol.  */
 
-bfd_boolean
+bool
 _bfd_elf_gc_mark_reloc (struct bfd_link_info *info,
 			asection *sec,
 			elf_gc_mark_hook_fn gc_mark_hook,
 			struct elf_reloc_cookie *cookie)
 {
   asection *rsec;
-  bfd_boolean start_stop = FALSE;
+  bool start_stop = false;
 
   rsec = _bfd_elf_gc_mark_rsec (info, sec, gc_mark_hook, cookie, &start_stop);
   while (rsec != NULL)
@@ -13514,25 +13514,25 @@ _bfd_elf_gc_mark_reloc (struct bfd_link_info *info,
 	      || (rsec->owner->flags & DYNAMIC) != 0)
 	    rsec->gc_mark = 1;
 	  else if (!_bfd_elf_gc_mark (info, rsec, gc_mark_hook))
-	    return FALSE;
+	    return false;
 	}
       if (!start_stop)
 	break;
       rsec = bfd_get_next_section_by_name (rsec->owner, rsec);
     }
-  return TRUE;
+  return true;
 }
 
 /* The mark phase of garbage collection.  For a given section, mark
    it and any sections in this section's group, and all the sections
    which define symbols to which it refers.  */
 
-bfd_boolean
+bool
 _bfd_elf_gc_mark (struct bfd_link_info *info,
 		  asection *sec,
 		  elf_gc_mark_hook_fn gc_mark_hook)
 {
-  bfd_boolean ret;
+  bool ret;
   asection *group_sec, *eh_frame;
 
   sec->gc_mark = 1;
@@ -13541,10 +13541,10 @@ _bfd_elf_gc_mark (struct bfd_link_info *info,
   group_sec = elf_section_data (sec)->next_in_group;
   if (group_sec && !group_sec->gc_mark)
     if (!_bfd_elf_gc_mark (info, group_sec, gc_mark_hook))
-      return FALSE;
+      return false;
 
   /* Look through the section relocs.  */
-  ret = TRUE;
+  ret = true;
   eh_frame = elf_eh_frame_section (sec->owner);
   if ((sec->flags & SEC_RELOC) != 0
       && sec->reloc_count > 0
@@ -13553,13 +13553,13 @@ _bfd_elf_gc_mark (struct bfd_link_info *info,
       struct elf_reloc_cookie cookie;
 
       if (!init_reloc_cookie_for_section (&cookie, info, sec))
-	ret = FALSE;
+	ret = false;
       else
 	{
 	  for (; cookie.rel < cookie.relend; cookie.rel++)
 	    if (!_bfd_elf_gc_mark_reloc (info, sec, gc_mark_hook, &cookie))
 	      {
-		ret = FALSE;
+		ret = false;
 		break;
 	      }
 	  fini_reloc_cookie_for_section (&cookie, sec);
@@ -13571,12 +13571,12 @@ _bfd_elf_gc_mark (struct bfd_link_info *info,
       struct elf_reloc_cookie cookie;
 
       if (!init_reloc_cookie_for_section (&cookie, info, eh_frame))
-	ret = FALSE;
+	ret = false;
       else
 	{
 	  if (!_bfd_elf_gc_mark_fdes (info, sec, eh_frame,
 				      gc_mark_hook, &cookie))
-	    ret = FALSE;
+	    ret = false;
 	  fini_reloc_cookie_for_section (&cookie, eh_frame);
 	}
     }
@@ -13584,7 +13584,7 @@ _bfd_elf_gc_mark (struct bfd_link_info *info,
   eh_frame = elf_section_eh_frame_entry (sec);
   if (ret && eh_frame && !eh_frame->gc_mark)
     if (!_bfd_elf_gc_mark (info, eh_frame, gc_mark_hook))
-      ret = FALSE;
+      ret = false;
 
   return ret;
 }
@@ -13599,8 +13599,8 @@ _bfd_elf_gc_mark_debug_special_section_group (asection *grp)
   /* Used to iterate the section group.  */
   asection *msec;
 
-  bfd_boolean is_special_grp = TRUE;
-  bfd_boolean is_debug_grp = TRUE;
+  bool is_special_grp = true;
+  bool is_debug_grp = true;
 
   /* First scan to see if group contains any section other than debug
      and special section.  */
@@ -13608,10 +13608,10 @@ _bfd_elf_gc_mark_debug_special_section_group (asection *grp)
   do
     {
       if ((msec->flags & SEC_DEBUGGING) == 0)
-	is_debug_grp = FALSE;
+	is_debug_grp = false;
 
       if ((msec->flags & (SEC_ALLOC | SEC_LOAD | SEC_RELOC)) != 0)
-	is_special_grp = FALSE;
+	is_special_grp = false;
 
       msec = elf_next_in_group (msec);
     }
@@ -13632,7 +13632,7 @@ _bfd_elf_gc_mark_debug_special_section_group (asection *grp)
 
 /* Keep debug and special sections.  */
 
-bfd_boolean
+bool
 _bfd_elf_gc_mark_extra_sections (struct bfd_link_info *info,
 				 elf_gc_mark_hook_fn mark_hook)
 {
@@ -13641,9 +13641,9 @@ _bfd_elf_gc_mark_extra_sections (struct bfd_link_info *info,
   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
     {
       asection *isec;
-      bfd_boolean some_kept;
-      bfd_boolean debug_frag_seen;
-      bfd_boolean has_kept_debug_info;
+      bool some_kept;
+      bool debug_frag_seen;
+      bool has_kept_debug_info;
 
       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
 	continue;
@@ -13654,7 +13654,7 @@ _bfd_elf_gc_mark_extra_sections (struct bfd_link_info *info,
       /* Ensure all linker created sections are kept,
 	 see if any other section is already marked,
 	 and note if we have any fragmented debug sections.  */
-      debug_frag_seen = some_kept = has_kept_debug_info = FALSE;
+      debug_frag_seen = some_kept = has_kept_debug_info = false;
       for (isec = ibfd->sections; isec != NULL; isec = isec->next)
 	{
 	  if ((isec->flags & SEC_LINKER_CREATED) != 0)
@@ -13662,7 +13662,7 @@ _bfd_elf_gc_mark_extra_sections (struct bfd_link_info *info,
 	  else if (isec->gc_mark
 		   && (isec->flags & SEC_ALLOC) != 0
 		   && elf_section_type (isec) != SHT_NOTE)
-	    some_kept = TRUE;
+	    some_kept = true;
 	  else
 	    {
 	      /* Since all sections, except for backend specific ones,
@@ -13676,7 +13676,7 @@ _bfd_elf_gc_mark_extra_sections (struct bfd_link_info *info,
 		  if (linked_to_sec->gc_mark)
 		    {
 		      if (!_bfd_elf_gc_mark (info, isec, mark_hook))
-			return FALSE;
+			return false;
 		      break;
 		    }
 		  linked_to_sec->linker_mark = 1;
@@ -13690,7 +13690,7 @@ _bfd_elf_gc_mark_extra_sections (struct bfd_link_info *info,
 	  if (!debug_frag_seen
 	      && (isec->flags & SEC_DEBUGGING)
 	      && startswith (isec->name, ".debug_line."))
-	    debug_frag_seen = TRUE;
+	    debug_frag_seen = true;
 	  else if (strcmp (bfd_section_name (isec),
 			   "__patchable_function_entries") == 0
 		   && elf_linked_to_section (isec) == NULL)
@@ -13719,7 +13719,7 @@ _bfd_elf_gc_mark_extra_sections (struct bfd_link_info *info,
 		   && elf_linked_to_section (isec) == NULL)
 	    isec->gc_mark = 1;
 	  if (isec->gc_mark && (isec->flags & SEC_DEBUGGING) != 0)
-	    has_kept_debug_info = TRUE;
+	    has_kept_debug_info = true;
 	}
 
       /* Look for CODE sections which are going to be discarded,
@@ -13763,12 +13763,12 @@ _bfd_elf_gc_mark_extra_sections (struct bfd_link_info *info,
 	      && (isec->flags & SEC_DEBUGGING) != 0)
 	    if (!_bfd_elf_gc_mark (info, isec,
 				   elf_gc_mark_debug_section))
-	      return FALSE;
+	      return false;
     }
-  return TRUE;
+  return true;
 }
 
-static bfd_boolean
+static bool
 elf_gc_sweep (bfd *abfd, struct bfd_link_info *info)
 {
   bfd *sub;
@@ -13816,28 +13816,28 @@ elf_gc_sweep (bfd *abfd, struct bfd_link_info *info)
 	}
     }
 
-  return TRUE;
+  return true;
 }
 
 /* Propagate collected vtable information.  This is called through
    elf_link_hash_traverse.  */
 
-static bfd_boolean
+static bool
 elf_gc_propagate_vtable_entries_used (struct elf_link_hash_entry *h, void *okp)
 {
   /* Those that are not vtables.  */
   if (h->start_stop
       || h->u2.vtable == NULL
       || h->u2.vtable->parent == NULL)
-    return TRUE;
+    return true;
 
   /* Those vtables that do not have parents, we cannot merge.  */
   if (h->u2.vtable->parent == (struct elf_link_hash_entry *) -1)
-    return TRUE;
+    return true;
 
   /* If we've already been done, exit.  */
   if (h->u2.vtable->used && h->u2.vtable->used[-1])
-    return TRUE;
+    return true;
 
   /* Make sure the parent's table is up to date.  */
   elf_gc_propagate_vtable_entries_used (h->u2.vtable->parent, okp);
@@ -13852,11 +13852,11 @@ elf_gc_propagate_vtable_entries_used (struct elf_link_hash_entry *h, void *okp)
   else
     {
       size_t n;
-      bfd_boolean *cu, *pu;
+      bool *cu, *pu;
 
       /* Or the parent's entries into ours.  */
       cu = h->u2.vtable->used;
-      cu[-1] = TRUE;
+      cu[-1] = true;
       pu = h->u2.vtable->parent->u2.vtable->used;
       if (pu != NULL)
 	{
@@ -13869,17 +13869,17 @@ elf_gc_propagate_vtable_entries_used (struct elf_link_hash_entry *h, void *okp)
 	  while (n--)
 	    {
 	      if (*pu)
-		*cu = TRUE;
+		*cu = true;
 	      pu++;
 	      cu++;
 	    }
 	}
     }
 
-  return TRUE;
+  return true;
 }
 
-static bfd_boolean
+static bool
 elf_gc_smash_unused_vtentry_relocs (struct elf_link_hash_entry *h, void *okp)
 {
   asection *sec;
@@ -13893,7 +13893,7 @@ elf_gc_smash_unused_vtentry_relocs (struct elf_link_hash_entry *h, void *okp)
   if (h->start_stop
       || h->u2.vtable == NULL
       || h->u2.vtable->parent == NULL)
-    return TRUE;
+    return true;
 
   BFD_ASSERT (h->root.type == bfd_link_hash_defined
 	      || h->root.type == bfd_link_hash_defweak);
@@ -13902,9 +13902,9 @@ elf_gc_smash_unused_vtentry_relocs (struct elf_link_hash_entry *h, void *okp)
   hstart = h->root.u.def.value;
   hend = hstart + h->size;
 
-  relstart = _bfd_elf_link_read_relocs (sec->owner, sec, NULL, NULL, TRUE);
+  relstart = _bfd_elf_link_read_relocs (sec->owner, sec, NULL, NULL, true);
   if (!relstart)
-    return *(bfd_boolean *) okp = FALSE;
+    return *(bool *) okp = false;
   bed = get_elf_backend_data (sec->owner);
   log_file_align = bed->s->log_file_align;
 
@@ -13925,14 +13925,14 @@ elf_gc_smash_unused_vtentry_relocs (struct elf_link_hash_entry *h, void *okp)
 	rel->r_offset = rel->r_info = rel->r_addend = 0;
       }
 
-  return TRUE;
+  return true;
 }
 
 /* Mark sections containing dynamically referenced symbols.  When
    building shared libraries, we must assume that any visible symbol is
    referenced.  */
 
-bfd_boolean
+bool
 bfd_elf_gc_mark_dynamic_ref_symbol (struct elf_link_hash_entry *h, void *inf)
 {
   struct bfd_link_info *info = (struct bfd_link_info *) inf;
@@ -13958,7 +13958,7 @@ bfd_elf_gc_mark_dynamic_ref_symbol (struct elf_link_hash_entry *h, void *inf)
 					       h->root.root.string)))))
     h->root.u.def.section->flags |= SEC_KEEP;
 
-  return TRUE;
+  return true;
 }
 
 /* Keep all sections containing symbols undefined on the command-line,
@@ -13974,7 +13974,7 @@ _bfd_elf_gc_keep (struct bfd_link_info *info)
       struct elf_link_hash_entry *h;
 
       h = elf_link_hash_lookup (elf_hash_table (info), sym->name,
-				FALSE, FALSE, FALSE);
+				false, false, false);
 
       if (h != NULL
 	  && (h->root.type == bfd_link_hash_defined
@@ -13984,7 +13984,7 @@ _bfd_elf_gc_keep (struct bfd_link_info *info)
     }
 }
 
-bfd_boolean
+bool
 bfd_elf_parse_eh_frame_entries (bfd *abfd ATTRIBUTE_UNUSED,
 				struct bfd_link_info *info)
 {
@@ -14002,7 +14002,7 @@ bfd_elf_parse_eh_frame_entries (bfd *abfd ATTRIBUTE_UNUSED,
 	continue;
 
       if (!init_reloc_cookie (&cookie, info, ibfd))
-	return FALSE;
+	return false;
 
       for (sec = ibfd->sections; sec; sec = sec->next)
 	{
@@ -14014,15 +14014,15 @@ bfd_elf_parse_eh_frame_entries (bfd *abfd ATTRIBUTE_UNUSED,
 	    }
 	}
     }
-  return TRUE;
+  return true;
 }
 
 /* Do mark and sweep of unused sections.  */
 
-bfd_boolean
+bool
 bfd_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
 {
-  bfd_boolean ok = TRUE;
+  bool ok = true;
   bfd *sub;
   elf_gc_mark_hook_fn gc_mark_hook;
   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
@@ -14032,7 +14032,7 @@ bfd_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
       || !is_elf_hash_table (info->hash))
     {
       _bfd_error_handler(_("warning: gc-sections option ignored"));
-      return TRUE;
+      return true;
     }
 
   bed->gc_keep (info);
@@ -14065,12 +14065,12 @@ bfd_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
   /* Apply transitive closure to the vtable entry usage info.  */
   elf_link_hash_traverse (htab, elf_gc_propagate_vtable_entries_used, &ok);
   if (!ok)
-    return FALSE;
+    return false;
 
   /* Kill the vtable relocations that were not used.  */
   elf_link_hash_traverse (htab, elf_gc_smash_unused_vtentry_relocs, &ok);
   if (!ok)
-    return FALSE;
+    return false;
 
   /* Mark dynamically referenced symbols.  */
   if (htab->dynamic_sections_created || info->gc_keep_exported)
@@ -14113,7 +14113,7 @@ bfd_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
 		    && (elf_section_flags (o) & SHF_GNU_RETAIN))))
 	  {
 	    if (!_bfd_elf_gc_mark (info, o, gc_mark_hook))
-	      return FALSE;
+	      return false;
 	  }
     }
 
@@ -14126,7 +14126,7 @@ bfd_elf_gc_sections (bfd *abfd, struct bfd_link_info *info)
 
 /* Called from check_relocs to record the existence of a VTINHERIT reloc.  */
 
-bfd_boolean
+bool
 bfd_elf_gc_record_vtinherit (bfd *abfd,
 			     asection *sec,
 			     struct elf_link_hash_entry *h,
@@ -14163,7 +14163,7 @@ bfd_elf_gc_record_vtinherit (bfd *abfd,
   _bfd_error_handler (_("%pB: %pA+%#" PRIx64 ": no symbol found for INHERIT"),
 		      abfd, sec, (uint64_t) offset);
   bfd_set_error (bfd_error_invalid_operation);
-  return FALSE;
+  return false;
 
  win:
   if (!child->u2.vtable)
@@ -14171,7 +14171,7 @@ bfd_elf_gc_record_vtinherit (bfd *abfd,
       child->u2.vtable = ((struct elf_link_virtual_table_entry *)
 			  bfd_zalloc (abfd, sizeof (*child->u2.vtable)));
       if (!child->u2.vtable)
-	return FALSE;
+	return false;
     }
   if (!h)
     {
@@ -14185,12 +14185,12 @@ bfd_elf_gc_record_vtinherit (bfd *abfd,
   else
     child->u2.vtable->parent = h;
 
-  return TRUE;
+  return true;
 }
 
 /* Called from check_relocs to record the existence of a VTENTRY reloc.  */
 
-bfd_boolean
+bool
 bfd_elf_gc_record_vtentry (bfd *abfd, asection *sec,
 			   struct elf_link_hash_entry *h,
 			   bfd_vma addend)
@@ -14204,7 +14204,7 @@ bfd_elf_gc_record_vtentry (bfd *abfd, asection *sec,
       _bfd_error_handler (_("%pB: section '%pA': corrupt VTENTRY entry"),
 			  abfd, sec);
       bfd_set_error (bfd_error_bad_value);
-      return FALSE;
+      return false;
     }
 
   if (!h->u2.vtable)
@@ -14212,13 +14212,13 @@ bfd_elf_gc_record_vtentry (bfd *abfd, asection *sec,
       h->u2.vtable = ((struct elf_link_virtual_table_entry *)
 		      bfd_zalloc (abfd, sizeof (*h->u2.vtable)));
       if (!h->u2.vtable)
-	return FALSE;
+	return false;
     }
 
   if (addend >= h->u2.vtable->size)
     {
       size_t size, bytes, file_align;
-      bfd_boolean *ptr = h->u2.vtable->used;
+      bool *ptr = h->u2.vtable->used;
 
       /* While the symbol is undefined, we have to be prepared to handle
 	 a zero size.  */
@@ -14239,35 +14239,35 @@ bfd_elf_gc_record_vtentry (bfd *abfd, asection *sec,
 
       /* Allocate one extra entry for use as a "done" flag for the
 	 consolidation pass.  */
-      bytes = ((size >> log_file_align) + 1) * sizeof (bfd_boolean);
+      bytes = ((size >> log_file_align) + 1) * sizeof (bool);
 
       if (ptr)
 	{
-	  ptr = (bfd_boolean *) bfd_realloc (ptr - 1, bytes);
+	  ptr = (bool *) bfd_realloc (ptr - 1, bytes);
 
 	  if (ptr != NULL)
 	    {
 	      size_t oldbytes;
 
 	      oldbytes = (((h->u2.vtable->size >> log_file_align) + 1)
-			  * sizeof (bfd_boolean));
+			  * sizeof (bool));
 	      memset (((char *) ptr) + oldbytes, 0, bytes - oldbytes);
 	    }
 	}
       else
-	ptr = (bfd_boolean *) bfd_zmalloc (bytes);
+	ptr = (bool *) bfd_zmalloc (bytes);
 
       if (ptr == NULL)
-	return FALSE;
+	return false;
 
       /* And arrange for that done flag to be at index -1.  */
       h->u2.vtable->used = ptr + 1;
       h->u2.vtable->size = size;
     }
 
-  h->u2.vtable->used[addend >> log_file_align] = TRUE;
+  h->u2.vtable->used[addend >> log_file_align] = true;
 
-  return TRUE;
+  return true;
 }
 
 /* Map an ELF section header flag to its corresponding string.  */
@@ -14294,7 +14294,7 @@ static const elf_flags_to_name_table elf_flags_to_names [] =
 };
 
 /* Returns TRUE if the section is to be included, otherwise FALSE.  */
-bfd_boolean
+bool
 bfd_elf_lookup_section_flags (struct bfd_link_info *info,
 			      struct flag_info *flaginfo,
 			      asection *section)
@@ -14325,7 +14325,7 @@ bfd_elf_lookup_section_flags (struct bfd_link_info *info,
 		    with_hex |= hexval;
 		  else if (tf->with == without_flags)
 		    without_hex |= hexval;
-		  tf->valid = TRUE;
+		  tf->valid = true;
 		  continue;
 		}
 	    }
@@ -14337,7 +14337,7 @@ bfd_elf_lookup_section_flags (struct bfd_link_info *info,
 		    with_hex |= elf_flags_to_names[i].flag_value;
 		  else if (tf->with == without_flags)
 		    without_hex |= elf_flags_to_names[i].flag_value;
-		  tf->valid = TRUE;
+		  tf->valid = true;
 		  break;
 		}
 	    }
@@ -14345,21 +14345,21 @@ bfd_elf_lookup_section_flags (struct bfd_link_info *info,
 	    {
 	      info->callbacks->einfo
 		(_("unrecognized INPUT_SECTION_FLAG %s\n"), tf->name);
-	      return FALSE;
+	      return false;
 	    }
 	}
-      flaginfo->flags_initialized = TRUE;
+      flaginfo->flags_initialized = true;
       flaginfo->only_with_flags |= with_hex;
       flaginfo->not_with_flags |= without_hex;
     }
 
   if ((flaginfo->only_with_flags & sh_flags) != flaginfo->only_with_flags)
-    return FALSE;
+    return false;
 
   if ((flaginfo->not_with_flags & sh_flags) != 0)
-    return FALSE;
+    return false;
 
-  return TRUE;
+  return true;
 }
 
 struct alloc_got_off_arg {
@@ -14370,7 +14370,7 @@ struct alloc_got_off_arg {
 /* We need a special top-level link routine to convert got reference counts
    to real got offsets.  */
 
-static bfd_boolean
+static bool
 elf_gc_allocate_got_offsets (struct elf_link_hash_entry *h, void *arg)
 {
   struct alloc_got_off_arg *gofarg = (struct alloc_got_off_arg *) arg;
@@ -14385,13 +14385,13 @@ elf_gc_allocate_got_offsets (struct elf_link_hash_entry *h, void *arg)
   else
     h->got.offset = (bfd_vma) -1;
 
-  return TRUE;
+  return true;
 }
 
 /* And an accompanying bit to work out final got entry offsets once
    we're done.  Should be called from final_link.  */
 
-bfd_boolean
+bool
 bfd_elf_gc_common_finalize_got_offsets (bfd *abfd,
 					struct bfd_link_info *info)
 {
@@ -14403,7 +14403,7 @@ bfd_elf_gc_common_finalize_got_offsets (bfd *abfd,
   BFD_ASSERT (abfd == info->output_bfd);
 
   if (! is_elf_hash_table (info->hash))
-    return FALSE;
+    return false;
 
   /* The GOT offset is relative to the .got section, but the GOT header is
      put into the .got.plt section, if the backend uses it.  */
@@ -14451,23 +14451,23 @@ bfd_elf_gc_common_finalize_got_offsets (bfd *abfd,
   elf_link_hash_traverse (elf_hash_table (info),
 			  elf_gc_allocate_got_offsets,
 			  &gofarg);
-  return TRUE;
+  return true;
 }
 
 /* Many folk need no more in the way of final link than this, once
    got entry reference counting is enabled.  */
 
-bfd_boolean
+bool
 bfd_elf_gc_common_final_link (bfd *abfd, struct bfd_link_info *info)
 {
   if (!bfd_elf_gc_common_finalize_got_offsets (abfd, info))
-    return FALSE;
+    return false;
 
   /* Invoke the regular ELF backend linker to do all the work.  */
   return bfd_elf_final_link (abfd, info);
 }
 
-bfd_boolean
+bool
 bfd_elf_reloc_symbol_deleted_p (bfd_vma offset, void *cookie)
 {
   struct elf_reloc_cookie *rcookie = (struct elf_reloc_cookie *) cookie;
@@ -14481,13 +14481,13 @@ bfd_elf_reloc_symbol_deleted_p (bfd_vma offset, void *cookie)
 
       if (! rcookie->bad_symtab)
 	if (rcookie->rel->r_offset > offset)
-	  return FALSE;
+	  return false;
       if (rcookie->rel->r_offset != offset)
 	continue;
 
       r_symndx = rcookie->rel->r_info >> rcookie->r_sym_shift;
       if (r_symndx == STN_UNDEF)
-	return TRUE;
+	return true;
 
       if (r_symndx >= rcookie->locsymcount
 	  || ELF_ST_BIND (rcookie->locsyms[r_symndx].st_info) != STB_LOCAL)
@@ -14505,7 +14505,7 @@ bfd_elf_reloc_symbol_deleted_p (bfd_vma offset, void *cookie)
 	      && (h->root.u.def.section->owner != rcookie->abfd
 		  || h->root.u.def.section->kept_section != NULL
 		  || discarded_section (h->root.u.def.section)))
-	    return TRUE;
+	    return true;
 	}
       else
 	{
@@ -14521,11 +14521,11 @@ bfd_elf_reloc_symbol_deleted_p (bfd_vma offset, void *cookie)
 	  if (isec != NULL
 	      && (isec->kept_section != NULL
 		  || discarded_section (isec)))
-	    return TRUE;
+	    return true;
 	}
-      return FALSE;
+      return false;
     }
-  return FALSE;
+  return false;
 }
 
 /* Discard unneeded references to discarded sections.
@@ -14679,7 +14679,7 @@ bfd_elf_discard_info (bfd *output_bfd, struct bfd_link_info *info)
   return changed;
 }
 
-bfd_boolean
+bool
 _bfd_elf_section_already_linked (bfd *abfd,
 				 asection *sec,
 				 struct bfd_link_info *info)
@@ -14690,19 +14690,19 @@ _bfd_elf_section_already_linked (bfd *abfd,
   struct bfd_section_already_linked_hash_entry *already_linked_list;
 
   if (sec->output_section == bfd_abs_section_ptr)
-    return FALSE;
+    return false;
 
   flags = sec->flags;
 
   /* Return if it isn't a linkonce section.  A comdat group section
      also has SEC_LINK_ONCE set.  */
   if ((flags & SEC_LINK_ONCE) == 0)
-    return FALSE;
+    return false;
 
   /* Don't put group member sections on our list of already linked
      sections.  They are handled as a group via their group section.  */
   if (elf_sec_group (sec) != NULL)
-    return FALSE;
+    return false;
 
   /* For a SHT_GROUP section, use the group signature as the key.  */
   name = sec->name;
@@ -14742,7 +14742,7 @@ _bfd_elf_section_already_linked (bfd *abfd,
 	  /* The section has already been linked.  See if we should
 	     issue a warning.  */
 	  if (!_bfd_handle_already_linked (sec, l, info))
-	    return FALSE;
+	    return false;
 
 	  if (flags & SEC_GROUP)
 	    {
@@ -14761,7 +14761,7 @@ _bfd_elf_section_already_linked (bfd *abfd,
 		}
 	    }
 
-	  return TRUE;
+	  return true;
 	}
     }
 
@@ -14828,7 +14828,7 @@ _bfd_elf_section_already_linked (bfd *abfd,
   return sec->output_section == bfd_abs_section_ptr;
 }
 
-bfd_boolean
+bool
 _bfd_elf_common_definition (Elf_Internal_Sym *sym)
 {
   return sym->st_shndx == SHN_COMMON;
@@ -14864,7 +14864,7 @@ _bfd_elf_default_got_elt_size (bfd *abfd,
 static const char *
 get_dynamic_reloc_section_name (bfd *       abfd,
 				asection *  sec,
-				bfd_boolean is_rela)
+				bool is_rela)
 {
   char *name;
   const char *old_name = bfd_section_name (sec);
@@ -14885,15 +14885,15 @@ get_dynamic_reloc_section_name (bfd *       abfd,
    of IS_RELA.  */
 
 asection *
-_bfd_elf_get_dynamic_reloc_section (bfd *       abfd,
-				    asection *  sec,
-				    bfd_boolean is_rela)
+_bfd_elf_get_dynamic_reloc_section (bfd *abfd,
+				    asection *sec,
+				    bool is_rela)
 {
-  asection * reloc_sec = elf_section_data (sec)->sreloc;
+  asection *reloc_sec = elf_section_data (sec)->sreloc;
 
   if (reloc_sec == NULL)
     {
-      const char * name = get_dynamic_reloc_section_name (abfd, sec, is_rela);
+      const char *name = get_dynamic_reloc_section_name (abfd, sec, is_rela);
 
       if (name != NULL)
 	{
@@ -14922,7 +14922,7 @@ _bfd_elf_make_dynamic_reloc_section (asection *sec,
 				     bfd *dynobj,
 				     unsigned int alignment,
 				     bfd *abfd,
-				     bfd_boolean is_rela)
+				     bool is_rela)
 {
   asection * reloc_sec = elf_section_data (sec)->sreloc;
 
@@ -14978,7 +14978,7 @@ _bfd_elf_copy_link_hash_symbol_type (bfd *abfd,
   ehdest->target_internal = ehsrc->target_internal;
 
   isym.st_other = ehsrc->other;
-  elf_merge_st_other (abfd, ehdest, isym.st_other, NULL, TRUE, FALSE);
+  elf_merge_st_other (abfd, ehdest, isym.st_other, NULL, true, false);
 }
 
 /* Append a RELA relocation REL to section S in BFD.  */
@@ -15012,7 +15012,7 @@ bfd_elf_define_start_stop (struct bfd_link_info *info,
   struct elf_link_hash_entry *h;
 
   h = elf_link_hash_lookup (elf_hash_table (info), symbol,
-			    FALSE, FALSE, TRUE);
+			    false, false, true);
   /* NB: Common symbols will be turned into definition later.  */
   if (h != NULL
       && !h->root.ldscript_def
@@ -15022,7 +15022,7 @@ bfd_elf_define_start_stop (struct bfd_link_info *info,
 	      && !h->def_regular
 	      && h->root.type != bfd_link_hash_common)))
     {
-      bfd_boolean was_dynamic = h->ref_dynamic || h->def_dynamic;
+      bool was_dynamic = h->ref_dynamic || h->def_dynamic;
       h->verinfo.verdef = NULL;
       h->root.type = bfd_link_hash_defined;
       h->root.u.def.section = sec;
@@ -15036,7 +15036,7 @@ bfd_elf_define_start_stop (struct bfd_link_info *info,
 	  /* .startof. and .sizeof. symbols are local.  */
 	  const struct elf_backend_data *bed;
 	  bed = get_elf_backend_data (info->output_bfd);
-	  (*bed->elf_backend_hide_symbol) (info, h, TRUE);
+	  (*bed->elf_backend_hide_symbol) (info, h, true);
 	}
       else
 	{
@@ -15071,13 +15071,13 @@ _bfd_elf_readonly_dynrelocs (struct elf_link_hash_entry *h)
 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
    read-only sections.  */
 
-bfd_boolean
+bool
 _bfd_elf_maybe_set_textrel (struct elf_link_hash_entry *h, void *inf)
 {
   asection *sec;
 
   if (h->root.type == bfd_link_hash_indirect)
-    return TRUE;
+    return true;
 
   sec = _bfd_elf_readonly_dynrelocs (h);
   if (sec != NULL)
@@ -15097,16 +15097,16 @@ _bfd_elf_maybe_set_textrel (struct elf_link_hash_entry *h, void *inf)
 				sec->owner, h->root.root.string, sec);
 
       /* Not an error, just cut short the traversal.  */
-      return FALSE;
+      return false;
     }
-  return TRUE;
+  return true;
 }
 
 /* Add dynamic tags.  */
 
-bfd_boolean
+bool
 _bfd_elf_add_dynamic_tags (bfd *output_bfd, struct bfd_link_info *info,
-			   bfd_boolean need_dynamic_reloc)
+			   bool need_dynamic_reloc)
 {
   struct elf_link_hash_table *htab = elf_hash_table (info);
 
@@ -15126,7 +15126,7 @@ _bfd_elf_add_dynamic_tags (bfd *output_bfd, struct bfd_link_info *info,
       if (bfd_link_executable (info))
 	{
 	  if (!add_dynamic_entry (DT_DEBUG, 0))
-	    return FALSE;
+	    return false;
 	}
 
       if (htab->dt_pltgot_required || htab->splt->size != 0)
@@ -15134,7 +15134,7 @@ _bfd_elf_add_dynamic_tags (bfd *output_bfd, struct bfd_link_info *info,
 	  /* DT_PLTGOT is used by prelink even if there is no PLT
 	     relocation.  */
 	  if (!add_dynamic_entry (DT_PLTGOT, 0))
-	    return FALSE;
+	    return false;
 	}
 
       if (htab->dt_jmprel_required || htab->srelplt->size != 0)
@@ -15144,13 +15144,13 @@ _bfd_elf_add_dynamic_tags (bfd *output_bfd, struct bfd_link_info *info,
 				     (bed->rela_plts_and_copies_p
 				      ? DT_RELA : DT_REL))
 	      || !add_dynamic_entry (DT_JMPREL, 0))
-	    return FALSE;
+	    return false;
 	}
 
       if (htab->tlsdesc_plt
 	  && (!add_dynamic_entry (DT_TLSDESC_PLT, 0)
 	      || !add_dynamic_entry (DT_TLSDESC_GOT, 0)))
-	return FALSE;
+	return false;
 
       if (need_dynamic_reloc)
 	{
@@ -15160,7 +15160,7 @@ _bfd_elf_add_dynamic_tags (bfd *output_bfd, struct bfd_link_info *info,
 		  || !add_dynamic_entry (DT_RELASZ, 0)
 		  || !add_dynamic_entry (DT_RELAENT,
 					 bed->s->sizeof_rela))
-		return FALSE;
+		return false;
 	    }
 	  else
 	    {
@@ -15168,7 +15168,7 @@ _bfd_elf_add_dynamic_tags (bfd *output_bfd, struct bfd_link_info *info,
 		  || !add_dynamic_entry (DT_RELSZ, 0)
 		  || !add_dynamic_entry (DT_RELENT,
 					 bed->s->sizeof_rel))
-		return FALSE;
+		return false;
 	    }
 
 	  /* If any dynamic relocs apply to a read-only section,
@@ -15186,11 +15186,11 @@ _bfd_elf_add_dynamic_tags (bfd *output_bfd, struct bfd_link_info *info,
 		   bfd_link_dll (info) ? "-fPIC" : "-fPIE");
 
 	      if (!add_dynamic_entry (DT_TEXTREL, 0))
-		return FALSE;
+		return false;
 	    }
 	}
     }
 #undef add_dynamic_entry
 
-  return TRUE;
+  return true;
 }