WebSVN – Kolibri OS – Diff – /contrib/toolchain/binutils/ld/ldcref.c


/* ldcref.c -- output a cross reference table
   Copyright (C) 1996-2015 Free Software Foundation, Inc.
   Written by Ian Lance Taylor 
 
   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;
 
  if (demangling)
  return strcmp ((*p1)->demangled, (*p2)->demangled);
  else
    return strcmp ((*p1)->root.string, (*p2)->root.string);
}
 
/* 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;
	    }
	}
    }
 
  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)
    {
      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->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)
	    {
	      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);
}

Rev 5199	Rev 6324
1	/* ldcref.c -- output a cross reference table	1	/* ldcref.c -- output a cross reference table
2	Copyright 1996-2013 Free Software Foundation, Inc.	2	Copyright (C) 1996-2015 Free Software Foundation, Inc.
3	Written by Ian Lance Taylor	3	Written by Ian Lance Taylor
4		4
5	This file is part of the GNU Binutils.	5	This file is part of the GNU Binutils.
6		6
7	This program is free software; you can redistribute it and/or modify	7	This program is free software; you can redistribute it and/or modify
8	it under the terms of the GNU General Public License as published by	8	it under the terms of the GNU General Public License as published by
9	the Free Software Foundation; either version 3 of the License, or	9	the Free Software Foundation; either version 3 of the License, or
10	(at your option) any later version.	10	(at your option) any later version.
11		11
12	This program is distributed in the hope that it will be useful,	12	This program is distributed in the hope that it will be useful,
13	but WITHOUT ANY WARRANTY; without even the implied warranty of	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	GNU General Public License for more details.	15	GNU General Public License for more details.
16		16
17	You should have received a copy of the GNU General Public License	17	You should have received a copy of the GNU General Public License
18	along with this program; if not, write to the Free Software	18	along with this program; if not, write to the Free Software
19	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,	19	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20	MA 02110-1301, USA. */	20	MA 02110-1301, USA. */
21		21
22		22
23	/* This file holds routines that manage the cross reference table.	23	/* This file holds routines that manage the cross reference table.
24	The table is used to generate cross reference reports. It is also	24	The table is used to generate cross reference reports. It is also
25	used to implement the NOCROSSREFS command in the linker script. */	25	used to implement the NOCROSSREFS command in the linker script. */
26		26
27	#include "sysdep.h"	27	#include "sysdep.h"
28	#include "bfd.h"	28	#include "bfd.h"
29	#include "bfdlink.h"	29	#include "bfdlink.h"
30	#include "libiberty.h"	30	#include "libiberty.h"
31	#include "demangle.h"	31	#include "demangle.h"
32	#include "objalloc.h"	32	#include "objalloc.h"
33		33
34	#include "ld.h"	34	#include "ld.h"
35	#include "ldmain.h"	35	#include "ldmain.h"
36	#include "ldmisc.h"	36	#include "ldmisc.h"
37	#include "ldexp.h"	37	#include "ldexp.h"
38	#include "ldlang.h"	38	#include "ldlang.h"
39		39
40	/* We keep an instance of this structure for each reference to a	40	/* We keep an instance of this structure for each reference to a
41	symbol from a given object. */	41	symbol from a given object. */
42		42
-		43	struct cref_ref
43	struct cref_ref {	44	{
44	/* The next reference. */	45	/* The next reference. */
45	struct cref_ref *next;	46	struct cref_ref *next;
46	/* The object. */	47	/* The object. */
47	bfd *abfd;	48	bfd *abfd;
48	/* True if the symbol is defined. */	49	/* True if the symbol is defined. */
49	unsigned int def : 1;	50	unsigned int def : 1;
50	/* True if the symbol is common. */	51	/* True if the symbol is common. */
51	unsigned int common : 1;	52	unsigned int common : 1;
52	/* True if the symbol is undefined. */	53	/* True if the symbol is undefined. */
53	unsigned int undef : 1;	54	unsigned int undef : 1;
54	};	55	};
55		56
56	/* We keep a hash table of symbols. Each entry looks like this. */	57	/* We keep a hash table of symbols. Each entry looks like this. */
57		58
-		59	struct cref_hash_entry
58	struct cref_hash_entry {	60	{
59	struct bfd_hash_entry root;	61	struct bfd_hash_entry root;
60	/* The demangled name. */	62	/* The demangled name. */
61	const char *demangled;	63	const char *demangled;
62	/* References to and definitions of this symbol. */	64	/* References to and definitions of this symbol. */
63	struct cref_ref *refs;	65	struct cref_ref *refs;
64	};	66	};
65		67
66	/* This is what the hash table looks like. */	68	/* This is what the hash table looks like. */
67		69
-		70	struct cref_hash_table
68	struct cref_hash_table {	71	{
69	struct bfd_hash_table root;	72	struct bfd_hash_table root;
70	};	73	};
71		74
72	/* Forward declarations. */	75	/* Forward declarations. */
73		76
74	static void output_one_cref (FILE , struct cref_hash_entry );	77	static void output_one_cref (FILE , struct cref_hash_entry );
75	static void check_local_sym_xref (lang_input_statement_type *);	78	static void check_local_sym_xref (lang_input_statement_type *);
76	static bfd_boolean check_nocrossref (struct cref_hash_entry , void );	79	static bfd_boolean check_nocrossref (struct cref_hash_entry , void );
77	static void check_refs (const char , bfd_boolean, asection , bfd *,	80	static void check_refs (const char , bfd_boolean, asection , bfd *,
78	struct lang_nocrossrefs *);	81	struct lang_nocrossrefs *);
79	static void check_reloc_refs (bfd , asection , void *);	82	static void check_reloc_refs (bfd , asection , void *);
80		83
81	/* Look up an entry in the cref hash table. */	84	/* Look up an entry in the cref hash table. */
82		85
83	#define cref_hash_lookup(table, string, create, copy) \	86	#define cref_hash_lookup(table, string, create, copy) \
84	((struct cref_hash_entry *) \	87	((struct cref_hash_entry *) \
85	bfd_hash_lookup (&(table)->root, (string), (create), (copy)))	88	bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
86		89
87	/* Traverse the cref hash table. */	90	/* Traverse the cref hash table. */
88		91
89	#define cref_hash_traverse(table, func, info) \	92	#define cref_hash_traverse(table, func, info) \
90	(bfd_hash_traverse \	93	(bfd_hash_traverse \
91	(&(table)->root, \	94	(&(table)->root, \
92	(bfd_boolean () (struct bfd_hash_entry , void *)) (func), \	95	(bfd_boolean () (struct bfd_hash_entry , void *)) (func), \
93	(info)))	96	(info)))
94		97
95	/* The cref hash table. */	98	/* The cref hash table. */
96		99
97	static struct cref_hash_table cref_table;	100	static struct cref_hash_table cref_table;
98		101
99	/* Whether the cref hash table has been initialized. */	102	/* Whether the cref hash table has been initialized. */
100		103
101	static bfd_boolean cref_initialized;	104	static bfd_boolean cref_initialized;
102		105
103	/* The number of symbols seen so far. */	106	/* The number of symbols seen so far. */
104		107
105	static size_t cref_symcount;	108	static size_t cref_symcount;
106		109
107	/* Used to take a snapshot of the cref hash table when starting to	110	/* Used to take a snapshot of the cref hash table when starting to
108	add syms from an as-needed library. */	111	add syms from an as-needed library. */
109	static struct bfd_hash_entry **old_table;	112	static struct bfd_hash_entry **old_table;
110	static unsigned int old_size;	113	static unsigned int old_size;
111	static unsigned int old_count;	114	static unsigned int old_count;
112	static void *old_tab;	115	static void * old_tab;
113	static void *alloc_mark;	116	static void * alloc_mark;
114	static size_t tabsize, entsize, refsize;	117	static size_t tabsize, entsize, refsize;
115	static size_t old_symcount;	118	static size_t old_symcount;
116		119
117	/* Create an entry in a cref hash table. */	120	/* Create an entry in a cref hash table. */
118		121
119	static struct bfd_hash_entry *	122	static struct bfd_hash_entry *
120	cref_hash_newfunc (struct bfd_hash_entry *entry,	123	cref_hash_newfunc (struct bfd_hash_entry *entry,
121	struct bfd_hash_table *table,	124	struct bfd_hash_table *table,
122	const char *string)	125	const char *string)
123	{	126	{
124	struct cref_hash_entry ret = (struct cref_hash_entry ) entry;	127	struct cref_hash_entry ret = (struct cref_hash_entry ) entry;
125		128
126	/* Allocate the structure if it has not already been allocated by a	129	/* Allocate the structure if it has not already been allocated by a
127	subclass. */	130	subclass. */
128	if (ret == NULL)	131	if (ret == NULL)
129	ret = ((struct cref_hash_entry *)	132	ret = ((struct cref_hash_entry *)
130	bfd_hash_allocate (table, sizeof (struct cref_hash_entry)));	133	bfd_hash_allocate (table, sizeof (struct cref_hash_entry)));
131	if (ret == NULL)	134	if (ret == NULL)
132	return NULL;	135	return NULL;
133		136
134	/* Call the allocation method of the superclass. */	137	/* Call the allocation method of the superclass. */
135	ret = ((struct cref_hash_entry *)	138	ret = ((struct cref_hash_entry *)
136	bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));	139	bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
137	if (ret != NULL)	140	if (ret != NULL)
138	{	141	{
139	/* Set local fields. */	142	/* Set local fields. */
140	ret->demangled = NULL;	143	ret->demangled = NULL;
141	ret->refs = NULL;	144	ret->refs = NULL;
142		145
143	/* Keep a count of the number of entries created in the hash	146	/* Keep a count of the number of entries created in the hash
144	table. */	147	table. */
145	++cref_symcount;	148	++cref_symcount;
146	}	149	}
147		150
148	return &ret->root;	151	return &ret->root;
149	}	152	}
150		153
151	/* Add a symbol to the cref hash table. This is called for every	154	/* Add a symbol to the cref hash table. This is called for every
152	global symbol that is seen during the link. */	155	global symbol that is seen during the link. */
153		156
154	void	157	void
155	add_cref (const char *name,	158	add_cref (const char *name,
156	bfd *abfd,	159	bfd *abfd,
157	asection *section,	160	asection *section,
158	bfd_vma value ATTRIBUTE_UNUSED)	161	bfd_vma value ATTRIBUTE_UNUSED)
159	{	162	{
160	struct cref_hash_entry *h;	163	struct cref_hash_entry *h;
161	struct cref_ref *r;	164	struct cref_ref *r;
162		165
163	if (! cref_initialized)	166	if (! cref_initialized)
164	{	167	{
165	if (!bfd_hash_table_init (&cref_table.root, cref_hash_newfunc,	168	if (!bfd_hash_table_init (&cref_table.root, cref_hash_newfunc,
166	sizeof (struct cref_hash_entry)))	169	sizeof (struct cref_hash_entry)))
167	einfo (_("%X%P: bfd_hash_table_init of cref table failed: %E\n"));	170	einfo (_("%X%P: bfd_hash_table_init of cref table failed: %E\n"));
168	cref_initialized = TRUE;	171	cref_initialized = TRUE;
169	}	172	}
170		173
171	h = cref_hash_lookup (&cref_table, name, TRUE, FALSE);	174	h = cref_hash_lookup (&cref_table, name, TRUE, FALSE);
172	if (h == NULL)	175	if (h == NULL)
173	einfo (_("%X%P: cref_hash_lookup failed: %E\n"));	176	einfo (_("%X%P: cref_hash_lookup failed: %E\n"));
174		177
175	for (r = h->refs; r != NULL; r = r->next)	178	for (r = h->refs; r != NULL; r = r->next)
176	if (r->abfd == abfd)	179	if (r->abfd == abfd)
177	break;	180	break;
178		181
179	if (r == NULL)	182	if (r == NULL)
180	{	183	{
181	r = (struct cref_ref ) bfd_hash_allocate (&cref_table.root, sizeof r);	184	r = (struct cref_ref ) bfd_hash_allocate (&cref_table.root, sizeof r);
182	if (r == NULL)	185	if (r == NULL)
183	einfo (_("%X%P: cref alloc failed: %E\n"));	186	einfo (_("%X%P: cref alloc failed: %E\n"));
184	r->next = h->refs;	187	r->next = h->refs;
185	h->refs = r;	188	h->refs = r;
186	r->abfd = abfd;	189	r->abfd = abfd;
187	r->def = FALSE;	190	r->def = FALSE;
188	r->common = FALSE;	191	r->common = FALSE;
189	r->undef = FALSE;	192	r->undef = FALSE;
190	}	193	}
191		194
192	if (bfd_is_und_section (section))	195	if (bfd_is_und_section (section))
193	r->undef = TRUE;	196	r->undef = TRUE;
194	else if (bfd_is_com_section (section))	197	else if (bfd_is_com_section (section))
195	r->common = TRUE;	198	r->common = TRUE;
196	else	199	else
197	r->def = TRUE;	200	r->def = TRUE;
198	}	201	}
199		202
200	/* Called before loading an as-needed library to take a snapshot of	203	/* Called before loading an as-needed library to take a snapshot of
201	the cref hash table, and after we have loaded or found that the	204	the cref hash table, and after we have loaded or found that the
202	library was not needed. */	205	library was not needed. */
203		206
204	bfd_boolean	207	bfd_boolean
205	handle_asneeded_cref (bfd *abfd ATTRIBUTE_UNUSED,	208	handle_asneeded_cref (bfd *abfd ATTRIBUTE_UNUSED,
206	enum notice_asneeded_action act)	209	enum notice_asneeded_action act)
207	{	210	{
208	unsigned int i;	211	unsigned int i;
209		212
210	if (!cref_initialized)	213	if (!cref_initialized)
211	return TRUE;	214	return TRUE;
212		215
213	if (act == notice_as_needed)	216	if (act == notice_as_needed)
214	{	217	{
215	char old_ent, old_ref;	218	char old_ent, old_ref;
216		219
217	for (i = 0; i < cref_table.root.size; i++)	220	for (i = 0; i < cref_table.root.size; i++)
218	{	221	{
219	struct bfd_hash_entry *p;	222	struct bfd_hash_entry *p;
220	struct cref_hash_entry *c;	223	struct cref_hash_entry *c;
221	struct cref_ref *r;	224	struct cref_ref *r;
222		225
223	for (p = cref_table.root.table[i]; p != NULL; p = p->next)	226	for (p = cref_table.root.table[i]; p != NULL; p = p->next)
224	{	227	{
225	entsize += cref_table.root.entsize;	228	entsize += cref_table.root.entsize;
226	c = (struct cref_hash_entry *) p;	229	c = (struct cref_hash_entry *) p;
227	for (r = c->refs; r != NULL; r = r->next)	230	for (r = c->refs; r != NULL; r = r->next)
228	refsize += sizeof (struct cref_ref);	231	refsize += sizeof (struct cref_ref);
229	}	232	}
230	}	233	}
231		234
232	tabsize = cref_table.root.size * sizeof (struct bfd_hash_entry *);	235	tabsize = cref_table.root.size * sizeof (struct bfd_hash_entry *);
233	old_tab = xmalloc (tabsize + entsize + refsize);	236	old_tab = xmalloc (tabsize + entsize + refsize);
234		237
235	alloc_mark = bfd_hash_allocate (&cref_table.root, 1);	238	alloc_mark = bfd_hash_allocate (&cref_table.root, 1);
236	if (alloc_mark == NULL)	239	if (alloc_mark == NULL)
237	return FALSE;	240	return FALSE;
238		241
239	memcpy (old_tab, cref_table.root.table, tabsize);	242	memcpy (old_tab, cref_table.root.table, tabsize);
240	old_ent = (char *) old_tab + tabsize;	243	old_ent = (char *) old_tab + tabsize;
241	old_ref = (char *) old_ent + entsize;	244	old_ref = (char *) old_ent + entsize;
242	old_table = cref_table.root.table;	245	old_table = cref_table.root.table;
243	old_size = cref_table.root.size;	246	old_size = cref_table.root.size;
244	old_count = cref_table.root.count;	247	old_count = cref_table.root.count;
245	old_symcount = cref_symcount;	248	old_symcount = cref_symcount;
246		249
247	for (i = 0; i < cref_table.root.size; i++)	250	for (i = 0; i < cref_table.root.size; i++)
248	{	251	{
249	struct bfd_hash_entry *p;	252	struct bfd_hash_entry *p;
250	struct cref_hash_entry *c;	253	struct cref_hash_entry *c;
251	struct cref_ref *r;	254	struct cref_ref *r;
252		255
253	for (p = cref_table.root.table[i]; p != NULL; p = p->next)	256	for (p = cref_table.root.table[i]; p != NULL; p = p->next)
254	{	257	{
255	memcpy (old_ent, p, cref_table.root.entsize);	258	memcpy (old_ent, p, cref_table.root.entsize);
256	old_ent = (char *) old_ent + cref_table.root.entsize;	259	old_ent = (char *) old_ent + cref_table.root.entsize;
257	c = (struct cref_hash_entry *) p;	260	c = (struct cref_hash_entry *) p;
258	for (r = c->refs; r != NULL; r = r->next)	261	for (r = c->refs; r != NULL; r = r->next)
259	{	262	{
260	memcpy (old_ref, r, sizeof (struct cref_ref));	263	memcpy (old_ref, r, sizeof (struct cref_ref));
261	old_ref = (char *) old_ref + sizeof (struct cref_ref);	264	old_ref = (char *) old_ref + sizeof (struct cref_ref);
262	}	265	}
263	}	266	}
264	}	267	}
265	return TRUE;	268	return TRUE;
266	}	269	}
267		270
268	if (act == notice_not_needed)	271	if (act == notice_not_needed)
269	{	272	{
270	char old_ent, old_ref;	273	char old_ent, old_ref;
271		274
272	if (old_tab == NULL)	275	if (old_tab == NULL)
273	{	276	{
274	/* The only way old_tab can be NULL is if the cref hash table	277	/* The only way old_tab can be NULL is if the cref hash table
275	had not been initialised when notice_as_needed. */	278	had not been initialised when notice_as_needed. */
276	bfd_hash_table_free (&cref_table.root);	279	bfd_hash_table_free (&cref_table.root);
277	cref_initialized = FALSE;	280	cref_initialized = FALSE;
278	return TRUE;	281	return TRUE;
279	}	282	}
280		283
281	old_ent = (char *) old_tab + tabsize;	284	old_ent = (char *) old_tab + tabsize;
282	old_ref = (char *) old_ent + entsize;	285	old_ref = (char *) old_ent + entsize;
283	cref_table.root.table = old_table;	286	cref_table.root.table = old_table;
284	cref_table.root.size = old_size;	287	cref_table.root.size = old_size;
285	cref_table.root.count = old_count;	288	cref_table.root.count = old_count;
286	memcpy (cref_table.root.table, old_tab, tabsize);	289	memcpy (cref_table.root.table, old_tab, tabsize);
287	cref_symcount = old_symcount;	290	cref_symcount = old_symcount;
288		291
289	for (i = 0; i < cref_table.root.size; i++)	292	for (i = 0; i < cref_table.root.size; i++)
290	{	293	{
291	struct bfd_hash_entry *p;	294	struct bfd_hash_entry *p;
292	struct cref_hash_entry *c;	295	struct cref_hash_entry *c;
293	struct cref_ref *r;	296	struct cref_ref *r;
294		297
295	for (p = cref_table.root.table[i]; p != NULL; p = p->next)	298	for (p = cref_table.root.table[i]; p != NULL; p = p->next)
296	{	299	{
297	memcpy (p, old_ent, cref_table.root.entsize);	300	memcpy (p, old_ent, cref_table.root.entsize);
298	old_ent = (char *) old_ent + cref_table.root.entsize;	301	old_ent = (char *) old_ent + cref_table.root.entsize;
299	c = (struct cref_hash_entry *) p;	302	c = (struct cref_hash_entry *) p;
300	for (r = c->refs; r != NULL; r = r->next)	303	for (r = c->refs; r != NULL; r = r->next)
301	{	304	{
302	memcpy (r, old_ref, sizeof (struct cref_ref));	305	memcpy (r, old_ref, sizeof (struct cref_ref));
303	old_ref = (char *) old_ref + sizeof (struct cref_ref);	306	old_ref = (char *) old_ref + sizeof (struct cref_ref);
304	}	307	}
305	}	308	}
306	}	309	}
307		310
308	objalloc_free_block ((struct objalloc *) cref_table.root.memory,	311	objalloc_free_block ((struct objalloc *) cref_table.root.memory,
309	alloc_mark);	312	alloc_mark);
310	}	313	}
311	else if (act != notice_needed)	314	else if (act != notice_needed)
312	return FALSE;	315	return FALSE;
313		316
314	free (old_tab);	317	free (old_tab);
315	old_tab = NULL;	318	old_tab = NULL;
316	return TRUE;	319	return TRUE;
317	}	320	}
318		321
319	/* Copy the addresses of the hash table entries into an array. This	322	/* Copy the addresses of the hash table entries into an array. This
320	is called via cref_hash_traverse. We also fill in the demangled	323	is called via cref_hash_traverse. We also fill in the demangled
321	name. */	324	name. */
322		325
323	static bfd_boolean	326	static bfd_boolean
324	cref_fill_array (struct cref_hash_entry h, void data)	327	cref_fill_array (struct cref_hash_entry h, void data)
325	{	328	{
326	struct cref_hash_entry *pph = (struct cref_hash_entry *) data;	329	struct cref_hash_entry *pph = (struct cref_hash_entry *) data;
327		330
328	ASSERT (h->demangled == NULL);	331	ASSERT (h->demangled == NULL);
329	h->demangled = bfd_demangle (link_info.output_bfd, h->root.string,	332	h->demangled = bfd_demangle (link_info.output_bfd, h->root.string,
330	DMGL_ANSI \| DMGL_PARAMS);	333	DMGL_ANSI \| DMGL_PARAMS);
331	if (h->demangled == NULL)	334	if (h->demangled == NULL)
332	h->demangled = h->root.string;	335	h->demangled = h->root.string;
333		336
334	**pph = h;	337	**pph = h;
335		338
336	++*pph;	339	++*pph;
337		340
338	return TRUE;	341	return TRUE;
339	}	342	}
340		343
341	/* Sort an array of cref hash table entries by name. */	344	/* Sort an array of cref hash table entries by name. */
342		345
343	static int	346	static int
344	cref_sort_array (const void a1, const void a2)	347	cref_sort_array (const void a1, const void a2)
345	{	348	{
346	const struct cref_hash_entry * const *p1 =	349	const struct cref_hash_entry * const *p1 =
347	(const struct cref_hash_entry * const *) a1;	350	(const struct cref_hash_entry * const *) a1;
348	const struct cref_hash_entry * const *p2 =	351	const struct cref_hash_entry * const *p2 =
349	(const struct cref_hash_entry * const *) a2;	352	(const struct cref_hash_entry * const *) a2;
-		353
350		354	if (demangling)
-		355	return strcmp ((p1)->demangled, (p2)->demangled);
-		356	else
351	return strcmp ((p1)->demangled, (p2)->demangled);	357	return strcmp ((p1)->root.string, (p2)->root.string);
352	}	358	}
353		359
354	/* Write out the cref table. */	360	/* Write out the cref table. */
355		361
356	#define FILECOL (50)	362	#define FILECOL (50)
357		363
358	void	364	void
359	output_cref (FILE *fp)	365	output_cref (FILE *fp)
360	{	366	{
361	int len;	367	int len;
362	struct cref_hash_entry csyms, csym_fill, csym, csym_end;	368	struct cref_hash_entry csyms, csym_fill, csym, csym_end;
363	const char *msg;	369	const char *msg;
364		370
365	fprintf (fp, _("\nCross Reference Table\n\n"));	371	fprintf (fp, _("\nCross Reference Table\n\n"));
366	msg = _("Symbol");	372	msg = _("Symbol");
367	fprintf (fp, "%s", msg);	373	fprintf (fp, "%s", msg);
368	len = strlen (msg);	374	len = strlen (msg);
369	while (len < FILECOL)	375	while (len < FILECOL)
370	{	376	{
371	putc (' ', fp);	377	putc (' ', fp);
372	++len;	378	++len;
373	}	379	}
374	fprintf (fp, _("File\n"));	380	fprintf (fp, _("File\n"));
375		381
376	if (! cref_initialized)	382	if (! cref_initialized)
377	{	383	{
378	fprintf (fp, _("No symbols\n"));	384	fprintf (fp, _("No symbols\n"));
379	return;	385	return;
380	}	386	}
381		387
382	csyms = (struct cref_hash_entry *) xmalloc (cref_symcount sizeof (*csyms));	388	csyms = (struct cref_hash_entry *) xmalloc (cref_symcount sizeof (*csyms));
383		389
384	csym_fill = csyms;	390	csym_fill = csyms;
385	cref_hash_traverse (&cref_table, cref_fill_array, &csym_fill);	391	cref_hash_traverse (&cref_table, cref_fill_array, &csym_fill);
386	ASSERT ((size_t) (csym_fill - csyms) == cref_symcount);	392	ASSERT ((size_t) (csym_fill - csyms) == cref_symcount);
387		393
388	qsort (csyms, cref_symcount, sizeof (*csyms), cref_sort_array);	394	qsort (csyms, cref_symcount, sizeof (*csyms), cref_sort_array);
389		395
390	csym_end = csyms + cref_symcount;	396	csym_end = csyms + cref_symcount;
391	for (csym = csyms; csym < csym_end; csym++)	397	for (csym = csyms; csym < csym_end; csym++)
392	output_one_cref (fp, *csym);	398	output_one_cref (fp, *csym);
393	}	399	}
394		400
395	/* Output one entry in the cross reference table. */	401	/* Output one entry in the cross reference table. */
396		402
397	static void	403	static void
398	output_one_cref (FILE fp, struct cref_hash_entry h)	404	output_one_cref (FILE fp, struct cref_hash_entry h)
399	{	405	{
400	int len;	406	int len;
401	struct bfd_link_hash_entry *hl;	407	struct bfd_link_hash_entry *hl;
402	struct cref_ref *r;	408	struct cref_ref *r;
403		409
404	hl = bfd_link_hash_lookup (link_info.hash, h->root.string, FALSE,	410	hl = bfd_link_hash_lookup (link_info.hash, h->root.string, FALSE,
405	FALSE, TRUE);	411	FALSE, TRUE);
406	if (hl == NULL)	412	if (hl == NULL)
407	einfo ("%P: symbol `%T' missing from main hash table\n",	413	einfo ("%P: symbol `%T' missing from main hash table\n",
408	h->root.string);	414	h->root.string);
409	else	415	else
410	{	416	{
411	/* If this symbol is defined in a dynamic object but never	417	/* If this symbol is defined in a dynamic object but never
412	referenced by a normal object, then don't print it. */	418	referenced by a normal object, then don't print it. */
413	if (hl->type == bfd_link_hash_defined)	419	if (hl->type == bfd_link_hash_defined)
414	{	420	{
415	if (hl->u.def.section->output_section == NULL)	421	if (hl->u.def.section->output_section == NULL)
416	return;	422	return;
417	if (hl->u.def.section->owner != NULL	423	if (hl->u.def.section->owner != NULL
418	&& (hl->u.def.section->owner->flags & DYNAMIC) != 0)	424	&& (hl->u.def.section->owner->flags & DYNAMIC) != 0)
419	{	425	{
420	for (r = h->refs; r != NULL; r = r->next)	426	for (r = h->refs; r != NULL; r = r->next)
421	if ((r->abfd->flags & DYNAMIC) == 0)	427	if ((r->abfd->flags & DYNAMIC) == 0)
422	break;	428	break;
423	if (r == NULL)	429	if (r == NULL)
424	return;	430	return;
425	}	431	}
426	}	432	}
427	}	433	}
-		434
-		435	if (demangling)
428		436	{
429	fprintf (fp, "%s ", h->demangled);	437	fprintf (fp, "%s ", h->demangled);
-		438	len = strlen (h->demangled) + 1;
-		439	}
-		440	else
-		441	{
-		442	fprintf (fp, "%s ", h->root.string);
-		443	len = strlen (h->root.string) + 1;
430	len = strlen (h->demangled) + 1;	444	}
431		445
432	for (r = h->refs; r != NULL; r = r->next)	446	for (r = h->refs; r != NULL; r = r->next)
433	{	447	{
434	if (r->def)	448	if (r->def)
435	{	449	{
436	while (len < FILECOL)	450	while (len < FILECOL)
437	{	451	{
438	putc (' ', fp);	452	putc (' ', fp);
439	++len;	453	++len;
440	}	454	}
441	lfinfo (fp, "%B\n", r->abfd);	455	lfinfo (fp, "%B\n", r->abfd);
442	len = 0;	456	len = 0;
443	}	457	}
444	}	458	}
445		459
446	for (r = h->refs; r != NULL; r = r->next)	460	for (r = h->refs; r != NULL; r = r->next)
447	{	461	{
448	if (r->common)	462	if (r->common)
449	{	463	{
450	while (len < FILECOL)	464	while (len < FILECOL)
451	{	465	{
452	putc (' ', fp);	466	putc (' ', fp);
453	++len;	467	++len;
454	}	468	}
455	lfinfo (fp, "%B\n", r->abfd);	469	lfinfo (fp, "%B\n", r->abfd);
456	len = 0;	470	len = 0;
457	}	471	}
458	}	472	}
459		473
460	for (r = h->refs; r != NULL; r = r->next)	474	for (r = h->refs; r != NULL; r = r->next)
461	{	475	{
462	if (! r->def && ! r->common)	476	if (! r->def && ! r->common)
463	{	477	{
464	while (len < FILECOL)	478	while (len < FILECOL)
465	{	479	{
466	putc (' ', fp);	480	putc (' ', fp);
467	++len;	481	++len;
468	}	482	}
469	lfinfo (fp, "%B\n", r->abfd);	483	lfinfo (fp, "%B\n", r->abfd);
470	len = 0;	484	len = 0;
471	}	485	}
472	}	486	}
473		487
474	ASSERT (len == 0);	488	ASSERT (len == 0);
475	}	489	}
476		490
477	/* Check for prohibited cross references. */	491	/* Check for prohibited cross references. */
478		492
479	void	493	void
480	check_nocrossrefs (void)	494	check_nocrossrefs (void)
481	{	495	{
482	if (! cref_initialized)	496	if (! cref_initialized)
483	return;	497	return;
484		498
485	cref_hash_traverse (&cref_table, check_nocrossref, NULL);	499	cref_hash_traverse (&cref_table, check_nocrossref, NULL);
486		500

Subversion Repositories Kolibri OS

(root)/contrib/toolchain/binutils/ld/ldcref.c @ 8361 – Rev 5199 → 6324