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, 215 insertions, 220 deletions

diff --git a/bfd/bfd-in2.h b/bfd/bfd-in2.h
index 9fbde9d..40d35a1 100644
--- a/bfd/bfd-in2.h
+++ b/bfd/bfd-in2.h
@@ -346,7 +346,7 @@ struct bfd_hash_table
 };
 
 /* Initialize a hash table.  */
-extern bfd_boolean bfd_hash_table_init
+extern bool bfd_hash_table_init
   (struct bfd_hash_table *,
    struct bfd_hash_entry *(*) (struct bfd_hash_entry *,
 			       struct bfd_hash_table *,
@@ -354,7 +354,7 @@ extern bfd_boolean bfd_hash_table_init
    unsigned int);
 
 /* Initialize a hash table specifying a size.  */
-extern bfd_boolean bfd_hash_table_init_n
+extern bool bfd_hash_table_init_n
   (struct bfd_hash_table *,
    struct bfd_hash_entry *(*) (struct bfd_hash_entry *,
 			       struct bfd_hash_table *,
@@ -370,8 +370,7 @@ extern void bfd_hash_table_free
    COPY argument must be TRUE if this routine should copy the string
    into newly allocated memory when adding an entry.  */
 extern struct bfd_hash_entry *bfd_hash_lookup
-  (struct bfd_hash_table *, const char *, bfd_boolean create,
-   bfd_boolean copy);
+  (struct bfd_hash_table *, const char *, bool create, bool copy);
 
 /* Insert an entry in a hash table.  */
 extern struct bfd_hash_entry *bfd_hash_insert
@@ -399,7 +398,7 @@ extern void *bfd_hash_allocate
    INFO argument is passed to the function.  */
 extern void bfd_hash_traverse
   (struct bfd_hash_table *,
-   bfd_boolean (*) (struct bfd_hash_entry *, void *),
+   bool (*) (struct bfd_hash_entry *, void *),
    void *info);
 
 /* Allows the default size of a hash table to be configured. New hash
@@ -462,15 +461,15 @@ extern int bfd_stat (bfd *, struct stat *);
 #endif
 extern void _bfd_warn_deprecated (const char *, const char *, int, const char *);
 
-extern bfd_boolean bfd_cache_close
+extern bool bfd_cache_close
   (bfd *abfd);
 /* NB: This declaration should match the autogenerated one in libbfd.h.  */
 
-extern bfd_boolean bfd_cache_close_all (void);
+extern bool bfd_cache_close_all (void);
 
-extern bfd_boolean bfd_record_phdr
-  (bfd *, unsigned long, bfd_boolean, flagword, bfd_boolean, bfd_vma,
-   bfd_boolean, bfd_boolean, unsigned int, struct bfd_section **);
+extern bool bfd_record_phdr
+  (bfd *, unsigned long, bool, flagword, bool, bfd_vma,
+   bool, bool, unsigned int, struct bfd_section **);
 
 /* Byte swapping routines.  */
 
@@ -497,8 +496,8 @@ void bfd_putl16 (bfd_vma, void *);
 
 /* Byte swapping routines which take size and endiannes as arguments.  */
 
-bfd_uint64_t bfd_get_bits (const void *, int, bfd_boolean);
-void bfd_put_bits (bfd_uint64_t, void *, int, bfd_boolean);
+bfd_uint64_t bfd_get_bits (const void *, int, bool);
+void bfd_put_bits (bfd_uint64_t, void *, int, bool);
 
 
 /* mmap hacks */
@@ -525,8 +524,8 @@ extern void bfd_init_window
   (bfd_window *);
 extern void bfd_free_window
   (bfd_window *);
-extern bfd_boolean bfd_get_file_window
-  (bfd *, file_ptr, bfd_size_type, bfd_window *, bfd_boolean);
+extern bool bfd_get_file_window
+  (bfd *, file_ptr, bfd_size_type, bfd_window *, bool);
 
 /* Externally visible ELF routines.  */
 
@@ -558,7 +557,7 @@ struct bfd_link_hash_entry;
 
 /* Return TRUE if the start of STR matches PREFIX, FALSE otherwise.  */
 
-static inline bfd_boolean
+static inline bool
 startswith (const char *str, const char *prefix)
 {
   return strncmp (str, prefix, strlen (prefix)) == 0;
@@ -602,15 +601,15 @@ bfd *bfd_openr_iovec (const char *filename, const char *target,
 
 bfd *bfd_openw (const char *filename, const char *target);
 
-bfd_boolean bfd_close (bfd *abfd);
+bool bfd_close (bfd *abfd);
 
-bfd_boolean bfd_close_all_done (bfd *);
+bool bfd_close_all_done (bfd *);
 
 bfd *bfd_create (const char *filename, bfd *templ);
 
-bfd_boolean bfd_make_writable (bfd *abfd);
+bool bfd_make_writable (bfd *abfd);
 
-bfd_boolean bfd_make_readable (bfd *abfd);
+bool bfd_make_readable (bfd *abfd);
 
 void *bfd_alloc (bfd *abfd, bfd_size_type wanted);
 
@@ -632,7 +631,7 @@ char *bfd_follow_gnu_debugaltlink (bfd *abfd, const char *dir);
 struct bfd_section *bfd_create_gnu_debuglink_section
    (bfd *abfd, const char *filename);
 
-bfd_boolean bfd_fill_in_gnu_debuglink_section
+bool bfd_fill_in_gnu_debuglink_section
    (bfd *abfd, struct bfd_section *sect, const char *filename);
 
 char *bfd_follow_build_id_debuglink (bfd *abfd, const char *dir);
@@ -1244,7 +1243,7 @@ bfd_section_userdata (const asection *sec)
 {
   return sec->userdata;
 }
-static inline bfd_boolean
+static inline bool
 bfd_is_com_section (const asection *sec)
 {
   return (sec->flags & SEC_IS_COMMON) != 0;
@@ -1254,33 +1253,33 @@ bfd_is_com_section (const asection *sec)
    because not all callers use the return value.  A macro implementation
    would use a comma expression, eg: "((ptr)->foo = val, TRUE)" and some
    compilers will complain about comma expressions that have no effect.  */
-static inline bfd_boolean
+static inline bool
 bfd_set_section_userdata (asection *sec, void *val)
 {
   sec->userdata = val;
-  return TRUE;
+  return true;
 }
 
-static inline bfd_boolean
+static inline bool
 bfd_set_section_vma (asection *sec, bfd_vma val)
 {
   sec->vma = sec->lma = val;
-  sec->user_set_vma = TRUE;
-  return TRUE;
+  sec->user_set_vma = true;
+  return true;
 }
 
-static inline bfd_boolean
+static inline bool
 bfd_set_section_lma (asection *sec, bfd_vma val)
 {
   sec->lma = val;
-  return TRUE;
+  return true;
 }
 
-static inline bfd_boolean
+static inline bool
 bfd_set_section_alignment (asection *sec, unsigned int val)
 {
   sec->alignment_power = val;
-  return TRUE;
+  return true;
 }
 
 /* These sections are global, and are managed by BFD.  The application
@@ -1302,25 +1301,25 @@ extern asection _bfd_std_section[4];
 /* Pointer to the indirect section.  */
 #define bfd_ind_section_ptr (&_bfd_std_section[3])
 
-static inline bfd_boolean
+static inline bool
 bfd_is_und_section (const asection *sec)
 {
   return sec == bfd_und_section_ptr;
 }
 
-static inline bfd_boolean
+static inline bool
 bfd_is_abs_section (const asection *sec)
 {
   return sec == bfd_abs_section_ptr;
 }
 
-static inline bfd_boolean
+static inline bool
 bfd_is_ind_section (const asection *sec)
 {
   return sec == bfd_ind_section_ptr;
 }
 
-static inline bfd_boolean
+static inline bool
 bfd_is_const_section (const asection *sec)
 {
   return (sec >= _bfd_std_section
@@ -1329,7 +1328,7 @@ bfd_is_const_section (const asection *sec)
 }
 
 /* Return TRUE if input section SEC has been discarded.  */
-static inline bfd_boolean
+static inline bool
 discarded_section (const asection *sec)
 {
   return (!bfd_is_abs_section (sec)
@@ -1400,7 +1399,7 @@ asection *bfd_get_linker_section (bfd *abfd, const char *name);
 asection *bfd_get_section_by_name_if
    (bfd *abfd,
     const char *name,
-    bfd_boolean (*func) (bfd *abfd, asection *sect, void *obj),
+    bool (*func) (bfd *abfd, asection *sect, void *obj),
     void *obj);
 
 char *bfd_get_unique_section_name
@@ -1418,7 +1417,7 @@ asection *bfd_make_section_with_flags
 
 asection *bfd_make_section (bfd *, const char *name);
 
-bfd_boolean bfd_set_section_flags (asection *sec, flagword flags);
+bool bfd_set_section_flags (asection *sec, flagword flags);
 
 void bfd_rename_section
    (asection *sec, const char *newname);
@@ -1430,33 +1429,33 @@ void bfd_map_over_sections
 
 asection *bfd_sections_find_if
    (bfd *abfd,
-    bfd_boolean (*operation) (bfd *abfd, asection *sect, void *obj),
+    bool (*operation) (bfd *abfd, asection *sect, void *obj),
     void *obj);
 
-bfd_boolean bfd_set_section_size (asection *sec, bfd_size_type val);
+bool bfd_set_section_size (asection *sec, bfd_size_type val);
 
-bfd_boolean bfd_set_section_contents
+bool bfd_set_section_contents
    (bfd *abfd, asection *section, const void *data,
     file_ptr offset, bfd_size_type count);
 
-bfd_boolean bfd_get_section_contents
+bool bfd_get_section_contents
    (bfd *abfd, asection *section, void *location, file_ptr offset,
     bfd_size_type count);
 
-bfd_boolean bfd_malloc_and_get_section
+bool bfd_malloc_and_get_section
    (bfd *abfd, asection *section, bfd_byte **buf);
 
-bfd_boolean bfd_copy_private_section_data
+bool bfd_copy_private_section_data
    (bfd *ibfd, asection *isec, bfd *obfd, asection *osec);
 
 #define bfd_copy_private_section_data(ibfd, isection, obfd, osection) \
        BFD_SEND (obfd, _bfd_copy_private_section_data, \
                  (ibfd, isection, obfd, osection))
-bfd_boolean bfd_generic_is_group_section (bfd *, const asection *sec);
+bool bfd_generic_is_group_section (bfd *, const asection *sec);
 
 const char *bfd_generic_group_name (bfd *, const asection *sec);
 
-bfd_boolean bfd_generic_discard_group (bfd *abfd, asection *group);
+bool bfd_generic_discard_group (bfd *abfd, asection *group);
 
 /* Extracted from archures.c.  */
 enum bfd_architecture
@@ -1965,17 +1964,16 @@ typedef struct bfd_arch_info
   /* TRUE if this is the default machine for the architecture.
      The default arch should be the first entry for an arch so that
      all the entries for that arch can be accessed via <<next>>.  */
-  bfd_boolean the_default;
+  bool the_default;
   const struct bfd_arch_info * (*compatible) (const struct bfd_arch_info *,
                                               const struct bfd_arch_info *);
 
-  bfd_boolean (*scan) (const struct bfd_arch_info *, const char *);
+  bool (*scan) (const struct bfd_arch_info *, const char *);
 
   /* Allocate via bfd_malloc and return a fill buffer of size COUNT.  If
      IS_BIGENDIAN is TRUE, the order of bytes is big endian.  If CODE is
      TRUE, the buffer contains code.  */
-  void *(*fill) (bfd_size_type count, bfd_boolean is_bigendian,
-                 bfd_boolean code);
+  void *(*fill) (bfd_size_type count, bool is_bigendian, bool code);
 
   const struct bfd_arch_info *next;
 
@@ -1998,11 +1996,11 @@ const bfd_arch_info_type *bfd_scan_arch (const char *string);
 const char **bfd_arch_list (void);
 
 const bfd_arch_info_type *bfd_arch_get_compatible
-   (const bfd *abfd, const bfd *bbfd, bfd_boolean accept_unknowns);
+   (const bfd *abfd, const bfd *bbfd, bool accept_unknowns);
 
 void bfd_set_arch_info (bfd *abfd, const bfd_arch_info_type *arg);
 
-bfd_boolean bfd_default_set_arch_mach
+bool bfd_default_set_arch_mach
    (bfd *abfd, enum bfd_architecture arch, unsigned long mach);
 
 enum bfd_architecture bfd_get_arch (const bfd *abfd);
@@ -2187,8 +2185,8 @@ struct reloc_howto_struct
   { (unsigned) type, size < 0 ? -size : size, bits, right, left, ovf,  \
     size < 0, pcrel, inplace, pcrel_off, src_mask, dst_mask, func, name }
 #define EMPTY_HOWTO(C) \
-  HOWTO ((C), 0, 0, 0, FALSE, 0, complain_overflow_dont, NULL, \
-         NULL, FALSE, 0, 0, FALSE)
+  HOWTO ((C), 0, 0, 0, false, 0, complain_overflow_dont, NULL, \
+         NULL, false, 0, 0, false)
 
 unsigned int bfd_get_reloc_size (reloc_howto_type *);
 
@@ -2206,7 +2204,7 @@ bfd_reloc_status_type bfd_check_overflow
     unsigned int addrsize,
     bfd_vma relocation);
 
-bfd_boolean bfd_reloc_offset_in_range
+bool bfd_reloc_offset_in_range
    (reloc_howto_type *howto,
     bfd *abfd,
     asection *section,
@@ -6440,14 +6438,14 @@ asymbol;
 #define bfd_get_symtab_upper_bound(abfd) \
        BFD_SEND (abfd, _bfd_get_symtab_upper_bound, (abfd))
 
-bfd_boolean bfd_is_local_label (bfd *abfd, asymbol *sym);
+bool bfd_is_local_label (bfd *abfd, asymbol *sym);
 
-bfd_boolean bfd_is_local_label_name (bfd *abfd, const char *name);
+bool bfd_is_local_label_name (bfd *abfd, const char *name);
 
 #define bfd_is_local_label_name(abfd, name) \
        BFD_SEND (abfd, _bfd_is_local_label_name, (abfd, name))
 
-bfd_boolean bfd_is_target_special_symbol (bfd *abfd, asymbol *sym);
+bool bfd_is_target_special_symbol (bfd *abfd, asymbol *sym);
 
 #define bfd_is_target_special_symbol(abfd, sym) \
        BFD_SEND (abfd, _bfd_is_target_special_symbol, (abfd, sym))
@@ -6455,7 +6453,7 @@ bfd_boolean bfd_is_target_special_symbol (bfd *abfd, asymbol *sym);
 #define bfd_canonicalize_symtab(abfd, location) \
        BFD_SEND (abfd, _bfd_canonicalize_symtab, (abfd, location))
 
-bfd_boolean bfd_set_symtab
+bool bfd_set_symtab
    (bfd *abfd, asymbol **location, unsigned int count);
 
 void bfd_print_symbol_vandf (bfd *abfd, void *file, asymbol *symbol);
@@ -6470,11 +6468,11 @@ asymbol *_bfd_generic_make_empty_symbol (bfd *);
 
 int bfd_decode_symclass (asymbol *symbol);
 
-bfd_boolean bfd_is_undefined_symclass (int symclass);
+bool bfd_is_undefined_symclass (int symclass);
 
 void bfd_symbol_info (asymbol *symbol, symbol_info *ret);
 
-bfd_boolean bfd_copy_private_symbol_data
+bool bfd_copy_private_symbol_data
    (bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym);
 
 #define bfd_copy_private_symbol_data(ibfd, isymbol, obfd, osymbol) \
@@ -6819,7 +6817,7 @@ bfd_get_filename (const bfd *abfd)
   return abfd->filename;
 }
 
-static inline bfd_boolean
+static inline bool
 bfd_get_cacheable (const bfd *abfd)
 {
   return abfd->cacheable;
@@ -6867,13 +6865,13 @@ bfd_count_sections (const bfd *abfd)
   return abfd->section_count;
 }
 
-static inline bfd_boolean
+static inline bool
 bfd_has_map (const bfd *abfd)
 {
   return abfd->has_armap;
 }
 
-static inline bfd_boolean
+static inline bool
 bfd_is_thin_archive (const bfd *abfd)
 {
   return abfd->is_thin_archive;
@@ -6886,15 +6884,15 @@ bfd_usrdata (const bfd *abfd)
 }
 
 /* See note beside bfd_set_section_userdata.  */
-static inline bfd_boolean
-bfd_set_cacheable (bfd * abfd, bfd_boolean val)
+static inline bool
+bfd_set_cacheable (bfd * abfd, bool val)
 {
   abfd->cacheable = val;
-  return TRUE;
+  return true;
 }
 
 static inline void
-bfd_set_thin_archive (bfd *abfd, bfd_boolean val)
+bfd_set_thin_archive (bfd *abfd, bool val)
 {
   abfd->is_thin_archive = val;
 }
@@ -7029,7 +7027,7 @@ bfd_section_list_insert_before (bfd *abfd, asection *b, asection *s)
     abfd->sections = s;
 }
 
-static inline bfd_boolean
+static inline bool
 bfd_section_removed_from_list (const bfd *abfd, const asection *s)
 {
   return s->next ? s->next->prev != s : abfd->section_last != s;
@@ -7101,13 +7099,13 @@ void bfd_set_reloc
 
 #define bfd_set_reloc(abfd, asect, location, count) \
        BFD_SEND (abfd, _bfd_set_reloc, (abfd, asect, location, count))
-bfd_boolean bfd_set_file_flags (bfd *abfd, flagword flags);
+bool bfd_set_file_flags (bfd *abfd, flagword flags);
 
 int bfd_get_arch_size (bfd *abfd);
 
 int bfd_get_sign_extend_vma (bfd *abfd);
 
-bfd_boolean bfd_set_start_address (bfd *abfd, bfd_vma vma);
+bool bfd_set_start_address (bfd *abfd, bfd_vma vma);
 
 unsigned int bfd_get_gp_size (bfd *abfd);
 
@@ -7115,17 +7113,17 @@ void bfd_set_gp_size (bfd *abfd, unsigned int i);
 
 bfd_vma bfd_scan_vma (const char *string, const char **end, int base);
 
-bfd_boolean bfd_copy_private_header_data (bfd *ibfd, bfd *obfd);
+bool bfd_copy_private_header_data (bfd *ibfd, bfd *obfd);
 
 #define bfd_copy_private_header_data(ibfd, obfd) \
        BFD_SEND (obfd, _bfd_copy_private_header_data, \
                  (ibfd, obfd))
-bfd_boolean bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd);
+bool bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd);
 
 #define bfd_copy_private_bfd_data(ibfd, obfd) \
        BFD_SEND (obfd, _bfd_copy_private_bfd_data, \
                  (ibfd, obfd))
-bfd_boolean bfd_set_private_flags (bfd *abfd, flagword flags);
+bool bfd_set_private_flags (bfd *abfd, flagword flags);
 
 #define bfd_set_private_flags(abfd, flags) \
        BFD_SEND (abfd, _bfd_set_private_flags, (abfd, flags))
@@ -7225,20 +7223,20 @@ bfd_boolean bfd_set_private_flags (bfd *abfd, flagword flags);
 
 extern bfd_byte *bfd_get_relocated_section_contents
   (bfd *, struct bfd_link_info *, struct bfd_link_order *, bfd_byte *,
-   bfd_boolean, asymbol **);
+   bool, asymbol **);
 
-bfd_boolean bfd_alt_mach_code (bfd *abfd, int alternative);
+bool bfd_alt_mach_code (bfd *abfd, int alternative);
 
 bfd_vma bfd_emul_get_maxpagesize (const char *);
 
-bfd_vma bfd_emul_get_commonpagesize (const char *, bfd_boolean);
+bfd_vma bfd_emul_get_commonpagesize (const char *, bool);
 
 char *bfd_demangle (bfd *, const char *, int);
 
 void bfd_update_compression_header
    (bfd *abfd, bfd_byte *contents, asection *sec);
 
-bfd_boolean bfd_check_compression_header
+bool bfd_check_compression_header
    (bfd *abfd, bfd_byte *contents, asection *sec,
     bfd_size_type *uncompressed_size,
     unsigned int *uncompressed_alignment_power);
@@ -7248,7 +7246,7 @@ int bfd_get_compression_header_size (bfd *abfd, asection *sec);
 bfd_size_type bfd_convert_section_size
    (bfd *ibfd, asection *isec, bfd *obfd, bfd_size_type size);
 
-bfd_boolean bfd_convert_section_contents
+bool bfd_convert_section_contents
    (bfd *ibfd, asection *isec, bfd *obfd,
     bfd_byte **ptr, bfd_size_type *ptr_size);
 
@@ -7256,7 +7254,7 @@ bfd_boolean bfd_convert_section_contents
 symindex bfd_get_next_mapent
    (bfd *abfd, symindex previous, carsym **sym);
 
-bfd_boolean bfd_set_archive_head (bfd *output, bfd *new_head);
+bool bfd_set_archive_head (bfd *output, bfd *new_head);
 
 bfd *bfd_openr_next_archived_file (bfd *archive, bfd *previous);
 
@@ -7267,10 +7265,10 @@ int bfd_core_file_failing_signal (bfd *abfd);
 
 int bfd_core_file_pid (bfd *abfd);
 
-bfd_boolean core_file_matches_executable_p
+bool core_file_matches_executable_p
    (bfd *core_bfd, bfd *exec_bfd);
 
-bfd_boolean generic_core_file_matches_executable_p
+bool generic_core_file_matches_executable_p
    (bfd *core_bfd, bfd *exec_bfd);
 
 /* Extracted from targets.c.  */
@@ -7297,7 +7295,7 @@ bfd_boolean generic_core_file_matches_executable_p
 
 /* Defined to TRUE if unused section symbol should be kept.  */
 #ifndef TARGET_KEEP_UNUSED_SECTION_SYMBOLS
-#define TARGET_KEEP_UNUSED_SECTION_SYMBOLS TRUE
+#define TARGET_KEEP_UNUSED_SECTION_SYMBOLS true
 #endif
 
 enum bfd_flavour
@@ -7374,7 +7372,7 @@ typedef struct bfd_target
   unsigned char match_priority;
 
  /* TRUE if unused section symbols should be kept.  */
-  bfd_boolean keep_unused_section_symbols;
+  bool keep_unused_section_symbols;
 
   /* Entries for byte swapping for data. These are different from the
      other entry points, since they don't take a BFD as the first argument.
@@ -7408,10 +7406,10 @@ typedef struct bfd_target
   bfd_cleanup (*_bfd_check_format[bfd_type_end]) (bfd *);
 
   /* Set the format of a file being written.  */
-  bfd_boolean (*_bfd_set_format[bfd_type_end]) (bfd *);
+  bool (*_bfd_set_format[bfd_type_end]) (bfd *);
 
   /* Write cached information into a file being written, at <<bfd_close>>.  */
-  bfd_boolean (*_bfd_write_contents[bfd_type_end]) (bfd *);
+  bool (*_bfd_write_contents[bfd_type_end]) (bfd *);
 
 
   /* Generic entry points.  */
@@ -7423,17 +7421,16 @@ typedef struct bfd_target
   NAME##_get_section_contents_in_window
 
   /* Called when the BFD is being closed to do any necessary cleanup.  */
-  bfd_boolean (*_close_and_cleanup) (bfd *);
+  bool (*_close_and_cleanup) (bfd *);
   /* Ask the BFD to free all cached information.  */
-  bfd_boolean (*_bfd_free_cached_info) (bfd *);
+  bool (*_bfd_free_cached_info) (bfd *);
   /* Called when a new section is created.  */
-  bfd_boolean (*_new_section_hook) (bfd *, sec_ptr);
+  bool (*_new_section_hook) (bfd *, sec_ptr);
   /* Read the contents of a section.  */
-  bfd_boolean (*_bfd_get_section_contents) (bfd *, sec_ptr, void *, file_ptr,
-                                            bfd_size_type);
-  bfd_boolean (*_bfd_get_section_contents_in_window) (bfd *, sec_ptr,
-                                                      bfd_window *, file_ptr,
-                                                      bfd_size_type);
+  bool (*_bfd_get_section_contents) (bfd *, sec_ptr, void *, file_ptr,
+                                     bfd_size_type);
+  bool (*_bfd_get_section_contents_in_window) (bfd *, sec_ptr, bfd_window *,
+                                               file_ptr, bfd_size_type);
 
   /* Entry points to copy private data.  */
 #define BFD_JUMP_TABLE_COPY(NAME) \
@@ -7448,34 +7445,32 @@ typedef struct bfd_target
 
   /* Called to copy BFD general private data from one object file
      to another.  */
-  bfd_boolean (*_bfd_copy_private_bfd_data) (bfd *, bfd *);
+  bool (*_bfd_copy_private_bfd_data) (bfd *, bfd *);
   /* Called to merge BFD general private data from one object file
      to a common output file when linking.  */
-  bfd_boolean (*_bfd_merge_private_bfd_data) (bfd *, struct bfd_link_info *);
+  bool (*_bfd_merge_private_bfd_data) (bfd *, struct bfd_link_info *);
   /* Called to initialize BFD private section data from one object file
      to another.  */
 #define bfd_init_private_section_data(ibfd, isec, obfd, osec, link_info) \
        BFD_SEND (obfd, _bfd_init_private_section_data, \
                  (ibfd, isec, obfd, osec, link_info))
-  bfd_boolean (*_bfd_init_private_section_data) (bfd *, sec_ptr, bfd *,
-                                                 sec_ptr,
-                                                 struct bfd_link_info *);
+  bool (*_bfd_init_private_section_data) (bfd *, sec_ptr, bfd *, sec_ptr,
+                                          struct bfd_link_info *);
   /* Called to copy BFD private section data from one object file
      to another.  */
-  bfd_boolean (*_bfd_copy_private_section_data) (bfd *, sec_ptr, bfd *,
-                                                 sec_ptr);
+  bool (*_bfd_copy_private_section_data) (bfd *, sec_ptr, bfd *, sec_ptr);
   /* Called to copy BFD private symbol data from one symbol
      to another.  */
-  bfd_boolean (*_bfd_copy_private_symbol_data) (bfd *, asymbol *, bfd *,
-                                                asymbol *);
+  bool (*_bfd_copy_private_symbol_data) (bfd *, asymbol *,
+                                         bfd *, asymbol *);
   /* Called to copy BFD private header data from one object file
      to another.  */
-  bfd_boolean (*_bfd_copy_private_header_data) (bfd *, bfd *);
+  bool (*_bfd_copy_private_header_data) (bfd *, bfd *);
   /* Called to set private backend flags.  */
-  bfd_boolean (*_bfd_set_private_flags) (bfd *, flagword);
+  bool (*_bfd_set_private_flags) (bfd *, flagword);
 
   /* Called to print private BFD data.  */
-  bfd_boolean (*_bfd_print_private_bfd_data) (bfd *, void *);
+  bool (*_bfd_print_private_bfd_data) (bfd *, void *);
 
   /* Core file entry points.  */
 #define BFD_JUMP_TABLE_CORE(NAME) \
@@ -7484,10 +7479,10 @@ typedef struct bfd_target
   NAME##_core_file_matches_executable_p, \
   NAME##_core_file_pid
 
-  char *      (*_core_file_failing_command) (bfd *);
-  int         (*_core_file_failing_signal) (bfd *);
-  bfd_boolean (*_core_file_matches_executable_p) (bfd *, bfd *);
-  int         (*_core_file_pid) (bfd *);
+  char *(*_core_file_failing_command) (bfd *);
+  int   (*_core_file_failing_signal) (bfd *);
+  bool  (*_core_file_matches_executable_p) (bfd *, bfd *);
+  int   (*_core_file_pid) (bfd *);
 
   /* Archive entry points.  */
 #define BFD_JUMP_TABLE_ARCHIVE(NAME) \
@@ -7503,22 +7498,21 @@ typedef struct bfd_target
   NAME##_generic_stat_arch_elt, \
   NAME##_update_armap_timestamp
 
-  bfd_boolean (*_bfd_slurp_armap) (bfd *);
-  bfd_boolean (*_bfd_slurp_extended_name_table) (bfd *);
-  bfd_boolean (*_bfd_construct_extended_name_table) (bfd *, char **,
-                                                     bfd_size_type *,
-                                                     const char **);
-  void        (*_bfd_truncate_arname) (bfd *, const char *, char *);
-  bfd_boolean (*write_armap) (bfd *, unsigned int, struct orl *,
-                              unsigned int, int);
-  void *      (*_bfd_read_ar_hdr_fn) (bfd *);
-  bfd_boolean (*_bfd_write_ar_hdr_fn) (bfd *, bfd *);
-  bfd *       (*openr_next_archived_file) (bfd *, bfd *);
+  bool (*_bfd_slurp_armap) (bfd *);
+  bool (*_bfd_slurp_extended_name_table) (bfd *);
+  bool (*_bfd_construct_extended_name_table) (bfd *, char **,
+                                              bfd_size_type *,
+                                              const char **);
+  void (*_bfd_truncate_arname) (bfd *, const char *, char *);
+  bool (*write_armap) (bfd *, unsigned, struct orl *, unsigned, int);
+  void *(*_bfd_read_ar_hdr_fn) (bfd *);
+  bool (*_bfd_write_ar_hdr_fn) (bfd *, bfd *);
+  bfd *(*openr_next_archived_file) (bfd *, bfd *);
 #define bfd_get_elt_at_index(b,i) \
        BFD_SEND (b, _bfd_get_elt_at_index, (b,i))
-  bfd *       (*_bfd_get_elt_at_index) (bfd *, symindex);
-  int         (*_bfd_stat_arch_elt) (bfd *, struct stat *);
-  bfd_boolean (*_bfd_update_armap_timestamp) (bfd *);
+  bfd *(*_bfd_get_elt_at_index) (bfd *, symindex);
+  int  (*_bfd_stat_arch_elt) (bfd *, struct stat *);
+  bool (*_bfd_update_armap_timestamp) (bfd *);
 
   /* Entry points used for symbols.  */
 #define BFD_JUMP_TABLE_SYMBOLS(NAME) \
@@ -7538,47 +7532,47 @@ typedef struct bfd_target
   NAME##_read_minisymbols, \
   NAME##_minisymbol_to_symbol
 
-  long        (*_bfd_get_symtab_upper_bound) (bfd *);
-  long        (*_bfd_canonicalize_symtab) (bfd *, struct bfd_symbol **);
+  long (*_bfd_get_symtab_upper_bound) (bfd *);
+  long (*_bfd_canonicalize_symtab) (bfd *, struct bfd_symbol **);
   struct bfd_symbol *
-              (*_bfd_make_empty_symbol) (bfd *);
-  void        (*_bfd_print_symbol) (bfd *, void *, struct bfd_symbol *,
-                                    bfd_print_symbol_type);
+       (*_bfd_make_empty_symbol) (bfd *);
+  void (*_bfd_print_symbol) (bfd *, void *, struct bfd_symbol *,
+                             bfd_print_symbol_type);
 #define bfd_print_symbol(b,p,s,e) \
        BFD_SEND (b, _bfd_print_symbol, (b,p,s,e))
-  void        (*_bfd_get_symbol_info) (bfd *, struct bfd_symbol *,
-                                       symbol_info *);
+  void  (*_bfd_get_symbol_info) (bfd *, struct bfd_symbol *, symbol_info *);
 #define bfd_get_symbol_info(b,p,e) \
        BFD_SEND (b, _bfd_get_symbol_info, (b,p,e))
-  const char *(*_bfd_get_symbol_version_string) (bfd *, struct bfd_symbol *,
-                                                 bfd_boolean,
-                                                 bfd_boolean *);
+  const char *
+       (*_bfd_get_symbol_version_string) (bfd *, struct bfd_symbol *,
+                                          bool, bool *);
 #define bfd_get_symbol_version_string(b,s,p,h) \
        BFD_SEND (b, _bfd_get_symbol_version_string, (b,s,p,h))
-  bfd_boolean (*_bfd_is_local_label_name) (bfd *, const char *);
-  bfd_boolean (*_bfd_is_target_special_symbol) (bfd *, asymbol *);
-  alent *     (*_get_lineno) (bfd *, struct bfd_symbol *);
-  bfd_boolean (*_bfd_find_nearest_line) (bfd *, struct bfd_symbol **,
-                                         struct bfd_section *, bfd_vma,
-                                         const char **, const char **,
-                                         unsigned int *, unsigned int *);
-  bfd_boolean (*_bfd_find_line) (bfd *, struct bfd_symbol **,
-                                 struct bfd_symbol *, const char **,
-                                 unsigned int *);
-  bfd_boolean (*_bfd_find_inliner_info)
+  bool (*_bfd_is_local_label_name) (bfd *, const char *);
+  bool (*_bfd_is_target_special_symbol) (bfd *, asymbol *);
+  alent *
+       (*_get_lineno) (bfd *, struct bfd_symbol *);
+  bool (*_bfd_find_nearest_line) (bfd *, struct bfd_symbol **,
+                                  struct bfd_section *, bfd_vma,
+                                  const char **, const char **,
+                                  unsigned int *, unsigned int *);
+  bool (*_bfd_find_line) (bfd *, struct bfd_symbol **,
+                          struct bfd_symbol *, const char **,
+                          unsigned int *);
+  bool (*_bfd_find_inliner_info)
     (bfd *, const char **, const char **, unsigned int *);
  /* Back-door to allow format-aware applications to create debug symbols
     while using BFD for everything else.  Currently used by the assembler
     when creating COFF files.  */
-  asymbol *   (*_bfd_make_debug_symbol) (bfd *, void *, unsigned long size);
+  asymbol *
+       (*_bfd_make_debug_symbol) (bfd *, void *, unsigned long size);
 #define bfd_read_minisymbols(b, d, m, s) \
        BFD_SEND (b, _read_minisymbols, (b, d, m, s))
-  long        (*_read_minisymbols) (bfd *, bfd_boolean, void **,
-                                    unsigned int *);
+  long (*_read_minisymbols) (bfd *, bool, void **, unsigned int *);
 #define bfd_minisymbol_to_symbol(b, d, m, f) \
        BFD_SEND (b, _minisymbol_to_symbol, (b, d, m, f))
-  asymbol *   (*_minisymbol_to_symbol) (bfd *, bfd_boolean, const void *,
-                                        asymbol *);
+  asymbol *
+       (*_minisymbol_to_symbol) (bfd *, bool, const void *, asymbol *);
 
   /* Routines for relocs.  */
 #define BFD_JUMP_TABLE_RELOCS(NAME) \
@@ -7588,25 +7582,25 @@ typedef struct bfd_target
   NAME##_bfd_reloc_type_lookup, \
   NAME##_bfd_reloc_name_lookup
 
-  long        (*_get_reloc_upper_bound) (bfd *, sec_ptr);
-  long        (*_bfd_canonicalize_reloc) (bfd *, sec_ptr, arelent **,
-                                          struct bfd_symbol **);
-  void        (*_bfd_set_reloc) (bfd *, sec_ptr, arelent **, unsigned int);
+  long (*_get_reloc_upper_bound) (bfd *, sec_ptr);
+  long (*_bfd_canonicalize_reloc) (bfd *, sec_ptr, arelent **,
+                                   struct bfd_symbol **);
+  void (*_bfd_set_reloc) (bfd *, sec_ptr, arelent **, unsigned int);
   /* See documentation on reloc types.  */
   reloc_howto_type *
-              (*reloc_type_lookup) (bfd *, bfd_reloc_code_real_type);
+       (*reloc_type_lookup) (bfd *, bfd_reloc_code_real_type);
   reloc_howto_type *
-              (*reloc_name_lookup) (bfd *, const char *);
+       (*reloc_name_lookup) (bfd *, const char *);
 
   /* Routines used when writing an object file.  */
 #define BFD_JUMP_TABLE_WRITE(NAME) \
   NAME##_set_arch_mach, \
   NAME##_set_section_contents
 
-  bfd_boolean (*_bfd_set_arch_mach) (bfd *, enum bfd_architecture,
+  bool (*_bfd_set_arch_mach) (bfd *, enum bfd_architecture,
                                      unsigned long);
-  bfd_boolean (*_bfd_set_section_contents) (bfd *, sec_ptr, const void *,
-                                            file_ptr, bfd_size_type);
+  bool (*_bfd_set_section_contents) (bfd *, sec_ptr, const void *,
+                                     file_ptr, bfd_size_type);
 
   /* Routines used by the linker.  */
 #define BFD_JUMP_TABLE_LINK(NAME) \
@@ -7631,72 +7625,73 @@ typedef struct bfd_target
   NAME##_bfd_link_hide_symbol, \
   NAME##_bfd_define_start_stop
 
-  int         (*_bfd_sizeof_headers) (bfd *, struct bfd_link_info *);
-  bfd_byte *  (*_bfd_get_relocated_section_contents) (bfd *,
-                                                      struct bfd_link_info *,
-                                                      struct bfd_link_order *,
-                                                      bfd_byte *, bfd_boolean,
-                                                      struct bfd_symbol **);
+  int  (*_bfd_sizeof_headers) (bfd *, struct bfd_link_info *);
+  bfd_byte *
+       (*_bfd_get_relocated_section_contents) (bfd *,
+                                               struct bfd_link_info *,
+                                               struct bfd_link_order *,
+                                               bfd_byte *, bool,
+                                               struct bfd_symbol **);
 
-  bfd_boolean (*_bfd_relax_section) (bfd *, struct bfd_section *,
-                                     struct bfd_link_info *, bfd_boolean *);
+  bool (*_bfd_relax_section) (bfd *, struct bfd_section *,
+                              struct bfd_link_info *, bool *);
 
   /* Create a hash table for the linker.  Different backends store
      different information in this table.  */
   struct bfd_link_hash_table *
-              (*_bfd_link_hash_table_create) (bfd *);
+       (*_bfd_link_hash_table_create) (bfd *);
 
   /* Add symbols from this object file into the hash table.  */
-  bfd_boolean (*_bfd_link_add_symbols) (bfd *, struct bfd_link_info *);
+  bool (*_bfd_link_add_symbols) (bfd *, struct bfd_link_info *);
 
   /* Indicate that we are only retrieving symbol values from this section.  */
-  void        (*_bfd_link_just_syms) (asection *, struct bfd_link_info *);
+  void (*_bfd_link_just_syms) (asection *, struct bfd_link_info *);
 
   /* Copy the symbol type and other attributes for a linker script
      assignment of one symbol to another.  */
 #define bfd_copy_link_hash_symbol_type(b, t, f) \
        BFD_SEND (b, _bfd_copy_link_hash_symbol_type, (b, t, f))
-  void        (*_bfd_copy_link_hash_symbol_type) (bfd *,
-                                                  struct bfd_link_hash_entry *,
-                                                  struct bfd_link_hash_entry *);
+  void (*_bfd_copy_link_hash_symbol_type) (bfd *,
+                                           struct bfd_link_hash_entry *,
+                                           struct bfd_link_hash_entry *);
 
   /* Do a link based on the link_order structures attached to each
      section of the BFD.  */
-  bfd_boolean (*_bfd_final_link) (bfd *, struct bfd_link_info *);
+  bool (*_bfd_final_link) (bfd *, struct bfd_link_info *);
 
   /* Should this section be split up into smaller pieces during linking.  */
-  bfd_boolean (*_bfd_link_split_section) (bfd *, struct bfd_section *);
+  bool (*_bfd_link_split_section) (bfd *, struct bfd_section *);
 
   /* Check the relocations in the bfd for validity.  */
-  bfd_boolean (* _bfd_link_check_relocs)(bfd *, struct bfd_link_info *);
+  bool (* _bfd_link_check_relocs)(bfd *, struct bfd_link_info *);
 
   /* Remove sections that are not referenced from the output.  */
-  bfd_boolean (*_bfd_gc_sections) (bfd *, struct bfd_link_info *);
+  bool (*_bfd_gc_sections) (bfd *, struct bfd_link_info *);
 
   /* Sets the bitmask of allowed and disallowed section flags.  */
-  bfd_boolean (*_bfd_lookup_section_flags) (struct bfd_link_info *,
-                                            struct flag_info *, asection *);
+  bool (*_bfd_lookup_section_flags) (struct bfd_link_info *,
+                                     struct flag_info *, asection *);
 
   /* Attempt to merge SEC_MERGE sections.  */
-  bfd_boolean (*_bfd_merge_sections) (bfd *, struct bfd_link_info *);
+  bool (*_bfd_merge_sections) (bfd *, struct bfd_link_info *);
 
   /* Is this section a member of a group?  */
-  bfd_boolean (*_bfd_is_group_section) (bfd *, const struct bfd_section *);
+  bool (*_bfd_is_group_section) (bfd *, const struct bfd_section *);
 
   /* The group name, if section is a member of a group.  */
   const char *(*_bfd_group_name) (bfd *, const struct bfd_section *);
 
   /* Discard members of a group.  */
-  bfd_boolean (*_bfd_discard_group) (bfd *, struct bfd_section *);
+  bool (*_bfd_discard_group) (bfd *, struct bfd_section *);
 
   /* Check if SEC has been already linked during a reloceatable or
      final link.  */
-  bfd_boolean (*_section_already_linked) (bfd *, asection *,
-                                          struct bfd_link_info *);
+  bool (*_section_already_linked) (bfd *, asection *,
+                                   struct bfd_link_info *);
 
   /* Define a common symbol.  */
-  bfd_boolean (*_bfd_define_common_symbol) (bfd *, struct bfd_link_info *,
-                                            struct bfd_link_hash_entry *);
+  bool (*_bfd_define_common_symbol) (bfd *, struct bfd_link_info *,
+                                     struct bfd_link_hash_entry *);
 
   /* Hide a symbol.  */
   void (*_bfd_link_hide_symbol) (bfd *, struct bfd_link_info *,
@@ -7704,8 +7699,8 @@ typedef struct bfd_target
 
   /* Define a __start, __stop, .startof. or .sizeof. symbol.  */
   struct bfd_link_hash_entry *
-              (*_bfd_define_start_stop) (struct bfd_link_info *, const char *,
-                                         asection *);
+       (*_bfd_define_start_stop) (struct bfd_link_info *, const char *,
+                                  asection *);
 
   /* Routines to handle dynamic symbols and relocs.  */
 #define BFD_JUMP_TABLE_DYNAMIC(NAME) \
@@ -7716,18 +7711,18 @@ typedef struct bfd_target
   NAME##_canonicalize_dynamic_reloc
 
   /* Get the amount of memory required to hold the dynamic symbols.  */
-  long        (*_bfd_get_dynamic_symtab_upper_bound) (bfd *);
+  long (*_bfd_get_dynamic_symtab_upper_bound) (bfd *);
   /* Read in the dynamic symbols.  */
-  long        (*_bfd_canonicalize_dynamic_symtab) (bfd *, struct bfd_symbol **);
+  long (*_bfd_canonicalize_dynamic_symtab) (bfd *, struct bfd_symbol **);
   /* Create synthetized symbols.  */
-  long        (*_bfd_get_synthetic_symtab) (bfd *, long, struct bfd_symbol **,
-                                            long, struct bfd_symbol **,
-                                            struct bfd_symbol **);
+  long (*_bfd_get_synthetic_symtab) (bfd *, long, struct bfd_symbol **,
+                                     long, struct bfd_symbol **,
+                                     struct bfd_symbol **);
   /* Get the amount of memory required to hold the dynamic relocs.  */
-  long        (*_bfd_get_dynamic_reloc_upper_bound) (bfd *);
+  long (*_bfd_get_dynamic_reloc_upper_bound) (bfd *);
   /* Read in the dynamic relocs.  */
-  long        (*_bfd_canonicalize_dynamic_reloc) (bfd *, arelent **,
-                                                  struct bfd_symbol **);
+  long (*_bfd_canonicalize_dynamic_reloc) (bfd *, arelent **,
+                                           struct bfd_symbol **);
 
   /* Opposite endian version of this target.  */
   const struct bfd_target *alternative_target;
@@ -7756,31 +7751,31 @@ bfd_applicable_file_flags (const bfd *abfd)
   return abfd->xvec->object_flags;
 }
 
-static inline bfd_boolean
+static inline bool
 bfd_family_coff (const bfd *abfd)
 {
   return (bfd_get_flavour (abfd) == bfd_target_coff_flavour
           || bfd_get_flavour (abfd) == bfd_target_xcoff_flavour);
 }
 
-static inline bfd_boolean
+static inline bool
 bfd_big_endian (const bfd *abfd)
 {
   return abfd->xvec->byteorder == BFD_ENDIAN_BIG;
 }
-static inline bfd_boolean
+static inline bool
 bfd_little_endian (const bfd *abfd)
 {
   return abfd->xvec->byteorder == BFD_ENDIAN_LITTLE;
 }
 
-static inline bfd_boolean
+static inline bool
 bfd_header_big_endian (const bfd *abfd)
 {
   return abfd->xvec->header_byteorder == BFD_ENDIAN_BIG;
 }
 
-static inline bfd_boolean
+static inline bool
 bfd_header_little_endian (const bfd *abfd)
 {
   return abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE;
@@ -7806,19 +7801,19 @@ bfd_asymbol_flavour (const asymbol *sy)
   return sy->the_bfd->xvec->flavour;
 }
 
-static inline bfd_boolean
+static inline bool
 bfd_keep_unused_section_symbols (const bfd *abfd)
 {
   return abfd->xvec->keep_unused_section_symbols;
 }
 
-bfd_boolean bfd_set_default_target (const char *name);
+bool bfd_set_default_target (const char *name);
 
 const bfd_target *bfd_find_target (const char *target_name, bfd *abfd);
 
 const bfd_target *bfd_get_target_info (const char *target_name,
     bfd *abfd,
-    bfd_boolean *is_bigendian,
+    bool *is_bigendian,
     int *underscoring,
     const char **def_target_arch);
 const char ** bfd_target_list (void);
@@ -7830,12 +7825,12 @@ const bfd_target *bfd_iterate_over_targets
 const char *bfd_flavour_name (enum bfd_flavour flavour);
 
 /* Extracted from format.c.  */
-bfd_boolean bfd_check_format (bfd *abfd, bfd_format format);
+bool bfd_check_format (bfd *abfd, bfd_format format);
 
-bfd_boolean bfd_check_format_matches
+bool bfd_check_format_matches
    (bfd *abfd, bfd_format format, char ***matching);
 
-bfd_boolean bfd_set_format (bfd *abfd, bfd_format format);
+bool bfd_set_format (bfd *abfd, bfd_format format);
 
 const char *bfd_format_string (bfd_format format);
 
@@ -7851,19 +7846,19 @@ const char *bfd_format_string (bfd_format format);
    && bfd_is_abs_section ((H)->u.def.section) \
    && !(H)->rel_from_abs)
 
-bfd_boolean bfd_link_split_section (bfd *abfd, asection *sec);
+bool bfd_link_split_section (bfd *abfd, asection *sec);
 
 #define bfd_link_split_section(abfd, sec) \
        BFD_SEND (abfd, _bfd_link_split_section, (abfd, sec))
 
-bfd_boolean bfd_section_already_linked (bfd *abfd,
+bool bfd_section_already_linked (bfd *abfd,
     asection *sec,
     struct bfd_link_info *info);
 
 #define bfd_section_already_linked(abfd, sec, info) \
        BFD_SEND (abfd, _section_already_linked, (abfd, sec, info))
 
-bfd_boolean bfd_generic_define_common_symbol
+bool bfd_generic_define_common_symbol
    (bfd *output_bfd, struct bfd_link_info *info,
     struct bfd_link_hash_entry *h);
 
@@ -7886,18 +7881,18 @@ struct bfd_link_hash_entry *bfd_generic_define_start_stop
 
 struct bfd_elf_version_tree * bfd_find_version_for_sym
    (struct bfd_elf_version_tree *verdefs,
-    const char *sym_name, bfd_boolean *hide);
+    const char *sym_name, bool *hide);
 
-bfd_boolean bfd_hide_sym_by_version
+bool bfd_hide_sym_by_version
    (struct bfd_elf_version_tree *verdefs, const char *sym_name);
 
-bfd_boolean bfd_link_check_relocs
+bool bfd_link_check_relocs
    (bfd *abfd, struct bfd_link_info *info);
 
-bfd_boolean _bfd_generic_link_check_relocs
+bool _bfd_generic_link_check_relocs
    (bfd *abfd, struct bfd_link_info *info);
 
-bfd_boolean bfd_merge_private_bfd_data
+bool bfd_merge_private_bfd_data
    (bfd *ibfd, struct bfd_link_info *info);
 
 #define bfd_merge_private_bfd_data(ibfd, info) \
@@ -7908,28 +7903,28 @@ bfd_byte *bfd_simple_get_relocated_section_contents
    (bfd *abfd, asection *sec, bfd_byte *outbuf, asymbol **symbol_table);
 
 /* Extracted from compress.c.  */
-bfd_boolean bfd_get_full_section_contents
+bool bfd_get_full_section_contents
    (bfd *abfd, asection *section, bfd_byte **ptr);
 
 void bfd_cache_section_contents
    (asection *sec, void *contents);
 
-bfd_boolean bfd_is_section_compressed_with_header
+bool bfd_is_section_compressed_with_header
    (bfd *abfd, asection *section,
     int *compression_header_size_p,
     bfd_size_type *uncompressed_size_p,
     unsigned int *uncompressed_alignment_power_p);
 
-bfd_boolean bfd_is_section_compressed
+bool bfd_is_section_compressed
    (bfd *abfd, asection *section);
 
-bfd_boolean bfd_init_section_decompress_status
+bool bfd_init_section_decompress_status
    (bfd *abfd, asection *section);
 
-bfd_boolean bfd_init_section_compress_status
+bool bfd_init_section_compress_status
    (bfd *abfd, asection *section);
 
-bfd_boolean bfd_compress_section
+bool bfd_compress_section
    (bfd *abfd, asection *section, bfd_byte *uncompressed_buffer);
 
 #ifdef __cplusplus