. } u;
.
. {* Selector for the union above. *}
-. bfd_boolean is_sym;
+. bool is_sym;
.} combined_entry_type;
.
.
. struct lineno_cache_entry *lineno;
.
. {* Have the line numbers been relocated yet ? *}
-. bfd_boolean done_lineno;
+. bool done_lineno;
.} coff_symbol_type;
*/
/* Define a macro that can be used to initialise both the fields relating
to long section names in the backend data struct simultaneously. */
#if COFF_ENABLE_LONG_SECTION_NAMES
-#define COFF_DEFAULT_LONG_SECTION_NAMES (TRUE), COFF_LONG_SECTION_NAMES_SETTER
+#define COFF_DEFAULT_LONG_SECTION_NAMES (true), COFF_LONG_SECTION_NAMES_SETTER
#else /* !COFF_ENABLE_LONG_SECTION_NAMES */
-#define COFF_DEFAULT_LONG_SECTION_NAMES (FALSE), COFF_LONG_SECTION_NAMES_SETTER
+#define COFF_DEFAULT_LONG_SECTION_NAMES (false), COFF_LONG_SECTION_NAMES_SETTER
#endif /* COFF_ENABLE_LONG_SECTION_NAMES */
#if defined (COFF_LONG_SECTION_NAMES)
-static bfd_boolean bfd_coff_set_long_section_names_allowed
+static bool bfd_coff_set_long_section_names_allowed
(bfd *, int);
#else /* !defined (COFF_LONG_SECTION_NAMES) */
-static bfd_boolean bfd_coff_set_long_section_names_disallowed
+static bool bfd_coff_set_long_section_names_disallowed
(bfd *, int);
#endif /* defined (COFF_LONG_SECTION_NAMES) */
static long sec_to_styp_flags
(const char *, flagword);
-static bfd_boolean styp_to_sec_flags
+static bool styp_to_sec_flags
(bfd *, void *, const char *, asection *, flagword *);
-static bfd_boolean coff_bad_format_hook
+static bool coff_bad_format_hook
(bfd *, void *);
static void coff_set_custom_section_alignment
(bfd *, asection *, const struct coff_section_alignment_entry *,
const unsigned int);
-static bfd_boolean coff_new_section_hook
+static bool coff_new_section_hook
(bfd *, asection *);
-static bfd_boolean coff_set_arch_mach_hook
+static bool coff_set_arch_mach_hook
(bfd *, void *);
-static bfd_boolean coff_write_relocs
+static bool coff_write_relocs
(bfd *, int);
-static bfd_boolean coff_set_flags
+static bool coff_set_flags
(bfd *, unsigned int *, unsigned short *);
-static bfd_boolean coff_set_arch_mach
+static bool coff_set_arch_mach
(bfd *, enum bfd_architecture, unsigned long) ATTRIBUTE_UNUSED;
-static bfd_boolean coff_compute_section_file_positions
+static bool coff_compute_section_file_positions
(bfd *);
-static bfd_boolean coff_write_object_contents
+static bool coff_write_object_contents
(bfd *) ATTRIBUTE_UNUSED;
-static bfd_boolean coff_set_section_contents
+static bool coff_set_section_contents
(bfd *, asection *, const void *, file_ptr, bfd_size_type);
-static bfd_boolean coff_slurp_line_table
+static bool coff_slurp_line_table
(bfd *, asection *);
-static bfd_boolean coff_slurp_symbol_table
+static bool coff_slurp_symbol_table
(bfd *);
static enum coff_symbol_classification coff_classify_symbol
(bfd *, struct internal_syment *);
-static bfd_boolean coff_slurp_reloc_table
+static bool coff_slurp_reloc_table
(bfd *, asection *, asymbol **);
static long coff_canonicalize_reloc
(bfd *, asection *, arelent **, asymbol **);
(bfd *, flagword, void *, const char *, asection *);
#endif
#ifdef TICOFF
-static bfd_boolean ticoff0_bad_format_hook
+static bool ticoff0_bad_format_hook
(bfd *, void * );
-static bfd_boolean ticoff1_bad_format_hook
+static bool ticoff1_bad_format_hook
(bfd *, void * );
#endif
\f
/* void warning(); */
#if defined (COFF_LONG_SECTION_NAMES)
-static bfd_boolean
+static bool
bfd_coff_set_long_section_names_allowed (bfd *abfd, int enable)
{
coff_backend_info (abfd)->_bfd_coff_long_section_names = enable;
- return TRUE;
+ return true;
}
#else /* !defined (COFF_LONG_SECTION_NAMES) */
-static bfd_boolean
+static bool
bfd_coff_set_long_section_names_disallowed (bfd *abfd, int enable)
{
(void) abfd;
(void) enable;
- return FALSE;
+ return false;
}
#endif /* defined (COFF_LONG_SECTION_NAMES) */
sec_to_styp_flags (const char *sec_name, flagword sec_flags)
{
long styp_flags = 0;
- bfd_boolean is_dbg = FALSE;
+ bool is_dbg = false;
if (startswith (sec_name, DOT_DEBUG)
|| startswith (sec_name, DOT_ZDEBUG)
|| startswith (sec_name, GNU_LINKONCE_WT)
#endif
|| startswith (sec_name, ".stab"))
- is_dbg = TRUE;
+ is_dbg = true;
/* caution: there are at least three groups of symbols that have
very similar bits and meanings: IMAGE_SCN*, SEC_*, and STYP_*.
#ifndef COFF_WITH_PE
-static bfd_boolean
+static bool
styp_to_sec_flags (bfd *abfd,
void * hdr,
const char *name,
flagword *flags_ptr)
{
struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
- long styp_flags = internal_s->s_flags;
+ unsigned long styp_flags = internal_s->s_flags;
flagword sec_flags = 0;
#ifdef STYP_BLOCK
#endif
if (flags_ptr == NULL)
- return FALSE;
+ return false;
* flags_ptr = sec_flags;
- return TRUE;
+ return true;
}
#else /* COFF_WITH_PE */
required information. FIXME: Is the COMDAT symbol index used for
any purpose other than objdump? */
-static bfd_boolean
+static bool
styp_to_sec_flags (bfd *abfd,
void * hdr,
const char *name,
struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
unsigned long styp_flags = internal_s->s_flags;
flagword sec_flags;
- bfd_boolean result = TRUE;
- bfd_boolean is_dbg = FALSE;
+ bool result = true;
+ bool is_dbg = false;
if (startswith (name, DOT_DEBUG)
|| startswith (name, DOT_ZDEBUG)
|| startswith (name, GNU_DEBUGALTLINK)
#endif
|| startswith (name, ".stab"))
- is_dbg = TRUE;
+ is_dbg = true;
/* Assume read only unless IMAGE_SCN_MEM_WRITE is specified. */
sec_flags = SEC_READONLY;
/* xgettext:c-format */
(_("%pB (%s): section flag %s (%#lx) ignored"),
abfd, name, unhandled, flag);
- result = FALSE;
+ result = false;
}
}
. unsigned int _bfd_relsz;
. unsigned int _bfd_linesz;
. unsigned int _bfd_filnmlen;
-. bfd_boolean _bfd_coff_long_filenames;
+. bool _bfd_coff_long_filenames;
.
-. bfd_boolean _bfd_coff_long_section_names;
-. bfd_boolean (*_bfd_coff_set_long_section_names)
+. bool _bfd_coff_long_section_names;
+. bool (*_bfd_coff_set_long_section_names)
. (bfd *, int);
.
. unsigned int _bfd_coff_default_section_alignment_power;
-. bfd_boolean _bfd_coff_force_symnames_in_strings;
+. bool _bfd_coff_force_symnames_in_strings;
. unsigned int _bfd_coff_debug_string_prefix_length;
. unsigned int _bfd_coff_max_nscns;
.
. void (*_bfd_coff_swap_reloc_in)
. (bfd *abfd, void *, void *);
.
-. bfd_boolean (*_bfd_coff_bad_format_hook)
+. bool (*_bfd_coff_bad_format_hook)
. (bfd *, void *);
.
-. bfd_boolean (*_bfd_coff_set_arch_mach_hook)
+. bool (*_bfd_coff_set_arch_mach_hook)
. (bfd *, void *);
.
. void * (*_bfd_coff_mkobject_hook)
. (bfd *, void *, void *);
.
-. bfd_boolean (*_bfd_styp_to_sec_flags_hook)
+. bool (*_bfd_styp_to_sec_flags_hook)
. (bfd *, void *, const char *, asection *, flagword *);
.
. void (*_bfd_set_alignment_hook)
. (bfd *, asection *, void *);
.
-. bfd_boolean (*_bfd_coff_slurp_symbol_table)
+. bool (*_bfd_coff_slurp_symbol_table)
. (bfd *);
.
-. bfd_boolean (*_bfd_coff_symname_in_debug)
+. bool (*_bfd_coff_symname_in_debug)
. (bfd *, struct internal_syment *);
.
-. bfd_boolean (*_bfd_coff_pointerize_aux_hook)
+. bool (*_bfd_coff_pointerize_aux_hook)
. (bfd *, combined_entry_type *, combined_entry_type *,
. unsigned int, combined_entry_type *);
.
-. bfd_boolean (*_bfd_coff_print_aux)
+. bool (*_bfd_coff_print_aux)
. (bfd *, FILE *, combined_entry_type *, combined_entry_type *,
. combined_entry_type *, unsigned int);
.
. enum coff_symbol_classification (*_bfd_coff_classify_symbol)
. (bfd *, struct internal_syment *);
.
-. bfd_boolean (*_bfd_coff_compute_section_file_positions)
+. bool (*_bfd_coff_compute_section_file_positions)
. (bfd *);
.
-. bfd_boolean (*_bfd_coff_start_final_link)
+. bool (*_bfd_coff_start_final_link)
. (bfd *, struct bfd_link_info *);
.
-. bfd_boolean (*_bfd_coff_relocate_section)
+. bool (*_bfd_coff_relocate_section)
. (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
. struct internal_reloc *, struct internal_syment *, asection **);
.
. (bfd *, asection *, struct internal_reloc *,
. struct coff_link_hash_entry *, struct internal_syment *, bfd_vma *);
.
-. bfd_boolean (*_bfd_coff_adjust_symndx)
+. bool (*_bfd_coff_adjust_symndx)
. (bfd *, struct bfd_link_info *, bfd *, asection *,
-. struct internal_reloc *, bfd_boolean *);
+. struct internal_reloc *, bool *);
.
-. bfd_boolean (*_bfd_coff_link_add_one_symbol)
+. bool (*_bfd_coff_link_add_one_symbol)
. (struct bfd_link_info *, bfd *, const char *, flagword,
-. asection *, bfd_vma, const char *, bfd_boolean, bfd_boolean,
+. asection *, bfd_vma, const char *, bool, bool,
. struct bfd_link_hash_entry **);
.
-. bfd_boolean (*_bfd_coff_link_output_has_begun)
+. bool (*_bfd_coff_link_output_has_begun)
. (bfd *, struct coff_final_link_info *);
.
-. bfd_boolean (*_bfd_coff_final_link_postscript)
+. bool (*_bfd_coff_final_link_postscript)
. (bfd *, struct coff_final_link_info *);
.
-. bfd_boolean (*_bfd_coff_print_pdata)
+. bool (*_bfd_coff_print_pdata)
. (bfd *, void *);
.
.} bfd_coff_backend_data;
/* See whether the magic number matches. */
-static bfd_boolean
+static bool
coff_bad_format_hook (bfd * abfd ATTRIBUTE_UNUSED, void * filehdr)
{
struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
if (BADMAG (*internal_f))
- return FALSE;
+ return false;
- return TRUE;
+ return true;
}
#ifdef TICOFF
-static bfd_boolean
+static bool
ticoff0_bad_format_hook (bfd *abfd ATTRIBUTE_UNUSED, void * filehdr)
{
struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
if (COFF0_BADMAG (*internal_f))
- return FALSE;
+ return false;
- return TRUE;
+ return true;
}
#endif
#ifdef TICOFF
-static bfd_boolean
+static bool
ticoff1_bad_format_hook (bfd *abfd ATTRIBUTE_UNUSED, void * filehdr)
{
struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
if (COFF1_BADMAG (*internal_f))
- return FALSE;
+ return false;
- return TRUE;
+ return true;
}
#endif
/* Initialize a section structure with information peculiar to this
particular implementation of COFF. */
-static bfd_boolean
+static bool
coff_new_section_hook (bfd * abfd, asection * section)
{
combined_entry_type *native;
/* Set up the section symbol. */
if (!_bfd_generic_new_section_hook (abfd, section))
- return FALSE;
+ return false;
/* Allocate aux records for section symbols, to store size and
related info.
amt = sizeof (combined_entry_type) * 10;
native = (combined_entry_type *) bfd_zalloc (abfd, amt);
if (native == NULL)
- return FALSE;
+ return false;
/* We don't need to set up n_name, n_value, or n_scnum in the native
symbol information, since they'll be overridden by the BFD symbol
in case this symbol winds up getting written out. The value 0
for n_numaux is already correct. */
- native->is_sym = TRUE;
+ native->is_sym = true;
native->u.syment.n_type = T_NULL;
native->u.syment.n_sclass = sclass;
coff_section_alignment_table,
coff_section_alignment_table_size);
- return TRUE;
+ return true;
}
#ifdef COFF_ALIGN_IN_SECTION_HEADER
#ifndef coff_mkobject
-static bfd_boolean
+static bool
coff_mkobject (bfd * abfd)
{
coff_data_type *coff;
abfd->tdata.coff_obj_data = bfd_zalloc (abfd, amt);
if (abfd->tdata.coff_obj_data == NULL)
- return FALSE;
+ return false;
coff = coff_data (abfd);
coff->symbols = NULL;
coff->conversion_table = NULL;
/* make_abs_section(abfd);*/
- return TRUE;
+ return true;
}
#endif
# else
xcoff->xcoff64 = 0;
# endif
- xcoff->full_aouthdr = TRUE;
+ xcoff->full_aouthdr = true;
xcoff->toc = internal_a->o_toc;
xcoff->sntoc = internal_a->o_sntoc;
xcoff->snentry = internal_a->o_snentry;
would be target independent and would also be much more successful
at linking together COFF files for different architectures. */
-static bfd_boolean
+static bool
coff_set_arch_mach_hook (bfd *abfd, void * filehdr)
{
unsigned long machine;
machine = ((unsigned)internal_f->f_flags & F_MACHMASK) >> 12;
break;
default:
- return FALSE;
+ return false;
}
break;
#endif
machine = bfd_mach_z8002;
break;
default:
- return FALSE;
+ return false;
}
break;
#endif
bfd_size_type amt = bfd_coff_symesz (abfd);
if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0)
- return FALSE;
+ return false;
buf = _bfd_malloc_and_read (abfd, amt, amt);
if (buf == NULL)
- return FALSE;
+ return false;
bfd_coff_swap_sym_in (abfd, buf, & sym);
if (sym.n_sclass == C_FILE)
cputype = sym.n_type & 0xff;
}
bfd_default_set_arch_mach (abfd, arch, machine);
- return TRUE;
+ return true;
}
-static bfd_boolean
+static bool
symname_in_debug_hook (bfd *abfd ATTRIBUTE_UNUSED,
struct internal_syment *sym ATTRIBUTE_UNUSED)
{
#ifdef SYMNAME_IN_DEBUG
return SYMNAME_IN_DEBUG (sym) != 0;
#else
- return FALSE;
+ return false;
#endif
}
/* Handle the csect auxent of a C_EXT, C_AIX_WEAKEXT or C_HIDEXT symbol. */
-static bfd_boolean
+static bool
coff_pointerize_aux_hook (bfd *abfd ATTRIBUTE_UNUSED,
combined_entry_type *table_base,
combined_entry_type *symbol,
/* Return TRUE to indicate that the caller should not do any
further work on this auxent. */
- return TRUE;
+ return true;
}
/* Return FALSE to indicate that this auxent should be handled by
the caller. */
- return FALSE;
+ return false;
}
#else
/* Print an aux entry. This returns TRUE if it has printed it. */
-static bfd_boolean
+static bool
coff_print_aux (bfd *abfd ATTRIBUTE_UNUSED,
FILE *file ATTRIBUTE_UNUSED,
combined_entry_type *table_base ATTRIBUTE_UNUSED,
(unsigned int) aux->u.auxent.x_csect.x_smclas,
aux->u.auxent.x_csect.x_stab,
(unsigned int) aux->u.auxent.x_csect.x_snstab);
- return TRUE;
+ return true;
}
#endif
/* Return FALSE to indicate that no special action was taken. */
- return FALSE;
+ return false;
}
/*
#endif /* TARG_AUX */
-static bfd_boolean
+static bool
coff_write_relocs (bfd * abfd, int first_undef)
{
asection *s;
if (p == NULL)
{
if (s->reloc_count > 0)
- return FALSE;
+ return false;
}
else
{
#endif
if (bfd_seek (abfd, s->rel_filepos, SEEK_SET) != 0)
- return FALSE;
+ return false;
#ifdef COFF_WITH_EXTENDED_RELOC_COUNTER
if ((obj_pe (abfd) || obj_go32 (abfd)) && s->reloc_count >= 0xffff)
coff_swap_reloc_out (abfd, &n, &dst);
if (bfd_bwrite (& dst, (bfd_size_type) bfd_coff_relsz (abfd),
abfd) != bfd_coff_relsz (abfd))
- return FALSE;
+ return false;
}
#endif
_bfd_error_handler (_("%pB: reloc against a non-existent"
" symbol index: %ld"),
abfd, n.r_symndx);
- return FALSE;
+ return false;
}
}
}
if (bfd_bwrite (& dst, (bfd_size_type) bfd_coff_relsz (abfd),
abfd) != bfd_coff_relsz (abfd))
- return FALSE;
+ return false;
}
#ifdef TARG_AUX
#endif
}
- return TRUE;
+ return true;
}
/* Set flags and magic number of a coff file from architecture and machine
type. Result is TRUE if we can represent the arch&type, FALSE if not. */
-static bfd_boolean
+static bool
coff_set_flags (bfd * abfd,
unsigned int *magicp ATTRIBUTE_UNUSED,
unsigned short *flagsp ATTRIBUTE_UNUSED)
*flagsp = bfd_get_mach (abfd) << 12;
break;
default:
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
#endif
#ifdef Z8KMAGIC
{
case bfd_mach_z8001: *flagsp = F_Z8001; break;
case bfd_mach_z8002: *flagsp = F_Z8002; break;
- default: return FALSE;
+ default: return false;
}
- return TRUE;
+ return true;
#endif
#ifdef TIC30MAGIC
case bfd_arch_tic30:
*magicp = TIC30MAGIC;
- return TRUE;
+ return true;
#endif
#ifdef TICOFF_DEFAULT_MAGIC
*magicp = TICOFF2MAGIC;
break;
default:
- return FALSE;
+ return false;
}
}
TICOFF_TARGET_MACHINE_SET (flagsp, bfd_get_mach (abfd));
- return TRUE;
+ return true;
#endif
#ifdef ARMMAGIC
case bfd_mach_arm_5TE: * flagsp |= F_ARM_5; break;
case bfd_mach_arm_XScale: * flagsp |= F_ARM_5; break;
}
- return TRUE;
+ return true;
#endif
#if defined(I386MAGIC) || defined(AMD64MAGIC)
#if defined AMD64MAGIC
*magicp = AMD64MAGIC;
#endif
- return TRUE;
+ return true;
#endif
#ifdef IA64MAGIC
case bfd_arch_ia64:
*magicp = IA64MAGIC;
- return TRUE;
+ return true;
#endif
#ifdef SH_ARCH_MAGIC_BIG
else
*magicp = SH_ARCH_MAGIC_LITTLE;
#endif
- return TRUE;
+ return true;
#endif
#ifdef MIPS_ARCH_MAGIC_WINCE
case bfd_arch_mips:
*magicp = MIPS_ARCH_MAGIC_WINCE;
- return TRUE;
+ return true;
#endif
#ifdef SPARCMAGIC
/* Just overwrite the usual value if we're doing Lynx. */
*magicp = LYNXCOFFMAGIC;
#endif
- return TRUE;
+ return true;
#endif
#ifdef RS6000COFF_C
case bfd_arch_powerpc:
BFD_ASSERT (bfd_get_flavour (abfd) == bfd_target_xcoff_flavour);
*magicp = bfd_xcoff_magic_number (abfd);
- return TRUE;
+ return true;
#endif
#ifdef MCOREMAGIC
case bfd_arch_mcore:
* magicp = MCOREMAGIC;
- return TRUE;
+ return true;
#endif
default: /* Unknown architecture. */
- /* Fall through to "return FALSE" below, to avoid
- "statement never reached" errors on the one below. */
break;
}
- return FALSE;
+ return false;
}
-static bfd_boolean
+static bool
coff_set_arch_mach (bfd * abfd,
enum bfd_architecture arch,
unsigned long machine)
unsigned short dummy2;
if (! bfd_default_set_arch_mach (abfd, arch, machine))
- return FALSE;
+ return false;
if (arch != bfd_arch_unknown
&& ! coff_set_flags (abfd, &dummy1, &dummy2))
- return FALSE; /* We can't represent this type. */
+ return false; /* We can't represent this type. */
- return TRUE; /* We're easy... */
+ return true; /* We're easy... */
}
#ifdef COFF_IMAGE_WITH_PE
#undef ALIGN_SECTIONS_IN_FILE
#endif
-static bfd_boolean
+static bool
coff_compute_section_file_positions (bfd * abfd)
{
asection *current;
file_ptr sofar = bfd_coff_filhsz (abfd);
- bfd_boolean align_adjust;
+ bool align_adjust;
unsigned int target_index;
#ifdef ALIGN_SECTIONS_IN_FILE
asection *previous = NULL;
_bfd_error_handler
/* xgettext:c-format */
(_("%pB: page size is too large (0x%x)"), abfd, page_size);
- return FALSE;
+ return false;
}
}
else
amt = sizeof (struct asection *) * (count + 1);
section_list = (asection **) bfd_malloc (amt);
if (section_list == NULL)
- return FALSE;
+ return false;
i = 0;
for (current = abfd->sections; current != NULL; current = current->next)
_bfd_error_handler
/* xgettext:c-format */
(_("%pB: too many sections (%d)"), abfd, target_index);
- return FALSE;
+ return false;
}
- align_adjust = FALSE;
+ align_adjust = false;
for (current = abfd->sections;
current != NULL;
current = current->next)
current->used_by_bfd = bfd_zalloc (abfd, amt);
if (current->used_by_bfd == NULL)
- return FALSE;
+ return false;
}
if (pei_section_data (abfd, current) == NULL)
{
coff_section_data (abfd, current)->tdata = bfd_zalloc (abfd, amt);
if (coff_section_data (abfd, current)->tdata == NULL)
- return FALSE;
+ return false;
}
if (pei_section_data (abfd, current)->virt_size == 0)
pei_section_data (abfd, current)->virt_size = current->size;
size, in case the caller only writes out data to the
unaligned size. */
if (pei_section_data (abfd, current)->virt_size < current->size)
- align_adjust = TRUE;
+ align_adjust = true;
#endif
#ifdef _LIB
b = 0;
if (bfd_seek (abfd, sofar - 1, SEEK_SET) != 0
|| bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
- return FALSE;
+ return false;
}
/* Make sure the relocations are aligned. We don't need to make
sofar = BFD_ALIGN (sofar, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER);
obj_relocbase (abfd) = sofar;
- abfd->output_has_begun = TRUE;
+ abfd->output_has_begun = true;
- return TRUE;
+ return true;
}
#ifdef COFF_IMAGE_WITH_PE
-static bfd_boolean
+static bool
coff_read_word (bfd *abfd, unsigned int *value, unsigned int *pelength)
{
unsigned char b[2];
if (status < 1)
{
*value = 0;
- return FALSE;
+ return false;
}
if (status == 1)
*pelength += status;
- return TRUE;
+ return true;
}
static unsigned int
coff_compute_checksum (bfd *abfd, unsigned int *pelength)
{
- bfd_boolean more_data;
+ bool more_data;
file_ptr filepos;
unsigned int value;
unsigned int total;
return (0xffff & (total + (total >> 0x10)));
}
-static bfd_boolean
+static bool
coff_apply_checksum (bfd *abfd)
{
unsigned int computed;
unsigned int pelength;
if (bfd_seek (abfd, 0x3c, SEEK_SET) != 0)
- return FALSE;
+ return false;
if (!coff_read_word (abfd, &peheader, &pelength))
- return FALSE;
+ return false;
if (bfd_seek (abfd, peheader + 0x58, SEEK_SET) != 0)
- return FALSE;
+ return false;
checksum = 0;
bfd_bwrite (&checksum, (bfd_size_type) 4, abfd);
if (bfd_seek (abfd, peheader, SEEK_SET) != 0)
- return FALSE;
+ return false;
computed = coff_compute_checksum (abfd, &pelength);
checksum = computed + pelength;
if (bfd_seek (abfd, peheader + 0x58, SEEK_SET) != 0)
- return FALSE;
+ return false;
bfd_bwrite (&checksum, (bfd_size_type) 4, abfd);
- return TRUE;
+ return true;
}
#endif /* COFF_IMAGE_WITH_PE */
-static bfd_boolean
+static bool
coff_write_object_contents (bfd * abfd)
{
asection *current;
- bfd_boolean hasrelocs = FALSE;
- bfd_boolean haslinno = FALSE;
+ bool hasrelocs = false;
+ bool haslinno = false;
#ifdef COFF_IMAGE_WITH_PE
- bfd_boolean hasdebug = FALSE;
+ bool hasdebug = false;
#endif
file_ptr scn_base;
file_ptr reloc_base;
file_ptr sym_base;
unsigned long reloc_size = 0, reloc_count = 0;
unsigned long lnno_size = 0;
- bfd_boolean long_section_names;
+ bool long_section_names;
asection *text_sec = NULL;
asection *data_sec = NULL;
asection *bss_sec = NULL;
if (! abfd->output_has_begun)
{
if (! coff_compute_section_file_positions (abfd))
- return FALSE;
+ return false;
}
reloc_base = obj_relocbase (abfd);
}
if (bfd_seek (abfd, scn_base, SEEK_SET) != 0)
- return FALSE;
+ return false;
- long_section_names = FALSE;
+ long_section_names = false;
for (current = abfd->sections;
current != NULL;
current = current->next)
{
struct internal_scnhdr section;
#ifdef COFF_IMAGE_WITH_PE
- bfd_boolean is_reloc_section = FALSE;
+ bool is_reloc_section = false;
if (strcmp (current->name, DOT_RELOC) == 0)
{
- is_reloc_section = TRUE;
- hasrelocs = TRUE;
+ is_reloc_section = true;
+ hasrelocs = true;
pe_data (abfd)->has_reloc_section = 1;
}
#endif
/* xgettext:c-format */
(_("%pB: section %pA: string table overflow at offset %ld"),
abfd, current, (unsigned long) string_size);
- return FALSE;
+ return false;
}
/* We do not need to use snprintf here as we have already verfied
/* Then strncpy takes care of any padding for us. */
strncpy (section.s_name, s_name_buf, SCNNMLEN);
string_size += len + 1;
- long_section_names = TRUE;
+ long_section_names = true;
}
}
#endif
#ifndef COFF_IMAGE_WITH_PE
/* In PEI, relocs come in the .reloc section. */
if (current->reloc_count != 0)
- hasrelocs = TRUE;
+ hasrelocs = true;
#endif
if (current->lineno_count != 0)
- haslinno = TRUE;
+ haslinno = true;
#ifdef COFF_IMAGE_WITH_PE
if ((current->flags & SEC_DEBUGGING) != 0
&& ! is_reloc_section)
- hasdebug = TRUE;
+ hasdebug = true;
#endif
#ifdef RS6000COFF_C
#ifdef COFF_ENCODE_ALIGNMENT
- COFF_ENCODE_ALIGNMENT(section, current->alignment_power);
- if ((unsigned int)COFF_DECODE_ALIGNMENT(section.s_flags)
- != current->alignment_power)
+ if (COFF_ENCODE_ALIGNMENT (abfd, section, current->alignment_power)
+ && (COFF_DECODE_ALIGNMENT (section.s_flags)
+ != current->alignment_power))
{
- bfd_boolean warn = coff_data (abfd)->link_info
- && !bfd_link_relocatable (coff_data (abfd)->link_info);
+ bool warn = (coff_data (abfd)->link_info
+ && !bfd_link_relocatable (coff_data (abfd)->link_info));
_bfd_error_handler
/* xgettext:c-format */
(_("%pB:%s section %s: alignment 2**%u not representable"),
- abfd, warn ? " warning:" : "", current->name,
- current->alignment_power);
+ abfd, warn ? " warning:" : "", current->name,
+ current->alignment_power);
if (!warn)
{
bfd_set_error (bfd_error_nonrepresentable_section);
- return FALSE;
+ return false;
}
}
#endif
if (bfd_coff_swap_scnhdr_out (abfd, §ion, &buff) == 0
|| bfd_bwrite (& buff, amt, abfd) != amt)
- return FALSE;
+ return false;
}
#ifdef COFF_WITH_PE
amt = bfd_coff_scnhsz (abfd);
if (bfd_coff_swap_scnhdr_out (abfd, &scnhdr, &buff) == 0
|| bfd_bwrite (& buff, amt, abfd) != amt)
- return FALSE;
+ return false;
}
}
#endif
int firstundef;
if (!coff_renumber_symbols (abfd, &firstundef))
- return FALSE;
+ return false;
coff_mangle_symbols (abfd);
if (! coff_write_symbols (abfd))
- return FALSE;
+ return false;
if (! coff_write_linenumbers (abfd))
- return FALSE;
+ return false;
if (! coff_write_relocs (abfd, firstundef))
- return FALSE;
+ return false;
}
#ifdef COFF_LONG_SECTION_NAMES
else if (long_section_names && ! obj_coff_strings_written (abfd))
/* If we have long section names we have to write out the string
table even if there are no symbols. */
if (! coff_write_symbols (abfd))
- return FALSE;
+ return false;
}
#endif
/* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
/* Now write header. */
if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
- return FALSE;
+ return false;
{
char * buff;
buff = (char *) bfd_malloc (amount);
if (buff == NULL)
- return FALSE;
+ return false;
bfd_coff_swap_filehdr_out (abfd, & internal_f, buff);
amount = bfd_bwrite (buff, amount, abfd);
free (buff);
if (amount != bfd_coff_filhsz (abfd))
- return FALSE;
+ return false;
}
if (abfd->flags & EXEC_P)
buff = (char *) bfd_malloc (amount);
if (buff == NULL)
- return FALSE;
+ return false;
coff_swap_aouthdr_out (abfd, & internal_a, buff);
amount = bfd_bwrite (buff, amount, abfd);
free (buff);
if (amount != bfd_coff_aoutsz (abfd))
- return FALSE;
+ return false;
#ifdef COFF_IMAGE_WITH_PE
if (! coff_apply_checksum (abfd))
- return FALSE;
+ return false;
#endif
}
#ifdef RS6000COFF_C
else
size = SMALL_AOUTSZ;
if (bfd_bwrite (& buff, (bfd_size_type) size, abfd) != size)
- return FALSE;
+ return false;
}
#endif
#endif
- return TRUE;
+ return true;
}
-static bfd_boolean
+static bool
coff_set_section_contents (bfd * abfd,
sec_ptr section,
const void * location,
if (! abfd->output_has_begun) /* Set by bfd.c handler. */
{
if (! coff_compute_section_file_positions (abfd))
- return FALSE;
+ return false;
}
#if defined(_LIB) && !defined(TARG_AUX)
/* Don't write out bss sections - one way to do this is to
see if the filepos has not been set. */
if (section->filepos == 0)
- return TRUE;
+ return true;
if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0)
- return FALSE;
+ return false;
if (count == 0)
- return TRUE;
+ return true;
return bfd_bwrite (location, count, abfd) == count;
}
return 0;
}
-static bfd_boolean
+static bool
coff_slurp_line_table (bfd *abfd, asection *asect)
{
LINENO *native_lineno;
unsigned int counter;
alent *cache_ptr;
bfd_vma prev_offset = 0;
- bfd_boolean ordered = TRUE;
+ bool ordered = true;
unsigned int nbr_func;
LINENO *src;
- bfd_boolean have_func;
- bfd_boolean ret = TRUE;
+ bool have_func;
+ bool ret = true;
size_t amt;
if (asect->lineno_count == 0)
- return TRUE;
+ return true;
BFD_ASSERT (asect->lineno == NULL);
_bfd_error_handler
(_("%pB: warning: line number count (%#lx) exceeds section size (%#lx)"),
abfd, (unsigned long) asect->lineno_count, (unsigned long) asect->size);
- return FALSE;
+ return false;
}
if (_bfd_mul_overflow (asect->lineno_count + 1, sizeof (alent), &amt))
{
bfd_set_error (bfd_error_file_too_big);
- return FALSE;
+ return false;
}
lineno_cache = (alent *) bfd_alloc (abfd, amt);
if (lineno_cache == NULL)
- return FALSE;
+ return false;
native_lineno = (LINENO *) buy_and_read (abfd, asect->line_filepos,
asect->lineno_count,
_bfd_error_handler
(_("%pB: warning: line number table read failed"), abfd);
bfd_release (abfd, lineno_cache);
- return FALSE;
+ return false;
}
cache_ptr = lineno_cache;
asect->lineno = lineno_cache;
src = native_lineno;
nbr_func = 0;
- have_func = FALSE;
+ have_func = false;
for (counter = 0; counter < asect->lineno_count; counter++, src++)
{
unsigned long symndx;
coff_symbol_type *sym;
- have_func = FALSE;
+ have_func = false;
symndx = dst.l_addr.l_symndx;
if (symndx >= obj_raw_syment_count (abfd))
{
(_("%pB: warning: illegal symbol index 0x%lx in line number entry %d"),
abfd, symndx, counter);
cache_ptr->line_number = -1;
- ret = FALSE;
+ ret = false;
continue;
}
(_("%pB: warning: illegal symbol index 0x%lx in line number entry %d"),
abfd, symndx, counter);
cache_ptr->line_number = -1;
- ret = FALSE;
+ ret = false;
continue;
}
sym = (coff_symbol_type *) (ent->u.syment._n._n_n._n_zeroes);
(_("%pB: warning: illegal symbol in line number entry %d"),
abfd, counter);
cache_ptr->line_number = -1;
- ret = FALSE;
+ ret = false;
continue;
}
- have_func = TRUE;
+ have_func = true;
nbr_func++;
cache_ptr->u.sym = (asymbol *) sym;
if (sym->lineno != NULL)
sym->lineno = cache_ptr;
if (sym->symbol.value < prev_offset)
- ordered = FALSE;
+ ordered = false;
prev_offset = sym->symbol.value;
}
else if (!have_func)
if (_bfd_mul_overflow (nbr_func, sizeof (alent *), &amt))
{
bfd_set_error (bfd_error_file_too_big);
- ret = FALSE;
+ ret = false;
}
else if ((func_table = (alent **) bfd_alloc (abfd, amt)) != NULL)
{
if (_bfd_mul_overflow (asect->lineno_count, sizeof (alent), &amt))
{
bfd_set_error (bfd_error_file_too_big);
- ret = FALSE;
+ ret = false;
}
else if ((n_lineno_cache = (alent *) bfd_alloc (abfd, amt)) != NULL)
{
asect->lineno_count * sizeof (alent));
}
else
- ret = FALSE;
+ ret = false;
bfd_release (abfd, func_table);
}
else
- ret = FALSE;
+ ret = false;
}
return ret;
that if coff_relocate_section is defined, the linker will read
symbols via coff_link_add_symbols, rather than via this routine. */
-static bfd_boolean
+static bool
coff_slurp_symbol_table (bfd * abfd)
{
combined_entry_type *native_symbols;
coff_symbol_type *cached_area;
unsigned int *table_ptr;
unsigned int number_of_symbols = 0;
- bfd_boolean ret = TRUE;
+ bool ret = true;
size_t amt;
if (obj_symbols (abfd))
- return TRUE;
+ return true;
/* Read in the symbol table. */
if ((native_symbols = coff_get_normalized_symtab (abfd)) == NULL)
- return FALSE;
+ return false;
/* Allocate enough room for all the symbols in cached form. */
if (_bfd_mul_overflow (obj_raw_syment_count (abfd),
sizeof (*cached_area), &amt))
{
bfd_set_error (bfd_error_file_too_big);
- return FALSE;
+ return false;
}
cached_area = (coff_symbol_type *) bfd_alloc (abfd, amt);
if (cached_area == NULL)
- return FALSE;
+ return false;
if (_bfd_mul_overflow (obj_raw_syment_count (abfd),
sizeof (*table_ptr), &amt))
{
bfd_set_error (bfd_error_file_too_big);
- return FALSE;
+ return false;
}
table_ptr = (unsigned int *) bfd_zalloc (abfd, amt);
if (table_ptr == NULL)
- return FALSE;
+ return false;
else
{
coff_symbol_type *dst = cached_area;
dst->symbol.flags = 0;
/* PR 17512: file: 079-7098-0.001:0.1. */
dst->symbol.value = 0;
- dst->done_lineno = FALSE;
+ dst->done_lineno = false;
switch (src->u.syment.n_sclass)
{
(_("%pB: unrecognized storage class %d for %s symbol `%s'"),
abfd, src->u.syment.n_sclass,
dst->symbol.section->name, dst->symbol.name);
- ret = FALSE;
+ ret = false;
/* Fall through. */
case C_HIDDEN: /* Ext symbol in dmert public lib. */
/* PR 20722: These symbols can also be generated by
while (p)
{
if (! coff_slurp_line_table (abfd, p))
- return FALSE;
+ return false;
p = p->next;
}
}
}
#endif
-static bfd_boolean
+static bool
coff_slurp_reloc_table (bfd * abfd, sec_ptr asect, asymbol ** symbols)
{
RELOC *native_relocs;
size_t amt;
if (asect->relocation)
- return TRUE;
+ return true;
if (asect->reloc_count == 0)
- return TRUE;
+ return true;
if (asect->flags & SEC_CONSTRUCTOR)
- return TRUE;
+ return true;
if (!coff_slurp_symbol_table (abfd))
- return FALSE;
+ return false;
native_relocs = (RELOC *) buy_and_read (abfd, asect->rel_filepos,
asect->reloc_count,
if (_bfd_mul_overflow (asect->reloc_count, sizeof (arelent), &amt))
{
bfd_set_error (bfd_error_file_too_big);
- return FALSE;
+ return false;
}
reloc_cache = (arelent *) bfd_alloc (abfd, amt);
if (reloc_cache == NULL || native_relocs == NULL)
- return FALSE;
+ return false;
for (idx = 0; idx < asect->reloc_count; idx++)
{
(_("%pB: illegal relocation type %d at address %#" PRIx64),
abfd, dst.r_type, (uint64_t) dst.r_vaddr);
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ return false;
}
}
asect->relocation = reloc_cache;
- return TRUE;
+ return true;
}
#ifndef coff_rtype_to_howto
#ifndef coff_link_output_has_begun
-static bfd_boolean
+static bool
coff_link_output_has_begun (bfd * abfd,
struct coff_final_link_info * info ATTRIBUTE_UNUSED)
{
#ifndef coff_final_link_postscript
-static bfd_boolean
+static bool
coff_final_link_postscript (bfd * abfd ATTRIBUTE_UNUSED,
struct coff_final_link_info * pfinfo ATTRIBUTE_UNUSED)
{
- return TRUE;
+ return true;
}
#endif
coff_SWAP_scnhdr_out,
FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN,
#ifdef COFF_LONG_FILENAMES
- TRUE,
+ true,
#else
- FALSE,
+ false,
#endif
COFF_DEFAULT_LONG_SECTION_NAMES,
COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
#ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
- TRUE,
+ true,
#else
- FALSE,
+ false,
#endif
#ifdef COFF_DEBUG_STRING_WIDE_PREFIX
4,
coff_SWAP_scnhdr_out,
FILHSZ_V0, AOUTSZ, SCNHSZ_V01, SYMESZ, AUXESZ, RELSZ_V0, LINESZ, FILNMLEN,
#ifdef COFF_LONG_FILENAMES
- TRUE,
+ true,
#else
- FALSE,
+ false,
#endif
COFF_DEFAULT_LONG_SECTION_NAMES,
COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
#ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
- TRUE,
+ true,
#else
- FALSE,
+ false,
#endif
#ifdef COFF_DEBUG_STRING_WIDE_PREFIX
4,
coff_SWAP_scnhdr_out,
FILHSZ, AOUTSZ, SCNHSZ_V01, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN,
#ifdef COFF_LONG_FILENAMES
- TRUE,
+ true,
#else
- FALSE,
+ false,
#endif
COFF_DEFAULT_LONG_SECTION_NAMES,
COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
#ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
- TRUE,
+ true,
#else
- FALSE,
+ false,
#endif
#ifdef COFF_DEBUG_STRING_WIDE_PREFIX
4,
coff_SWAP_scnhdr_out,
FILHSZ_BIGOBJ, AOUTSZ, SCNHSZ, SYMESZ_BIGOBJ, AUXESZ_BIGOBJ,
RELSZ, LINESZ, FILNMLEN_BIGOBJ,
- TRUE,
+ true,
COFF_DEFAULT_LONG_SECTION_NAMES,
COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
- FALSE,
+ false,
2,
1U << 31,
coff_bigobj_swap_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
projects / deliverable / binutils-gdb.git / blobdiff