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, 333 insertions, 333 deletions

diff --git a/bfd/elf64-alpha.c b/bfd/elf64-alpha.c
index 0f67af4..1f68f82 100644
--- a/bfd/elf64-alpha.c
+++ b/bfd/elf64-alpha.c
@@ -84,9 +84,9 @@
 /* Set by ld emulation.  Putting this into the link_info or hash structure
    is simply working too hard.  */
 #ifdef USE_SECUREPLT
-bfd_boolean elf64_alpha_use_secureplt = TRUE;
+bool elf64_alpha_use_secureplt = true;
 #else
-bfd_boolean elf64_alpha_use_secureplt = FALSE;
+bool elf64_alpha_use_secureplt = false;
 #endif
 
 #define OLD_PLT_HEADER_SIZE	32
@@ -210,7 +210,7 @@ struct alpha_elf_link_hash_table
 #define alpha_elf_link_hash_traverse(table, func, info)			\
   (elf_link_hash_traverse						\
    (&(table)->root,							\
-    (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func),	\
+    (bool (*) (struct elf_link_hash_entry *, void *)) (func),		\
     (info)))
 
 /* Get the Alpha ELF linker hash table from a link_info structure.  */
@@ -230,7 +230,7 @@ struct alpha_elf_link_hash_table
    equality wrt PLT entries -- we don't create a PLT entry if a symbol's
    address is ever taken.  */
 
-static inline bfd_boolean
+static inline bool
 alpha_elf_dynamic_symbol_p (struct elf_link_hash_entry *h,
 			    struct bfd_link_info *info)
 {
@@ -351,14 +351,14 @@ struct alpha_elf_obj_tdata
    && elf_tdata (bfd) != NULL \
    && elf_object_id (bfd) == ALPHA_ELF_DATA)
 
-static bfd_boolean
+static bool
 elf64_alpha_mkobject (bfd *abfd)
 {
   return bfd_elf_allocate_object (abfd, sizeof (struct alpha_elf_obj_tdata),
 				  ALPHA_ELF_DATA);
 }
 
-static bfd_boolean
+static bool
 elf64_alpha_object_p (bfd *abfd)
 {
   /* Set the right machine number for an Alpha ELF file.  */
@@ -490,45 +490,45 @@ static reloc_howto_type elf64_alpha_howto_table[] =
 	 0,			/* rightshift */
 	 3,			/* size (0 = byte, 1 = short, 2 = long) */
 	 0,			/* bitsize */
-	 TRUE,			/* pc_relative */
+	 true,			/* pc_relative */
 	 0,			/* bitpos */
 	 complain_overflow_dont, /* complain_on_overflow */
 	 elf64_alpha_reloc_nil,	/* special_function */
 	 "NONE",		/* name */
-	 FALSE,			/* partial_inplace */
+	 false,			/* partial_inplace */
 	 0,			/* src_mask */
 	 0,			/* dst_mask */
-	 TRUE),			/* pcrel_offset */
+	 true),			/* pcrel_offset */
 
   /* A 32 bit reference to a symbol.  */
   HOWTO (R_ALPHA_REFLONG,	/* type */
 	 0,			/* rightshift */
 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
 	 32,			/* bitsize */
-	 FALSE,			/* pc_relative */
+	 false,			/* pc_relative */
 	 0,			/* bitpos */
 	 complain_overflow_bitfield, /* complain_on_overflow */
 	 bfd_elf_generic_reloc,	/* special_function */
 	 "REFLONG",		/* name */
-	 FALSE,			/* partial_inplace */
+	 false,			/* partial_inplace */
 	 0xffffffff,		/* src_mask */
 	 0xffffffff,		/* dst_mask */
-	 FALSE),		/* pcrel_offset */
+	 false),		/* pcrel_offset */
 
   /* A 64 bit reference to a symbol.  */
   HOWTO (R_ALPHA_REFQUAD,	/* type */
 	 0,			/* rightshift */
 	 4,			/* size (0 = byte, 1 = short, 2 = long) */
 	 64,			/* bitsize */
-	 FALSE,			/* pc_relative */
+	 false,			/* pc_relative */
 	 0,			/* bitpos */
 	 complain_overflow_bitfield, /* complain_on_overflow */
 	 bfd_elf_generic_reloc,	/* special_function */
 	 "REFQUAD",		/* name */
-	 FALSE,			/* partial_inplace */
+	 false,			/* partial_inplace */
 	 MINUS_ONE,		/* src_mask */
 	 MINUS_ONE,		/* dst_mask */
-	 FALSE),		/* pcrel_offset */
+	 false),		/* pcrel_offset */
 
   /* A 32 bit GP relative offset.  This is just like REFLONG except
      that when the value is used the value of the gp register will be
@@ -537,30 +537,30 @@ static reloc_howto_type elf64_alpha_howto_table[] =
 	 0,			/* rightshift */
 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
 	 32,			/* bitsize */
-	 FALSE,			/* pc_relative */
+	 false,			/* pc_relative */
 	 0,			/* bitpos */
 	 complain_overflow_bitfield, /* complain_on_overflow */
 	 bfd_elf_generic_reloc,	/* special_function */
 	 "GPREL32",		/* name */
-	 FALSE,			/* partial_inplace */
+	 false,			/* partial_inplace */
 	 0xffffffff,		/* src_mask */
 	 0xffffffff,		/* dst_mask */
-	 FALSE),		/* pcrel_offset */
+	 false),		/* pcrel_offset */
 
   /* Used for an instruction that refers to memory off the GP register.  */
   HOWTO (R_ALPHA_LITERAL,	/* type */
 	 0,			/* rightshift */
 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
 	 16,			/* bitsize */
-	 FALSE,			/* pc_relative */
+	 false,			/* pc_relative */
 	 0,			/* bitpos */
 	 complain_overflow_signed, /* complain_on_overflow */
 	 bfd_elf_generic_reloc,	/* special_function */
 	 "ELF_LITERAL",		/* name */
-	 FALSE,			/* partial_inplace */
+	 false,			/* partial_inplace */
 	 0xffff,		/* src_mask */
 	 0xffff,		/* dst_mask */
-	 FALSE),		/* pcrel_offset */
+	 false),		/* pcrel_offset */
 
   /* This reloc only appears immediately following an ELF_LITERAL reloc.
      It identifies a use of the literal.  The symbol index is special:
@@ -573,15 +573,15 @@ static reloc_howto_type elf64_alpha_howto_table[] =
 	 0,			/* rightshift */
 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
 	 32,			/* bitsize */
-	 FALSE,			/* pc_relative */
+	 false,			/* pc_relative */
 	 0,			/* bitpos */
 	 complain_overflow_dont, /* complain_on_overflow */
 	 elf64_alpha_reloc_nil,	/* special_function */
 	 "LITUSE",		/* name */
-	 FALSE,			/* partial_inplace */
+	 false,			/* partial_inplace */
 	 0,			/* src_mask */
 	 0,			/* dst_mask */
-	 FALSE),		/* pcrel_offset */
+	 false),		/* pcrel_offset */
 
   /* Load the gp register.  This is always used for a ldah instruction
      which loads the upper 16 bits of the gp register.  The symbol
@@ -603,90 +603,90 @@ static reloc_howto_type elf64_alpha_howto_table[] =
 	 16,			/* rightshift */
 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
 	 16,			/* bitsize */
-	 FALSE,			/* pc_relative */
+	 false,			/* pc_relative */
 	 0,			/* bitpos */
 	 complain_overflow_dont, /* complain_on_overflow */
 	 elf64_alpha_reloc_gpdisp, /* special_function */
 	 "GPDISP",		/* name */
-	 FALSE,			/* partial_inplace */
+	 false,			/* partial_inplace */
 	 0xffff,		/* src_mask */
 	 0xffff,		/* dst_mask */
-	 TRUE),			/* pcrel_offset */
+	 true),			/* pcrel_offset */
 
   /* A 21 bit branch.  */
   HOWTO (R_ALPHA_BRADDR,	/* type */
 	 2,			/* rightshift */
 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
 	 21,			/* bitsize */
-	 TRUE,			/* pc_relative */
+	 true,			/* pc_relative */
 	 0,			/* bitpos */
 	 complain_overflow_signed, /* complain_on_overflow */
 	 bfd_elf_generic_reloc,	/* special_function */
 	 "BRADDR",		/* name */
-	 FALSE,			/* partial_inplace */
+	 false,			/* partial_inplace */
 	 0x1fffff,		/* src_mask */
 	 0x1fffff,		/* dst_mask */
-	 TRUE),			/* pcrel_offset */
+	 true),			/* pcrel_offset */
 
   /* A hint for a jump to a register.  */
   HOWTO (R_ALPHA_HINT,		/* type */
 	 2,			/* rightshift */
 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
 	 14,			/* bitsize */
-	 TRUE,			/* pc_relative */
+	 true,			/* pc_relative */
 	 0,			/* bitpos */
 	 complain_overflow_dont, /* complain_on_overflow */
 	 bfd_elf_generic_reloc,	/* special_function */
 	 "HINT",		/* name */
-	 FALSE,			/* partial_inplace */
+	 false,			/* partial_inplace */
 	 0x3fff,		/* src_mask */
 	 0x3fff,		/* dst_mask */
-	 TRUE),			/* pcrel_offset */
+	 true),			/* pcrel_offset */
 
   /* 16 bit PC relative offset.  */
   HOWTO (R_ALPHA_SREL16,	/* type */
 	 0,			/* rightshift */
 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
 	 16,			/* bitsize */
-	 TRUE,			/* pc_relative */
+	 true,			/* pc_relative */
 	 0,			/* bitpos */
 	 complain_overflow_signed, /* complain_on_overflow */
 	 bfd_elf_generic_reloc,	/* special_function */
 	 "SREL16",		/* name */
-	 FALSE,			/* partial_inplace */
+	 false,			/* partial_inplace */
 	 0xffff,		/* src_mask */
 	 0xffff,		/* dst_mask */
-	 TRUE),			/* pcrel_offset */
+	 true),			/* pcrel_offset */
 
   /* 32 bit PC relative offset.  */
   HOWTO (R_ALPHA_SREL32,	/* type */
 	 0,			/* rightshift */
 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
 	 32,			/* bitsize */
-	 TRUE,			/* pc_relative */
+	 true,			/* pc_relative */
 	 0,			/* bitpos */
 	 complain_overflow_signed, /* complain_on_overflow */
 	 bfd_elf_generic_reloc,	/* special_function */
 	 "SREL32",		/* name */
-	 FALSE,			/* partial_inplace */
+	 false,			/* partial_inplace */
 	 0xffffffff,		/* src_mask */
 	 0xffffffff,		/* dst_mask */
-	 TRUE),			/* pcrel_offset */
+	 true),			/* pcrel_offset */
 
   /* A 64 bit PC relative offset.  */
   HOWTO (R_ALPHA_SREL64,	/* type */
 	 0,			/* rightshift */
 	 4,			/* size (0 = byte, 1 = short, 2 = long) */
 	 64,			/* bitsize */
-	 TRUE,			/* pc_relative */
+	 true,			/* pc_relative */
 	 0,			/* bitpos */
 	 complain_overflow_signed, /* complain_on_overflow */
 	 bfd_elf_generic_reloc,	/* special_function */
 	 "SREL64",		/* name */
-	 FALSE,			/* partial_inplace */
+	 false,			/* partial_inplace */
 	 MINUS_ONE,		/* src_mask */
 	 MINUS_ONE,		/* dst_mask */
-	 TRUE),			/* pcrel_offset */
+	 true),			/* pcrel_offset */
 
   /* Skip 12 - 16; deprecated ECOFF relocs.  */
   SKIP_HOWTO (12),
