/* Routines to link ECOFF debugging information.
- Copyright (C) 1993-2016 Free Software Foundation, Inc.
+ Copyright (C) 1993-2021 Free Software Foundation, Inc.
Written by Ian Lance Taylor, Cygnus Support, <ian@cygnus.com>.
This file is part of BFD, the Binary File Descriptor library.
#include "bfd.h"
#include "bfdlink.h"
#include "libbfd.h"
+#include "ecoff-bfd.h"
#include "objalloc.h"
#include "aout/stab_gnu.h"
#include "coff/internal.h"
/* now the fun stuff... */
if (bigend)
{
- intern->fBitfield = 0 != (ext->t_bits1[0] & TIR_BITS1_FBITFIELD_BIG);
- intern->continued = 0 != (ext->t_bits1[0] & TIR_BITS1_CONTINUED_BIG);
- intern->bt = (ext->t_bits1[0] & TIR_BITS1_BT_BIG)
- >> TIR_BITS1_BT_SH_BIG;
- intern->tq4 = (ext->t_tq45[0] & TIR_BITS_TQ4_BIG)
+ intern->fBitfield = 0 != (ext->t_bits1[0] & TIR_BITS1_FBITFIELD_BIG);
+ intern->continued = 0 != (ext->t_bits1[0] & TIR_BITS1_CONTINUED_BIG);
+ intern->bt = (ext->t_bits1[0] & TIR_BITS1_BT_BIG)
+ >> TIR_BITS1_BT_SH_BIG;
+ intern->tq4 = (ext->t_tq45[0] & TIR_BITS_TQ4_BIG)
>> TIR_BITS_TQ4_SH_BIG;
- intern->tq5 = (ext->t_tq45[0] & TIR_BITS_TQ5_BIG)
+ intern->tq5 = (ext->t_tq45[0] & TIR_BITS_TQ5_BIG)
>> TIR_BITS_TQ5_SH_BIG;
- intern->tq0 = (ext->t_tq01[0] & TIR_BITS_TQ0_BIG)
+ intern->tq0 = (ext->t_tq01[0] & TIR_BITS_TQ0_BIG)
>> TIR_BITS_TQ0_SH_BIG;
- intern->tq1 = (ext->t_tq01[0] & TIR_BITS_TQ1_BIG)
+ intern->tq1 = (ext->t_tq01[0] & TIR_BITS_TQ1_BIG)
>> TIR_BITS_TQ1_SH_BIG;
- intern->tq2 = (ext->t_tq23[0] & TIR_BITS_TQ2_BIG)
+ intern->tq2 = (ext->t_tq23[0] & TIR_BITS_TQ2_BIG)
>> TIR_BITS_TQ2_SH_BIG;
- intern->tq3 = (ext->t_tq23[0] & TIR_BITS_TQ3_BIG)
+ intern->tq3 = (ext->t_tq23[0] & TIR_BITS_TQ3_BIG)
>> TIR_BITS_TQ3_SH_BIG;
}
else
{
- intern->fBitfield = 0 != (ext->t_bits1[0] & TIR_BITS1_FBITFIELD_LITTLE);
- intern->continued = 0 != (ext->t_bits1[0] & TIR_BITS1_CONTINUED_LITTLE);
- intern->bt = (ext->t_bits1[0] & TIR_BITS1_BT_LITTLE)
+ intern->fBitfield = 0 != (ext->t_bits1[0] & TIR_BITS1_FBITFIELD_LITTLE);
+ intern->continued = 0 != (ext->t_bits1[0] & TIR_BITS1_CONTINUED_LITTLE);
+ intern->bt = (ext->t_bits1[0] & TIR_BITS1_BT_LITTLE)
>> TIR_BITS1_BT_SH_LITTLE;
- intern->tq4 = (ext->t_tq45[0] & TIR_BITS_TQ4_LITTLE)
+ intern->tq4 = (ext->t_tq45[0] & TIR_BITS_TQ4_LITTLE)
>> TIR_BITS_TQ4_SH_LITTLE;
- intern->tq5 = (ext->t_tq45[0] & TIR_BITS_TQ5_LITTLE)
+ intern->tq5 = (ext->t_tq45[0] & TIR_BITS_TQ5_LITTLE)
>> TIR_BITS_TQ5_SH_LITTLE;
- intern->tq0 = (ext->t_tq01[0] & TIR_BITS_TQ0_LITTLE)
+ intern->tq0 = (ext->t_tq01[0] & TIR_BITS_TQ0_LITTLE)
>> TIR_BITS_TQ0_SH_LITTLE;
- intern->tq1 = (ext->t_tq01[0] & TIR_BITS_TQ1_LITTLE)
+ intern->tq1 = (ext->t_tq01[0] & TIR_BITS_TQ1_LITTLE)
>> TIR_BITS_TQ1_SH_LITTLE;
- intern->tq2 = (ext->t_tq23[0] & TIR_BITS_TQ2_LITTLE)
+ intern->tq2 = (ext->t_tq23[0] & TIR_BITS_TQ2_LITTLE)
>> TIR_BITS_TQ2_SH_LITTLE;
- intern->tq3 = (ext->t_tq23[0] & TIR_BITS_TQ3_LITTLE)
+ intern->tq3 = (ext->t_tq23[0] & TIR_BITS_TQ3_LITTLE)
>> TIR_BITS_TQ3_SH_LITTLE;
}
{
intern->rfd = (ext->r_bits[0] << RNDX_BITS0_RFD_SH_LEFT_BIG)
| ((ext->r_bits[1] & RNDX_BITS1_RFD_BIG)
- >> RNDX_BITS1_RFD_SH_BIG);
+ >> RNDX_BITS1_RFD_SH_BIG);
intern->index = ((ext->r_bits[1] & RNDX_BITS1_INDEX_BIG)
- << RNDX_BITS1_INDEX_SH_LEFT_BIG)
+ << RNDX_BITS1_INDEX_SH_LEFT_BIG)
| (ext->r_bits[2] << RNDX_BITS2_INDEX_SH_LEFT_BIG)
| (ext->r_bits[3] << RNDX_BITS3_INDEX_SH_LEFT_BIG);
}
{
intern->rfd = (ext->r_bits[0] << RNDX_BITS0_RFD_SH_LEFT_LITTLE)
| ((ext->r_bits[1] & RNDX_BITS1_RFD_LITTLE)
- << RNDX_BITS1_RFD_SH_LEFT_LITTLE);
+ << RNDX_BITS1_RFD_SH_LEFT_LITTLE);
intern->index = ((ext->r_bits[1] & RNDX_BITS1_INDEX_LITTLE)
- >> RNDX_BITS1_INDEX_SH_LITTLE)
+ >> RNDX_BITS1_INDEX_SH_LITTLE)
| (ext->r_bits[2] << RNDX_BITS2_INDEX_SH_LEFT_LITTLE)
| ((unsigned int) ext->r_bits[3]
<< RNDX_BITS3_INDEX_SH_LEFT_LITTLE);
/* Add bytes to a buffer. Return success. */
-static bfd_boolean
+static bool
ecoff_add_bytes (char **buf, char **bufend, size_t need)
{
size_t have;
}
newbuf = (char *) bfd_realloc (*buf, (bfd_size_type) have + want);
if (newbuf == NULL)
- return FALSE;
+ return false;
*buf = newbuf;
*bufend = *buf + have + want;
- return TRUE;
+ return true;
}
/* We keep a hash table which maps strings to numbers. We use it to
/* The length of the information. */
unsigned long size;
/* Whether this information comes from a file or not. */
- bfd_boolean filep;
+ bool filep;
union
{
struct
/* Add a file entry to a shuffle list. */
-static bfd_boolean
+static bool
add_file_shuffle (struct accumulate *ainfo,
struct shuffle **head,
struct shuffle **tail,
(*tail)->size += size;
if ((*tail)->size > ainfo->largest_file_shuffle)
ainfo->largest_file_shuffle = (*tail)->size;
- return TRUE;
+ return true;
}
n = (struct shuffle *) objalloc_alloc (ainfo->memory,
if (!n)
{
bfd_set_error (bfd_error_no_memory);
- return FALSE;
+ return false;
}
n->next = NULL;
n->size = size;
- n->filep = TRUE;
+ n->filep = true;
n->u.file.input_bfd = input_bfd;
n->u.file.offset = offset;
if (*head == (struct shuffle *) NULL)
*tail = n;
if (size > ainfo->largest_file_shuffle)
ainfo->largest_file_shuffle = size;
- return TRUE;
+ return true;
}
/* Add a memory entry to a shuffle list. */
-static bfd_boolean
+static bool
add_memory_shuffle (struct accumulate *ainfo,
struct shuffle **head,
struct shuffle **tail,
if (!n)
{
bfd_set_error (bfd_error_no_memory);
- return FALSE;
+ return false;
}
n->next = NULL;
n->size = size;
- n->filep = FALSE;
+ n->filep = false;
n->u.memory = data;
if (*head == (struct shuffle *) NULL)
*head = n;
if (*tail != (struct shuffle *) NULL)
(*tail)->next = n;
*tail = n;
- return TRUE;
+ return true;
}
/* Initialize the FDR hash table. This returns a handle which is then
struct bfd_link_info *info)
{
struct accumulate *ainfo;
- bfd_size_type amt = sizeof (struct accumulate);
+ size_t amt = sizeof (struct accumulate);
ainfo = (struct accumulate *) bfd_malloc (amt);
if (!ainfo)
linker information structure. HANDLE is returned by
bfd_ecoff_debug_init. */
-bfd_boolean
+bool
bfd_ecoff_debug_accumulate (void * handle,
bfd *output_bfd,
struct ecoff_debug_info *output_debug,
if (!input_debug->ifdmap || !rfd_out)
{
bfd_set_error (bfd_error_no_memory);
- return FALSE;
+ return false;
}
if (!add_memory_shuffle (ainfo, &ainfo->rfd, &ainfo->rfd_end, rfd_out, sz))
- return FALSE;
+ return false;
copied = 0;
lookup = (char *) bfd_malloc ((bfd_size_type) strlen (name) + 20);
if (lookup == NULL)
- return FALSE;
+ return false;
sprintf (lookup, "%s %lx %lx", name, (unsigned long) fdr.csym,
(unsigned long) fdr.caux);
- fh = string_hash_lookup (&ainfo->fdr_hash, lookup, TRUE, TRUE);
+ fh = string_hash_lookup (&ainfo->fdr_hash, lookup, true, true);
free (lookup);
if (fh == (struct string_hash_entry *) NULL)
- return FALSE;
+ return false;
if (fh->val != -1)
{
if (!fdr_out)
{
bfd_set_error (bfd_error_no_memory);
- return FALSE;
+ return false;
}
if (!add_memory_shuffle (ainfo, &ainfo->fdr, &ainfo->fdr_end, fdr_out, sz))
- return FALSE;
+ return false;
for (fdr_ptr = fdr_start, i = 0;
fdr_ptr < fdr_end;
fdr_ptr += fdr_add, i++)
bfd_byte *sym_out;
bfd_byte *lraw_src;
bfd_byte *lraw_end;
- bfd_boolean fgotfilename;
+ bool fgotfilename;
if (input_debug->ifdmap[i] < output_symhdr->ifdMax)
{
/* Swap in the local symbols, adjust their values, and swap them
out again. */
- fgotfilename = FALSE;
+ fgotfilename = false;
sz = fdr.csym * external_sym_size;
sym_out = (bfd_byte *) objalloc_alloc (ainfo->memory, sz);
if (!sym_out)
{
bfd_set_error (bfd_error_no_memory);
- return FALSE;
+ return false;
}
if (!add_memory_shuffle (ainfo, &ainfo->sym, &ainfo->sym_end, sym_out,
sz))
- return FALSE;
+ return false;
lraw_src = ((bfd_byte *) input_debug->external_sym
+ fdr.isymBase * input_swap->external_sym_size);
lraw_end = lraw_src + fdr.csym * input_swap->external_sym_size;
prevent us from easily merging different FDR's. */
if (! bfd_link_relocatable (info))
{
- bfd_boolean ffilename;
+ bool ffilename;
const char *name;
if (! fgotfilename && internal_sym.iss == fdr.rss)
- ffilename = TRUE;
+ ffilename = true;
else
- ffilename = FALSE;
+ ffilename = false;
/* Hash the name into the string table. */
name = input_debug->ss + fdr.issBase + internal_sym.iss;
{
struct string_hash_entry *sh;
- sh = string_hash_lookup (&ainfo->str_hash, name, TRUE, TRUE);
+ sh = string_hash_lookup (&ainfo->str_hash, name, true, true);
if (sh == (struct string_hash_entry *) NULL)
- return FALSE;
+ return false;
if (sh->val == -1)
{
sh->val = output_symhdr->issMax;
if (ffilename)
{
fdr.rss = internal_sym.iss;
- fgotfilename = TRUE;
+ fgotfilename = true;
}
}
file_ptr pos = input_symhdr->cbLineOffset + fdr.cbLineOffset;
if (!add_file_shuffle (ainfo, &ainfo->line, &ainfo->line_end,
input_bfd, pos, (unsigned long) fdr.cbLine))
- return FALSE;
+ return false;
fdr.ilineBase = output_symhdr->ilineMax;
fdr.cbLineOffset = output_symhdr->cbLine;
output_symhdr->ilineMax += fdr.cline;
if (!add_file_shuffle (ainfo, &ainfo->aux, &ainfo->aux_end,
input_bfd, pos,
fdr.caux * sizeof (union aux_ext)))
- return FALSE;
+ return false;
fdr.iauxBase = output_symhdr->iauxMax;
output_symhdr->iauxMax += fdr.caux;
}
if (! bfd_link_relocatable (info))
{
- /* When are are hashing strings, we lie about the number of
+ /* When we are hashing strings, we lie about the number of
strings attached to each FDR. We need to set cbSs
because some versions of dbx apparently use it to decide
how much of the string table to read in. */
file_ptr pos = input_symhdr->cbSsOffset + fdr.issBase;
if (!add_file_shuffle (ainfo, &ainfo->ss, &ainfo->ss_end,
input_bfd, pos, (unsigned long) fdr.cbSs))
- return FALSE;
+ return false;
fdr.issBase = output_symhdr->issMax;
output_symhdr->issMax += fdr.cbSs;
}
unsigned long size = fdr.cpd * external_pdr_size;
if (!add_file_shuffle (ainfo, &ainfo->pdr, &ainfo->pdr_end,
input_bfd, pos, size))
- return FALSE;
+ return false;
}
BFD_ASSERT (external_opt_size == input_swap->external_opt_size);
if (fdr.copt > 0)
unsigned long size = fdr.copt * external_opt_size;
if (!add_file_shuffle (ainfo, &ainfo->opt, &ainfo->opt_end,
input_bfd, pos, size))
- return FALSE;
+ return false;
}
}
else
if (!out)
{
bfd_set_error (bfd_error_no_memory);
- return FALSE;
+ return false;
}
if (!add_memory_shuffle (ainfo, &ainfo->pdr, &ainfo->pdr_end, out,
sz))
- return FALSE;
+ return false;
for (; in < end; in += insz, out += outsz)
{
PDR pdr;
if (!out)
{
bfd_set_error (bfd_error_no_memory);
- return FALSE;
+ return false;
}
if (!add_memory_shuffle (ainfo, &ainfo->opt, &ainfo->opt_end, out,
sz))
- return FALSE;
+ return false;
for (; in < end; in += insz, out += outsz)
{
OPTR opt;
++output_symhdr->ifdMax;
}
- return TRUE;
+ return true;
}
/* Add a string to the debugging information we are accumulating.
if (bfd_link_relocatable (info))
{
if (!add_memory_shuffle (ainfo, &ainfo->ss, &ainfo->ss_end,
- (bfd_byte *) string, len + 1))
+ (bfd_byte *) string, len + 1))
return -1;
ret = symhdr->issMax;
symhdr->issMax += len + 1;
{
struct string_hash_entry *sh;
- sh = string_hash_lookup (&ainfo->str_hash, string, TRUE, TRUE);
+ sh = string_hash_lookup (&ainfo->str_hash, string, true, true);
if (sh == (struct string_hash_entry *) NULL)
return -1;
if (sh->val == -1)
/* Add debugging information from a non-ECOFF file. */
-bfd_boolean
+bool
bfd_ecoff_debug_accumulate_other (void * handle,
bfd *output_bfd,
struct ecoff_debug_info *output_debug,
fdr.issBase = output_symhdr->issMax;
fdr.cbSs = 0;
fdr.rss = ecoff_add_string (ainfo, info, output_debug, &fdr,
- input_bfd->filename);
+ bfd_get_filename (input_bfd));
if (fdr.rss == -1)
- return FALSE;
+ return false;
fdr.isymBase = output_symhdr->isymMax;
/* Get the local symbols from the input BFD. */
symsize = bfd_get_symtab_upper_bound (input_bfd);
if (symsize < 0)
- return FALSE;
+ return false;
symbols = (asymbol **) bfd_alloc (output_bfd, (bfd_size_type) symsize);
if (symbols == (asymbol **) NULL)
- return FALSE;
+ return false;
symcount = bfd_canonicalize_symtab (input_bfd, symbols);
if (symcount < 0)
- return FALSE;
+ return false;
sym_end = symbols + symcount;
/* Handle the local symbols. Any external symbols are handled
(*sym_ptr)->name);
if (internal_sym.iss == -1)
- return FALSE;
+ return false;
if (bfd_is_com_section ((*sym_ptr)->section)
|| bfd_is_und_section ((*sym_ptr)->section))
internal_sym.value = (*sym_ptr)->value;
if (!external_sym)
{
bfd_set_error (bfd_error_no_memory);
- return FALSE;
+ return false;
}
(*swap_sym_out) (output_bfd, &internal_sym, external_sym);
add_memory_shuffle (ainfo, &ainfo->sym, &ainfo->sym_end,
if (!external_fdr)
{
bfd_set_error (bfd_error_no_memory);
- return FALSE;
+ return false;
}
(*output_swap->swap_fdr_out) (output_bfd, &fdr, external_fdr);
add_memory_shuffle (ainfo, &ainfo->fdr, &ainfo->fdr_end,
++output_symhdr->ifdMax;
- return TRUE;
+ return true;
}
/* Set up ECOFF debugging information for the external symbols.
probably be changed to use a shuffle structure. The assembler uses
this interface, so that must be changed to do something else. */
-bfd_boolean
+bool
bfd_ecoff_debug_externals (bfd *abfd,
struct ecoff_debug_info *debug,
const struct ecoff_debug_swap *swap,
- bfd_boolean relocatable,
- bfd_boolean (*get_extr) (asymbol *, EXTR *),
+ bool relocatable,
+ bool (*get_extr) (asymbol *, EXTR *),
void (*set_index) (asymbol *, bfd_size_type))
{
HDRR * const symhdr = &debug->symbolic_header;
sym_ptr_ptr = bfd_get_outsymbols (abfd);
if (sym_ptr_ptr == NULL)
- return TRUE;
+ return true;
for (c = bfd_get_symcount (abfd); c > 0; c--, sym_ptr_ptr++)
{
if (! bfd_ecoff_debug_one_external (abfd, debug, swap,
sym_ptr->name, &esym))
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
/* Add a single external symbol to the debugging information. */
-bfd_boolean
+bool
bfd_ecoff_debug_one_external (bfd *abfd,
struct ecoff_debug_info *debug,
const struct ecoff_debug_swap *swap,
if (! ecoff_add_bytes ((char **) &debug->ssext,
(char **) &debug->ssext_end,
symhdr->issExtMax + namelen + 1))
- return FALSE;
+ return false;
}
if ((size_t) ((char *) debug->external_ext_end
- (char *) debug->external_ext)
if (! ecoff_add_bytes ((char **) &external_ext,
(char **) &external_ext_end,
(symhdr->iextMax + 1) * (size_t) external_ext_size))
- return FALSE;
+ return false;
debug->external_ext = external_ext;
debug->external_ext_end = external_ext_end;
}
strcpy (debug->ssext + symhdr->issExtMax, name);
symhdr->issExtMax += namelen + 1;
- return TRUE;
+ return true;
}
/* Align the ECOFF debugging information. */
going to be placed at. This assumes that the counts are set
correctly. */
-static bfd_boolean
+static bool
ecoff_write_symhdr (bfd *abfd,
struct ecoff_debug_info *debug,
const struct ecoff_debug_swap *swap,
/* Go to the right location in the file. */
if (bfd_seek (abfd, where, SEEK_SET) != 0)
- return FALSE;
+ return false;
where += swap->external_hdr_size;
!= swap->external_hdr_size)
goto error_return;
- if (buff != NULL)
- free (buff);
- return TRUE;
+ free (buff);
+ return true;
error_return:
- if (buff != NULL)
- free (buff);
- return FALSE;
+ free (buff);
+ return false;
}
/* Write out the ECOFF debugging information. This function assumes
information to. This function fills in the file offsets in the
symbolic header. */
-bfd_boolean
+bool
bfd_ecoff_write_debug (bfd *abfd,
struct ecoff_debug_info *debug,
const struct ecoff_debug_swap *swap,
HDRR * const symhdr = &debug->symbolic_header;
if (! ecoff_write_symhdr (abfd, debug, swap, where))
- return FALSE;
+ return false;
#define WRITE(ptr, count, size, offset) \
- BFD_ASSERT (symhdr->offset == 0 \
- || (bfd_vma) bfd_tell (abfd) == symhdr->offset); \
- if (bfd_bwrite (debug->ptr, (bfd_size_type) size * symhdr->count, abfd)\
- != size * symhdr->count) \
- return FALSE;
+ BFD_ASSERT (symhdr->offset == 0 \
+ || (bfd_vma) bfd_tell (abfd) == symhdr->offset); \
+ if (symhdr->count != 0 \
+ && bfd_bwrite (debug->ptr, \
+ (bfd_size_type) size * symhdr->count, \
+ abfd) != size * symhdr->count) \
+ return false;
WRITE (line, cbLine, sizeof (unsigned char), cbLineOffset);
WRITE (external_dnr, idnMax, swap->external_dnr_size, cbDnOffset);
WRITE (external_ext, iextMax, swap->external_ext_size, cbExtOffset);
#undef WRITE
- return TRUE;
+ return true;
}
/* Write out a shuffle list. */
-static bfd_boolean
+static bool
ecoff_write_shuffle (bfd *abfd,
const struct ecoff_debug_swap *swap,
struct shuffle *shuffle,
{
if (bfd_bwrite (l->u.memory, (bfd_size_type) l->size, abfd)
!= l->size)
- return FALSE;
+ return false;
}
else
{
|| bfd_bread (space, (bfd_size_type) l->size,
l->u.file.input_bfd) != l->size
|| bfd_bwrite (space, (bfd_size_type) l->size, abfd) != l->size)
- return FALSE;
+ return false;
}
total += l->size;
}
i = swap->debug_align - (total & (swap->debug_align - 1));
s = (bfd_byte *) bfd_zmalloc ((bfd_size_type) i);
if (s == NULL && i != 0)
- return FALSE;
+ return false;
if (bfd_bwrite (s, (bfd_size_type) i, abfd) != i)
{
free (s);
- return FALSE;
+ return false;
}
free (s);
}
- return TRUE;
+ return true;
}
/* Write out debugging information using accumulated linker
information. */
-bfd_boolean
+bool
bfd_ecoff_write_accumulated_debug (void * handle,
bfd *abfd,
struct ecoff_debug_info *debug,
/* The external strings and symbol are not converted over to using
shuffles. FIXME: They probably should be. */
amt = debug->symbolic_header.issExtMax;
- if (bfd_bwrite (debug->ssext, amt, abfd) != amt)
+ if (amt != 0 && bfd_bwrite (debug->ssext, amt, abfd) != amt)
goto error_return;
if ((debug->symbolic_header.issExtMax & (swap->debug_align - 1)) != 0)
{
== (bfd_vma) bfd_tell (abfd)));
amt = debug->symbolic_header.iextMax * swap->external_ext_size;
- if (bfd_bwrite (debug->external_ext, amt, abfd) != amt)
+ if (amt != 0 && bfd_bwrite (debug->external_ext, amt, abfd) != amt)
goto error_return;
- if (space != NULL)
- free (space);
- return TRUE;
+ free (space);
+ return true;
error_return:
- if (space != NULL)
- free (space);
- return FALSE;
+ free (space);
+ return false;
}
\f
/* Handle the find_nearest_line function for both ECOFF and MIPS ELF
table will be sorted by address so we can look it up via binary
search. */
-static bfd_boolean
+static bool
mk_fdrtab (bfd *abfd,
struct ecoff_debug_info * const debug_info,
const struct ecoff_debug_swap * const debug_swap,
FDR *fdr_ptr;
FDR *fdr_start;
FDR *fdr_end;
- bfd_boolean stabs;
+ bool stabs;
long len;
bfd_size_type amt;
amt = (bfd_size_type) len * sizeof (struct ecoff_fdrtab_entry);
line_info->fdrtab = (struct ecoff_fdrtab_entry*) bfd_zalloc (abfd, amt);
if (line_info->fdrtab == NULL)
- return FALSE;
+ return false;
line_info->fdrtab_len = len;
tab = line_info->fdrtab;
/* Check whether this file has stabs debugging information. In
a file with stabs debugging information, the second local
symbol is named @stabs. */
- stabs = FALSE;
+ stabs = false;
if (fdr_ptr->csym >= 2)
{
char *sym_ptr;
(*debug_swap->swap_sym_in) (abfd, sym_ptr, &sym);
if (strcmp (debug_info->ss + fdr_ptr->issBase + sym.iss,
STABS_SYMBOL) == 0)
- stabs = TRUE;
+ stabs = true;
}
if (!stabs)
qsort (line_info->fdrtab, (size_t) len,
sizeof (struct ecoff_fdrtab_entry), cmp_fdrtab_entry);
- return TRUE;
+ return true;
}
/* Return index of first FDR that covers to OFFSET. */
/* Look up a line given an address, storing the information in
LINE_INFO->cache. */
-static bfd_boolean
+static bool
lookup_line (bfd *abfd,
struct ecoff_debug_info * const debug_info,
const struct ecoff_debug_swap * const debug_swap,
{
struct ecoff_fdrtab_entry *tab;
bfd_vma offset;
- bfd_boolean stabs;
+ bool stabs;
FDR *fdr_ptr;
int i;
don't have it already. */
if (line_info->fdrtab == NULL
&& !mk_fdrtab (abfd, debug_info, debug_swap, line_info))
- return FALSE;
+ return false;
tab = line_info->fdrtab;
/* Find first FDR for address OFFSET. */
i = fdrtab_lookup (line_info, offset);
if (i < 0)
- return FALSE; /* no FDR, no fun... */
+ return false; /* no FDR, no fun... */
/* eraxxon: 'fdrtab_lookup' doesn't give what we want, at least for Compaq's
C++ compiler 6.2. Consider three FDRs with starting addresses of x, y,
(output format has been edited for our purposes):
FDR [2]: (main.C): First instruction: 0x12000207c <x>
- PDR [5] for File [2]: LoopTest__Xv <0x1200020a0> (a)
- PDR [7] for File [2]: foo__Xv <0x120002168>
- FDR [1]: (-1): First instruction: 0x1200020e8 <y>
- PDR [3] for File [1]: <0x120001ad0> (b)
- FDR [6]: (-1): First instruction: 0x1200026f0 <z>
+ PDR [5] for File [2]: LoopTest__Xv <0x1200020a0> (a)
+ PDR [7] for File [2]: foo__Xv <0x120002168>
+ FDR [1]: (-1): First instruction: 0x1200020e8 <y>
+ PDR [3] for File [1]: <0x120001ad0> (b)
+ FDR [6]: (-1): First instruction: 0x1200026f0 <z>
(a) In the case of PDR5, the vma is such that the first few instructions
of the procedure can be found. But since the size of this procedure is
/* Check whether this file has stabs debugging information. In a
file with stabs debugging information, the second local symbol is
named @stabs. */
- stabs = FALSE;
+ stabs = false;
if (fdr_ptr->csym >= 2)
{
char *sym_ptr;
(*debug_swap->swap_sym_in) (abfd, sym_ptr, &sym);
if (strcmp (debug_info->ss + fdr_ptr->issBase + sym.iss,
STABS_SYMBOL) == 0)
- stabs = TRUE;
+ stabs = true;
}
if (!stabs)
unsigned char *line_end;
int lineno;
/* This file uses ECOFF debugging information. Each FDR has a
- list of procedure descriptors (PDR). The address in the FDR
- is the absolute address of the first procedure. The address
- in the first PDR gives the offset of that procedure relative
- to the object file's base-address. The addresses in
- subsequent PDRs specify each procedure's address relative to
- the object file's base-address. To make things more juicy,
- whenever the PROF bit in the PDR is set, the real entry point
- of the procedure may be 16 bytes below what would normally be
- the procedure's entry point. Instead, DEC came up with a
- wicked scheme to create profiled libraries "on the fly":
- instead of shipping a regular and a profiled version of each
- library, they insert 16 bytes of unused space in front of
- each procedure and set the "prof" bit in the PDR to indicate
- that there is a gap there (this is done automagically by "as"
- when option "-pg" is specified). Thus, normally, you link
- against such a library and, except for lots of 16 byte gaps
- between functions, things will behave as usual. However,
- when invoking "ld" with option "-pg", it will fill those gaps
- with code that calls mcount(). It then moves the function's
- entry point down by 16 bytes, and out pops a binary that has
- all functions profiled.
-
- NOTE: Neither FDRs nor PDRs are strictly sorted in memory
- order. For example, when including header-files that
- define functions, the FDRs follow behind the including
- file, even though their code may have been generated at
- a lower address. File coff-alpha.c from libbfd
- illustrates this (use "odump -PFv" to look at a file's
- FDR/PDR). Similarly, PDRs are sometimes out of order
- as well. An example of this is OSF/1 v3.0 libc's
- malloc.c. I'm not sure why this happens, but it could
- be due to optimizations that reorder a function's
- position within an object-file.
-
- Strategy:
-
- On the first call to this function, we build a table of FDRs
- that is sorted by the base-address of the object-file the FDR
- is referring to. Notice that each object-file may contain
- code from multiple source files (e.g., due to code defined in
- include files). Thus, for any given base-address, there may
- be multiple FDRs (but this case is, fortunately, uncommon).
- lookup(addr) guarantees to return the first FDR that applies
- to address ADDR. Thus, after invoking lookup(), we have a
- list of FDRs that may contain the PDR for ADDR. Next, we
- walk through the PDRs of these FDRs and locate the one that
- is closest to ADDR (i.e., for which the difference between
- ADDR and the PDR's entry point is positive and minimal).
- Once, the right FDR and PDR are located, we simply walk
- through the line-number table to lookup the line-number that
- best matches ADDR. Obviously, things could be sped up by
- keeping a sorted list of PDRs instead of a sorted list of
- FDRs. However, this would increase space requirements
- considerably, which is undesirable. */
+ list of procedure descriptors (PDR). The address in the FDR
+ is the absolute address of the first procedure. The address
+ in the first PDR gives the offset of that procedure relative
+ to the object file's base-address. The addresses in
+ subsequent PDRs specify each procedure's address relative to
+ the object file's base-address. To make things more juicy,
+ whenever the PROF bit in the PDR is set, the real entry point
+ of the procedure may be 16 bytes below what would normally be
+ the procedure's entry point. Instead, DEC came up with a
+ wicked scheme to create profiled libraries "on the fly":
+ instead of shipping a regular and a profiled version of each
+ library, they insert 16 bytes of unused space in front of
+ each procedure and set the "prof" bit in the PDR to indicate
+ that there is a gap there (this is done automagically by "as"
+ when option "-pg" is specified). Thus, normally, you link
+ against such a library and, except for lots of 16 byte gaps
+ between functions, things will behave as usual. However,
+ when invoking "ld" with option "-pg", it will fill those gaps
+ with code that calls mcount(). It then moves the function's
+ entry point down by 16 bytes, and out pops a binary that has
+ all functions profiled.
+
+ NOTE: Neither FDRs nor PDRs are strictly sorted in memory
+ order. For example, when including header-files that
+ define functions, the FDRs follow behind the including
+ file, even though their code may have been generated at
+ a lower address. File coff-alpha.c from libbfd
+ illustrates this (use "odump -PFv" to look at a file's
+ FDR/PDR). Similarly, PDRs are sometimes out of order
+ as well. An example of this is OSF/1 v3.0 libc's
+ malloc.c. I'm not sure why this happens, but it could
+ be due to optimizations that reorder a function's
+ position within an object-file.
+
+ Strategy:
+
+ On the first call to this function, we build a table of FDRs
+ that is sorted by the base-address of the object-file the FDR
+ is referring to. Notice that each object-file may contain
+ code from multiple source files (e.g., due to code defined in
+ include files). Thus, for any given base-address, there may
+ be multiple FDRs (but this case is, fortunately, uncommon).
+ lookup(addr) guarantees to return the first FDR that applies
+ to address ADDR. Thus, after invoking lookup(), we have a
+ list of FDRs that may contain the PDR for ADDR. Next, we
+ walk through the PDRs of these FDRs and locate the one that
+ is closest to ADDR (i.e., for which the difference between
+ ADDR and the PDR's entry point is positive and minimal).
+ Once, the right FDR and PDR are located, we simply walk
+ through the line-number table to lookup the line-number that
+ best matches ADDR. Obviously, things could be sped up by
+ keeping a sorted list of PDRs instead of a sorted list of
+ FDRs. However, this would increase space requirements
+ considerably, which is undesirable. */
external_pdr_size = debug_swap->external_pdr_size;
/* eraxxon: The Horrible Hack: Because of the problems above, set 'i'
i = 0;
/* Search FDR list starting at tab[i] for the PDR that best matches
- OFFSET. Normally, the FDR list is only one entry long. */
+ OFFSET. Normally, the FDR list is only one entry long. */
best_fdr = NULL;
do
{
/* eraxxon: 'dist' and 'min_dist' can be negative now
- because we iterate over every FDR rather than just ones
- with a base address less than or equal to 'offset'. */
+ because we iterate over every FDR rather than just ones
+ with a base address less than or equal to 'offset'. */
bfd_signed_vma dist = -1, min_dist = -1;
char *pdr_hold;
char *pdr_end;
dist = offset - (pdr.adr - 0x10 * pdr.prof);
/* eraxxon: 'dist' can be negative now. Note that
- 'min_dist' can be negative if 'pdr_hold' below is NULL. */
+ 'min_dist' can be negative if 'pdr_hold' below is NULL. */
if (!pdr_hold || (dist >= 0 && dist < min_dist))
{
min_dist = dist;
while (++i < line_info->fdrtab_len);
if (!best_fdr || !best_pdr)
- return FALSE; /* Shouldn't happen... */
+ return false; /* Shouldn't happen... */
/* Phew, finally we got something that we can hold onto. */
fdr_ptr = best_fdr;
pdr_ptr = best_pdr;
(*debug_swap->swap_pdr_in) (abfd, pdr_ptr, &pdr);
/* Now we can look for the actual line number. The line numbers
- are stored in a very funky format, which I won't try to
- describe. The search is bounded by the end of the FDRs line
- number entries. */
+ are stored in a very funky format, which I won't try to
+ describe. The search is bounded by the end of the FDRs line
+ number entries. */
line_end = debug_info->line + fdr_ptr->cbLineOffset + fdr_ptr->cbLine;
/* Make offset relative to procedure entry. */
}
/* If fdr_ptr->rss is -1, then this file does not have full
- symbols, at least according to gdb/mipsread.c. */
+ symbols, at least according to gdb/mipsread.c. */
if (fdr_ptr->rss == -1)
{
line_info->cache.filename = NULL;
const char *line_file_name;
bfd_vma low_func_vma;
bfd_vma low_line_vma;
- bfd_boolean past_line;
- bfd_boolean past_fn;
+ bool past_line;
+ bool past_fn;
char *sym_ptr, *sym_ptr_end;
size_t len, funclen;
char *buffer = NULL;
line_file_name = NULL;
low_func_vma = 0;
low_line_vma = 0;
- past_line = FALSE;
- past_fn = FALSE;
+ past_line = false;
+ past_fn = false;
external_sym_size = debug_swap->external_sym_size;
debug_info->ss + fdr_ptr->issBase + sym.iss;
/* Check the next symbol to see if it is also an
- N_SO symbol. */
+ N_SO symbol. */
if (sym_ptr + external_sym_size < sym_ptr_end)
{
SYMR nextsym;
if (ECOFF_IS_STAB (&nextsym)
&& ECOFF_UNMARK_STAB (nextsym.index) == N_SO)
{
- directory_name = current_file_name;
+ directory_name = current_file_name;
main_file_name = current_file_name =
debug_info->ss + fdr_ptr->issBase + nextsym.iss;
sym_ptr += external_sym_size;
case N_FUN:
if (sym.value > offset)
- past_fn = TRUE;
+ past_fn = true;
else if (sym.value >= low_func_vma)
{
low_func_vma = sym.value;
else if (sym.st == stLabel && sym.index != indexNil)
{
if (sym.value > offset)
- past_line = TRUE;
+ past_line = true;
else if (sym.value >= low_line_vma)
{
low_line_vma = sym.value;
main_file_name = line_file_name;
/* We need to remove the stuff after the colon in the function
- name. We also need to put the directory name and the file
- name together. */
+ name. We also need to put the directory name and the file
+ name together. */
if (function_name == NULL)
len = funclen = 0;
else
if (len != 0)
{
- if (line_info->find_buffer != NULL)
- free (line_info->find_buffer);
+ free (line_info->find_buffer);
buffer = (char *) bfd_malloc ((bfd_size_type) len);
- if (buffer == NULL)
- return FALSE;
line_info->find_buffer = buffer;
+ if (buffer == NULL)
+ return false;
}
if (function_name != NULL)
}
}
- return TRUE;
+ return true;
}
/* Do the work of find_nearest_line. */
-bfd_boolean
+bool
_bfd_ecoff_locate_line (bfd *abfd,
asection *section,
bfd_vma offset,
if (! lookup_line (abfd, debug_info, debug_swap, line_info))
{
line_info->cache.sect = NULL;
- return FALSE;
+ return false;
}
}
*functionname_ptr = line_info->cache.functionname;
*retline_ptr = line_info->cache.line_num;
- return TRUE;
+ return true;
}
\f
/* These routines copy symbolic information into a memory buffer.
/* Collect a shuffle into a memory buffer. */
-static bfd_boolean
+static bool
ecoff_collect_shuffle (struct shuffle *l, bfd_byte *buff)
{
unsigned long total;
if (bfd_seek (l->u.file.input_bfd, l->u.file.offset, SEEK_SET) != 0
|| (bfd_bread (buff, (bfd_size_type) l->size, l->u.file.input_bfd)
!= l->size))
- return FALSE;
+ return false;
}
total += l->size;
buff += l->size;
}
- return TRUE;
+ return true;
}
/* Copy PDR information into a memory buffer. */
-bfd_boolean
+bool
_bfd_ecoff_get_accumulated_pdr (void * handle,
bfd_byte *buff)
{
/* Copy symbol information into a memory buffer. */
-bfd_boolean
+bool
_bfd_ecoff_get_accumulated_sym (void * handle, bfd_byte *buff)
{
struct accumulate *ainfo = (struct accumulate *) handle;
/* Copy the string table into a memory buffer. */
-bfd_boolean
+bool
_bfd_ecoff_get_accumulated_ss (void * handle, bfd_byte *buff)
{
struct accumulate *ainfo = (struct accumulate *) handle;
buff += len + 1;
}
- return TRUE;
+ return true;
}
projects / deliverable / binutils-gdb.git / blobdiff