diff options
author | Jing Yu <jingyu@google.com> | 2011-12-20 10:27:58 -0800 |
---|---|---|
committer | Jing Yu <jingyu@google.com> | 2011-12-20 10:27:58 -0800 |
commit | cf3cdbf8b3cda61a619299e7966a83df66244036 (patch) | |
tree | 201e2bcfc955f16802d3257112d29736cb3a3ce8 /binutils-2.21/ld/ldcref.c | |
parent | e4df3e0a5bb640ccfa2f30ee67fe9b3146b152d6 (diff) | |
download | toolchain_binutils-cf3cdbf8b3cda61a619299e7966a83df66244036.zip toolchain_binutils-cf3cdbf8b3cda61a619299e7966a83df66244036.tar.gz toolchain_binutils-cf3cdbf8b3cda61a619299e7966a83df66244036.tar.bz2 |
Add binutils-2.21.
Use --enable-gold=default for dual linker support.
Change-Id: Id1a744c7db58a0b5e7a3be174cdfa875f2f86e49
Diffstat (limited to 'binutils-2.21/ld/ldcref.c')
-rw-r--r-- | binutils-2.21/ld/ldcref.c | 691 |
1 files changed, 691 insertions, 0 deletions
diff --git a/binutils-2.21/ld/ldcref.c b/binutils-2.21/ld/ldcref.c new file mode 100644 index 0000000..2f6a46c --- /dev/null +++ b/binutils-2.21/ld/ldcref.c @@ -0,0 +1,691 @@ +/* ldcref.c -- output a cross reference table + Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, + 2007, 2008 Free Software Foundation, Inc. + Written by Ian Lance Taylor <ian@cygnus.com> + + 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 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. + + 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 "sysdep.h" +#include "bfd.h" +#include "bfdlink.h" +#include "libiberty.h" +#include "demangle.h" +#include "objalloc.h" + +#include "ld.h" +#include "ldmain.h" +#include "ldmisc.h" +#include "ldexp.h" +#include "ldlang.h" + +/* We keep an instance of this structure for each reference to a + symbol from a given object. */ + +struct cref_ref { + /* The next reference. */ + struct cref_ref *next; + /* The object. */ + bfd *abfd; + /* True if the symbol is defined. */ + unsigned int def : 1; + /* True if the symbol is common. */ + unsigned int common : 1; + /* True if the symbol is undefined. */ + unsigned int undef : 1; +}; + +/* We keep a hash table of symbols. Each entry looks like this. */ + +struct cref_hash_entry { + struct bfd_hash_entry root; + /* The demangled name. */ + 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 bfd_hash_table root; +}; + +/* Forward declarations. */ + +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 *, + struct lang_nocrossrefs *); +static void check_reloc_refs (bfd *, asection *, void *); + +/* Look up an entry in the cref hash table. */ + +#define cref_hash_lookup(table, string, create, copy) \ + ((struct cref_hash_entry *) \ + bfd_hash_lookup (&(table)->root, (string), (create), (copy))) + +/* Traverse the cref hash table. */ + +#define cref_hash_traverse(table, func, info) \ + (bfd_hash_traverse \ + (&(table)->root, \ + (bfd_boolean (*) (struct bfd_hash_entry *, void *)) (func), \ + (info))) + +/* The cref hash table. */ + +static struct cref_hash_table cref_table; + +/* Whether the cref hash table has been initialized. */ + +static bfd_boolean cref_initialized; + +/* The number of symbols seen so far. */ + +static size_t cref_symcount; + +/* Used to take a snapshot of the cref hash table when starting to + add syms from an as-needed library. */ +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 size_t tabsize, entsize, refsize; +static size_t old_symcount; + +/* Create an entry in a cref hash table. */ + +static struct bfd_hash_entry * +cref_hash_newfunc (struct bfd_hash_entry *entry, + struct bfd_hash_table *table, + const char *string) +{ + struct cref_hash_entry *ret = (struct cref_hash_entry *) entry; + + /* Allocate the structure if it has not already been allocated by a + subclass. */ + if (ret == NULL) + ret = ((struct cref_hash_entry *) + bfd_hash_allocate (table, sizeof (struct cref_hash_entry))); + if (ret == NULL) + return NULL; + + /* Call the allocation method of the superclass. */ + ret = ((struct cref_hash_entry *) + bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string)); + if (ret != NULL) + { + /* Set local fields. */ + ret->demangled = NULL; + ret->refs = NULL; + + /* Keep a count of the number of entries created in the hash + table. */ + ++cref_symcount; + } + + return &ret->root; +} + +/* Add a symbol to the cref hash table. This is called for every + global symbol that is seen during the link. */ + +void +add_cref (const char *name, + bfd *abfd, + asection *section, + bfd_vma value ATTRIBUTE_UNUSED) +{ + struct cref_hash_entry *h; + struct cref_ref *r; + + if (! cref_initialized) + { + 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; + } + + h = cref_hash_lookup (&cref_table, name, TRUE, FALSE); + if (h == NULL) + einfo (_("%X%P: cref_hash_lookup failed: %E\n")); + + for (r = h->refs; r != NULL; r = r->next) + if (r->abfd == abfd) + break; + + if (r == NULL) + { + 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; + h->refs = r; + r->abfd = abfd; + r->def = FALSE; + r->common = FALSE; + r->undef = FALSE; + } + + if (bfd_is_und_section (section)) + r->undef = TRUE; + else if (bfd_is_com_section (section)) + r->common = TRUE; + else + 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 +handle_asneeded_cref (bfd *abfd ATTRIBUTE_UNUSED, + enum notice_asneeded_action act) +{ + unsigned int i; + + if (!cref_initialized) + return TRUE; + + if (act == notice_as_needed) + { + char *old_ent, *old_ref; + + for (i = 0; i < cref_table.root.size; i++) + { + struct bfd_hash_entry *p; + struct cref_hash_entry *c; + struct cref_ref *r; + + for (p = cref_table.root.table[i]; p != NULL; p = p->next) + { + entsize += cref_table.root.entsize; + c = (struct cref_hash_entry *) p; + for (r = c->refs; r != NULL; r = r->next) + refsize += sizeof (struct cref_ref); + } + } + + tabsize = cref_table.root.size * sizeof (struct bfd_hash_entry *); + old_tab = xmalloc (tabsize + entsize + refsize); + + alloc_mark = bfd_hash_allocate (&cref_table.root, 1); + if (alloc_mark == NULL) + return FALSE; + + memcpy (old_tab, cref_table.root.table, tabsize); + old_ent = (char *) old_tab + tabsize; + old_ref = (char *) old_ent + entsize; + old_table = cref_table.root.table; + old_size = cref_table.root.size; + old_count = cref_table.root.count; + old_symcount = cref_symcount; + + for (i = 0; i < cref_table.root.size; i++) + { + struct bfd_hash_entry *p; + struct cref_hash_entry *c; + struct cref_ref *r; + + for (p = cref_table.root.table[i]; p != NULL; p = p->next) + { + memcpy (old_ent, p, cref_table.root.entsize); + old_ent = (char *) old_ent + cref_table.root.entsize; + c = (struct cref_hash_entry *) p; + for (r = c->refs; r != NULL; r = r->next) + { + memcpy (old_ref, r, sizeof (struct cref_ref)); + old_ref = (char *) old_ref + sizeof (struct cref_ref); + } + } + } + return TRUE; + } + + if (act == notice_not_needed) + { + char *old_ent, *old_ref; + + if (old_tab == NULL) + { + /* 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; + } + + old_ent = (char *) old_tab + tabsize; + old_ref = (char *) old_ent + entsize; + cref_table.root.table = old_table; + cref_table.root.size = old_size; + cref_table.root.count = old_count; + memcpy (cref_table.root.table, old_tab, tabsize); + cref_symcount = old_symcount; + + for (i = 0; i < cref_table.root.size; i++) + { + struct bfd_hash_entry *p; + struct cref_hash_entry *c; + struct cref_ref *r; + + for (p = cref_table.root.table[i]; p != NULL; p = p->next) + { + memcpy (p, old_ent, cref_table.root.entsize); + old_ent = (char *) old_ent + cref_table.root.entsize; + c = (struct cref_hash_entry *) p; + for (r = c->refs; r != NULL; r = r->next) + { + memcpy (r, old_ref, sizeof (struct cref_ref)); + old_ref = (char *) old_ref + sizeof (struct cref_ref); + } + } + } + + objalloc_free_block ((struct objalloc *) cref_table.root.memory, + alloc_mark); + } + else if (act != notice_needed) + return FALSE; + + free (old_tab); + old_tab = NULL; + 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 +cref_fill_array (struct cref_hash_entry *h, void *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, + DMGL_ANSI | DMGL_PARAMS); + if (h->demangled == NULL) + h->demangled = h->root.string; + + **pph = h; + + ++*pph; + + return TRUE; +} + +/* Sort an array of cref hash table entries by name. */ + +static int +cref_sort_array (const void *a1, const void *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); +} + +/* Write out the cref table. */ + +#define FILECOL (50) + +void +output_cref (FILE *fp) +{ + int len; + struct cref_hash_entry **csyms, **csym_fill, **csym, **csym_end; + const char *msg; + + fprintf (fp, _("\nCross Reference Table\n\n")); + msg = _("Symbol"); + fprintf (fp, "%s", msg); + len = strlen (msg); + while (len < FILECOL) + { + putc (' ', fp); + ++len; + } + fprintf (fp, _("File\n")); + + if (! cref_initialized) + { + fprintf (fp, _("No symbols\n")); + return; + } + + csyms = (struct cref_hash_entry **) xmalloc (cref_symcount * sizeof (*csyms)); + + csym_fill = csyms; + cref_hash_traverse (&cref_table, cref_fill_array, &csym_fill); + ASSERT ((size_t) (csym_fill - csyms) == cref_symcount); + + qsort (csyms, cref_symcount, sizeof (*csyms), cref_sort_array); + + csym_end = csyms + cref_symcount; + for (csym = csyms; csym < csym_end; csym++) + output_one_cref (fp, *csym); +} + +/* Output one entry in the cross reference table. */ + +static void +output_one_cref (FILE *fp, struct cref_hash_entry *h) +{ + int len; + struct bfd_link_hash_entry *hl; + struct cref_ref *r; + + 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", + h->root.string); + else + { + /* If this symbol is defined in a dynamic object but never + referenced by a normal object, then don't print it. */ + if (hl->type == bfd_link_hash_defined) + { + if (hl->u.def.section->output_section == NULL) + return; + if (hl->u.def.section->owner != NULL + && (hl->u.def.section->owner->flags & DYNAMIC) != 0) + { + for (r = h->refs; r != NULL; r = r->next) + if ((r->abfd->flags & DYNAMIC) == 0) + break; + if (r == NULL) + return; + } + } + } + + fprintf (fp, "%s ", h->demangled); + len = strlen (h->demangled) + 1; + + for (r = h->refs; r != NULL; r = r->next) + { + if (r->def) + { + 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) + { + while (len < FILECOL) + { + putc (' ', fp); + ++len; + } + lfinfo (fp, "%B\n", r->abfd); + len = 0; + } + } + + ASSERT (len == 0); +} + +/* Check for prohibited cross references. */ + +void +check_nocrossrefs (void) +{ + if (! cref_initialized) + return; + + cref_hash_traverse (&cref_table, check_nocrossref, NULL); + + lang_for_each_file (check_local_sym_xref); +} + +/* Check for prohibited cross references to local and section symbols. */ + +static void +check_local_sym_xref (lang_input_statement_type *statement) +{ + bfd *abfd; + asymbol **syms; + + abfd = statement->the_bfd; + if (abfd == NULL) + return; + + if (!bfd_generic_link_read_symbols (abfd)) + einfo (_("%B%F: could not read symbols: %E\n"), abfd); + + for (syms = bfd_get_outsymbols (abfd); *syms; ++syms) + { + asymbol *sym = *syms; + if (sym->flags & (BSF_GLOBAL | BSF_WARNING | BSF_INDIRECT | BSF_FILE)) + continue; + if ((sym->flags & (BSF_LOCAL | BSF_SECTION_SYM)) != 0 + && sym->section->output_section != NULL) + { + const char *outsecname, *symname; + struct lang_nocrossrefs *ncrs; + struct lang_nocrossref *ncr; + + outsecname = sym->section->output_section->name; + symname = NULL; + if ((sym->flags & BSF_SECTION_SYM) == 0) + symname = sym->name; + for (ncrs = nocrossref_list; ncrs != NULL; ncrs = ncrs->next) + for (ncr = ncrs->list; ncr != NULL; ncr = ncr->next) + if (strcmp (ncr->name, outsecname) == 0) + check_refs (symname, FALSE, sym->section, abfd, ncrs); + } + } +} + +/* Check one symbol to see if it is a prohibited cross reference. */ + +static bfd_boolean +check_nocrossref (struct cref_hash_entry *h, void *ignore ATTRIBUTE_UNUSED) +{ + struct bfd_link_hash_entry *hl; + asection *defsec; + const char *defsecname; + struct lang_nocrossrefs *ncrs; + struct lang_nocrossref *ncr; + struct cref_ref *ref; + + 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"), + h->root.string); + return TRUE; + } + + if (hl->type != bfd_link_hash_defined + && hl->type != bfd_link_hash_defweak) + return TRUE; + + defsec = hl->u.def.section->output_section; + if (defsec == NULL) + return TRUE; + defsecname = bfd_get_section_name (defsec->owner, 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, + ref->abfd, ncrs); + + return TRUE; +} + +/* The struct is used to pass information from check_refs to + check_reloc_refs through bfd_map_over_sections. */ + +struct check_refs_info { + const char *sym_name; + asection *defsec; + struct lang_nocrossrefs *ncrs; + asymbol **asymbols; + bfd_boolean global; +}; + +/* This function is called for each symbol defined in a section which + prohibits cross references. We need to look through all references + to this symbol, and ensure that the references are not from + prohibited sections. */ + +static void +check_refs (const char *name, + bfd_boolean global, + asection *sec, + bfd *abfd, + struct lang_nocrossrefs *ncrs) +{ + struct check_refs_info info; + + /* We need to look through the relocations for this BFD, to see + if any of the relocations which refer to this symbol are from + a prohibited section. Note that we need to do this even for + the BFD in which the symbol is defined, since even a single + BFD might contain a prohibited cross reference. */ + + 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 = bfd_get_outsymbols (abfd); + bfd_map_over_sections (abfd, check_reloc_refs, &info); +} + +/* This is called via bfd_map_over_sections. INFO->SYM_NAME is a symbol + defined in INFO->DEFSECNAME. If this section maps into any of the + sections listed in INFO->NCRS, other than INFO->DEFSECNAME, then we + look through the relocations. If any of the relocations are to + INFO->SYM_NAME, then we report a prohibited cross reference error. */ + +static void +check_reloc_refs (bfd *abfd, asection *sec, void *iarg) +{ + struct check_refs_info *info = (struct check_refs_info *) iarg; + asection *outsec; + const char *outsecname; + asection *outdefsec; + const char *outdefsecname; + struct lang_nocrossref *ncr; + const char *symname; + bfd_boolean global; + long relsize; + arelent **relpp; + long relcount; + arelent **p, **pend; + + outsec = sec->output_section; + outsecname = bfd_get_section_name (outsec->owner, outsec); + + outdefsec = info->defsec->output_section; + outdefsecname = bfd_get_section_name (outdefsec->owner, outdefsec); + + /* The section where the symbol is defined is permitted. */ + if (strcmp (outsecname, outdefsecname) == 0) + return; + + for (ncr = info->ncrs->list; ncr != NULL; ncr = ncr->next) + if (strcmp (outsecname, ncr->name) == 0) + break; + + if (ncr == NULL) + return; + + /* This section is one for which cross references are prohibited. + Look through the relocations, and see if any of them are to + INFO->SYM_NAME. If INFO->SYMNAME is NULL, check for relocations + against the section symbol. If INFO->GLOBAL is TRUE, the + definition is global, check for relocations against the global + symbols. Otherwise check for relocations against the local and + section symbols. */ + + symname = info->sym_name; + global = info->global; + + relsize = bfd_get_reloc_upper_bound (abfd, sec); + if (relsize < 0) + einfo (_("%B%F: 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); + + p = relpp; + pend = p + relcount; + for (; p < pend && *p != NULL; p++) + { + arelent *q = *p; + + 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)) + || ((*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)) + && (symname != NULL + ? strcmp (bfd_asymbol_name (*q->sym_ptr_ptr), symname) == 0 + : ((*q->sym_ptr_ptr)->flags & BSF_SECTION_SYM) != 0)) + { + /* We found a reloc for the symbol. The symbol is defined + 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"), + abfd, sec, q->address, outsecname, + bfd_asymbol_name (*q->sym_ptr_ptr), outdefsecname); + } + } + + free (relpp); +} |