@@ -700,45 +700,45 @@ static reloc_howto_type elf64_alpha_howto_table[] =
 	 0,			/* rightshift */
 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
 	 16,			/* bitsize */
-	 FALSE,			/* pc_relative */
+	 false,			/* pc_relative */
 	 0,			/* bitpos */
 	 complain_overflow_signed, /* complain_on_overflow */
 	 bfd_elf_generic_reloc,	/* special_function */
 	 "GPRELHIGH",		/* name */
-	 FALSE,			/* partial_inplace */
+	 false,			/* partial_inplace */
 	 0xffff,		/* src_mask */
 	 0xffff,		/* dst_mask */
-	 FALSE),		/* pcrel_offset */
+	 false),		/* pcrel_offset */
 
   /* The low 16 bits of the displacement from GP to the target.  */
   HOWTO (R_ALPHA_GPRELLOW,
 	 0,			/* rightshift */
 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
 	 16,			/* bitsize */
-	 FALSE,			/* pc_relative */
+	 false,			/* pc_relative */
 	 0,			/* bitpos */
 	 complain_overflow_dont, /* complain_on_overflow */
 	 bfd_elf_generic_reloc,	/* special_function */
 	 "GPRELLOW",		/* name */
-	 FALSE,			/* partial_inplace */
+	 false,			/* partial_inplace */
 	 0xffff,		/* src_mask */
 	 0xffff,		/* dst_mask */
-	 FALSE),		/* pcrel_offset */
+	 false),		/* pcrel_offset */
 
   /* A 16-bit displacement from the GP to the target.  */
   HOWTO (R_ALPHA_GPREL16,
 	 0,			/* rightshift */
 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
 	 16,			/* bitsize */
-	 FALSE,			/* pc_relative */
+	 false,			/* pc_relative */
 	 0,			/* bitpos */
 	 complain_overflow_signed, /* complain_on_overflow */
 	 bfd_elf_generic_reloc,	/* special_function */
 	 "GPREL16",		/* name */
-	 FALSE,			/* partial_inplace */
+	 false,			/* partial_inplace */
 	 0xffff,		/* src_mask */
 	 0xffff,		/* dst_mask */
-	 FALSE),		/* pcrel_offset */
+	 false),		/* pcrel_offset */
 
   /* Skip 20 - 23; deprecated ECOFF relocs.  */
   SKIP_HOWTO (20),
@@ -756,120 +756,120 @@ static reloc_howto_type elf64_alpha_howto_table[] =
 	 0,
 	 0,
 	 0,
-	 FALSE,
+	 false,
 	 0,
 	 complain_overflow_dont,
 	 bfd_elf_generic_reloc,
 	 "COPY",
-	 FALSE,
+	 false,
 	 0,
 	 0,
-	 TRUE),
+	 true),
 
   /* A dynamic relocation for a .got entry.  */
   HOWTO (R_ALPHA_GLOB_DAT,
 	 0,
 	 0,
 	 0,
-	 FALSE,
+	 false,
 	 0,
 	 complain_overflow_dont,
 	 bfd_elf_generic_reloc,
 	 "GLOB_DAT",
-	 FALSE,
+	 false,
 	 0,
 	 0,
-	 TRUE),
+	 true),
 
   /* A dynamic relocation for a .plt entry.  */
   HOWTO (R_ALPHA_JMP_SLOT,
 	 0,
 	 0,
 	 0,
-	 FALSE,
+	 false,
 	 0,
 	 complain_overflow_dont,
 	 bfd_elf_generic_reloc,
 	 "JMP_SLOT",
-	 FALSE,
+	 false,
 	 0,
 	 0,
-	 TRUE),
+	 true),
 
   /* A dynamic relocation to add the base of the DSO to a 64-bit field.  */
   HOWTO (R_ALPHA_RELATIVE,
 	 0,
 	 0,
 	 0,
-	 FALSE,
+	 false,
 	 0,
 	 complain_overflow_dont,
 	 bfd_elf_generic_reloc,
 	 "RELATIVE",
-	 FALSE,
+	 false,
 	 0,
 	 0,
-	 TRUE),
+	 true),
 
   /* A 21 bit branch that adjusts for gp loads.  */
   HOWTO (R_ALPHA_BRSGP,		/* type */
 	 2,			/* rightshift */
 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
 	 21,			/* bitsize */
-	 TRUE,			/* pc_relative */
+	 true,			/* pc_relative */
 	 0,			/* bitpos */
 	 complain_overflow_signed, /* complain_on_overflow */
 	 bfd_elf_generic_reloc,	/* special_function */
 	 "BRSGP",		/* name */
-	 FALSE,			/* partial_inplace */
+	 false,			/* partial_inplace */
 	 0x1fffff,		/* src_mask */
 	 0x1fffff,		/* dst_mask */
-	 TRUE),			/* pcrel_offset */
+	 true),			/* pcrel_offset */
 
   /* Creates a tls_index for the symbol in the got.  */
   HOWTO (R_ALPHA_TLSGD,		/* type */
 	 0,			/* rightshift */
 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
 	 16,			/* bitsize */
-	 FALSE,			/* pc_relative */
+	 false,			/* pc_relative */
 	 0,			/* bitpos */
 	 complain_overflow_signed, /* complain_on_overflow */
 	 bfd_elf_generic_reloc,	/* special_function */
 	 "TLSGD",		/* name */
-	 FALSE,			/* partial_inplace */
+	 false,			/* partial_inplace */
 	 0xffff,		/* src_mask */
 	 0xffff,		/* dst_mask */
-	 FALSE),		/* pcrel_offset */
+	 false),		/* pcrel_offset */
 
   /* Creates a tls_index for the (current) module in the got.  */
   HOWTO (R_ALPHA_TLSLDM,	/* type */
 	 0,			/* rightshift */
 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
 	 16,			/* bitsize */
-	 FALSE,			/* pc_relative */
+	 false,			/* pc_relative */
 	 0,			/* bitpos */
 	 complain_overflow_signed, /* complain_on_overflow */
 	 bfd_elf_generic_reloc,	/* special_function */
 	 "TLSLDM",		/* name */
-	 FALSE,			/* partial_inplace */
+	 false,			/* partial_inplace */
 	 0xffff,		/* src_mask */
 	 0xffff,		/* dst_mask */
-	 FALSE),		/* pcrel_offset */
+	 false),		/* pcrel_offset */
 
   /* A dynamic relocation for a DTP module entry.  */
   HOWTO (R_ALPHA_DTPMOD64,	/* type */
 	 0,			/* rightshift */
 	 4,			/* size (0 = byte, 1 = short, 2 = long) */
 	 64,			/* bitsize */
-	 FALSE,			/* pc_relative */
+	 false,			/* pc_relative */
 	 0,			/* bitpos */
 	 complain_overflow_bitfield, /* complain_on_overflow */
 	 bfd_elf_generic_reloc,	/* special_function */
 	 "DTPMOD64",		/* name */
-	 FALSE,			/* partial_inplace */
+	 false,			/* partial_inplace */
 	 MINUS_ONE,		/* src_mask */
 	 MINUS_ONE,		/* dst_mask */
-	 FALSE),		/* pcrel_offset */
+	 false),		/* pcrel_offset */
 
   /* Creates a 64-bit offset in the got for the displacement
      from DTP to the target.  */
@@ -877,75 +877,75 @@ static reloc_howto_type elf64_alpha_howto_table[] =
 	 0,			/* rightshift */
 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
 	 16,			/* bitsize */
-	 FALSE,			/* pc_relative */
+	 false,			/* pc_relative */
 	 0,			/* bitpos */
 	 complain_overflow_signed, /* complain_on_overflow */
 	 bfd_elf_generic_reloc,	/* special_function */
 	 "GOTDTPREL",		/* name */
-	 FALSE,			/* partial_inplace */
+	 false,			/* partial_inplace */
 	 0xffff,		/* src_mask */
 	 0xffff,		/* dst_mask */
-	 FALSE),		/* pcrel_offset */
+	 false),		/* pcrel_offset */
 
   /* A dynamic relocation for a displacement from DTP to the target.  */
   HOWTO (R_ALPHA_DTPREL64,	/* type */
 	 0,			/* rightshift */
 	 4,			/* size (0 = byte, 1 = short, 2 = long) */
 	 64,			/* bitsize */
-	 FALSE,			/* pc_relative */
+	 false,			/* pc_relative */
 	 0,			/* bitpos */
 	 complain_overflow_bitfield, /* complain_on_overflow */
 	 bfd_elf_generic_reloc,	/* special_function */
 	 "DTPREL64",		/* name */
-	 FALSE,			/* partial_inplace */
+	 false,			/* partial_inplace */
 	 MINUS_ONE,		/* src_mask */
 	 MINUS_ONE,		/* dst_mask */
-	 FALSE),		/* pcrel_offset */
+	 false),		/* pcrel_offset */
 
   /* The high 16 bits of the displacement from DTP to the target.  */
   HOWTO (R_ALPHA_DTPRELHI,	/* type */
 	 0,			/* rightshift */
 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
 	 16,			/* bitsize */
-	 FALSE,			/* pc_relative */
+	 false,			/* pc_relative */
 	 0,			/* bitpos */
 	 complain_overflow_signed, /* complain_on_overflow */
 	 bfd_elf_generic_reloc,	/* special_function */
 	 "DTPRELHI",		/* name */
-	 FALSE,			/* partial_inplace */
+	 false,			/* partial_inplace */
 	 0xffff,		/* src_mask */
 	 0xffff,		/* dst_mask */
-	 FALSE),		/* pcrel_offset */
+	 false),		/* pcrel_offset */
 
   /* The low 16 bits of the displacement from DTP to the target.  */
   HOWTO (R_ALPHA_DTPRELLO,	/* type */
 	 0,			/* rightshift */
 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
 	 16,			/* bitsize */
-	 FALSE,			/* pc_relative */
+	 false,			/* pc_relative */
 	 0,			/* bitpos */
 	 complain_overflow_dont, /* complain_on_overflow */
 	 bfd_elf_generic_reloc,	/* special_function */
 	 "DTPRELLO",		/* name */
-	 FALSE,			/* partial_inplace */
+	 false,			/* partial_inplace */
 	 0xffff,		/* src_mask */
 	 0xffff,		/* dst_mask */
-	 FALSE),		/* pcrel_offset */
+	 false),		/* pcrel_offset */
 
   /* A 16-bit displacement from DTP to the target.  */
   HOWTO (R_ALPHA_DTPREL16,	/* type */
 	 0,			/* rightshift */
 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
 	 16,			/* bitsize */
-	 FALSE,			/* pc_relative */
+	 false,			/* pc_relative */
 	 0,			/* bitpos */
 	 complain_overflow_signed, /* complain_on_overflow */
 	 bfd_elf_generic_reloc,	/* special_function */
 	 "DTPREL16",		/* name */
-	 FALSE,			/* partial_inplace */
+	 false,			/* partial_inplace */
 	 0xffff,		/* src_mask */
 	 0xffff,		/* dst_mask */
-	 FALSE),		/* pcrel_offset */
+	 false),		/* pcrel_offset */
 
   /* Creates a 64-bit offset in the got for the displacement
      from TP to the target.  */
