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

diff --git a/bfd/dwarf2.c b/bfd/dwarf2.c
index dbaec40..0a8a557 100644
--- a/bfd/dwarf2.c
+++ b/bfd/dwarf2.c
@@ -202,7 +202,7 @@ struct dwarf2_debug
 #define STASH_INFO_HASH_DISABLED   2
 
   /* True if we opened bfd_ptr.  */
-  bfd_boolean close_on_cleanup;
+  bool close_on_cleanup;
 };
 
 struct arange
@@ -295,7 +295,7 @@ struct comp_unit
   bfd_vma base_address;
 
   /* TRUE if symbols are cached in hash table for faster lookup by name.  */
-  bfd_boolean cached;
+  bool cached;
 };
 
 /* This data structure holds the information of an abbrev.  */
@@ -303,7 +303,7 @@ struct abbrev_info
 {
   unsigned int         number;		/* Number identifying abbrev.  */
   enum dwarf_tag       tag;		/* DWARF tag.  */
-  bfd_boolean          has_children;	/* TRUE if the abbrev has children.  */
+  bool                 has_children;	/* TRUE if the abbrev has children.  */
   unsigned int         num_attrs;	/* Number of attributes.  */
   struct attr_abbrev * attrs;		/* An array of attribute descriptions.  */
   struct abbrev_info * next;		/* Next in chain.  */
@@ -478,30 +478,30 @@ create_info_hash_table (bfd *abfd)
    right type of info in inserted as info is passed as a void* pointer.
    This function returns true if there is no error.  */
 
-static bfd_boolean
+static bool
 insert_info_hash_table (struct info_hash_table *hash_table,
 			const char *key,
 			void *info,
-			bfd_boolean copy_p)
+			bool copy_p)
 {
   struct info_hash_entry *entry;
   struct info_list_node *node;
 
   entry = (struct info_hash_entry*) bfd_hash_lookup (&hash_table->base,
-						     key, TRUE, copy_p);
+						     key, true, copy_p);
   if (!entry)
-    return FALSE;
+    return false;
 
   node = (struct info_list_node *) bfd_hash_allocate (&hash_table->base,
 						      sizeof (*node));
   if (!node)
-    return FALSE;
+    return false;
 
   node->info = info;
   node->next = entry->head;
   entry->head = node;
 
-  return TRUE;
+  return true;
 }
 
 /* Look up an info entry list from an info hash table.  Return NULL
@@ -513,7 +513,7 @@ lookup_info_hash_table (struct info_hash_table *hash_table, const char *key)
   struct info_hash_entry *entry;
 
   entry = (struct info_hash_entry*) bfd_hash_lookup (&hash_table->base, key,
-						     FALSE, FALSE);
+						     false, false);
   return entry ? entry->head : NULL;
 }
 
@@ -523,7 +523,7 @@ lookup_info_hash_table (struct info_hash_table *hash_table, const char *key)
    section contents, otherwise use bfd_get_section_contents.  Fail if
    the located section does not contain at least OFFSET bytes.  */
 
-static bfd_boolean
+static bool
 read_section (bfd *	      abfd,
 	      const struct dwarf_debug_section *sec,
 	      asymbol **      syms,
@@ -553,7 +553,7 @@ read_section (bfd *	      abfd,
 	  _bfd_error_handler (_("DWARF error: can't find %s section."),
 			      sec->uncompressed_name);
 	  bfd_set_error (bfd_error_bad_value);
-	  return FALSE;
+	  return false;
 	}
 
       amt = bfd_get_section_limit_octets (abfd, msec);
@@ -564,7 +564,7 @@ read_section (bfd *	      abfd,
 	  _bfd_error_handler (_("DWARF error: section %s is larger than its filesize! (0x%lx vs 0x%lx)"),
 			      section_name, (long) amt, (long) filesize);
 	  bfd_set_error (bfd_error_bad_value);
-	  return FALSE;
+	  return false;
 	}
       *section_size = amt;
       /* Paranoia - alloc one extra so that we can make sure a string
@@ -574,18 +574,18 @@ read_section (bfd *	      abfd,
 	{
 	  /* Paranoia - this should never happen.  */
 	  bfd_set_error (bfd_error_no_memory);
-	  return FALSE;
+	  return false;
 	}
       contents = (bfd_byte *) bfd_malloc (amt);
       if (contents == NULL)
-	return FALSE;
+	return false;
       if (syms
 	  ? !bfd_simple_get_relocated_section_contents (abfd, msec, contents,
 							syms)
 	  : !bfd_get_section_contents (abfd, msec, contents, 0, *section_size))
 	{
 	  free (contents);
-	  return FALSE;
+	  return false;
 	}
       contents[*section_size] = 0;
       *section_buffer = contents;
@@ -601,10 +601,10 @@ read_section (bfd *	      abfd,
 			  (uint64_t) offset, section_name,
 			  (uint64_t) *section_size);
       bfd_set_error (bfd_error_bad_value);
-      return FALSE;
+      return false;
     }
 
-  return TRUE;
+  return true;
 }
 
 /* Read dwarf information from a buffer.  */
@@ -1043,7 +1043,7 @@ read_abbrevs (bfd *abfd, bfd_uint64_t offset, struct dwarf2_debug *stash,
   abbrev_ptr = file->dwarf_abbrev_buffer + offset;
   abbrev_end = file->dwarf_abbrev_buffer + file->dwarf_abbrev_size;
   abbrev_number = _bfd_safe_read_leb128 (abfd, abbrev_ptr, &bytes_read,
-					 FALSE, abbrev_end);
+					 false, abbrev_end);
   abbrev_ptr += bytes_read;
 
   /* Loop until we reach an abbrev number of 0.  */
@@ -1058,7 +1058,7 @@ read_abbrevs (bfd *abfd, bfd_uint64_t offset, struct dwarf2_debug *stash,
       cur_abbrev->number = abbrev_number;
       cur_abbrev->tag = (enum dwarf_tag)
 	_bfd_safe_read_leb128 (abfd, abbrev_ptr, &bytes_read,
-			       FALSE, abbrev_end);
+			       false, abbrev_end);
       abbrev_ptr += bytes_read;
       cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr, abbrev_end);
       abbrev_ptr += 1;
@@ -1070,15 +1070,15 @@ read_abbrevs (bfd *abfd, bfd_uint64_t offset, struct dwarf2_debug *stash,
 	  bfd_vma implicit_const = -1;
 
 	  abbrev_name = _bfd_safe_read_leb128 (abfd, abbrev_ptr, &bytes_read,
-					       FALSE, abbrev_end);
+					       false, abbrev_end);
 	  abbrev_ptr += bytes_read;
 	  abbrev_form = _bfd_safe_read_leb128 (abfd, abbrev_ptr, &bytes_read,
-					       FALSE, abbrev_end);
+					       false, abbrev_end);
 	  abbrev_ptr += bytes_read;
 	  if (abbrev_form == DW_FORM_implicit_const)
 	    {
 	      implicit_const = _bfd_safe_read_leb128 (abfd, abbrev_ptr,
-						      &bytes_read, TRUE,
+						      &bytes_read, true,
 						      abbrev_end);
 	      abbrev_ptr += bytes_read;
 	    }
@@ -1122,7 +1122,7 @@ read_abbrevs (bfd *abfd, bfd_uint64_t offset, struct dwarf2_debug *stash,
 	  >= file->dwarf_abbrev_size)
 	break;
       abbrev_number = _bfd_safe_read_leb128 (abfd, abbrev_ptr,
-					     &bytes_read, FALSE, abbrev_end);
+					     &bytes_read, false, abbrev_end);
       abbrev_ptr += bytes_read;
       if (lookup_abbrev (abbrev_number, abbrevs) != NULL)
 	break;
