/* ldcref.c -- output a cross reference table
- Copyright (C) 1996-2016 Free Software Foundation, Inc.
+ Copyright (C) 1996-2023 Free Software Foundation, Inc.
Written by Ian Lance Taylor <ian@cygnus.com>
This file is part of the GNU Binutils.
#include "sysdep.h"
#include "bfd.h"
#include "bfdlink.h"
+#include "ctf-api.h"
#include "libiberty.h"
#include "demangle.h"
#include "objalloc.h"
static void output_one_cref (FILE *, struct cref_hash_entry *);
static void check_local_sym_xref (lang_input_statement_type *);
-static bfd_boolean check_nocrossref (struct cref_hash_entry *, void *);
-static void check_refs (const char *, bfd_boolean, asection *, bfd *,
+static bool check_nocrossref (struct cref_hash_entry *, void *);
+static void check_refs (const char *, bool, asection *, bfd *,
struct lang_nocrossrefs *);
static void check_reloc_refs (bfd *, asection *, void *);
#define cref_hash_traverse(table, func, info) \
(bfd_hash_traverse \
(&(table)->root, \
- (bfd_boolean (*) (struct bfd_hash_entry *, void *)) (func), \
- (info)))
+ (bool (*) (struct bfd_hash_entry *, void *)) (func), (info)))
/* The cref hash table. */
/* Whether the cref hash table has been initialized. */
-static bfd_boolean cref_initialized;
+static bool cref_initialized;
/* The number of symbols seen so far. */
if (!bfd_hash_table_init (&cref_table.root, cref_hash_newfunc,
sizeof (struct cref_hash_entry)))
einfo (_("%X%P: bfd_hash_table_init of cref table failed: %E\n"));
- cref_initialized = TRUE;
+ cref_initialized = true;
}
- h = cref_hash_lookup (&cref_table, name, TRUE, FALSE);
+ h = cref_hash_lookup (&cref_table, name, true, false);
if (h == NULL)
einfo (_("%X%P: cref_hash_lookup failed: %E\n"));
r->next = h->refs;
h->refs = r;
r->abfd = abfd;
- r->def = FALSE;
- r->common = FALSE;
- r->undef = FALSE;
+ r->def = false;
+ r->common = false;
+ r->undef = false;
}
if (bfd_is_und_section (section))
- r->undef = TRUE;
+ r->undef = true;
else if (bfd_is_com_section (section))
- r->common = TRUE;
+ r->common = true;
else
- r->def = TRUE;
+ r->def = true;
}
/* Called before loading an as-needed library to take a snapshot of
the cref hash table, and after we have loaded or found that the
library was not needed. */
-bfd_boolean
+bool
handle_asneeded_cref (bfd *abfd ATTRIBUTE_UNUSED,
enum notice_asneeded_action act)
{
unsigned int i;
if (!cref_initialized)
- return TRUE;
+ return true;
if (act == notice_as_needed)
{
alloc_mark = bfd_hash_allocate (&cref_table.root, 1);
if (alloc_mark == NULL)
- return FALSE;
+ return false;
memcpy (old_tab, cref_table.root.table, tabsize);
old_ent = (char *) old_tab + tabsize;
}
}
}
- return TRUE;
+ return true;
}
if (act == notice_not_needed)
/* The only way old_tab can be NULL is if the cref hash table
had not been initialised when notice_as_needed. */
bfd_hash_table_free (&cref_table.root);
- cref_initialized = FALSE;
- return TRUE;
+ cref_initialized = false;
+ return true;
}
old_ent = (char *) old_tab + tabsize;
alloc_mark);
}
else if (act != notice_needed)
- return FALSE;
+ return false;
free (old_tab);
old_tab = NULL;
- return TRUE;
+ return true;
}
/* Copy the addresses of the hash table entries into an array. This
is called via cref_hash_traverse. We also fill in the demangled
name. */
-static bfd_boolean
+static bool
cref_fill_array (struct cref_hash_entry *h, void *data)
{
struct cref_hash_entry ***pph = (struct cref_hash_entry ***) data;
++*pph;
- return TRUE;
+ return true;
}
/* Sort an array of cref hash table entries by name. */
struct bfd_link_hash_entry *hl;
struct cref_ref *r;
- hl = bfd_link_hash_lookup (link_info.hash, h->root.string, FALSE,
- FALSE, TRUE);
+ hl = bfd_link_hash_lookup (link_info.hash, h->root.string, false,
+ false, true);
if (hl == NULL)
- einfo ("%P: symbol `%T' missing from main hash table\n",
+ einfo (_("%P: symbol `%pT' missing from main hash table\n"),
h->root.string);
else
{
putc (' ', fp);
++len;
}
- lfinfo (fp, "%B\n", r->abfd);
+ lfinfo (fp, "%pB\n", r->abfd);
len = 0;
}
}
putc (' ', fp);
++len;
}
- lfinfo (fp, "%B\n", r->abfd);
+ lfinfo (fp, "%pB\n", r->abfd);
len = 0;
}
}
putc (' ', fp);
++len;
}
- lfinfo (fp, "%B\n", r->abfd);
+ lfinfo (fp, "%pB\n", r->abfd);
len = 0;
}
}
return;
if (!bfd_generic_link_read_symbols (abfd))
- einfo (_("%B%F: could not read symbols: %E\n"), abfd);
+ einfo (_("%F%P: %pB: could not read symbols: %E\n"), abfd);
for (syms = bfd_get_outsymbols (abfd); *syms; ++syms)
{
for (ncr = ncrs->list; ncr != NULL; ncr = ncr->next)
{
if (strcmp (ncr->name, outsecname) == 0)
- check_refs (symname, FALSE, sym->section, abfd, ncrs);
+ check_refs (symname, false, sym->section, abfd, ncrs);
/* The NOCROSSREFS_TO command only checks symbols defined in
the first section in the list. */
if (ncrs->onlyfirst)
/* Check one symbol to see if it is a prohibited cross reference. */
-static bfd_boolean
+static bool
check_nocrossref (struct cref_hash_entry *h, void *ignore ATTRIBUTE_UNUSED)
{
struct bfd_link_hash_entry *hl;
struct lang_nocrossref *ncr;
struct cref_ref *ref;
- hl = bfd_link_hash_lookup (link_info.hash, h->root.string, FALSE,
- FALSE, TRUE);
+ hl = bfd_link_hash_lookup (link_info.hash, h->root.string, false,
+ false, true);
if (hl == NULL)
{
- einfo (_("%P: symbol `%T' missing from main hash table\n"),
+ einfo (_("%P: symbol `%pT' missing from main hash table\n"),
h->root.string);
- return TRUE;
+ return true;
}
if (hl->type != bfd_link_hash_defined
&& hl->type != bfd_link_hash_defweak)
- return TRUE;
+ return true;
defsec = hl->u.def.section->output_section;
if (defsec == NULL)
- return TRUE;
- defsecname = bfd_get_section_name (defsec->owner, defsec);
+ return true;
+ defsecname = bfd_section_name (defsec);
for (ncrs = nocrossref_list; ncrs != NULL; ncrs = ncrs->next)
for (ncr = ncrs->list; ncr != NULL; ncr = ncr->next)
{
if (strcmp (ncr->name, defsecname) == 0)
for (ref = h->refs; ref != NULL; ref = ref->next)
- check_refs (hl->root.string, TRUE, hl->u.def.section,
+ check_refs (hl->root.string, true, hl->u.def.section,
ref->abfd, ncrs);
/* The NOCROSSREFS_TO command only checks symbols defined in the first
section in the list. */
break;
}
- return TRUE;
+ return true;
}
/* The struct is used to pass information from check_refs to
asection *defsec;
struct lang_nocrossrefs *ncrs;
asymbol **asymbols;
- bfd_boolean global;
+ bool global;
};
/* This function is called for each symbol defined in a section which
static void
check_refs (const char *name,
- bfd_boolean global,
+ bool global,
asection *sec,
bfd *abfd,
struct lang_nocrossrefs *ncrs)
BFD might contain a prohibited cross reference. */
if (!bfd_generic_link_read_symbols (abfd))
- einfo (_("%B%F: could not read symbols: %E\n"), abfd);
+ einfo (_("%F%P: %pB: could not read symbols: %E\n"), abfd);
info.sym_name = name;
info.global = global;
const char *outdefsecname;
struct lang_nocrossref *ncr;
const char *symname;
- bfd_boolean global;
+ bool global;
long relsize;
arelent **relpp;
long relcount;
arelent **p, **pend;
outsec = sec->output_section;
- outsecname = bfd_get_section_name (outsec->owner, outsec);
+ outsecname = bfd_section_name (outsec);
outdefsec = info->defsec->output_section;
- outdefsecname = bfd_get_section_name (outdefsec->owner, outdefsec);
+ outdefsecname = bfd_section_name (outdefsec);
/* The section where the symbol is defined is permitted. */
if (strcmp (outsecname, outdefsecname) == 0)
relsize = bfd_get_reloc_upper_bound (abfd, sec);
if (relsize < 0)
- einfo (_("%B%F: could not read relocs: %E\n"), abfd);
+ einfo (_("%F%P: %pB: could not read relocs: %E\n"), abfd);
if (relsize == 0)
return;
relpp = (arelent **) xmalloc (relsize);
relcount = bfd_canonicalize_reloc (abfd, sec, relpp, info->asymbols);
if (relcount < 0)
- einfo (_("%B%F: could not read relocs: %E\n"), abfd);
+ einfo (_("%F%P: %pB: could not read relocs: %E\n"), abfd);
p = relpp;
pend = p + relcount;
if (q->sym_ptr_ptr != NULL
&& *q->sym_ptr_ptr != NULL
&& ((global
- && (bfd_is_und_section (bfd_get_section (*q->sym_ptr_ptr))
- || bfd_is_com_section (bfd_get_section (*q->sym_ptr_ptr))
+ && (bfd_is_und_section (bfd_asymbol_section (*q->sym_ptr_ptr))
+ || bfd_is_com_section (bfd_asymbol_section (*q->sym_ptr_ptr))
|| ((*q->sym_ptr_ptr)->flags & (BSF_GLOBAL
| BSF_WEAK)) != 0))
|| (!global
&& ((*q->sym_ptr_ptr)->flags & (BSF_LOCAL
| BSF_SECTION_SYM)) != 0
- && bfd_get_section (*q->sym_ptr_ptr) == info->defsec))
+ && bfd_asymbol_section (*q->sym_ptr_ptr) == info->defsec))
&& (symname != NULL
? strcmp (bfd_asymbol_name (*q->sym_ptr_ptr), symname) == 0
: ((*q->sym_ptr_ptr)->flags & BSF_SECTION_SYM) != 0))
in OUTSECNAME. This reloc is from a section which is
mapped into a section from which references to OUTSECNAME
are prohibited. We must report an error. */
- einfo (_("%X%C: prohibited cross reference from %s to `%T' in %s\n"),
+ einfo (_("%X%P: %H: prohibited cross reference from %s to `%pT' in %s\n"),
abfd, sec, q->address, outsecname,
bfd_asymbol_name (*q->sym_ptr_ptr), outdefsecname);
}
projects / thirdparty / binutils-gdb.git / blobdiff