@@ -953,75 +953,75 @@ static reloc_howto_type elf64_alpha_howto_table[] =
 	 0,			/* rightshift */
 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
 	 16,			/* bitsize */
-	 FALSE,			/* pc_relative */
+	 false,			/* pc_relative */
 	 0,			/* bitpos */
 	 complain_overflow_signed, /* complain_on_overflow */
 	 bfd_elf_generic_reloc,	/* special_function */
 	 "GOTTPREL",		/* name */
-	 FALSE,			/* partial_inplace */
+	 false,			/* partial_inplace */
 	 0xffff,		/* src_mask */
 	 0xffff,		/* dst_mask */
-	 FALSE),		/* pcrel_offset */
+	 false),		/* pcrel_offset */
 
   /* A dynamic relocation for a displacement from TP to the target.  */
   HOWTO (R_ALPHA_TPREL64,	/* type */
 	 0,			/* rightshift */
 	 4,			/* size (0 = byte, 1 = short, 2 = long) */
 	 64,			/* bitsize */
-	 FALSE,			/* pc_relative */
+	 false,			/* pc_relative */
 	 0,			/* bitpos */
 	 complain_overflow_bitfield, /* complain_on_overflow */
 	 bfd_elf_generic_reloc,	/* special_function */
 	 "TPREL64",		/* name */
-	 FALSE,			/* partial_inplace */
+	 false,			/* partial_inplace */
 	 MINUS_ONE,		/* src_mask */
 	 MINUS_ONE,		/* dst_mask */
-	 FALSE),		/* pcrel_offset */
+	 false),		/* pcrel_offset */
 
   /* The high 16 bits of the displacement from TP to the target.  */
   HOWTO (R_ALPHA_TPRELHI,	/* type */
 	 0,			/* rightshift */
 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
 	 16,			/* bitsize */
-	 FALSE,			/* pc_relative */
+	 false,			/* pc_relative */
 	 0,			/* bitpos */
 	 complain_overflow_signed, /* complain_on_overflow */
 	 bfd_elf_generic_reloc,	/* special_function */
 	 "TPRELHI",		/* name */
-	 FALSE,			/* partial_inplace */
+	 false,			/* partial_inplace */
 	 0xffff,		/* src_mask */
 	 0xffff,		/* dst_mask */
-	 FALSE),		/* pcrel_offset */
+	 false),		/* pcrel_offset */
 
   /* The low 16 bits of the displacement from TP to the target.  */
   HOWTO (R_ALPHA_TPRELLO,	/* type */
 	 0,			/* rightshift */
 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
 	 16,			/* bitsize */
-	 FALSE,			/* pc_relative */
+	 false,			/* pc_relative */
 	 0,			/* bitpos */
 	 complain_overflow_dont, /* complain_on_overflow */
 	 bfd_elf_generic_reloc,	/* special_function */
 	 "TPRELLO",		/* name */
-	 FALSE,			/* partial_inplace */
+	 false,			/* partial_inplace */
 	 0xffff,		/* src_mask */
 	 0xffff,		/* dst_mask */
-	 FALSE),		/* pcrel_offset */
+	 false),		/* pcrel_offset */
 
   /* A 16-bit displacement from TP to the target.  */
   HOWTO (R_ALPHA_TPREL16,	/* type */
 	 0,			/* rightshift */
 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
 	 16,			/* bitsize */
-	 FALSE,			/* pc_relative */
+	 false,			/* pc_relative */
 	 0,			/* bitpos */
 	 complain_overflow_signed, /* complain_on_overflow */
 	 bfd_elf_generic_reloc,	/* special_function */
 	 "TPREL16",		/* name */
-	 FALSE,			/* partial_inplace */
+	 false,			/* partial_inplace */
 	 0xffff,		/* src_mask */
 	 0xffff,		/* dst_mask */
-	 FALSE),		/* pcrel_offset */
+	 false),		/* pcrel_offset */
 };
 
 /* A mapping from BFD reloc types to Alpha ELF reloc types.  */
@@ -1102,7 +1102,7 @@ elf64_alpha_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 
 /* Given an Alpha ELF reloc type, fill in an arelent structure.  */
 
-static bfd_boolean
+static bool
 elf64_alpha_info_to_howto (bfd *abfd, arelent *cache_ptr,
 			   Elf_Internal_Rela *dst)
 {
@@ -1114,10 +1114,10 @@ elf64_alpha_info_to_howto (bfd *abfd, arelent *cache_ptr,
       _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
 			  abfd, r_type);
       bfd_set_error (bfd_error_bad_value);
-      return FALSE;
+      return false;
     }
   cache_ptr->howto = &elf64_alpha_howto_table[r_type];
-  return TRUE;
+  return true;
 }
 
 /* These two relocations create a two-word entry in the got.  */
@@ -1139,7 +1139,7 @@ elf64_alpha_info_to_howto (bfd *abfd, arelent *cache_ptr,
    is called when bfd_section_from_shdr finds a section with an unknown
    type.  */
 
-static bfd_boolean
+static bool
 elf64_alpha_section_from_shdr (bfd *abfd,
 			       Elf_Internal_Shdr *hdr,
 			       const char *name,
@@ -1156,41 +1156,41 @@ elf64_alpha_section_from_shdr (bfd *abfd,
     {
     case SHT_ALPHA_DEBUG:
       if (strcmp (name, ".mdebug") != 0)
-	return FALSE;
+	return false;
       break;
     default:
-      return FALSE;
+      return false;
     }
 
   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
-    return FALSE;
+    return false;
   newsect = hdr->bfd_section;
 
   if (hdr->sh_type == SHT_ALPHA_DEBUG)
     {
       if (!bfd_set_section_flags (newsect,
 				  bfd_section_flags (newsect) | SEC_DEBUGGING))
-	return FALSE;
+	return false;
     }
 
-  return TRUE;
+  return true;
 }
 
 /* Convert Alpha specific section flags to bfd internal section flags.  */
 
-static bfd_boolean
+static bool
 elf64_alpha_section_flags (const Elf_Internal_Shdr *hdr)
 {
   if (hdr->sh_flags & SHF_ALPHA_GPREL)
     hdr->bfd_section->flags |= SEC_SMALL_DATA;
 
-  return TRUE;
+  return true;
 }
 
 /* Set the correct type for an Alpha ELF section.  We do this by the
    section name, which is a hack, but ought to work.  */
 
-static bfd_boolean
+static bool
 elf64_alpha_fake_sections (bfd *abfd, Elf_Internal_Shdr *hdr, asection *sec)
 {
   register const char *name;
@@ -1214,13 +1214,13 @@ elf64_alpha_fake_sections (bfd *abfd, Elf_Internal_Shdr *hdr, asection *sec)
 	   || strcmp (name, ".lit8") == 0)
     hdr->sh_flags |= SHF_ALPHA_GPREL;
 
-  return TRUE;
+  return true;
 }
 
 /* Hook called by the linker routine which adds symbols from an object
    file.  We use it to put .comm items in .sbss, and not .bss.  */
 
-static bfd_boolean
+static bool
 elf64_alpha_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
 			     Elf_Internal_Sym *sym,
 			     const char **namep ATTRIBUTE_UNUSED,
@@ -1244,19 +1244,19 @@ elf64_alpha_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
 						| SEC_SMALL_DATA
 						| SEC_LINKER_CREATED));
 	  if (scomm == NULL)
-	    return FALSE;
+	    return false;
 	}
 
       *secp = scomm;
       *valp = sym->st_size;
     }
 
-  return TRUE;
+  return true;
 }
 
 /* Create the .got section.  */
 