@@ -1157,7 +1157,7 @@ read_abbrevs (bfd *abfd, bfd_uint64_t offset, struct dwarf2_debug *stash,
 
 /* Returns true if the form is one which has a string value.  */
 
-static inline bfd_boolean
+static inline bool
 is_str_attr (enum dwarf_form form)
 {
   return (form == DW_FORM_string
@@ -1323,7 +1323,7 @@ read_attribute_value (struct attribute *  attr,
       break;
     case DW_FORM_strx:
       attr->u.val = _bfd_safe_read_leb128 (abfd, info_ptr, &bytes_read,
-					 FALSE, info_ptr_end);
+					 false, info_ptr_end);
       info_ptr += bytes_read;
       attr->u.str = (char *) read_indexed_string (attr->u.val, unit);
       break;
@@ -1334,7 +1334,7 @@ read_attribute_value (struct attribute *  attr,
       if (blk == NULL)
 	return NULL;
       blk->size = _bfd_safe_read_leb128 (abfd, info_ptr, &bytes_read,
-					 FALSE, info_ptr_end);
+					 false, info_ptr_end);
       info_ptr += bytes_read;
       info_ptr = read_n_bytes (info_ptr, info_ptr_end, blk);
       attr->u.blk = blk;
@@ -1351,24 +1351,24 @@ read_attribute_value (struct attribute *  attr,
       break;
     case DW_FORM_sdata:
       attr->u.sval = _bfd_safe_read_leb128 (abfd, info_ptr, &bytes_read,
-					    TRUE, info_ptr_end);
+					    true, info_ptr_end);
       info_ptr += bytes_read;
       break;
     case DW_FORM_ref_udata:
     case DW_FORM_udata:
     case DW_FORM_addrx:
       attr->u.val = _bfd_safe_read_leb128 (abfd, info_ptr, &bytes_read,
-					   FALSE, info_ptr_end);
+					   false, info_ptr_end);
       info_ptr += bytes_read;
       break;
     case DW_FORM_indirect:
       form = _bfd_safe_read_leb128 (abfd, info_ptr, &bytes_read,
-				    FALSE, info_ptr_end);
+				    false, info_ptr_end);
       info_ptr += bytes_read;
       if (form == DW_FORM_implicit_const)
 	{
 	  implicit_const = _bfd_safe_read_leb128 (abfd, info_ptr, &bytes_read,
-						  TRUE, info_ptr_end);
+						  true, info_ptr_end);
 	  info_ptr += bytes_read;
 	}
       info_ptr = read_attribute_value (attr, form, implicit_const, unit,
@@ -1417,13 +1417,13 @@ read_attribute (struct attribute *    attr,
 /* Return whether DW_AT_name will return the same as DW_AT_linkage_name
    for a function.  */
 
-static bfd_boolean
+static bool
 non_mangled (int lang)
 {
   switch (lang)
     {
     default:
-      return FALSE;
+      return false;
 
     case DW_LANG_C89:
     case DW_LANG_C:
@@ -1437,7 +1437,7 @@ non_mangled (int lang)
     case DW_LANG_PLI:
     case DW_LANG_UPC:
     case DW_LANG_C11:
-      return TRUE;
+      return true;
     }
 }
 
@@ -1508,7 +1508,7 @@ struct funcinfo
   /* Source location line number.  */
   int			line;
   int			tag;
-  bfd_boolean		is_linkage;
+  bool			is_linkage;
   const char *		name;
   struct arange		arange;
   /* Where the symbol is defined.  */
@@ -1552,12 +1552,12 @@ struct varinfo
   /* Where the symbol is defined.  */
   asection *sec;
   /* Is this a stack variable?  */
-  bfd_boolean stack;
+  bool stack;
 };
 
 /* Return TRUE if NEW_LINE should sort after LINE.  */
 
-static inline bfd_boolean
+static inline bool
 new_line_sorts_after (struct line_info *new_line, struct line_info *line)
 {
   return (new_line->address > line->address
@@ -1571,7 +1571,7 @@ new_line_sorts_after (struct line_info *new_line, struct line_info *line)
    highest to lowest VMA (with possible duplicates); that is,
    line_info->prev_line always accesses an equal or smaller VMA.  */
 
-static bfd_boolean
+static bool
 add_line_info (struct line_info_table *table,
 	       bfd_vma address,
 	       unsigned char op_index,
@@ -1586,7 +1586,7 @@ add_line_info (struct line_info_table *table,
   struct line_info* info = (struct line_info *) bfd_alloc (table->abfd, amt);
 
   if (info == NULL)
-    return FALSE;
+    return false;
 
   /* Set member data of 'info'.  */
   info->prev_line = NULL;
@@ -1601,7 +1601,7 @@ add_line_info (struct line_info_table *table,
     {
       info->filename = (char *) bfd_alloc (table->abfd, strlen (filename) + 1);
       if (info->filename == NULL)
-	return FALSE;
+	return false;
       strcpy (info->filename, filename);
     }
   else
@@ -1640,7 +1640,7 @@ add_line_info (struct line_info_table *table,
       amt = sizeof (struct line_sequence);
       seq = (struct line_sequence *) bfd_malloc (amt);
       if (seq == NULL)
-	return FALSE;
+	return false;
       seq->low_pc = address;
       seq->prev_sequence = table->sequences;
       seq->last_line = info;
@@ -1689,7 +1689,7 @@ add_line_info (struct line_info_table *table,
       if (address < seq->low_pc)
 	seq->low_pc = address;
     }
-  return TRUE;
+  return true;
 }
 
 /* Extract a fully qualified filename from a line info table.
@@ -1762,7 +1762,7 @@ concat_filename (struct line_info_table *table, unsigned int file)
   return strdup (filename);
 }
 
-static bfd_boolean
+static bool
 arange_add (const struct comp_unit *unit, struct arange *first_arange,
 	    bfd_vma low_pc, bfd_vma high_pc)
 {
@@ -1770,14 +1770,14 @@ arange_add (const struct comp_unit *unit, struct arange *first_arange,
 
   /* Ignore empty ranges.  */
   if (low_pc == high_pc)
-    return TRUE;
+    return true;
 
   /* If the first arange is empty, use it.  */
   if (first_arange->high == 0)
     {
       first_arange->low = low_pc;
       first_arange->high = high_pc;
-      return TRUE;
+      return true;
     }
 
   /* Next see if we can cheaply extend an existing range.  */
@@ -1787,12 +1787,12 @@ arange_add (const struct comp_unit *unit, struct arange *first_arange,
       if (low_pc == arange->high)
 	{
 	  arange->high = high_pc;
-	  return TRUE;
+	  return true;
 	}
       if (high_pc == arange->low)
 	{
 	  arange->low = low_pc;
-	  return TRUE;
+	  return true;
 	}
       arange = arange->next;
     }
@@ -1802,12 +1802,12 @@ arange_add (const struct comp_unit *unit, struct arange *first_arange,
      Order isn't significant, so just insert after the first arange.  */
   arange = (struct arange *) bfd_alloc (unit->abfd, sizeof (*arange));
   if (arange == NULL)
-    return FALSE;
+    return false;
   arange->low = low_pc;
   arange->high = high_pc;
   arange->next = first_arange->next;
   first_arange->next = arange;
-  return TRUE;
+  return true;
 }
 
 /* Compare function for line sequences.  */
@@ -1846,7 +1846,7 @@ compare_sequences (const void* a, const void* b)
 
 /* Construct the line information table for quick lookup.  */
 
-static bfd_boolean
+static bool
 build_line_info_table (struct line_info_table *  table,
 		       struct line_sequence *    seq)
 {
@@ -1857,7 +1857,7 @@ build_line_info_table (struct line_info_table *  table,
   unsigned int line_index;
 
   if (seq->line_info_lookup != NULL)
-    return TRUE;
+    return true;
 
   /* Count the number of line information entries.  We could do this while
      scanning the debug information, but some entries may be added via
@@ -1869,14 +1869,14 @@ build_line_info_table (struct line_info_table *  table,
 
   seq->num_lines = num_lines;
   if (num_lines == 0)
-    return TRUE;
+    return true;
 
   /* Allocate space for the line information lookup table.  */
   amt = sizeof (struct line_info*) * num_lines;
   line_info_lookup = (struct line_info**) bfd_alloc (table->abfd, amt);
   seq->line_info_lookup = line_info_lookup;
   if (line_info_lookup == NULL)
-    return FALSE;
+    return false;
 
   /* Create the line information lookup table.  */
   line_index = num_lines;
@@ -1884,12 +1884,12 @@ build_line_info_table (struct line_info_table *  table,
     line_info_lookup[--line_index] = each_line;
 
   BFD_ASSERT (line_index == 0);
-  return TRUE;
+  return true;
 }
 
 /* Sort the line sequences for quick lookup.  */
 
-static bfd_boolean
+static bool
 sort_line_sequences (struct line_info_table* table)
 {
   size_t amt;
@@ -1900,13 +1900,13 @@ sort_line_sequences (struct line_info_table* table)
   bfd_vma last_high_pc;
 
   if (num_sequences == 0)
-    return TRUE;
+    return true;
 
   /* Allocate space for an array of sequences.  */
   amt = sizeof (struct line_sequence) * num_sequences;
   sequences = (struct line_sequence *) bfd_alloc (table->abfd, amt);
   if (sequences == NULL)
-    return FALSE;
+    return false;
 
   /* Copy the linked list into the array, freeing the original nodes.  */
   seq = table->sequences;
@@ -1954,12 +1954,12 @@ sort_line_sequences (struct line_info_table* table)
 
   table->sequences = sequences;
   table->num_sequences = num_sequences;
-  return TRUE;
+  return true;
 }
 
 /* Add directory to TABLE.  CUR_DIR memory ownership is taken by TABLE.  */
 
-static bfd_boolean
+static bool
 line_info_add_include_dir (struct line_info_table *table, char *cur_dir)
 {
   if ((table->num_dirs % DIR_ALLOC_CHUNK) == 0)
@@ -1972,15 +1972,15 @@ line_info_add_include_dir (struct line_info_table *table, char *cur_dir)
 
       tmp = (char **) bfd_realloc (table->dirs, amt);
       if (tmp == NULL)
-	return FALSE;
+	return false;
       table->dirs = tmp;
     }
 
   table->dirs[table->num_dirs++] = cur_dir;
-  return TRUE;
+  return true;
 }
 
-static bfd_boolean
+static bool
 line_info_add_include_dir_stub (struct line_info_table *table, char *cur_dir,
 				unsigned int dir ATTRIBUTE_UNUSED,
 				unsigned int xtime ATTRIBUTE_UNUSED,
@@ -1991,7 +1991,7 @@ line_info_add_include_dir_stub (struct line_info_table *table, char *cur_dir,
 
 /* Add file to TABLE.  CUR_FILE memory ownership is taken by TABLE.  */
 
-static bfd_boolean
+static bool
 line_info_add_file_name (struct line_info_table *table, char *cur_file,
 			 unsigned int dir, unsigned int xtime,
 			 unsigned int size)
@@ -2006,7 +2006,7 @@ line_info_add_file_name (struct line_info_table *table, char *cur_file,
 
       tmp = (struct fileinfo *) bfd_realloc (table->files, amt);
       if (tmp == NULL)
-	return FALSE;
+	return false;
       table->files = tmp;
     }
 
@@ -2015,7 +2015,7 @@ line_info_add_file_name (struct line_info_table *table, char *cur_file,
   table->files[table->num_files].time = xtime;
   table->files[table->num_files].size = size;
   table->num_files++;
-  return TRUE;
+  return true;
 }
 
 /* Read directory or file name entry format, starting with byte of
@@ -2023,14 +2023,14 @@ line_info_add_file_name (struct line_info_table *table, char *cur_file,
    entries count and the entries themselves in the described entry
    format.  */
 
-static bfd_boolean
+static bool
 read_formatted_entries (struct comp_unit *unit, bfd_byte **bufp,
 			bfd_byte *buf_end, struct line_info_table *table,
-			bfd_boolean (*callback) (struct line_info_table *table,
-						 char *cur_file,
-						 unsigned int dir,
-						 unsigned int time,
-						 unsigned int size))
+			bool (*callback) (struct line_info_table *table,
+					  char *cur_file,
+					  unsigned int dir,
+					  unsigned int time,
+					  unsigned int size))
 {
   bfd *abfd = unit->abfd;
   bfd_byte format_count, formati;
@@ -2044,19 +2044,19 @@ read_formatted_entries (struct comp_unit *unit, bfd_byte **bufp,
   format_header_data = buf;
   for (formati = 0; formati < format_count; formati++)
     {
-      _bfd_safe_read_leb128 (abfd, buf, &bytes_read, FALSE, buf_end);
+      _bfd_safe_read_leb128 (abfd, buf, &bytes_read, false, buf_end);
       buf += bytes_read;
-      _bfd_safe_read_leb128 (abfd, buf, &bytes_read, FALSE, buf_end);
+      _bfd_safe_read_leb128 (abfd, buf, &bytes_read, false, buf_end);
       buf += bytes_read;
     }
 
-  data_count = _bfd_safe_read_leb128 (abfd, buf, &bytes_read, FALSE, buf_end);
+  data_count = _bfd_safe_read_leb128 (abfd, buf, &bytes_read, false, buf_end);
   buf += bytes_read;
   if (format_count == 0 && data_count != 0)
     {
       _bfd_error_handler (_("DWARF error: zero format count"));
       bfd_set_error (bfd_error_bad_value);
-      return FALSE;
+      return false;
     }
 
   /* PR 22210.  Paranoia check.  Don't bother running the loop
@@ -2067,7 +2067,7 @@ read_formatted_entries (struct comp_unit *unit, bfd_byte **bufp,
 	(_("DWARF error: data count (%" PRIx64 ") larger than buffer size"),
 	 (uint64_t) data_count);
       bfd_set_error (bfd_error_bad_value);
-      return FALSE;
+      return false;
     }
 
   for (datai = 0; datai < data_count; datai++)
@@ -2085,7 +2085,7 @@ read_formatted_entries (struct comp_unit *unit, bfd_byte **bufp,
 	  struct attribute attr;
 
 	  content_type = _bfd_safe_read_leb128 (abfd, format, &bytes_read,
-						FALSE, buf_end);
+						false, buf_end);
 	  format += bytes_read;
 	  switch (content_type)
 	    {
@@ -2108,16 +2108,16 @@ read_formatted_entries (struct comp_unit *unit, bfd_byte **bufp,
 		(_("DWARF error: unknown format content type %" PRIu64),
 		 (uint64_t) content_type);
 	      bfd_set_error (bfd_error_bad_value);
-	      return FALSE;
+	      return false;
 	    }
 
-	  form = _bfd_safe_read_leb128 (abfd, format, &bytes_read, FALSE,
+	  form = _bfd_safe_read_leb128 (abfd, format, &bytes_read, false,
 					buf_end);
 	  format += bytes_read;
 
 	  buf = read_attribute_value (&attr, form, 0, unit, buf, buf_end);
 	  if (buf == NULL)
-	    return FALSE;
+	    return false;
 	  switch (form)
 	    {
 	    case DW_FORM_string:
@@ -2142,11 +2142,11 @@ read_formatted_entries (struct comp_unit *unit, bfd_byte **bufp,
       /* Skip the first "zero entry", which is the compilation dir/file.  */
       if (datai != 0)
 	if (!callback (table, fe.name, fe.dir, fe.time, fe.size))
-	  return FALSE;
+	  return false;
     }
 
   *bufp = buf;
-  return TRUE;
+  return true;
 }
 
 /* Decode the line number information for UNIT.  */
@@ -2361,11 +2361,11 @@ decode_line_info (struct comp_unit *unit)
 
 	  line_ptr += bytes_read;
 
-	  dir = _bfd_safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
+	  dir = _bfd_safe_read_leb128 (abfd, line_ptr, &bytes_read, false, line_end);
 	  line_ptr += bytes_read;
-	  xtime = _bfd_safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
+	  xtime = _bfd_safe_read_leb128 (abfd, line_ptr, &bytes_read, false, line_end);
 	  line_ptr += bytes_read;
-	  size = _bfd_safe_read_leb128 (abfd, line_ptr, &bytes_read, FALSE, line_end);
+	  size = _bfd_safe_read_leb128 (abfd, line_ptr, &bytes_read, false, line_end);
 	  line_ptr += bytes_read;
 
 	  if (!line_info_add_file_name (table, cur_file, dir, xtime, size))
@@ -2434,7 +2434,7 @@ decode_line_info (struct comp_unit *unit)
 	    {
 	    case DW_LNS_extended_op:
 	      exop_len = _bfd_safe_read_leb128 (abfd, line_ptr, &bytes_read,
-						FALSE, line_end);
+						false, line_end);
 	      line_ptr += bytes_read;
 	      extended_op = read_1_byte (abfd, line_ptr, line_end);
 	      line_ptr += 1;
@@ -2463,13 +2463,13 @@ decode_line_info (struct comp_unit *unit)
 		  cur_file = read_string (abfd, line_ptr, line_end, &bytes_read);
 		  line_ptr += bytes_read;
 		  dir = _bfd_safe_read_leb128 (abfd, line_ptr, &bytes_read,
-					       FALSE, line_end);
+					       false, line_end);
 		  line_ptr += bytes_read;
 		  xtime = _bfd_safe_read_leb128 (abfd, line_ptr, &bytes_read,
-						 FALSE, line_end);
+						 false, line_end);
 		  line_ptr += bytes_read;
 		  size = _bfd_safe_read_leb128 (abfd, line_ptr, &bytes_read,
-						FALSE, line_end);
+						false, line_end);
 		  line_ptr += bytes_read;
 		  if (!line_info_add_file_name (table, cur_file, dir,
 						xtime, size))
@@ -2478,7 +2478,7 @@ decode_line_info (struct comp_unit *unit)
 		case DW_LNE_set_discriminator:
 		  discriminator =
 		    _bfd_safe_read_leb128 (abfd, line_ptr, &bytes_read,
-					   FALSE, line_end);
+					   false, line_end);
 		  line_ptr += bytes_read;
 		  break;
 		case DW_LNE_HP_source_file_correlation:
@@ -2508,12 +2508,12 @@ decode_line_info (struct comp_unit *unit)
 		address += (lh.minimum_instruction_length
 			    * _bfd_safe_read_leb128 (abfd, line_ptr,
 						     &bytes_read,
-						     FALSE, line_end));
+						     false, line_end));
 	      else
 		{
 		  bfd_vma adjust = _bfd_safe_read_leb128 (abfd, line_ptr,
 							  &bytes_read,
-							  FALSE, line_end);
+							  false, line_end);
 		  address = ((op_index + adjust) / lh.maximum_ops_per_insn
 			     * lh.minimum_instruction_length);
 		  op_index = (op_index + adjust) % lh.maximum_ops_per_insn;
@@ -2522,7 +2522,7 @@ decode_line_info (struct comp_unit *unit)
 	      break;
 	    case DW_LNS_advance_line:
 	      line += _bfd_safe_read_leb128 (abfd, line_ptr, &bytes_read,
-					     TRUE, line_end);
+					     true, line_end);
 	      line_ptr += bytes_read;
 	      break;
 	    case DW_LNS_set_file:
@@ -2532,7 +2532,7 @@ decode_line_info (struct comp_unit *unit)
 		/* The file and directory tables are 0
 		   based, the references are 1 based.  */
 		filenum = _bfd_safe_read_leb128 (abfd, line_ptr, &bytes_read,
-						 FALSE, line_end);
+						 false, line_end);
 		line_ptr += bytes_read;
 		free (filename);
 		filename = concat_filename (table, filenum);
