/* ldcref.c -- output a cross reference table
- Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2006,
- 2007 Free Software Foundation, Inc.
+ Copyright (C) 1996-2016 Free Software Foundation, Inc.
Written by Ian Lance Taylor <ian@cygnus.com>
-This file is part of GLD, the Gnu Linker.
+ This file is part of the GNU Binutils.
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
+ MA 02110-1301, USA. */
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
/* This file holds routines that manage the cross reference table.
The table is used to generate cross reference reports. It is also
used to implement the NOCROSSREFS command in the linker script. */
-#include "bfd.h"
#include "sysdep.h"
+#include "bfd.h"
#include "bfdlink.h"
#include "libiberty.h"
#include "demangle.h"
/* 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. */
- char *demangled;
+ const char *demangled;
/* References to and definitions of this symbol. */
struct cref_ref *refs;
};
/* 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 (output_bfd, h->root.string,
+ h->demangled = bfd_demangle (link_info.output_bfd, h->root.string,
DMGL_ANSI | DMGL_PARAMS);
+ if (h->demangled == NULL)
+ h->demangled = h->root.string;
**pph = h;
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);