-static bfd_boolean
+static bool
 elf64_alpha_create_got_section (bfd *abfd,
 				struct bfd_link_info *info ATTRIBUTE_UNUSED)
 {
@@ -1264,14 +1264,14 @@ elf64_alpha_create_got_section (bfd *abfd,
   asection *s;
 
   if (! is_alpha_elf (abfd))
-    return FALSE;
+    return false;
 
   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
 	   | SEC_LINKER_CREATED);
   s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
   if (s == NULL
       || !bfd_set_section_alignment (s, 3))
-    return FALSE;
+    return false;
 
   alpha_elf_tdata (abfd)->got = s;
 
@@ -1280,12 +1280,12 @@ elf64_alpha_create_got_section (bfd *abfd,
      we've collected each object's info.  */
   alpha_elf_tdata (abfd)->gotobj = abfd;
 
-  return TRUE;
+  return true;
 }
 
 /* Create all the dynamic sections.  */
 
-static bfd_boolean
+static bool
 elf64_alpha_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
 {
   asection *s;
@@ -1293,7 +1293,7 @@ elf64_alpha_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
   struct elf_link_hash_entry *h;
 
   if (! is_alpha_elf (abfd))
-    return FALSE;
+    return false;
 
   /* We need to create .plt, .rela.plt, .got, and .rela.got sections.  */
 
@@ -1303,7 +1303,7 @@ elf64_alpha_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
   s = bfd_make_section_anyway_with_flags (abfd, ".plt", flags);
   elf_hash_table (info)->splt = s;
   if (s == NULL || ! bfd_set_section_alignment (s, 4))
-    return FALSE;
+    return false;
 
   /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
      .plt section.  */
@@ -1311,14 +1311,14 @@ elf64_alpha_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;
 
   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
 	   | SEC_LINKER_CREATED | SEC_READONLY);
   s = bfd_make_section_anyway_with_flags (abfd, ".rela.plt", flags);
   elf_hash_table (info)->srelplt = s;
   if (s == NULL || ! bfd_set_section_alignment (s, 3))
-    return FALSE;
+    return false;
 
   if (elf64_alpha_use_secureplt)
     {
@@ -1326,7 +1326,7 @@ elf64_alpha_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
       s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", flags);
       elf_hash_table (info)->sgotplt = s;
       if (s == NULL || ! bfd_set_section_alignment (s, 3))
-	return FALSE;
+	return false;
     }
 
   /* We may or may not have created a .got section for this object, but
@@ -1335,7 +1335,7 @@ elf64_alpha_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
   if (alpha_elf_tdata(abfd)->gotobj == NULL)
     {
       if (!elf64_alpha_create_got_section (abfd, info))
-	return FALSE;
+	return false;
     }
 
   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
@@ -1344,7 +1344,7 @@ elf64_alpha_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
   elf_hash_table (info)->srelgot = s;
   if (s == NULL
       || !bfd_set_section_alignment (s, 3))
-    return FALSE;
+    return false;
 
   /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the
      dynobj's .got section.  We don't do this in the linker script
@@ -1354,15 +1354,15 @@ elf64_alpha_create_dynamic_sections (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;
 }
 
 /* Read ECOFF debugging information from a .mdebug section into a
    ecoff_debug_info structure.  */
 
-static bfd_boolean
+static bool
 elf64_alpha_read_ecoff_info (bfd *abfd, asection *section,
 			     struct ecoff_debug_info *debug)
 {
@@ -1421,7 +1421,7 @@ elf64_alpha_read_ecoff_info (bfd *abfd, asection *section,
 
   debug->fdr = NULL;
 
-  return TRUE;
+  return true;
 
  error_return:
   free (ext_hdr);
@@ -1436,18 +1436,18 @@ elf64_alpha_read_ecoff_info (bfd *abfd, asection *section,
   free (debug->external_fdr);
   free (debug->external_rfd);
   free (debug->external_ext);
-  return FALSE;
+  return false;
 }
 
 /* Alpha ELF local labels start with '$'.  */
 
-static bfd_boolean
+static bool
 elf64_alpha_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED, const char *name)
 {
   return name[0] == '$';
 }
 
-static bfd_boolean
+static bool
 elf64_alpha_find_nearest_line (bfd *abfd, asymbol **symbols,
 			       asection *section, bfd_vma offset,
 			       const char **filename_ptr,
@@ -1463,7 +1463,7 @@ elf64_alpha_find_nearest_line (bfd *abfd, asymbol **symbols,
 				     dwarf_debug_sections,
 				     &elf_tdata (abfd)->dwarf2_find_line_info)
       == 1)
-    return TRUE;
+    return true;
 
   msec = bfd_get_section_by_name (abfd, ".mdebug");
   if (msec != NULL)
@@ -1493,13 +1493,13 @@ elf64_alpha_find_nearest_line (bfd *abfd, asymbol **symbols,
 	  if (fi == NULL)
 	    {
 	      msec->flags = origflags;
-	      return FALSE;
+	      return false;
 	    }
 
 	  if (!elf64_alpha_read_ecoff_info (abfd, msec, &fi->d))
 	    {
 	      msec->flags = origflags;
-	      return FALSE;
+	      return false;
 	    }
 
 	  /* Swap in the FDR information.  */
@@ -1508,7 +1508,7 @@ elf64_alpha_find_nearest_line (bfd *abfd, asymbol **symbols,
 	  if (fi->d.fdr == NULL)
 	    {
 	      msec->flags = origflags;
-	      return FALSE;
+	      return false;
 	    }
 	  external_fdr_size = swap->external_fdr_size;
 	  fdr_ptr = fi->d.fdr;
@@ -1533,7 +1533,7 @@ elf64_alpha_find_nearest_line (bfd *abfd, asymbol **symbols,
 				  line_ptr))
 	{
 	  msec->flags = origflags;
-	  return TRUE;
+	  return true;
 	}
 
       msec->flags = origflags;
@@ -1554,35 +1554,35 @@ struct extsym_info
   struct bfd_link_info *info;
   struct ecoff_debug_info *debug;
   const struct ecoff_debug_swap *swap;
-  bfd_boolean failed;
+  bool failed;
 };
 
-static bfd_boolean
+static bool
 elf64_alpha_output_extsym (struct alpha_elf_link_hash_entry *h, void * data)
 {
   struct extsym_info *einfo = (struct extsym_info *) data;
-  bfd_boolean strip;
+  bool strip;
   asection *sec, *output_section;
 
   if (h->root.indx == -2)
-    strip = FALSE;
+    strip = false;
   else if ((h->root.def_dynamic
 	    || h->root.ref_dynamic
 	    || h->root.root.type == bfd_link_hash_new)
 	   && !h->root.def_regular
 	   && !h->root.ref_regular)
-    strip = TRUE;
+    strip = true;
   else if (einfo->info->strip == strip_all
 	   || (einfo->info->strip == strip_some
 	       && bfd_hash_lookup (einfo->info->keep_hash,
 				   h->root.root.root.string,
-				   FALSE, FALSE) == NULL))
-    strip = TRUE;
+				   false, false) == NULL))
+    strip = true;
   else
-    strip = FALSE;
+    strip = false;
 
   if (strip)
-    return TRUE;
+    return true;
 
   if (h->esym.ifd == -2)
     {
@@ -1662,11 +1662,11 @@ elf64_alpha_output_extsym (struct alpha_elf_link_hash_entry *h, void * data)
 				      h->root.root.root.string,
 				      &h->esym))
     {
-      einfo->failed = TRUE;
-      return FALSE;
+      einfo->failed = true;
+      return false;
     }
 
-  return TRUE;
+  return true;
 }
 
 /* Search for and possibly create a got entry.  */
@@ -1747,7 +1747,7 @@ get_got_entry (bfd *abfd, struct alpha_elf_link_hash_entry *h,
   return gotent;
 }
 
