/* ldcref.c -- output a cross reference table
- Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2006,
- 2007, 2008 Free Software Foundation, Inc.
+ Copyright (C) 1996-2014 Free Software Foundation, Inc.
Written by Ian Lance Taylor <ian@cygnus.com>
This file is part of the GNU Binutils.
/* We keep an instance of this structure for each reference to a
symbol from a given object. */
-struct cref_ref {
+struct cref_ref
+{
/* The next reference. */
struct cref_ref *next;
/* The object. */
/* We keep a hash table of symbols. Each entry looks like this. */
-struct cref_hash_entry {
+struct cref_hash_entry
+{
struct bfd_hash_entry root;
/* The demangled name. */
const char *demangled;
/* This is what the hash table looks like. */
-struct cref_hash_table {
+struct cref_hash_table
+{
struct bfd_hash_table root;
};
static struct bfd_hash_entry **old_table;
static unsigned int old_size;
static unsigned int old_count;
-static void *old_tab;
-static void *alloc_mark;
+static void * old_tab;
+static void * alloc_mark;
static size_t tabsize, entsize, refsize;
static size_t old_symcount;
if (r == NULL)
{
- r = bfd_hash_allocate (&cref_table.root, sizeof *r);
+ r = (struct cref_ref *) bfd_hash_allocate (&cref_table.root, sizeof *r);
if (r == NULL)
einfo (_("%X%P: cref alloc failed: %E\n"));
r->next = h->refs;
entsize += cref_table.root.entsize;
c = (struct cref_hash_entry *) p;
for (r = c->refs; r != NULL; r = r->next)
- refsize += sizeof (struct cref_hash_entry);
+ refsize += sizeof (struct cref_ref);
}
}
c = (struct cref_hash_entry *) p;
for (r = c->refs; r != NULL; r = r->next)
{
- memcpy (old_ref, r, sizeof (struct cref_hash_entry));
- old_ref = (char *) old_ref + sizeof (struct cref_hash_entry);
+ memcpy (old_ref, r, sizeof (struct cref_ref));
+ old_ref = (char *) old_ref + sizeof (struct cref_ref);
}
}
}
c = (struct cref_hash_entry *) p;
for (r = c->refs; r != NULL; r = r->next)
{
- memcpy (r, old_ref, sizeof (struct cref_hash_entry));
- old_ref = (char *) old_ref + sizeof (struct cref_hash_entry);
+ memcpy (r, old_ref, sizeof (struct cref_ref));
+ old_ref = (char *) old_ref + sizeof (struct cref_ref);
}
}
}
static bfd_boolean
cref_fill_array (struct cref_hash_entry *h, void *data)
{
- struct cref_hash_entry ***pph = data;
+ struct cref_hash_entry ***pph = (struct cref_hash_entry ***) data;
ASSERT (h->demangled == NULL);
h->demangled = bfd_demangle (link_info.output_bfd, h->root.string,
static int
cref_sort_array (const void *a1, const void *a2)
{
- const struct cref_hash_entry * const *p1 = a1;
- const struct cref_hash_entry * const *p2 = a2;
+ const struct cref_hash_entry * const *p1 =
+ (const struct cref_hash_entry * const *) a1;
+ const struct cref_hash_entry * const *p2 =
+ (const struct cref_hash_entry * const *) a2;
- return strcmp ((*p1)->demangled, (*p2)->demangled);
+ if (demangling)
+ return strcmp ((*p1)->demangled, (*p2)->demangled);
+ else
+ return strcmp ((*p1)->root.string, (*p2)->root.string);
}
/* Write out the cref table. */
return;
}
- csyms = xmalloc (cref_symcount * sizeof (*csyms));
+ csyms = (struct cref_hash_entry **) xmalloc (cref_symcount * sizeof (*csyms));
csym_fill = csyms;
cref_hash_traverse (&cref_table, cref_fill_array, &csym_fill);
}
}
- fprintf (fp, "%s ", h->demangled);
- len = strlen (h->demangled) + 1;
+ if (demangling)
+ {
+ fprintf (fp, "%s ", h->demangled);
+ len = strlen (h->demangled) + 1;
+ }
+ else
+ {
+ fprintf (fp, "%s ", h->root.string);
+ len = strlen (h->root.string) + 1;
+ }
for (r = h->refs; r != NULL; r = r->next)
{
for (r = h->refs; r != NULL; r = r->next)
{
- if (! r->def)
+ if (r->common)
+ {
+ while (len < FILECOL)
+ {
+ putc (' ', fp);
+ ++len;
+ }
+ lfinfo (fp, "%B\n", r->abfd);
+ len = 0;
+ }
+ }
+
+ for (r = h->refs; r != NULL; r = r->next)
+ {
+ if (! r->def && ! r->common)
{
while (len < FILECOL)
{
check_local_sym_xref (lang_input_statement_type *statement)
{
bfd *abfd;
- lang_input_statement_type *li;
- asymbol **asymbols, **syms;
+ asymbol **syms;
abfd = statement->the_bfd;
if (abfd == NULL)
return;
- li = abfd->usrdata;
- if (li != NULL && li->asymbols != NULL)
- asymbols = li->asymbols;
- else
- {
- long symsize;
- long symbol_count;
-
- symsize = bfd_get_symtab_upper_bound (abfd);
- if (symsize < 0)
- einfo (_("%B%F: could not read symbols; %E\n"), abfd);
- asymbols = xmalloc (symsize);
- symbol_count = bfd_canonicalize_symtab (abfd, asymbols);
- if (symbol_count < 0)
- einfo (_("%B%F: could not read symbols: %E\n"), abfd);
- if (li != NULL)
- {
- li->asymbols = asymbols;
- li->symbol_count = symbol_count;
- }
- }
+ if (!bfd_generic_link_read_symbols (abfd))
+ einfo (_("%B%F: could not read symbols: %E\n"), abfd);
- for (syms = asymbols; *syms; ++syms)
+ for (syms = bfd_get_outsymbols (abfd); *syms; ++syms)
{
asymbol *sym = *syms;
if (sym->flags & (BSF_GLOBAL | BSF_WARNING | BSF_INDIRECT | BSF_FILE))
check_refs (symname, FALSE, sym->section, abfd, ncrs);
}
}
-
- if (li == NULL)
- free (asymbols);
}
/* Check one symbol to see if it is a prohibited cross reference. */
bfd *abfd,
struct lang_nocrossrefs *ncrs)
{
- lang_input_statement_type *li;
- asymbol **asymbols;
struct check_refs_info info;
/* We need to look through the relocations for this BFD, to see
the BFD in which the symbol is defined, since even a single
BFD might contain a prohibited cross reference. */
- li = abfd->usrdata;
- if (li != NULL && li->asymbols != NULL)
- asymbols = li->asymbols;
- else
- {
- long symsize;
- long symbol_count;
-
- symsize = bfd_get_symtab_upper_bound (abfd);
- if (symsize < 0)
- einfo (_("%B%F: could not read symbols; %E\n"), abfd);
- asymbols = xmalloc (symsize);
- symbol_count = bfd_canonicalize_symtab (abfd, asymbols);
- if (symbol_count < 0)
- einfo (_("%B%F: could not read symbols: %E\n"), abfd);
- if (li != NULL)
- {
- li->asymbols = asymbols;
- li->symbol_count = symbol_count;
- }
- }
+ if (!bfd_generic_link_read_symbols (abfd))
+ einfo (_("%B%F: could not read symbols: %E\n"), abfd);
info.sym_name = name;
info.global = global;
info.defsec = sec;
info.ncrs = ncrs;
- info.asymbols = asymbols;
+ info.asymbols = bfd_get_outsymbols (abfd);
bfd_map_over_sections (abfd, check_reloc_refs, &info);
-
- if (li == NULL)
- free (asymbols);
}
/* This is called via bfd_map_over_sections. INFO->SYM_NAME is a symbol
static void
check_reloc_refs (bfd *abfd, asection *sec, void *iarg)
{
- struct check_refs_info *info = iarg;
+ struct check_refs_info *info = (struct check_refs_info *) iarg;
asection *outsec;
const char *outsecname;
asection *outdefsec;
if (relsize == 0)
return;
- relpp = xmalloc (relsize);
+ 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);