@@ -2540,7 +2540,7 @@ decode_line_info (struct comp_unit *unit)
 	      }
 	    case DW_LNS_set_column:
 	      column = _bfd_safe_read_leb128 (abfd, line_ptr, &bytes_read,
-					      FALSE, line_end);
+					      false, line_end);
 	      line_ptr += bytes_read;
 	      break;
 	    case DW_LNS_negate_stmt:
@@ -2573,7 +2573,7 @@ decode_line_info (struct comp_unit *unit)
 	      for (i = 0; i < lh.standard_opcode_lengths[op_code]; i++)
 		{
 		  (void) _bfd_safe_read_leb128 (abfd, line_ptr, &bytes_read,
-						FALSE, line_end);
+						false, line_end);
 		  line_ptr += bytes_read;
 		}
 	      break;
@@ -2675,7 +2675,7 @@ lookup_address_in_line_info_table (struct line_info_table *table,
 
 /* Read in the .debug_ranges section for future reference.  */
 
-static bfd_boolean
+static bool
 read_debug_ranges (struct comp_unit * unit)
 {
   struct dwarf2_debug *stash = unit->stash;
@@ -2688,7 +2688,7 @@ read_debug_ranges (struct comp_unit * unit)
 
 /* Read in the .debug_rnglists section for future reference.  */
 
-static bfd_boolean
+static bool
 read_debug_rnglists (struct comp_unit * unit)
 {
   struct dwarf2_debug *stash = unit->stash;
@@ -2723,7 +2723,7 @@ compare_lookup_funcinfos (const void * a, const void * b)
   return 0;
 }
 
-static bfd_boolean
+static bool
 build_lookup_funcinfo_table (struct comp_unit * unit)
 {
   struct lookup_funcinfo *lookup_funcinfo_table = unit->lookup_funcinfo_table;
@@ -2735,13 +2735,13 @@ build_lookup_funcinfo_table (struct comp_unit * unit)
   bfd_vma low_addr, high_addr;
 
   if (lookup_funcinfo_table || number_of_functions == 0)
-    return TRUE;
+    return true;
 
   /* Create the function info lookup table.  */
   lookup_funcinfo_table = (struct lookup_funcinfo *)
     bfd_malloc (number_of_functions * sizeof (struct lookup_funcinfo));
   if (lookup_funcinfo_table == NULL)
-    return FALSE;
+    return false;
 
   /* Populate the function info lookup table.  */
   func_index = number_of_functions;
@@ -2787,7 +2787,7 @@ build_lookup_funcinfo_table (struct comp_unit * unit)
     }
 
   unit->lookup_funcinfo_table = lookup_funcinfo_table;
-  return TRUE;
+  return true;
 }
 
 /* If ADDR is within UNIT's function tables, set FUNCTION_PTR, and return
@@ -2795,7 +2795,7 @@ build_lookup_funcinfo_table (struct comp_unit * unit)
    that contains ADDR, to handle inlined functions without depending upon
    them being ordered in TABLE by increasing range.  */
 
-static bfd_boolean
+static bool
 lookup_address_in_function_table (struct comp_unit *unit,
 				  bfd_vma addr,
 				  struct funcinfo **function_ptr)
@@ -2809,13 +2809,13 @@ lookup_address_in_function_table (struct comp_unit *unit,
   struct arange *arange;
 
   if (number_of_functions == 0)
-    return FALSE;
+    return false;
 
   if (!build_lookup_funcinfo_table (unit))
-    return FALSE;
+    return false;
 
   if (unit->lookup_funcinfo_table[number_of_functions - 1].high_addr < addr)
-    return FALSE;
+    return false;
 
   /* Find the first function in the lookup table which may contain the
      specified address.  */
@@ -2867,16 +2867,16 @@ lookup_address_in_function_table (struct comp_unit *unit,
     }
 
   if (!best_fit)
-    return FALSE;
+    return false;
 
   *function_ptr = best_fit;
-  return TRUE;
+  return true;
 }
 
 /* If SYM at ADDR is within function table of UNIT, set FILENAME_PTR
    and LINENUMBER_PTR, and return TRUE.  */
 
-static bfd_boolean
+static bool
 lookup_symbol_in_function_table (struct comp_unit *unit,
 				 asymbol *sym,
 				 bfd_vma addr,
@@ -2917,10 +2917,10 @@ lookup_symbol_in_function_table (struct comp_unit *unit,
       best_fit->sec = sec;
       *filename_ptr = best_fit->file;
       *linenumber_ptr = best_fit->line;
-      return TRUE;
+      return true;
     }
   else
-    return FALSE;
+    return false;
 }
 
 /* Variable table functions.  */
@@ -2928,7 +2928,7 @@ lookup_symbol_in_function_table (struct comp_unit *unit,
 /* If SYM is within variable table of UNIT, set FILENAME_PTR and
    LINENUMBER_PTR, and return TRUE.  */
 
-static bfd_boolean
+static bool
 lookup_symbol_in_variable_table (struct comp_unit *unit,
 				 asymbol *sym,
 				 bfd_vma addr,
@@ -2953,22 +2953,22 @@ lookup_symbol_in_variable_table (struct comp_unit *unit,
       each->sec = sec;
       *filename_ptr = each->file;
       *linenumber_ptr = each->line;
-      return TRUE;
+      return true;
     }
 
-  return FALSE;
+  return false;
 }
 
 static struct comp_unit *stash_comp_unit (struct dwarf2_debug *,
 					  struct dwarf2_debug_file *);
-static bfd_boolean comp_unit_maybe_decode_line_info (struct comp_unit *);
+static bool comp_unit_maybe_decode_line_info (struct comp_unit *);
 
-static bfd_boolean
+static bool
 find_abstract_instance (struct comp_unit *unit,
 			struct attribute *attr_ptr,
 			unsigned int recur_count,
 			const char **pname,
-			bfd_boolean *is_linkage,
+			bool *is_linkage,
 			char **filename_ptr,
 			int *linenumber_ptr)
 {
@@ -2986,7 +2986,7 @@ find_abstract_instance (struct comp_unit *unit,
       _bfd_error_handler
 	(_("DWARF error: abstract instance recursion detected"));
       bfd_set_error (bfd_error_bad_value);
-      return FALSE;
+      return false;
     }
 
   /* DW_FORM_ref_addr can reference an entry in a different CU. It
@@ -3014,19 +3014,19 @@ find_abstract_instance (struct comp_unit *unit,
       info_ptr_end = info_ptr + unit->file->dwarf_info_size;
       total = info_ptr_end - info_ptr;
       if (!die_ref)
-	return TRUE;
+	return true;
       else if (die_ref >= total)
 	{
 	  _bfd_error_handler
 	    (_("DWARF error: invalid abstract instance DIE ref"));
 	  bfd_set_error (bfd_error_bad_value);
-	  return FALSE;
+	  return false;
 	}
       info_ptr += die_ref;
     }
   else if (attr_ptr->form == DW_FORM_GNU_ref_alt)
     {
-      bfd_boolean first_time = unit->stash->alt.dwarf_info_buffer == NULL;
+      bool first_time = unit->stash->alt.dwarf_info_buffer == NULL;
 
       info_ptr = read_alt_indirect_ref (unit, die_ref);
       if (first_time)
@@ -3037,7 +3037,7 @@ find_abstract_instance (struct comp_unit *unit,
 	    (_("DWARF error: unable to read alt ref %" PRIu64),
 	     (uint64_t) die_ref);
 	  bfd_set_error (bfd_error_bad_value);
-	  return FALSE;
+	  return false;
 	}
       info_ptr_end = (unit->stash->alt.dwarf_info_buffer
 		      + unit->stash->alt.dwarf_info_size);
@@ -3093,7 +3093,7 @@ find_abstract_instance (struct comp_unit *unit,
 		(_("DWARF error: unable to locate abstract instance DIE ref %"
 		   PRIu64), (uint64_t) die_ref);
 	      bfd_set_error (bfd_error_bad_value);
-	      return FALSE;
+	      return false;
 	    }
 	  unit = u;
 	  info_ptr_end = unit->end_ptr;
@@ -3114,13 +3114,13 @@ find_abstract_instance (struct comp_unit *unit,
 	  _bfd_error_handler
 	    (_("DWARF error: invalid abstract instance DIE ref"));
 	  bfd_set_error (bfd_error_bad_value);
-	  return FALSE;
+	  return false;
 	}
       info_ptr += die_ref;
     }
 
   abbrev_number = _bfd_safe_read_leb128 (abfd, info_ptr, &bytes_read,
-					 FALSE, info_ptr_end);
+					 false, info_ptr_end);
   info_ptr += bytes_read;
 
   if (abbrev_number)
@@ -3131,7 +3131,7 @@ find_abstract_instance (struct comp_unit *unit,
 	  _bfd_error_handler
 	    (_("DWARF error: could not find abbrev number %u"), abbrev_number);
 	  bfd_set_error (bfd_error_bad_value);
-	  return FALSE;
+	  return false;
 	}
       else
 	{
@@ -3150,14 +3150,14 @@ find_abstract_instance (struct comp_unit *unit,
 		    {
 		      name = attr.u.str;
 		      if (non_mangled (unit->lang))
-			*is_linkage = TRUE;
+			*is_linkage = true;
 		    }
 		  break;
 		case DW_AT_specification:
 		  if (!find_abstract_instance (unit, &attr, recur_count + 1,
 					       &name, is_linkage,
 					       filename_ptr, linenumber_ptr))
-		    return FALSE;
+		    return false;
 		  break;
 		case DW_AT_linkage_name:
 		case DW_AT_MIPS_linkage_name:
@@ -3166,12 +3166,12 @@ find_abstract_instance (struct comp_unit *unit,
 		  if (is_str_attr (attr.form))
 		    {
 		      name = attr.u.str;
-		      *is_linkage = TRUE;
+		      *is_linkage = true;
 		    }
 		  break;
 		case DW_AT_decl_file:
 		  if (!comp_unit_maybe_decode_line_info (unit))
-		    return FALSE;
+		    return false;
 		  *filename_ptr = concat_filename (unit->line_table,
 						   attr.u.val);
 		  break;
@@ -3185,10 +3185,10 @@ find_abstract_instance (struct comp_unit *unit,
 	}
     }
   *pname = name;
-  return TRUE;
+  return true;
 }
 
-static bfd_boolean
+static bool
 read_ranges (struct comp_unit *unit, struct arange *arange,
 	     bfd_uint64_t offset)
 {
@@ -3199,12 +3199,12 @@ read_ranges (struct comp_unit *unit, struct arange *arange,
   if (! unit->file->dwarf_ranges_buffer)
     {
       if (! read_debug_ranges (unit))
-	return FALSE;
+	return false;
     }
 
   ranges_ptr = unit->file->dwarf_ranges_buffer + offset;
   if (ranges_ptr < unit->file->dwarf_ranges_buffer)
-    return FALSE;
+    return false;
   ranges_end = unit->file->dwarf_ranges_buffer + unit->file->dwarf_ranges_size;
 
   for (;;)
@@ -3214,7 +3214,7 @@ read_ranges (struct comp_unit *unit, struct arange *arange,
 
       /* PR 17512: file: 62cada7d.  */
       if (ranges_ptr + 2 * unit->addr_size > ranges_end)
-	return FALSE;
+	return false;
 
       low_pc = read_address (unit, ranges_ptr, ranges_end);
       ranges_ptr += unit->addr_size;
@@ -3229,13 +3229,13 @@ read_ranges (struct comp_unit *unit, struct arange *arange,
 	{
 	  if (!arange_add (unit, arange,
 			   base_address + low_pc, base_address + high_pc))
-	    return FALSE;
+	    return false;
 	}
     }
-  return TRUE;
+  return true;
 }
 
-static bfd_boolean
+static bool
 read_rnglists (struct comp_unit *unit, struct arange *arange,
 	       bfd_uint64_t offset)
 {
@@ -3249,12 +3249,12 @@ read_rnglists (struct comp_unit *unit, struct arange *arange,
   if (! unit->file->dwarf_rnglists_buffer)
     {
       if (! read_debug_rnglists (unit))
-	return FALSE;
+	return false;
     }
 
   rngs_ptr = unit->file->dwarf_rnglists_buffer + offset;
   if (rngs_ptr < unit->file->dwarf_rnglists_buffer)
-    return FALSE;
+    return false;
   rngs_end = unit->file->dwarf_rnglists_buffer;
   rngs_end +=  unit->file->dwarf_rnglists_size;
 
@@ -3264,7 +3264,7 @@ read_rnglists (struct comp_unit *unit, struct arange *arange,
       unsigned int bytes_read;
 
       if (rngs_ptr + 1 > rngs_end)
-	return FALSE;
+	return false;
 
       rlet = read_1_byte (abfd, rngs_ptr, rngs_end);
       rngs_ptr++;
@@ -3272,40 +3272,40 @@ read_rnglists (struct comp_unit *unit, struct arange *arange,
       switch (rlet)
 	{
 	case DW_RLE_end_of_list:
-	  return TRUE;
+	  return true;
 
 	case DW_RLE_base_address:
 	  if (rngs_ptr + unit->addr_size > rngs_end)
-	    return FALSE;
+	    return false;
 	  base_address = read_address (unit, rngs_ptr, rngs_end);
 	  rngs_ptr += unit->addr_size;
 	  continue;
 
 	case DW_RLE_start_length:
 	  if (rngs_ptr + unit->addr_size > rngs_end)
-	    return FALSE;
+	    return false;
 	  low_pc = read_address (unit, rngs_ptr, rngs_end);
 	  rngs_ptr += unit->addr_size;
 	  high_pc = low_pc;
 	  high_pc += _bfd_safe_read_leb128 (abfd, rngs_ptr, &bytes_read,
-					    FALSE, rngs_end);
+					    false, rngs_end);
 	  rngs_ptr += bytes_read;
 	  break;
 
 	case DW_RLE_offset_pair:
 	  low_pc = base_address;
 	  low_pc += _bfd_safe_read_leb128 (abfd, rngs_ptr, &bytes_read,
-					   FALSE, rngs_end);
+					   false, rngs_end);
 	  rngs_ptr += bytes_read;
 	  high_pc = base_address;
 	  high_pc += _bfd_safe_read_leb128 (abfd, rngs_ptr, &bytes_read,
-					    FALSE, rngs_end);
+					    false, rngs_end);
 	  rngs_ptr += bytes_read;
 	  break;
 
 	case DW_RLE_start_end:
 	  if (rngs_ptr + 2 * unit->addr_size > rngs_end)
-	    return FALSE;
+	    return false;
 	  low_pc = read_address (unit, rngs_ptr, rngs_end);
 	  rngs_ptr += unit->addr_size;
 	  high_pc = read_address (unit, rngs_ptr, rngs_end);
@@ -3317,15 +3317,15 @@ read_rnglists (struct comp_unit *unit, struct arange *arange,
 	case DW_RLE_startx_endx:
 	case DW_RLE_startx_length:
 	default:
-	  return FALSE;
+	  return false;
 	}
 
       if (!arange_add (unit, arange, low_pc, high_pc))
-	return FALSE;
+	return false;
     }
 }
 
-static bfd_boolean
+static bool
 read_rangelist (struct comp_unit *unit, struct arange *arange,
 		bfd_uint64_t offset)
 {
@@ -3363,7 +3363,7 @@ lookup_var_by_offset (bfd_uint64_t offset, struct varinfo * table)
 /* Scan over each die in a comp. unit looking for functions to add
    to the function table and variables to the variable table.  */
 
-static bfd_boolean
+static bool
 scan_unit_for_symbols (struct comp_unit *unit)
 {
   bfd *abfd = unit->abfd;
@@ -3382,7 +3382,7 @@ scan_unit_for_symbols (struct comp_unit *unit)
   nested_funcs = (struct nest_funcinfo *)
     bfd_malloc (nested_funcs_size * sizeof (*nested_funcs));
   if (nested_funcs == NULL)
-    return FALSE;
+    return false;
   nested_funcs[nesting_level].func = 0;
 
   /* PR 27484: We must scan the DIEs twice.  The first time we look for
@@ -3403,7 +3403,7 @@ scan_unit_for_symbols (struct comp_unit *unit)
 
       current_offset = info_ptr - unit->info_ptr_unit;
       abbrev_number = _bfd_safe_read_leb128 (abfd, info_ptr, &bytes_read,
-					     FALSE, info_ptr_end);
+					     false, info_ptr_end);
       info_ptr += bytes_read;
 
       if (abbrev_number == 0)
@@ -3467,7 +3467,7 @@ scan_unit_for_symbols (struct comp_unit *unit)
 	      if (var == NULL)
 		goto fail;
 	      var->tag = abbrev->tag;
-	      var->stack = TRUE;
+	      var->stack = true;
 	      var->prev_var = unit->variable_table;
 	      unit->variable_table = var;
 	      var->unit_offset = current_offset;
@@ -3524,7 +3524,7 @@ scan_unit_for_symbols (struct comp_unit *unit)
       struct varinfo *var;
       bfd_vma low_pc = 0;
       bfd_vma high_pc = 0;
-      bfd_boolean high_pc_relative = FALSE;
+      bool high_pc_relative = false;
       bfd_uint64_t current_offset;
 
       /* PR 17512: file: 9f405d9d.  */
@@ -3533,7 +3533,7 @@ scan_unit_for_symbols (struct comp_unit *unit)
 
       current_offset = info_ptr - unit->info_ptr_unit;
       abbrev_number = _bfd_safe_read_leb128 (abfd, info_ptr, &bytes_read,
-					     FALSE, info_ptr_end);
+					     false, info_ptr_end);
       info_ptr += bytes_read;
 
       if (! abbrev_number)
@@ -3601,7 +3601,7 @@ scan_unit_for_symbols (struct comp_unit *unit)
 		    {
 		      func->name = attr.u.str;
 		      if (non_mangled (unit->lang))
-			func->is_linkage = TRUE;
+			func->is_linkage = true;
 		    }
 		  break;
 
@@ -3612,7 +3612,7 @@ scan_unit_for_symbols (struct comp_unit *unit)
 		  if (is_str_attr (attr.form))
 		    {
 		      func->name = attr.u.str;
-		      func->is_linkage = TRUE;
+		      func->is_linkage = true;
 		    }
 		  break;
 
@@ -3690,7 +3690,7 @@ scan_unit_for_symbols (struct comp_unit *unit)
 
 		case DW_AT_external:
 		  if (attr.u.val != 0)
-		    var->stack = FALSE;
+		    var->stack = false;
 		  break;
 
 		case DW_AT_location:
@@ -3704,7 +3704,7 @@ scan_unit_for_symbols (struct comp_unit *unit)
 		      if (attr.u.blk->data != NULL
 			  && *attr.u.blk->data == DW_OP_addr)
 			{
-			  var->stack = FALSE;
+			  var->stack = false;
 
 			  /* Verify that DW_OP_addr is the only opcode in the
 			     location, in which case the block size will be 1
@@ -3744,11 +3744,11 @@ scan_unit_for_symbols (struct comp_unit *unit)
     }
 
   free (nested_funcs);
-  return TRUE;
+  return true;
 
  fail:
   free (nested_funcs);
-  return FALSE;
+  return false;
 }
 
 /* Parse a DWARF2 compilation unit starting at INFO_PTR.  UNIT_LENGTH
@@ -3782,7 +3782,7 @@ parse_comp_unit (struct dwarf2_debug *stash,
   bfd_vma low_pc = 0;
   bfd_vma high_pc = 0;
   bfd *abfd = file->bfd_ptr;
-  bfd_boolean high_pc_relative = FALSE;
+  bool high_pc_relative = false;
   enum dwarf_unit_type unit_type;
 
   version = read_2_bytes (abfd, info_ptr, end_ptr);
@@ -3863,7 +3863,7 @@ parse_comp_unit (struct dwarf2_debug *stash,
     return NULL;
 
   abbrev_number = _bfd_safe_read_leb128 (abfd, info_ptr, &bytes_read,
-					 FALSE, end_ptr);
+					 false, end_ptr);
   info_ptr += bytes_read;
   if (! abbrev_number)
     {
@@ -3987,24 +3987,24 @@ parse_comp_unit (struct dwarf2_debug *stash,
    need to consult the line info table to see if a compilation unit
    really contains the given address.  */
 
-static bfd_boolean
+static bool
 comp_unit_contains_address (struct comp_unit *unit, bfd_vma addr)
 {
   struct arange *arange;
 
   if (unit->error)
-    return FALSE;
+    return false;
 
   arange = &unit->arange;
   do
     {
       if (addr >= arange->low && addr < arange->high)
-	return TRUE;
+	return true;
       arange = arange->next;
     }
   while (arange);
 
-  return FALSE;
+  return false;
 }
 
 /* If UNIT contains ADDR, set the output parameters to the values for
@@ -4023,10 +4023,10 @@ comp_unit_find_nearest_line (struct comp_unit *unit,
 			     unsigned int *linenumber_ptr,
 			     unsigned int *discriminator_ptr)
 {
-  bfd_boolean func_p;
+  bool func_p;
 
   if (!comp_unit_maybe_decode_line_info (unit))
-    return FALSE;
+    return false;
 
   *function_ptr = NULL;
   func_p = lookup_address_in_function_table (unit, addr, function_ptr);
@@ -4043,18 +4043,18 @@ comp_unit_find_nearest_line (struct comp_unit *unit,
    If not, decode it.  Returns TRUE if no errors were encountered;
    FALSE otherwise.  */
 
-static bfd_boolean
+static bool
 comp_unit_maybe_decode_line_info (struct comp_unit *unit)
 {
   if (unit->error)
-    return FALSE;
+    return false;
 
   if (! unit->line_table)
     {
       if (! unit->stmtlist)
 	{
 	  unit->error = 1;
-	  return FALSE;
+	  return false;
 	}
 
       unit->line_table = decode_line_info (unit);
@@ -4062,18 +4062,18 @@ comp_unit_maybe_decode_line_info (struct comp_unit *unit)
       if (! unit->line_table)
 	{
 	  unit->error = 1;
-	  return FALSE;
+	  return false;
 	}
 
       if (unit->first_child_die_ptr < unit->end_ptr
 	  && ! scan_unit_for_symbols (unit))
 	{
 	  unit->error = 1;
-	  return FALSE;
+	  return false;
 	}
     }
 
-  return TRUE;
+  return true;
 }
 
 /* If UNIT contains SYM at ADDR, set the output parameters to the
@@ -4084,7 +4084,7 @@ comp_unit_maybe_decode_line_info (struct comp_unit *unit)
    Return TRUE if UNIT contains SYM, and no errors were encountered;
    FALSE otherwise.  */
 
-static bfd_boolean
+static bool
 comp_unit_find_line (struct comp_unit *unit,
 		     asymbol *sym,
 		     bfd_vma addr,
@@ -4092,7 +4092,7 @@ comp_unit_find_line (struct comp_unit *unit,
 		     unsigned int *linenumber_ptr)
 {
   if (!comp_unit_maybe_decode_line_info (unit))
-    return FALSE;
+    return false;
 
   if (sym->flags & BSF_FUNCTION)
     return lookup_symbol_in_function_table (unit, sym, addr,
@@ -4138,7 +4138,7 @@ reverse_varinfo_list (struct varinfo *head)
    unit into hash tables for faster lookup.  Returns TRUE if no
    errors were enountered; FALSE otherwise.  */
 
-static bfd_boolean
+static bool
 comp_unit_hash_info (struct dwarf2_debug *stash,
 		     struct comp_unit *unit,
 		     struct info_hash_table *funcinfo_hash_table,
@@ -4146,12 +4146,12 @@ comp_unit_hash_info (struct dwarf2_debug *stash,
 {
   struct funcinfo* each_func;
   struct varinfo* each_var;
-  bfd_boolean okay = TRUE;
+  bool okay = true;
 
   BFD_ASSERT (stash->info_hash_status != STASH_INFO_HASH_DISABLED);
 
   if (!comp_unit_maybe_decode_line_info (unit))
-    return FALSE;
+    return false;
 
   BFD_ASSERT (!unit->cached);
 
@@ -4171,11 +4171,11 @@ comp_unit_hash_info (struct dwarf2_debug *stash,
 	   name string is either in the dwarf string buffer or
 	   info in the stash.  */
 	okay = insert_info_hash_table (funcinfo_hash_table, each_func->name,
-				       (void*) each_func, FALSE);
+				       (void*) each_func, false);
     }
   unit->function_table = reverse_funcinfo_list (unit->function_table);
   if (!okay)
-    return FALSE;
+    return false;
 
   /* We do the same for variable infos.  */
   unit->variable_table = reverse_varinfo_list (unit->variable_table);
@@ -4191,11 +4191,11 @@ comp_unit_hash_info (struct dwarf2_debug *stash,
 	   name string is either in the dwarf string buffer or
 	   info in the stash.  */
 	okay = insert_info_hash_table (varinfo_hash_table, each_var->name,
-				       (void*) each_var, FALSE);
+				       (void*) each_var, false);
     }
 
   unit->variable_table = reverse_varinfo_list (unit->variable_table);
-  unit->cached = TRUE;
+  unit->cached = true;
   return okay;
 }
 
@@ -4340,7 +4340,7 @@ unset_sections (struct dwarf2_debug *stash)
    logical section.  ??? We should probably do the same for other
    debug sections.  */
 
-static bfd_boolean
+static bool
 place_sections (bfd *orig_bfd, struct dwarf2_debug *stash)
 {
   bfd *abfd;
@@ -4354,7 +4354,7 @@ place_sections (bfd *orig_bfd, struct dwarf2_debug *stash)
       p = stash->adjusted_sections;
       for (; i > 0; i--, p++)
 	p->section->vma = p->adj_vma;
-      return TRUE;
+      return true;
     }
 
   debug_info_name = stash->debug_sections[debug_info].uncompressed_name;
@@ -4397,7 +4397,7 @@ place_sections (bfd *orig_bfd, struct dwarf2_debug *stash)
 
       p = (struct adjusted_section *) bfd_malloc (amt);
       if (p == NULL)
-	return FALSE;
+	return false;
 
       stash->adjusted_sections = p;
       stash->adjusted_section_count = i;
@@ -4457,7 +4457,7 @@ place_sections (bfd *orig_bfd, struct dwarf2_debug *stash)
   if (orig_bfd != stash->f.bfd_ptr)
     set_debug_vma (orig_bfd, stash->f.bfd_ptr);
 
-  return TRUE;
+  return true;
 }
 
 /* Look up a funcinfo by name using the given info hash table.  If found,
@@ -4466,7 +4466,7 @@ place_sections (bfd *orig_bfd, struct dwarf2_debug *stash)
    This function returns TRUE if a funcinfo that matches the given symbol
    and address is found with any error; otherwise it returns FALSE.  */
 
-static bfd_boolean
+static bool
 info_hash_lookup_funcinfo (struct info_hash_table *hash_table,
 			   asymbol *sym,
 			   bfd_vma addr,
@@ -4507,10 +4507,10 @@ info_hash_lookup_funcinfo (struct info_hash_table *hash_table,
       best_fit->sec = sec;
       *filename_ptr = best_fit->file;
       *linenumber_ptr = best_fit->line;
-      return TRUE;
+      return true;
     }
 
-  return FALSE;
+  return false;
 }
 
 /* Look up a varinfo by name using the given info hash table.  If found,
@@ -4519,7 +4519,7 @@ info_hash_lookup_funcinfo (struct info_hash_table *hash_table,
    This function returns TRUE if a varinfo that matches the given symbol
    and address is found with any error; otherwise it returns FALSE.  */
 
-static bfd_boolean
+static bool
 info_hash_lookup_varinfo (struct info_hash_table *hash_table,
 			  asymbol *sym,
 			  bfd_vma addr,
@@ -4542,25 +4542,25 @@ info_hash_lookup_varinfo (struct info_hash_table *hash_table,
 	  each->sec = sec;
 	  *filename_ptr = each->file;
 	  *linenumber_ptr = each->line;
-	  return TRUE;
+	  return true;
 	}
     }
 
-  return FALSE;
+  return false;
 }
 
 /* Update the funcinfo and varinfo info hash tables if they are
    not up to date.  Returns TRUE if there is no error; otherwise
    returns FALSE and disable the info hash tables.  */
 
-static bfd_boolean
+static bool
 stash_maybe_update_info_hash_tables (struct dwarf2_debug *stash)
 {
   struct comp_unit *each;
 
   /* Exit if hash tables are up-to-date.  */
   if (stash->f.all_comp_units == stash->hash_units_head)
-    return TRUE;
+    return true;
 
   if (stash->hash_units_head)
     each = stash->hash_units_head->prev_unit;
@@ -4573,13 +4573,13 @@ stash_maybe_update_info_hash_tables (struct dwarf2_debug *stash)
 				stash->varinfo_hash_table))
 	{
 	  stash->info_hash_status = STASH_INFO_HASH_DISABLED;
-	  return FALSE;
+	  return false;
 	}
       each = each->prev_unit;
     }
 
   stash->hash_units_head = stash->f.all_comp_units;
-  return TRUE;
+  return true;
 }
 
 /* Check consistency of info hash tables.  This is for debugging only.  */
@@ -4591,7 +4591,7 @@ stash_verify_info_hash_table (struct dwarf2_debug *stash)
   struct funcinfo *each_func;
   struct varinfo *each_var;
   struct info_list_node *node;
-  bfd_boolean found;
+  bool found;
 
   for (each_unit = stash->f.all_comp_units;
        each_unit;
@@ -4606,7 +4606,7 @@ stash_verify_info_hash_table (struct dwarf2_debug *stash)
 	  node = lookup_info_hash_table (stash->funcinfo_hash_table,
 					 each_func->name);
 	  BFD_ASSERT (node);
-	  found = FALSE;
+	  found = false;
 	  while (node && !found)
 	    {
 	      found = node->info == each_func;
@@ -4624,7 +4624,7 @@ stash_verify_info_hash_table (struct dwarf2_debug *stash)
 	  node = lookup_info_hash_table (stash->varinfo_hash_table,
 					 each_var->name);
 	  BFD_ASSERT (node);
-	  found = FALSE;
+	  found = false;
 	  while (node && !found)
 	    {
 	      found = node->info == each_var;
@@ -4672,7 +4672,7 @@ stash_maybe_enable_info_hash_tables (bfd *abfd, struct dwarf2_debug *stash)
    TRUE and update the locations pointed to by filename_ptr and linenumber_ptr;
    otherwise it returns FALSE.  */
 
-static bfd_boolean
+static bool
 stash_find_line_fast (struct dwarf2_debug *stash,
 		      asymbol *sym,
 		      bfd_vma addr,
@@ -4690,17 +4690,17 @@ stash_find_line_fast (struct dwarf2_debug *stash,
 
 /* Save current section VMAs.  */
 
-static bfd_boolean
+static bool
 save_section_vma (const bfd *abfd, struct dwarf2_debug *stash)
 {
   asection *s;
   unsigned int i;
 
   if (abfd->section_count == 0)
-    return TRUE;
+    return true;
   stash->sec_vma = bfd_malloc (sizeof (*stash->sec_vma) * abfd->section_count);
   if (stash->sec_vma == NULL)
-    return FALSE;
+    return false;
   stash->sec_vma_count = abfd->section_count;
   for (i = 0, s = abfd->sections;
        s != NULL && i < abfd->section_count;
@@ -4711,7 +4711,7 @@ save_section_vma (const bfd *abfd, struct dwarf2_debug *stash)
       else
 	stash->sec_vma[i] = s->vma;
     }
-  return TRUE;
+  return true;
 }
 
 /* Compare current section VMAs against those at the time the stash
@@ -4721,7 +4721,7 @@ save_section_vma (const bfd *abfd, struct dwarf2_debug *stash)
    sections, so the stashed section contents depend on symbol values,
    which in turn depend on section VMAs.  */
 
-static bfd_boolean
+static bool
 section_vma_same (const bfd *abfd, const struct dwarf2_debug *stash)
 {
   asection *s;
@@ -4731,7 +4731,7 @@ section_vma_same (const bfd *abfd, const struct dwarf2_debug *stash)
      when the stash was created and now, then we cannot trust the
      stashed vma information.  */
   if (abfd->section_count != stash->sec_vma_count)
-    return FALSE;
+    return false;
 
   for (i = 0, s = abfd->sections;
        s != NULL && i < abfd->section_count;
@@ -4744,9 +4744,9 @@ section_vma_same (const bfd *abfd, const struct dwarf2_debug *stash)
       else
 	vma = s->vma;
       if (vma != stash->sec_vma[i])
-	return FALSE;
+	return false;
     }
-  return TRUE;
+  return true;
 }
 
 /* Read debug information from DEBUG_BFD when DEBUG_BFD is specified.
@@ -4754,12 +4754,12 @@ section_vma_same (const bfd *abfd, const struct dwarf2_debug *stash)
    or its gnu_debuglink. The results will be stored in PINFO.
    The function returns TRUE iff debug information is ready.  */
 
-bfd_boolean
+bool
 _bfd_dwarf2_slurp_debug_info (bfd *abfd, bfd *debug_bfd,
 			      const struct dwarf_debug_section *debug_sections,
 			      asymbol **symbols,
 			      void **pinfo,
-			      bfd_boolean do_place)
+			      bool do_place)
 {
   size_t amt = sizeof (struct dwarf2_debug);
   bfd_size_type total_size;
@@ -4776,11 +4776,11 @@ _bfd_dwarf2_slurp_debug_info (bfd *abfd, bfd *debug_bfd,
 	  if (stash->f.bfd_ptr != NULL)
 	    {
 	      if (do_place && !place_sections (abfd, stash))
-		return FALSE;
-	      return TRUE;
+		return false;
+	      return true;
 	    }
 
-	  return FALSE;
+	  return false;
 	}
       _bfd_dwarf2_cleanup_debug_info (abfd, pinfo);
       memset (stash, 0, amt);
@@ -4789,23 +4789,23 @@ _bfd_dwarf2_slurp_debug_info (bfd *abfd, bfd *debug_bfd,
     {
       stash = (struct dwarf2_debug *) bfd_zalloc (abfd, amt);
       if (! stash)
-	return FALSE;
+	return false;
     }
   stash->orig_bfd = abfd;
   stash->debug_sections = debug_sections;
   stash->f.syms = symbols;
   if (!save_section_vma (abfd, stash))
-    return FALSE;
+    return false;
 
   stash->f.abbrev_offsets = htab_create_alloc (10, hash_abbrev, eq_abbrev,
 					       del_abbrev, calloc, free);
   if (!stash->f.abbrev_offsets)
-    return FALSE;
+    return false;
 
   stash->alt.abbrev_offsets = htab_create_alloc (10, hash_abbrev, eq_abbrev,
 						 del_abbrev, calloc, free);
   if (!stash->alt.abbrev_offsets)
-    return FALSE;
+    return false;
 
   *pinfo = stash;
 
@@ -4826,13 +4826,13 @@ _bfd_dwarf2_slurp_debug_info (bfd *abfd, bfd *debug_bfd,
 	   Note that at this point the stash has been allocated, but
 	   contains zeros.  This lets future calls to this function
 	   fail more quickly.  */
-	return FALSE;
+	return false;
 
       debug_bfd = bfd_openr (debug_filename, NULL);
       free (debug_filename);
       if (debug_bfd == NULL)
 	/* FIXME: Should we report our failure to follow the debuglink ?  */
-	return FALSE;
+	return false;
 
       /* Set BFD_DECOMPRESS to decompress debug sections.  */
       debug_bfd->flags |= BFD_DECOMPRESS;
@@ -4842,18 +4842,18 @@ _bfd_dwarf2_slurp_debug_info (bfd *abfd, bfd *debug_bfd,
 	  || !bfd_generic_link_read_symbols (debug_bfd))
 	{
 	  bfd_close (debug_bfd);
-	  return FALSE;
+	  return false;
 	}
 
       symbols = bfd_get_outsymbols (debug_bfd);
       stash->f.syms = symbols;
-      stash->close_on_cleanup = TRUE;
+      stash->close_on_cleanup = true;
     }
   stash->f.bfd_ptr = debug_bfd;
 
   if (do_place
       && !place_sections (abfd, stash))
-    return FALSE;
+    return false;
 
   /* There can be more than one DWARF2 info section in a BFD these
      days.  First handle the easy case when there's only one.  If
@@ -4873,7 +4873,7 @@ _bfd_dwarf2_slurp_debug_info (bfd *abfd, bfd *debug_bfd,
       if (! read_section (debug_bfd, &stash->debug_sections[debug_info],
 			  symbols, 0,
 			  &stash->f.dwarf_info_buffer, &total_size))
-	return FALSE;
+	return false;
     }
   else
     {
@@ -4887,14 +4887,14 @@ _bfd_dwarf2_slurp_debug_info (bfd *abfd, bfd *debug_bfd,
 	      || total_size + msec->size < msec->size)
 	    {
 	      bfd_set_error (bfd_error_no_memory);
-	      return FALSE;
+	      return false;
 	    }
 	  total_size += msec->size;
 	}
 
       stash->f.dwarf_info_buffer = (bfd_byte *) bfd_malloc (total_size);
       if (stash->f.dwarf_info_buffer == NULL)
-	return FALSE;
+	return false;
 
       total_size = 0;
       for (msec = find_debug_info (debug_bfd, debug_sections, NULL);
@@ -4910,7 +4910,7 @@ _bfd_dwarf2_slurp_debug_info (bfd *abfd, bfd *debug_bfd,
 	  if (!(bfd_simple_get_relocated_section_contents
 		(debug_bfd, msec, stash->f.dwarf_info_buffer + total_size,
 		 symbols)))
-	    return FALSE;
+	    return false;
 
 	  total_size += size;
 	}
@@ -4918,7 +4918,7 @@ _bfd_dwarf2_slurp_debug_info (bfd *abfd, bfd *debug_bfd,
 
   stash->f.info_ptr = stash->f.dwarf_info_buffer;
   stash->f.dwarf_info_size = total_size;
-  return TRUE;
+  return true;
 }
 
 /* Parse the next DWARF2 compilation unit at FILE->INFO_PTR.  */
@@ -5116,8 +5116,8 @@ _bfd_dwarf2_find_nearest_line (bfd *abfd,
   bfd_vma addr;
   struct comp_unit* each;
   struct funcinfo *function = NULL;
-  int found = FALSE;
-  bfd_boolean do_line;
+  int found = false;
+  bool do_line;
 
   *filename_ptr = NULL;
   if (functionname_ptr != NULL)
@@ -5129,7 +5129,7 @@ _bfd_dwarf2_find_nearest_line (bfd *abfd,
   if (! _bfd_dwarf2_slurp_debug_info (abfd, NULL, debug_sections,
 				      symbols, pinfo,
 				      (abfd->flags & (EXEC_P | DYNAMIC)) == 0))
-    return FALSE;
+    return false;
 
   stash = (struct dwarf2_debug *) *pinfo;
 
@@ -5169,7 +5169,7 @@ _bfd_dwarf2_find_nearest_line (bfd *abfd,
 		&& ((*tmp)->flags & BSF_SECTION_SYM) == 0)
 	      {
 		symbol = *tmp;
-		do_line = TRUE;
+		do_line = true;
 		/* For local symbols, keep going in the hope we find a
 		   global.  */
 		if ((symbol->flags & BSF_GLOBAL) != 0)
@@ -5186,7 +5186,7 @@ _bfd_dwarf2_find_nearest_line (bfd *abfd,
   /* A null info_ptr indicates that there is no dwarf2 info
      (or that an error occured while setting up the stash).  */
   if (! stash->f.info_ptr)
-    return FALSE;
+    return false;
 
   stash->inliner_chain = NULL;
 
@@ -5274,7 +5274,7 @@ _bfd_dwarf2_find_nearest_line (bfd *abfd,
 
       if (* linenumber_ptr)
 	{
-	  found = TRUE;
+	  found = true;
 	  goto done;
 	}
     }
@@ -5337,7 +5337,7 @@ _bfd_dwarf2_find_nearest_line (bfd *abfd,
 	    function->name = *functionname_ptr;
 	  /* Even if we didn't find a linkage name, say that we have
 	     to stop a repeated search of symbols.  */
-	  function->is_linkage = TRUE;
+	  function->is_linkage = true;
 	}
     }
 
@@ -5347,7 +5347,7 @@ _bfd_dwarf2_find_nearest_line (bfd *abfd,
   return found;
 }
 
-bfd_boolean
+bool
 _bfd_dwarf2_find_inliner_info (bfd *abfd ATTRIBUTE_UNUSED,
 			       const char **filename_ptr,
 			       const char **functionname_ptr,
@@ -5367,11 +5367,11 @@ _bfd_dwarf2_find_inliner_info (bfd *abfd ATTRIBUTE_UNUSED,
 	  *functionname_ptr = func->caller_func->name;
 	  *linenumber_ptr = func->caller_line;
 	  stash->inliner_chain = func->caller_func;
-	  return TRUE;
+	  return true;
 	}
     }
 
-  return FALSE;
+  return false;
 }
 
 void