-static bfd_boolean
+static bool
 elf64_alpha_want_plt (struct alpha_elf_link_hash_entry *ah)
 {
   return ((ah->root.type == STT_FUNC
@@ -1762,7 +1762,7 @@ elf64_alpha_want_plt (struct alpha_elf_link_hash_entry *ah)
    as is.  On the other hand, elf-eh-frame.c processing requires .eh_frame
    relocs to be sorted.  */
 
-static bfd_boolean
+static bool
 elf64_alpha_sort_relocs_p (asection *sec)
 {
   return (sec->flags & SEC_CODE) == 0;
@@ -1771,7 +1771,7 @@ elf64_alpha_sort_relocs_p (asection *sec)
 
 /* Handle dynamic relocations when doing an Alpha ELF link.  */
 
-static bfd_boolean
+static bool
 elf64_alpha_check_relocs (bfd *abfd, struct bfd_link_info *info,
 			  asection *sec, const Elf_Internal_Rela *relocs)
 {
@@ -1782,7 +1782,7 @@ elf64_alpha_check_relocs (bfd *abfd, struct bfd_link_info *info,
   const Elf_Internal_Rela *rel, *relend;
 
   if (bfd_link_relocatable (info))
-    return TRUE;
+    return true;
 
   BFD_ASSERT (is_alpha_elf (abfd));
 
@@ -1806,7 +1806,7 @@ elf64_alpha_check_relocs (bfd *abfd, struct bfd_link_info *info,
       unsigned long r_symndx, r_type;
       struct alpha_elf_link_hash_entry *h;
       unsigned int gotent_flags;
-      bfd_boolean maybe_dynamic;
+      bool maybe_dynamic;
       unsigned int need;
       bfd_vma addend;
 
@@ -1830,13 +1830,13 @@ elf64_alpha_check_relocs (bfd *abfd, struct bfd_link_info *info,
 	 locally or externally defined, as not all of the input files
 	 have yet been processed.  Do something with what we know, as
 	 this may help reduce memory usage and processing time later.  */
-      maybe_dynamic = FALSE;
+      maybe_dynamic = false;
       if (h && ((bfd_link_pic (info)
 		 && (!info->symbolic
 		     || info->unresolved_syms_in_shared_libs == RM_IGNORE))
 		|| !h->root.def_regular
 		|| h->root.root.type == bfd_link_hash_defweak))
-	maybe_dynamic = TRUE;
+	maybe_dynamic = true;
 
       need = 0;
       gotent_flags = 0;
@@ -1881,7 +1881,7 @@ elf64_alpha_check_relocs (bfd *abfd, struct bfd_link_info *info,
 	     reloc to the STN_UNDEF (0) symbol so that they all match.  */
 	  r_symndx = STN_UNDEF;
 	  h = 0;
-	  maybe_dynamic = FALSE;
+	  maybe_dynamic = false;
 	  /* FALLTHRU */
 
 	case R_ALPHA_TLSGD:
@@ -1912,7 +1912,7 @@ elf64_alpha_check_relocs (bfd *abfd, struct bfd_link_info *info,
 	  if (alpha_elf_tdata(abfd)->gotobj == NULL)
 	    {
 	      if (!elf64_alpha_create_got_section (abfd, info))
-		return FALSE;
+		return false;
 	    }
 	}
 
@@ -1922,7 +1922,7 @@ elf64_alpha_check_relocs (bfd *abfd, struct bfd_link_info *info,
 
 	  gotent = get_got_entry (abfd, h, r_type, r_symndx, addend);
 	  if (!gotent)
-	    return FALSE;
+	    return false;
 
 	  if (gotent_flags)
 	    {
@@ -1951,10 +1951,10 @@ elf64_alpha_check_relocs (bfd *abfd, struct bfd_link_info *info,
 	  if (sreloc == NULL)
 	    {
 	      sreloc = _bfd_elf_make_dynamic_reloc_section
-		(sec, dynobj, 3, abfd, /*rela?*/ TRUE);
+		(sec, dynobj, 3, abfd, /*rela?*/ true);
 
 	      if (sreloc == NULL)
-		return FALSE;
+		return false;
 	    }
 
 	  if (h)
@@ -1976,7 +1976,7 @@ elf64_alpha_check_relocs (bfd *abfd, struct bfd_link_info *info,
 		  size_t amt = sizeof (struct alpha_elf_reloc_entry);
 		  rent = (struct alpha_elf_reloc_entry *) bfd_alloc (abfd, amt);
 		  if (!rent)
-		    return FALSE;
+		    return false;
 
 		  rent->srel = sreloc;
 		  rent->sec = sec;
@@ -2006,7 +2006,7 @@ elf64_alpha_check_relocs (bfd *abfd, struct bfd_link_info *info,
 	}
     }
 
-  return TRUE;
+  return true;
 }
 
 /* Return the section that should be marked against GC for a given
@@ -2036,7 +2036,7 @@ elf64_alpha_gc_mark_hook (asection *sec, struct bfd_link_info *info,
    change the definition to something the rest of the link can
    understand.  */
 
-static bfd_boolean
+static bool
 elf64_alpha_adjust_dynamic_symbol (struct bfd_link_info *info,
 				   struct elf_link_hash_entry *h)
 {
@@ -2054,20 +2054,20 @@ elf64_alpha_adjust_dynamic_symbol (struct bfd_link_info *info,
      of STT_FUNC.  */
   if (alpha_elf_dynamic_symbol_p (h, info) && elf64_alpha_want_plt (ah))
     {
-      h->needs_plt = TRUE;
+      h->needs_plt = true;
 
       s = elf_hash_table(info)->splt;
       if (!s && !elf64_alpha_create_dynamic_sections (dynobj, info))
-	return FALSE;
+	return false;
 
       /* We need one plt entry per got subsection.  Delay allocation of
 	 the actual plt entries until size_plt_section, called from
 	 size_dynamic_sections or during relaxation.  */
 
-      return TRUE;
+      return true;
     }
   else
-    h->needs_plt = FALSE;
+    h->needs_plt = false;
 
   /* If this is a weak symbol, and there is a real definition, the
      processor independent code will have arranged for us to see the
@@ -2078,7 +2078,7 @@ elf64_alpha_adjust_dynamic_symbol (struct bfd_link_info *info,
       BFD_ASSERT (def->root.type == bfd_link_hash_defined);
       h->root.u.def.section = def->root.u.def.section;
       h->root.u.def.value = def->root.u.def.value;
-      return TRUE;
+      return true;
     }
 
   /* This is a reference to a symbol defined by a dynamic object which
@@ -2086,7 +2086,7 @@ elf64_alpha_adjust_dynamic_symbol (struct bfd_link_info *info,
      symbols even in regular objects, does not need the hackery of a
      .dynbss section and COPY dynamic relocations.  */
 
-  return TRUE;
+  return true;
 }
 
 /* Record STO_ALPHA_NOPV and STO_ALPHA_STD_GPLOAD.  */
@@ -2094,8 +2094,8 @@ elf64_alpha_adjust_dynamic_symbol (struct bfd_link_info *info,
 static void
 elf64_alpha_merge_symbol_attribute (struct elf_link_hash_entry *h,
 				    unsigned int st_other,
-				    bfd_boolean definition,
-				    bfd_boolean dynamic)
+				    bool definition,
+				    bool dynamic)
 {
   if (!dynamic && definition)
     h->other = ((h->other & ELF_ST_VISIBILITY (-1))
@@ -2185,7 +2185,7 @@ elf64_alpha_copy_indirect_symbol (struct bfd_link_info *info,
 
 /* Is it possible to merge two object file's .got tables?  */
 
-static bfd_boolean
+static bool
 elf64_alpha_can_merge_gots (bfd *a, bfd *b)
 {
   int total = alpha_elf_tdata (a)->total_got_size;
@@ -2193,11 +2193,11 @@ elf64_alpha_can_merge_gots (bfd *a, bfd *b)
 
   /* Trivial quick fallout test.  */
   if (total + alpha_elf_tdata (b)->total_got_size <= MAX_GOT_SIZE)
-    return TRUE;
+    return true;
 
   /* By their nature, local .got entries cannot be merged.  */
   if ((total += alpha_elf_tdata (b)->local_got_size) > MAX_GOT_SIZE)
-    return FALSE;
+    return false;
 
   /* Failing the common trivial comparison, we must effectively
      perform the merge.  Not actually performing the merge means that
@@ -2234,13 +2234,13 @@ elf64_alpha_can_merge_gots (bfd *a, bfd *b)
 
 	      total += alpha_got_entry_size (be->reloc_type);
 	      if (total > MAX_GOT_SIZE)
-		return FALSE;
+		return false;
 	    global_found:;
 	    }
 	}
     }
 
-  return TRUE;
+  return true;
 }
 
 /* Actually merge two .got tables.  */
@@ -2343,7 +2343,7 @@ elf64_alpha_merge_gots (bfd *a, bfd *b)
 
 /* Calculate the offsets for the got entries.  */
 
-static bfd_boolean
+static bool
 elf64_alpha_calc_got_offsets_for_symbol (struct alpha_elf_link_hash_entry *h,
 					 void * arg ATTRIBUTE_UNUSED)
 {
@@ -2361,7 +2361,7 @@ elf64_alpha_calc_got_offsets_for_symbol (struct alpha_elf_link_hash_entry *h,
 	*plge += alpha_got_entry_size (gotent->reloc_type);
       }
 
-  return TRUE;
+  return true;
 }
 
 static void
@@ -2415,16 +2415,16 @@ elf64_alpha_calc_got_offsets (struct bfd_link_info *info)
 
 /* Constructs the gots.  */
 
-static bfd_boolean
+static bool
 elf64_alpha_size_got_sections (struct bfd_link_info *info,
-			       bfd_boolean may_merge)
+			       bool may_merge)
 {
   bfd *i, *got_list, *cur_got_obj = NULL;
   struct alpha_elf_link_hash_table * htab;
 
   htab = alpha_elf_hash_table (info);
   if (htab == NULL)
-    return FALSE;
+    return false;
   got_list = htab->got_list;
 
   /* On the first time through, pretend we have an existing got list
@@ -2452,7 +2452,7 @@ elf64_alpha_size_got_sections (struct bfd_link_info *info,
 		/* xgettext:c-format */
 		(_("%pB: .got subsegment exceeds 64K (size %d)"),
 		 i, alpha_elf_tdata (this_got)->total_got_size);
-	      return FALSE;
+	      return false;
 	    }
 
 	  if (got_list == NULL)
@@ -2464,14 +2464,14 @@ elf64_alpha_size_got_sections (struct bfd_link_info *info,
 
       /* Strange degenerate case of no got references.  */
       if (got_list == NULL)
-	return TRUE;
+	return true;
 
       htab->got_list = got_list;
     }
 
   cur_got_obj = got_list;
   if (cur_got_obj == NULL)
-    return FALSE;
+    return false;
 
   if (may_merge)
     {
@@ -2498,20 +2498,20 @@ elf64_alpha_size_got_sections (struct bfd_link_info *info,
      everything therein.  */
   elf64_alpha_calc_got_offsets (info);
 
-  return TRUE;
+  return true;
 }
 
-static bfd_boolean
+static bool
 elf64_alpha_size_plt_section_1 (struct alpha_elf_link_hash_entry *h,
 				void * data)
 {
   asection *splt = (asection *) data;
   struct alpha_elf_got_entry *gotent;
-  bfd_boolean saw_one = FALSE;
+  bool saw_one = false;
 
   /* If we didn't need an entry before, we still don't.  */
   if (!h->root.needs_plt)
-    return TRUE;
+    return true;
 
   /* For each LITERAL got entry still in use, allocate a plt entry.  */
   for (gotent = h->got_entries; gotent ; gotent = gotent->next)
@@ -2522,14 +2522,14 @@ elf64_alpha_size_plt_section_1 (struct alpha_elf_link_hash_entry *h,
 	  splt->size = PLT_HEADER_SIZE;
 	gotent->plt_offset = splt->size;
 	splt->size += PLT_ENTRY_SIZE;
-	saw_one = TRUE;
+	saw_one = true;
       }
 
   /* If there weren't any, there's no longer a need for the PLT entry.  */
   if (!saw_one)
-    h->root.needs_plt = FALSE;
+    h->root.needs_plt = false;
 
-  return TRUE;
+  return true;
 }
 
 /* Called from relax_section to rebuild the PLT in light of potential changes
@@ -2577,7 +2577,7 @@ elf64_alpha_size_plt_section (struct bfd_link_info *info)
     }
 }
 
-static bfd_boolean
+static bool
 elf64_alpha_always_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
 				  struct bfd_link_info *info)
 {
@@ -2585,14 +2585,14 @@ elf64_alpha_always_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
   struct alpha_elf_link_hash_table * htab;
 
   if (bfd_link_relocatable (info))
-    return TRUE;
+    return true;
 
   htab = alpha_elf_hash_table (info);
   if (htab == NULL)
-    return FALSE;
+    return false;
 
-  if (!elf64_alpha_size_got_sections (info, TRUE))
-    return FALSE;
+  if (!elf64_alpha_size_got_sections (info, true))
+    return false;
 
   /* Allocate space for all of the .got subsections.  */
   i = htab->got_list;
@@ -2603,11 +2603,11 @@ elf64_alpha_always_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
 	{
 	  s->contents = (bfd_byte *) bfd_zalloc (i, s->size);
 	  if (s->contents == NULL)
-	    return FALSE;
+	    return false;
 	}
     }
 
-  return TRUE;
+  return true;
 }
 
 /* The number of dynamic relocations required by a static relocation.  */
@@ -2645,11 +2645,11 @@ alpha_dynamic_entries_for_reloc (int r_type, int dynamic, int shared, int pie)
 
 /* Work out the sizes of the dynamic relocation entries.  */
 
-static bfd_boolean
+static bool
 elf64_alpha_calc_dynrel_sizes (struct alpha_elf_link_hash_entry *h,
 			       struct bfd_link_info *info)
 {
-  bfd_boolean dynamic;
+  bool dynamic;
   struct alpha_elf_reloc_entry *relent;
   unsigned long entries;
 
@@ -2677,7 +2677,7 @@ elf64_alpha_calc_dynrel_sizes (struct alpha_elf_link_hash_entry *h,
      relocations.  Avoid the loop which may want to add RELATIVE relocs
      based on bfd_link_pic (info).  */
   if (h->root.root.type == bfd_link_hash_undefweak && !dynamic)
-    return TRUE;
+    return true;
 
   for (relent = h->reloc_entries; relent; relent = relent->next)
     {
@@ -2700,24 +2700,24 @@ elf64_alpha_calc_dynrel_sizes (struct alpha_elf_link_hash_entry *h,
 	}
     }
 
-  return TRUE;
+  return true;
 }
 
 /* Subroutine of elf64_alpha_size_rela_got_section for doing the
    global symbols.  */
 
-static bfd_boolean
+static bool
 elf64_alpha_size_rela_got_1 (struct alpha_elf_link_hash_entry *h,
 			     struct bfd_link_info *info)
 {
-  bfd_boolean dynamic;
+  bool dynamic;
   struct alpha_elf_got_entry *gotent;
   unsigned long entries;
 
   /* If we're using a plt for this symbol, then all of its relocations
      for its got entries go into .rela.plt.  */
   if (h->root.needs_plt)
-    return TRUE;
+    return true;
 
   /* If the symbol is dynamic, we'll need all the relocations in their
      natural form.  If this is a shared object, and it has been forced
@@ -2728,7 +2728,7 @@ elf64_alpha_size_rela_got_1 (struct alpha_elf_link_hash_entry *h,
      relocations.  Avoid the loop which may want to add RELATIVE relocs
      based on bfd_link_pic (info).  */
   if (h->root.root.type == bfd_link_hash_undefweak && !dynamic)
-    return TRUE;
+    return true;
 
   entries = 0;
   for (gotent = h->got_entries; gotent ; gotent = gotent->next)
@@ -2744,7 +2744,7 @@ elf64_alpha_size_rela_got_1 (struct alpha_elf_link_hash_entry *h,
       srel->size += sizeof (Elf64_External_Rela) * entries;
     }
 
-  return TRUE;
+  return true;
 }
 
 /* Set the sizes of the dynamic relocation sections.  */
@@ -2804,18 +2804,18 @@ elf64_alpha_size_rela_got_section (struct bfd_link_info *info)
 
 /* Set the sizes of the dynamic sections.  */
 
-static bfd_boolean
+static bool
 elf64_alpha_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
 				   struct bfd_link_info *info)
 {
   bfd *dynobj;
   asection *s;
-  bfd_boolean relplt, relocs;
+  bool relplt, relocs;
   struct alpha_elf_link_hash_table * htab;
 
   htab = alpha_elf_hash_table (info);
   if (htab == NULL)
-    return FALSE;
+    return false;
 
   dynobj = elf_hash_table(info)->dynobj;
   BFD_ASSERT(dynobj != NULL);
@@ -2846,8 +2846,8 @@ elf64_alpha_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
   /* The check_relocs and adjust_dynamic_symbol entry points have
      determined the sizes of the various dynamic sections.  Allocate
      memory for them.  */
-  relplt = FALSE;
-  relocs = FALSE;
+  relplt = false;
+  relocs = false;
   for (s = dynobj->sections; s != NULL; s = s->next)
     {
       const char *name;
@@ -2864,9 +2864,9 @@ elf64_alpha_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
 	  if (s->size != 0)
 	    {
 	      if (strcmp (name, ".rela.plt") == 0)
-		relplt = TRUE;
+		relplt = true;
 	      else
-		relocs = TRUE;
+		relocs = true;
 
 	      /* We use the reloc_count field as a counter if we need
 		 to copy relocs into the output file.  */
@@ -2898,7 +2898,7 @@ elf64_alpha_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
 	  /* Allocate memory for the section contents.  */
 	  s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
 	  if (s->contents == NULL)
-	    return FALSE;
+	    return false;
 	}
     }
 
@@ -2914,16 +2914,16 @@ elf64_alpha_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
 
       if (!_bfd_elf_add_dynamic_tags (output_bfd, info,
 				      relocs || relplt))
-	return FALSE;
+	return false;
 
       if (relplt
 	  && elf64_alpha_use_secureplt
 	  && !add_dynamic_entry (DT_ALPHA_PLTRO, 1))
-	return FALSE;
+	return false;
     }
 #undef add_dynamic_entry
 
-  return TRUE;
+  return true;
 }
 
 /* These functions do relaxation for Alpha ELF.
@@ -2953,8 +2953,8 @@ struct alpha_relax_info
   struct alpha_elf_link_hash_entry *h;
   struct alpha_elf_got_entry **first_gotent;
   struct alpha_elf_got_entry *gotent;
-  bfd_boolean changed_contents;
-  bfd_boolean changed_relocs;
+  bool changed_contents;
+  bool changed_relocs;
   unsigned char other;
 };
 
@@ -2973,7 +2973,7 @@ elf64_alpha_find_reloc_at_ofs (Elf_Internal_Rela *rel,
   return NULL;
 }
 
-static bfd_boolean
+static bool
 elf64_alpha_relax_got_load (struct alpha_relax_info *info, bfd_vma symval,
 			    Elf_Internal_Rela *irel, unsigned long r_type)
 {
@@ -2991,18 +2991,18 @@ elf64_alpha_relax_got_load (struct alpha_relax_info *info, bfd_vma symval,
 	(_("%pB: %pA+%#" PRIx64 ": warning: "
 	   "%s relocation against unexpected insn"),
 	 info->abfd, info->sec, (uint64_t) irel->r_offset, howto->name);
-      return TRUE;
+      return true;
     }
 
   /* Can't relax dynamic symbols.  */
   if (info->h != NULL
       && alpha_elf_dynamic_symbol_p (&info->h->root, info->link_info))
-    return TRUE;
+    return true;
 
   /* Can't use local-exec relocations in shared libraries.  */
   if (r_type == R_ALPHA_GOTTPREL
       && bfd_link_dll (info->link_info))
-    return TRUE;
+    return true;
 
   if (r_type == R_ALPHA_LITERAL)
     {
@@ -3021,7 +3021,7 @@ elf64_alpha_relax_got_load (struct alpha_relax_info *info, bfd_vma symval,
 	{
 	  /* We may only create GPREL relocs during the second pass.  */
 	  if (info->link_info->relax_pass == 0)
-	    return TRUE;
+	    return true;
 
 	  disp = symval - info->gp;
 	  insn = (OP_LDA << 26) | (insn & 0x03ff0000);
@@ -3049,15 +3049,15 @@ elf64_alpha_relax_got_load (struct alpha_relax_info *info, bfd_vma symval,
 	  break;
 	default:
 	  BFD_ASSERT (0);
-	  return FALSE;
+	  return false;
 	}
     }
 
   if (disp < -0x8000 || disp >= 0x8000)
-    return TRUE;
+    return true;
 
   bfd_put_32 (info->abfd, (bfd_vma) insn, info->contents + irel->r_offset);
-  info->changed_contents = TRUE;
+  info->changed_contents = true;
 
   /* Reduce the use count on this got entry by one, possibly
      eliminating it.  */
@@ -3071,7 +3071,7 @@ elf64_alpha_relax_got_load (struct alpha_relax_info *info, bfd_vma symval,
 
   /* Smash the existing GOT relocation for its 16-bit immediate pair.  */
   irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), r_type);
-  info->changed_relocs = TRUE;
+  info->changed_relocs = true;
 
   /* ??? Search forward through this basic block looking for insns
      that use the target register.  Stop after an insn modifying the
@@ -3086,7 +3086,7 @@ elf64_alpha_relax_got_load (struct alpha_relax_info *info, bfd_vma symval,
      This would mean that we'd have to _add_ relocations, the pain of
      which gives one pause.  */
 
-  return TRUE;
+  return true;
 }
 
 static bfd_vma
@@ -3159,19 +3159,19 @@ elf64_alpha_relax_opt_call (struct alpha_relax_info *info, bfd_vma symval)
   return symval + 8;
 }
 
-static bfd_boolean
+static bool
 elf64_alpha_relax_with_lituse (struct alpha_relax_info *info,
 			       bfd_vma symval, Elf_Internal_Rela *irel)
 {
   Elf_Internal_Rela *urel, *erel, *irelend = info->relend;
   int flags;
   bfd_signed_vma disp;
-  bfd_boolean fits16;
-  bfd_boolean fits32;
-  bfd_boolean lit_reused = FALSE;
-  bfd_boolean all_optimized = TRUE;
-  bfd_boolean changed_contents;
-  bfd_boolean changed_relocs;
+  bool fits16;
+  bool fits32;
+  bool lit_reused = false;
+  bool all_optimized = true;
+  bool changed_contents;
+  bool changed_relocs;
   bfd_byte *contents = info->contents;
   bfd *abfd = info->abfd;
   bfd_vma sec_output_vma;
@@ -3186,12 +3186,12 @@ elf64_alpha_relax_with_lituse (struct alpha_relax_info *info,
 	(_("%pB: %pA+%#" PRIx64 ": warning: "
 	   "%s relocation against unexpected insn"),
 	 abfd, info->sec, (uint64_t) irel->r_offset, "LITERAL");
-      return TRUE;
+      return true;
     }
 
   /* Can't relax dynamic symbols.  */
   if (alpha_elf_dynamic_symbol_p (&info->h->root, info->link_info))
-    return TRUE;
+    return true;
 
   changed_contents = info->changed_contents;
   changed_relocs = info->changed_relocs;
@@ -3226,14 +3226,14 @@ elf64_alpha_relax_with_lituse (struct alpha_relax_info *info,
 	default:
 	  /* This type is really just a placeholder to note that all
 	     uses cannot be optimized, but to still allow some.  */
-	  all_optimized = FALSE;
+	  all_optimized = false;
 	  break;
 
 	case LITUSE_ALPHA_BASE:
 	  /* We may only create GPREL relocs during the second pass.  */
 	  if (relax_pass == 0)
 	    {
-	      all_optimized = FALSE;
+	      all_optimized = false;
 	      break;
 	    }
 
@@ -3255,7 +3255,7 @@ elf64_alpha_relax_with_lituse (struct alpha_relax_info *info,
 		 register from the literal insn.  Leave the offset alone.  */
 	      insn = (insn & 0xffe0ffff) | (lit_insn & 0x001f0000);
 	      bfd_put_32 (abfd, (bfd_vma) insn, contents + urel_r_offset);
-	      changed_contents = TRUE;
+	      changed_contents = true;
 
 	      nrel = *urel;
 	      nrel.r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
@@ -3267,7 +3267,7 @@ elf64_alpha_relax_with_lituse (struct alpha_relax_info *info,
 	      if (urel < --erel)
 		*urel-- = *erel;
 	      *erel = nrel;
-	      changed_relocs = TRUE;
+	      changed_relocs = true;
 	    }
 
 	  /* If all mem+byte, we can optimize 32-bit mem displacements.  */
@@ -3279,18 +3279,18 @@ elf64_alpha_relax_with_lituse (struct alpha_relax_info *info,
 					   R_ALPHA_GPRELHIGH);
 	      lit_insn = (OP_LDAH << 26) | (lit_insn & 0x03ff0000);
 	      bfd_put_32 (abfd, (bfd_vma) lit_insn, contents + irel->r_offset);
-	      lit_reused = TRUE;
-	      changed_contents = TRUE;
+	      lit_reused = true;
+	      changed_contents = true;
 
 	      /* Since all relocs must be optimized, don't bother swapping
 		 this relocation to the end.  */
 	      urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
 					   R_ALPHA_GPRELLOW);
 	      urel->r_addend = irel->r_addend;
-	      changed_relocs = TRUE;
+	      changed_relocs = true;
 	    }
 	  else
-	    all_optimized = FALSE;
+	    all_optimized = false;
 	  break;
 
 	case LITUSE_ALPHA_BYTOFF:
@@ -3302,7 +3302,7 @@ elf64_alpha_relax_with_lituse (struct alpha_relax_info *info,
 	  insn &= ~ (unsigned) 0x001ff000;
 	  insn |= ((symval & 7) << 13) | 0x1000;
 	  bfd_put_32 (abfd, (bfd_vma) insn, contents + urel_r_offset);
-	  changed_contents = TRUE;
+	  changed_contents = true;
 
 	  nrel = *urel;
 	  nrel.r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
@@ -3313,7 +3313,7 @@ elf64_alpha_relax_with_lituse (struct alpha_relax_info *info,
 	  if (urel < --erel)
 	    *urel-- = *erel;
 	  *erel = nrel;
-	  changed_relocs = TRUE;
+	  changed_relocs = true;
 	  break;
 
 	case LITUSE_ALPHA_JSR:
@@ -3332,7 +3332,7 @@ elf64_alpha_relax_with_lituse (struct alpha_relax_info *info,
 		insn |= 31 << 16;
 		bfd_put_32 (abfd, (bfd_vma) insn, contents + urel_r_offset);
 
-		changed_contents = TRUE;
+		changed_contents = true;
 		break;
 	      }
 
@@ -3351,7 +3351,7 @@ elf64_alpha_relax_with_lituse (struct alpha_relax_info *info,
 		else
 		  insn = (OP_BR << 26) | (insn & 0x03e00000);
 		bfd_put_32 (abfd, (bfd_vma) insn, contents + urel_r_offset);
-		changed_contents = TRUE;
+		changed_contents = true;
 
 		nrel = *urel;
 		nrel.r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
@@ -3361,7 +3361,7 @@ elf64_alpha_relax_with_lituse (struct alpha_relax_info *info,
 		if (optdest)
 		  nrel.r_addend += optdest - symval;
 		else
-		  all_optimized = FALSE;
+		  all_optimized = false;
 
 		/* Kill any HINT reloc that might exist for this insn.  */
 		xrel = (elf64_alpha_find_reloc_at_ofs
@@ -3376,10 +3376,10 @@ elf64_alpha_relax_with_lituse (struct alpha_relax_info *info,
 		  *urel-- = *erel;
 		*erel = nrel;
 
-		info->changed_relocs = TRUE;
+		info->changed_relocs = true;
 	      }
 	    else
-	      all_optimized = FALSE;
+	      all_optimized = false;
 
 	    /* Even if the target is not in range for a direct branch,
 	       if we share a GP, we can eliminate the gp reload.  */
@@ -3407,8 +3407,8 @@ elf64_alpha_relax_with_lituse (struct alpha_relax_info *info,
 			bfd_put_32 (abfd, (bfd_vma) INSN_UNOP, p_lda);
 
 			gpdisp->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
-			changed_contents = TRUE;
-			changed_relocs = TRUE;
+			changed_contents = true;
+			changed_relocs = true;
 		      }
 		  }
 	      }
@@ -3439,10 +3439,10 @@ elf64_alpha_relax_with_lituse (struct alpha_relax_info *info,
       if (!lit_reused)
 	{
 	  irel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
-	  changed_relocs = TRUE;
+	  changed_relocs = true;
 
 	  bfd_put_32 (abfd, (bfd_vma) INSN_UNOP, contents + irel->r_offset);
-	  changed_contents = TRUE;
+	  changed_contents = true;
 	}
     }
 
@@ -3450,18 +3450,18 @@ elf64_alpha_relax_with_lituse (struct alpha_relax_info *info,
   info->changed_relocs = changed_relocs;
 
   if (all_optimized || relax_pass == 0)
-    return TRUE;
+    return true;
   return elf64_alpha_relax_got_load (info, symval, irel, R_ALPHA_LITERAL);
 }
 
-static bfd_boolean
+static bool
 elf64_alpha_relax_tls_get_addr (struct alpha_relax_info *info, bfd_vma symval,
-				Elf_Internal_Rela *irel, bfd_boolean is_gd)
+				Elf_Internal_Rela *irel, bool is_gd)
 {
   bfd_byte *pos[5];
   unsigned int insn, tlsgd_reg;
   Elf_Internal_Rela *gpdisp, *hint;
-  bfd_boolean dynamic, use_gottprel;
+  bool dynamic, use_gottprel;
   unsigned long new_symndx;
 
   dynamic = (info->h != NULL
@@ -3480,23 +3480,23 @@ elf64_alpha_relax_tls_get_addr (struct alpha_relax_info *info, bfd_vma symval,
 
   /* Otherwise we must be building an executable to do anything.  */
   else if (bfd_link_pic (info->link_info))
-    return TRUE;
+    return true;
 
   /* The TLSGD/TLSLDM relocation must be followed by a LITERAL and
      the matching LITUSE_TLS relocations.  */
   if (irel + 2 >= info->relend)
-    return TRUE;
+    return true;
   if (ELF64_R_TYPE (irel[1].r_info) != R_ALPHA_LITERAL
       || ELF64_R_TYPE (irel[2].r_info) != R_ALPHA_LITUSE
       || irel[2].r_addend != (is_gd ? LITUSE_ALPHA_TLSGD : LITUSE_ALPHA_TLSLDM))
-    return TRUE;
+    return true;
 
   /* There must be a GPDISP relocation positioned immediately after the
      LITUSE relocation.  */
   gpdisp = elf64_alpha_find_reloc_at_ofs (info->relocs, info->relend,
 					  irel[2].r_offset + 4, R_ALPHA_GPDISP);
   if (!gpdisp)
-    return TRUE;
+    return true;
 
   pos[0] = info->contents + irel[0].r_offset;
   pos[1] = info->contents + irel[1].r_offset;
@@ -3521,7 +3521,7 @@ elf64_alpha_relax_tls_get_addr (struct alpha_relax_info *info, bfd_vma symval,
       pos[1] = tmp;
     }
   if (pos[1] >= pos[2] || pos[2] >= pos[3])
-    return TRUE;
+    return true;
 
   /* Reduce the use count on the LITERAL relocation.  Do this before we
      smash the symndx when we adjust the relocations below.  */
@@ -3575,7 +3575,7 @@ elf64_alpha_relax_tls_get_addr (struct alpha_relax_info *info, bfd_vma symval,
 
      as appropriate.  */
 
-  use_gottprel = FALSE;
+  use_gottprel = false;
   new_symndx = is_gd ? ELF64_R_SYM (irel->r_info) : STN_UNDEF;
 
   /* Some compilers warn about a Boolean-looking expression being
@@ -3621,7 +3621,7 @@ elf64_alpha_relax_tls_get_addr (struct alpha_relax_info *info, bfd_vma symval,
       /* FALLTHRU */
 
     default:
-      use_gottprel = TRUE;
+      use_gottprel = true;
 
       insn = (OP_LDQ << 26) | (tlsgd_reg << 21) | (29 << 16);
       bfd_put_32 (info->abfd, (bfd_vma) insn, pos[0]);
@@ -3648,8 +3648,8 @@ elf64_alpha_relax_tls_get_addr (struct alpha_relax_info *info, bfd_vma symval,
   if (hint)
     hint->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
 
-  info->changed_contents = TRUE;
-  info->changed_relocs = TRUE;
+  info->changed_contents = true;
+  info->changed_relocs = true;
 
   /* Reduce the use count on the TLSGD/TLSLDM relocation.  */
   if (--info->gotent->use_count == 0)
@@ -3683,7 +3683,7 @@ elf64_alpha_relax_tls_get_addr (struct alpha_relax_info *info, bfd_vma symval,
 	      tprel_gotent = (struct alpha_elf_got_entry *)
 		bfd_alloc (info->abfd, sizeof (struct alpha_elf_got_entry));
 	      if (!tprel_gotent)
-		return FALSE;
+		return false;
 
 	      tprel_gotent->next = *info->first_gotent;
 	      *info->first_gotent = tprel_gotent;
@@ -3700,12 +3700,12 @@ elf64_alpha_relax_tls_get_addr (struct alpha_relax_info *info, bfd_vma symval,
 	}
     }
 
-  return TRUE;
+  return true;
 }
 
-static bfd_boolean
+static bool
 elf64_alpha_relax_section (bfd *abfd, asection *sec,
-			   struct bfd_link_info *link_info, bfd_boolean *again)
+			   struct bfd_link_info *link_info, bool *again)
 {
   Elf_Internal_Shdr *symtab_hdr;
   Elf_Internal_Rela *internal_relocs;
@@ -3718,16 +3718,16 @@ elf64_alpha_relax_section (bfd *abfd, asection *sec,
 
   htab = alpha_elf_hash_table (link_info);
   if (htab == NULL)
-    return FALSE;
+    return false;
 
   /* There's nothing to change, yet.  */
-  *again = FALSE;
+  *again = false;
 
   if (bfd_link_relocatable (link_info)
       || ((sec->flags & (SEC_CODE | SEC_RELOC | SEC_ALLOC))
 	  != (SEC_CODE | SEC_RELOC | SEC_ALLOC))
       || sec->reloc_count == 0)
-    return TRUE;
+    return true;
 
   BFD_ASSERT (is_alpha_elf (abfd));
   relax_pass = link_info->relax_pass;
@@ -3759,7 +3759,7 @@ elf64_alpha_relax_section (bfd *abfd, asection *sec,
 		     (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
 		      link_info->keep_memory));
   if (internal_relocs == NULL)
-    return FALSE;
+    return false;
 
   memset(&info, 0, sizeof (info));
   info.abfd = abfd;
@@ -3991,7 +3991,7 @@ elf64_alpha_relax_section (bfd *abfd, asection *sec,
 
   *again = info.changed_contents || info.changed_relocs;
 
-  return TRUE;
+  return true;
 
  error_return:
   if (symtab_hdr->contents != (unsigned char *) isymbuf)
@@ -4000,7 +4000,7 @@ elf64_alpha_relax_section (bfd *abfd, asection *sec,
     free (info.contents);
   if (elf_section_data (sec)->relocs != internal_relocs)
     free (internal_relocs);
-  return FALSE;
+  return false;
 }
 
 /* Emit a dynamic relocation for (DYNINDX, RTYPE, ADDEND) at (SEC, OFFSET)
@@ -4050,7 +4050,7 @@ elf64_alpha_relocate_section_r (bfd *output_bfd ATTRIBUTE_UNUSED,
   Elf_Internal_Rela *rel;
   Elf_Internal_Rela *relend;
   struct elf_link_hash_entry **sym_hashes;
-  bfd_boolean ret_val = TRUE;
+  bool ret_val = true;
 
   symtab_hdr_sh_info = elf_symtab_hdr (input_bfd).sh_info;
   sym_hashes = elf_sym_hashes (input_bfd);
@@ -4071,7 +4071,7 @@ elf64_alpha_relocate_section_r (bfd *output_bfd ATTRIBUTE_UNUSED,
 	    (_("%pB: unsupported relocation type %#x"),
 	     input_bfd, (int) r_type);
 	  bfd_set_error (bfd_error_bad_value);
-	  ret_val = FALSE;
+	  ret_val = false;
 	  continue;
 	}
 
@@ -4133,7 +4133,7 @@ elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
   bfd *dynobj, *gotobj;
   bfd_vma gp, tp_base, dtp_base;
   struct alpha_elf_got_entry **local_got_entries;
-  bfd_boolean ret_val;
+  bool ret_val;
 
   BFD_ASSERT (is_alpha_elf (input_bfd));
 
@@ -4145,7 +4145,7 @@ elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
 
   /* This is a final link.  */
 
-  ret_val = TRUE;
+  ret_val = true;
 
   symtab_hdr = &elf_symtab_hdr (input_bfd);
 
@@ -4206,9 +4206,9 @@ elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
       asection *sec = NULL;
       bfd_vma value;
       bfd_vma addend;
-      bfd_boolean dynamic_symbol_p;
-      bfd_boolean unresolved_reloc = FALSE;
-      bfd_boolean undef_weak_ref = FALSE;
+      bool dynamic_symbol_p;
+      bool unresolved_reloc = false;
+      bool undef_weak_ref = false;
       unsigned long r_type;
 
       r_type = ELF64_R_TYPE(rel->r_info);
@@ -4219,7 +4219,7 @@ elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
 	    (_("%pB: unsupported relocation type %#x"),
 	     input_bfd, (int) r_type);
 	  bfd_set_error (bfd_error_bad_value);
-	  ret_val = FALSE;
+	  ret_val = false;
 	  continue;
 	}
 
@@ -4285,11 +4285,11 @@ elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
 		}
 	    }
 
-	  dynamic_symbol_p = FALSE;
+	  dynamic_symbol_p = false;
 	}
       else
 	{
-	  bfd_boolean warned, ignored;
+	  bool warned, ignored;
 	  struct elf_link_hash_entry *hh;
 	  struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
 
@@ -4304,7 +4304,7 @@ elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
 	  if (value == 0
 	      && ! unresolved_reloc
 	      && hh->root.type == bfd_link_hash_undefweak)
-	    undef_weak_ref = TRUE;
+	    undef_weak_ref = true;
 
 	  h = (struct alpha_elf_link_hash_entry *) hh;
 	  dynamic_symbol_p = alpha_elf_dynamic_symbol_p (&h->root, info);
@@ -4384,7 +4384,7 @@ elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
 		/* xgettext:c-format */
 		(_("%pB: gp-relative relocation against dynamic symbol %s"),
 		 input_bfd, h->root.root.root.string);
-	      ret_val = FALSE;
+	      ret_val = false;
 	    }
 	  BFD_ASSERT(gp != 0);
 	  value -= gp;
@@ -4397,7 +4397,7 @@ elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
 		/* xgettext:c-format */
 		(_("%pB: gp-relative relocation against dynamic symbol %s"),
 		 input_bfd, h->root.root.root.string);
-	      ret_val = FALSE;
+	      ret_val = false;
 	    }
 	  BFD_ASSERT(gp != 0);
 	  value -= gp;
@@ -4424,7 +4424,7 @@ elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
 		/* xgettext:c-format */
 		(_("%pB: pc-relative relocation against dynamic symbol %s"),
 		 input_bfd, h->root.root.root.string);
-	      ret_val = FALSE;
+	      ret_val = false;
 	    }
 	  /* The regular PC-relative stuff measures from the start of
 	     the instruction rather than the end.  */
@@ -4453,7 +4453,7 @@ elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
 		  /* xgettext:c-format */
 		  (_("%pB: change in gp: BRSGP %s"),
 		   input_bfd, h->root.root.root.string);
-		ret_val = FALSE;
+		ret_val = false;
 	      }
 
 	    /* The symbol should be marked either NOPV or STD_GPLOAD.  */
@@ -4484,7 +4484,7 @@ elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
 		  /* xgettext:c-format */
 		  (_("%pB: !samegp reloc against symbol without .prologue: %s"),
 		   input_bfd, name);
-		ret_val = FALSE;
+		ret_val = false;
 		break;
 	      }
 
@@ -4543,7 +4543,7 @@ elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
 		      (_("%pB: unhandled dynamic relocation against %s"),
 		       input_bfd,
 		       h->root.root.root.string);
-		    ret_val = FALSE;
+		    ret_val = false;
 		  }
 		dynindx = 0;
 		dyntype = R_ALPHA_RELATIVE;
@@ -4568,7 +4568,7 @@ elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
 		/* xgettext:c-format */
 		(_("%pB: pc-relative relocation against dynamic symbol %s"),
 		 input_bfd, h->root.root.root.string);
-	      ret_val = FALSE;
+	      ret_val = false;
 	    }
 	  else if (bfd_link_pic (info)
 		   && undef_weak_ref)
@@ -4577,7 +4577,7 @@ elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
 		/* xgettext:c-format */
 		(_("%pB: pc-relative relocation against undefined weak symbol %s"),
 		 input_bfd, h->root.root.root.string);
-	      ret_val = FALSE;
+	      ret_val = false;
 	    }
 
 
@@ -4643,7 +4643,7 @@ elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
 		/* xgettext:c-format */
 		(_("%pB: dtp-relative relocation against dynamic symbol %s"),
 		 input_bfd, h->root.root.root.string);
-	      ret_val = FALSE;
+	      ret_val = false;
 	    }
 	  BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
 	  value -= dtp_base;
@@ -4660,7 +4660,7 @@ elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
 		/* xgettext:c-format */
 		(_("%pB: TLS local exec code cannot be linked into shared objects"),
 		input_bfd);
-	      ret_val = FALSE;
+	      ret_val = false;
 	    }
 	  else if (dynamic_symbol_p)
 	    {
@@ -4668,7 +4668,7 @@ elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
 		/* xgettext:c-format */
 		(_("%pB: tp-relative relocation against dynamic symbol %s"),
 		 input_bfd, h->root.root.root.string);
-	      ret_val = FALSE;
+	      ret_val = false;
 	    }
 	  BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
 	  value -= tp_base;
@@ -4747,7 +4747,7 @@ elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
 		name = (bfd_elf_string_from_elf_section
 			(input_bfd, symtab_hdr->sh_link, sym->st_name));
 		if (name == NULL)
-		  return FALSE;
+		  return false;
 		if (*name == '\0')
 		  name = bfd_section_name (sec);
 	      }
@@ -4769,7 +4769,7 @@ elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
 /* Finish up dynamic symbol handling.  We set the contents of various
    dynamic sections here.  */
 
-static bfd_boolean
+static bool
 elf64_alpha_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info,
 				   struct elf_link_hash_entry *h,
 				   Elf_Internal_Sym *sym)
@@ -4912,12 +4912,12 @@ elf64_alpha_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info,
       || h == elf_hash_table (info)->hplt)
     sym->st_shndx = SHN_ABS;
 
-  return TRUE;
+  return true;
 }
 
 /* Finish up the dynamic sections.  */
 
-static bfd_boolean
+static bool
 elf64_alpha_finish_dynamic_sections (bfd *output_bfd,
 				     struct bfd_link_info *info)
 {
@@ -5034,14 +5034,14 @@ elf64_alpha_finish_dynamic_sections (bfd *output_bfd,
 	}
     }
 
-  return TRUE;
+  return true;
 }
 
 /* We need to use a special link routine to handle the .mdebug section.
    We need to merge all instances of these sections together, not write
    them all out sequentially.  */
 
-static bfd_boolean
+static bool
 elf64_alpha_final_link (bfd *abfd, struct bfd_link_info *info)
 {
   asection *o;
@@ -5056,7 +5056,7 @@ elf64_alpha_final_link (bfd *abfd, struct bfd_link_info *info)
 
   htab = alpha_elf_hash_table (info);
   if (htab == NULL)
-    return FALSE;
+    return false;
 
   /* Go through the sections and collect the mdebug information.  */
   mdebug_sec = NULL;
@@ -5101,7 +5101,7 @@ elf64_alpha_final_link (bfd *abfd, struct bfd_link_info *info)
 
 	  mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
 	  if (mdebug_handle == NULL)
-	    return FALSE;
+	    return false;
 
 	  if (1)
 	    {
@@ -5140,7 +5140,7 @@ elf64_alpha_final_link (bfd *abfd, struct bfd_link_info *info)
 
 		  if (! bfd_ecoff_debug_one_external (abfd, &debug, swap,
 						      name[i], &esym))
-		    return FALSE;
+		    return false;
 		}
 	    }
 
@@ -5181,12 +5181,12 @@ elf64_alpha_final_link (bfd *abfd, struct bfd_link_info *info)
 		 ecoff_debug_info structure, so we do that now.  */
 	      if (!elf64_alpha_read_ecoff_info (input_bfd, input_section,
 						&input_debug))
-		return FALSE;
+		return false;
 
 	      if (! (bfd_ecoff_debug_accumulate
 		     (mdebug_handle, abfd, &debug, swap, input_bfd,
 		      &input_debug, input_swap, info)))
-		return FALSE;
+		return false;
 
 	      /* Loop through the external symbols.  For each one with
 		 interesting information, try to find the symbol in
@@ -5211,7 +5211,7 @@ elf64_alpha_final_link (bfd *abfd, struct bfd_link_info *info)
 		    continue;
 
 		  name = input_debug.ssext + ext.asym.iss;
-		  h = alpha_elf_link_hash_lookup (htab, name, FALSE, FALSE, TRUE);
+		  h = alpha_elf_link_hash_lookup (htab, name, false, false, true);
 		  if (h == NULL || h->esym.ifd != -2)
 		    continue;
 
@@ -5248,12 +5248,12 @@ elf64_alpha_final_link (bfd *abfd, struct bfd_link_info *info)
 	  einfo.info = info;
 	  einfo.debug = &debug;
 	  einfo.swap = swap;
-	  einfo.failed = FALSE;
+	  einfo.failed = false;
 	  elf_link_hash_traverse (elf_hash_table (info),
 				  elf64_alpha_output_extsym,
 				  &einfo);
 	  if (einfo.failed)
-	    return FALSE;
+	    return false;
 
 	  /* Set the size of the .mdebug section.  */
 	  o->size = bfd_ecoff_debug_size (abfd, &debug, swap);
@@ -5268,7 +5268,7 @@ elf64_alpha_final_link (bfd *abfd, struct bfd_link_info *info)
 
   /* Invoke the regular ELF backend linker to do all the work.  */
   if (! bfd_elf_final_link (abfd, info))
-    return FALSE;
+    return false;
 
   /* Now write out the computed sections.  */
 
@@ -5290,7 +5290,7 @@ elf64_alpha_final_link (bfd *abfd, struct bfd_link_info *info)
 					sgot->contents,
 					(file_ptr) sgot->output_offset,
 					sgot->size))
-	  return FALSE;
+	  return false;
       }
   }
 
@@ -5300,12 +5300,12 @@ elf64_alpha_final_link (bfd *abfd, struct bfd_link_info *info)
       if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
 					       swap, info,
 					       mdebug_sec->filepos))
-	return FALSE;
+	return false;
 
       bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
     }
 
-  return TRUE;
+  return true;
 }
 
 static enum elf_reloc_type_class
@@ -5517,13 +5517,13 @@ static const struct elf_size_info alpha_elf_size_info =
    "FreeBSD" label in the ELF header.  So we put this label on all
    executables and (for simplicity) also all other object files.  */
 
-static bfd_boolean
+static bool
 elf64_alpha_fbsd_init_file_header (bfd *abfd, struct bfd_link_info *info)
 {
   Elf_Internal_Ehdr * i_ehdrp;	/* ELF file header, internal form.  */
 
   if (!_bfd_elf_init_file_header (abfd, info))
-    return FALSE;
+    return false;
 
   i_ehdrp = elf_elfheader (abfd);
 
@@ -5533,7 +5533,7 @@ elf64_alpha_fbsd_init_file_header (bfd *abfd, struct bfd_link_info *info)
   /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard.  */
   memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
 #endif
-  return TRUE;
+  return true;
 }
 
 #undef elf_backend_init_file_header