[deliverable/binutils-gdb.git] / ld / ldcref.c

/* ldcref.c -- output a cross reference table
   Copyright 1996, 1997, 1998, 2000 Free Software Foundation, Inc.
   Written by Ian Lance Taylor <ian@cygnus.com>

This file is part of GLD, the Gnu Linker.

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 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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 "bfdlink.h"
#include "libiberty.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.  */
  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;
};

/* Local functions.  */

static struct bfd_hash_entry *cref_hash_newfunc
  PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
static boolean cref_fill_array PARAMS ((struct cref_hash_entry *, PTR));
static int cref_sort_array PARAMS ((const PTR, const PTR));
static void output_one_cref PARAMS ((FILE *, struct cref_hash_entry *));
static boolean check_nocrossref PARAMS ((struct cref_hash_entry *, PTR));
static void check_section_sym_xref PARAMS ((lang_input_statement_type *));
static void check_refs
  PARAMS ((const char *, asection *, bfd *, struct lang_nocrossrefs *));
static void check_reloc_refs PARAMS ((bfd *, asection *, PTR));

/* 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,							\
    (boolean (*) PARAMS ((struct bfd_hash_entry *, PTR))) (func),	\
    (info)))

/* The cref hash table.  */

static struct cref_hash_table cref_table;

/* Whether the cref hash table has been initialized.  */

static boolean cref_initialized;

/* The number of symbols seen so far.  */

static size_t cref_symcount;

/* Create an entry in a cref hash table.  */

static struct bfd_hash_entry *
cref_hash_newfunc (entry, table, string)
     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 (struct bfd_hash_entry *) ret;

  /* 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 (struct bfd_hash_entry *) ret;
}

/* Add a symbol to the cref hash table.  This is called for every
   symbol that is seen during the link.  */

void
add_cref (name, abfd, section, value)
     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))
	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 *) xmalloc (sizeof *r);
      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;
}

/* 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 boolean
cref_fill_array (h, data)
     struct cref_hash_entry *h;
     PTR data;
{
  struct cref_hash_entry ***pph = (struct cref_hash_entry ***) data;

  ASSERT (h->demangled == NULL);
  h->demangled = demangle (h->root.string);

  **pph = h;

  ++*pph;

  return true;
}

/* Sort an array of cref hash table entries by name.  */

static int
cref_sort_array (a1, a2)
     const PTR a1;
     const PTR a2;
{
  const struct cref_hash_entry **p1 = (const struct cref_hash_entry **) a1;
  const struct cref_hash_entry **p2 = (const struct cref_hash_entry **) a2;

  return strcmp ((*p1)->demangled, (*p2)->demangled);
}

/* Write out the cref table.  */

#define FILECOL (50)

void
output_cref (fp)
     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 (fp, h)
     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 ()
{
  if (! cref_initialized)
    return;

  cref_hash_traverse (&cref_table, check_nocrossref, (PTR) NULL);

  lang_for_each_file (check_section_sym_xref);
}

/* Checks for prohibited cross references to section symbols.  */

static void
check_section_sym_xref (statement)
     lang_input_statement_type *statement;
{
  bfd *abfd;
  asection *sec;

  abfd = statement->the_bfd;
  if (abfd == NULL)
    return;

  for (sec = abfd->sections; sec != NULL; sec = sec->next)
    {
      asection *outsec;

      outsec = sec->output_section;
      if (outsec != NULL)
	{
	  const char *outsecname;
	  struct lang_nocrossrefs *ncrs;
	  struct lang_nocrossref *ncr;

	  outsecname = outsec->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 (NULL, sec, abfd, ncrs);
	}
    }
}

/* Check one symbol to see if it is a prohibited cross reference.  */

static boolean
check_nocrossref (h, ignore)
     struct cref_hash_entry *h;
     PTR 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, 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;
};

/* 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 (name, sec, abfd, ncrs)
     const char *name;
     asection *sec;
     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
     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.  */

  li = (lang_input_statement_type *) 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 = (asymbol **) 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;
	}
    }

  info.sym_name = name;
  info.defsec = sec;
  info.ncrs = ncrs;
  info.asymbols = asymbols;
  bfd_map_over_sections (abfd, check_reloc_refs, (PTR) &info);

  if (li == NULL)
    free (asymbols);
}

/* 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 (abfd, sec, iarg)
     bfd *abfd;
     asection *sec;
     PTR 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;
  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.  */

  symname = info->sym_name;

  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
	  && (symname != NULL
	      ? strcmp (bfd_asymbol_name (*q->sym_ptr_ptr), symname) == 0
	      : (((*q->sym_ptr_ptr)->flags & BSF_SECTION_SYM) != 0
		 && bfd_get_section (*q->sym_ptr_ptr) == info->defsec)))
	{
	  /* 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);
}
Commit	Line	Data
252b5132	1	/* ldcref.c -- output a cross reference table
a2b64bed	2	Copyright 1996, 1997, 1998, 2000 Free Software Foundation, Inc.
252b5132 RH	3	Written by Ian Lance Taylor <ian@cygnus.com>
	4
	5	This file is part of GLD, the Gnu Linker.
	6
	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
	9	the Free Software Foundation; either version 2 of the License, or
	10	(at your option) any later version.
	11
	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	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
	19	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
	20
	21	/* This file holds routines that manage the cross reference table.
	22	The table is used to generate cross reference reports. It is also
	23	used to implement the NOCROSSREFS command in the linker script. */
	24
	25	#include "bfd.h"
	26	#include "sysdep.h"
	27	#include "bfdlink.h"
	28	#include "libiberty.h"
	29
	30	#include "ld.h"
	31	#include "ldmain.h"
	32	#include "ldmisc.h"
	33	#include "ldexp.h"
	34	#include "ldlang.h"
	35
	36	/* We keep an instance of this structure for each reference to a
	37	symbol from a given object. */
	38
89cdebba	39	struct cref_ref {
252b5132 RH	40	/* The next reference. */
	41	struct cref_ref *next;
	42	/* The object. */
	43	bfd *abfd;
	44	/* True if the symbol is defined. */
	45	unsigned int def : 1;
	46	/* True if the symbol is common. */
	47	unsigned int common : 1;
	48	/* True if the symbol is undefined. */
	49	unsigned int undef : 1;
	50	};
	51
	52	/* We keep a hash table of symbols. Each entry looks like this. */
	53
89cdebba	54	struct cref_hash_entry {
252b5132 RH	55	struct bfd_hash_entry root;
	56	/* The demangled name. */
	57	char *demangled;
	58	/* References to and definitions of this symbol. */
	59	struct cref_ref *refs;
	60	};
	61
	62	/* This is what the hash table looks like. */
	63
89cdebba	64	struct cref_hash_table {
252b5132 RH	65	struct bfd_hash_table root;
	66	};
	67
	68	/* Local functions. */
	69
	70	static struct bfd_hash_entry *cref_hash_newfunc
	71	PARAMS ((struct bfd_hash_entry , struct bfd_hash_table , const char *));
	72	static boolean cref_fill_array PARAMS ((struct cref_hash_entry *, PTR));
	73	static int cref_sort_array PARAMS ((const PTR, const PTR));
	74	static void output_one_cref PARAMS ((FILE , struct cref_hash_entry ));
	75	static boolean check_nocrossref PARAMS ((struct cref_hash_entry *, PTR));
e14ec88b	76	static void check_section_sym_xref PARAMS ((lang_input_statement_type *));
252b5132	77	static void check_refs
e14ec88b	78	PARAMS ((const char , asection , bfd , struct lang_nocrossrefs ));
252b5132 RH	79	static void check_reloc_refs PARAMS ((bfd , asection , PTR));
	80
	81	/* Look up an entry in the cref hash table. */
	82
	83	#define cref_hash_lookup(table, string, create, copy) \
	84	((struct cref_hash_entry *) \
	85	bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
	86
	87	/* Traverse the cref hash table. */
	88
	89	#define cref_hash_traverse(table, func, info) \
	90	(bfd_hash_traverse \
	91	(&(table)->root, \
	92	(boolean () PARAMS ((struct bfd_hash_entry , PTR))) (func), \
	93	(info)))
	94
	95	/* The cref hash table. */
	96
	97	static struct cref_hash_table cref_table;
	98
	99	/* Whether the cref hash table has been initialized. */
	100
	101	static boolean cref_initialized;
	102
	103	/* The number of symbols seen so far. */
	104
	105	static size_t cref_symcount;
	106
	107	/* Create an entry in a cref hash table. */
	108
	109	static struct bfd_hash_entry *
	110	cref_hash_newfunc (entry, table, string)
	111	struct bfd_hash_entry *entry;
	112	struct bfd_hash_table *table;
	113	const char *string;
	114	{
	115	struct cref_hash_entry ret = (struct cref_hash_entry ) entry;
	116
	117	/* Allocate the structure if it has not already been allocated by a
	118	subclass. */
	119	if (ret == NULL)
	120	ret = ((struct cref_hash_entry *)
	121	bfd_hash_allocate (table, sizeof (struct cref_hash_entry)));
	122	if (ret == NULL)
	123	return (struct bfd_hash_entry *) ret;
	124
	125	/* Call the allocation method of the superclass. */
	126	ret = ((struct cref_hash_entry *)
	127	bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
	128	if (ret != NULL)
	129	{
	130	/* Set local fields. */
	131	ret->demangled = NULL;
	132	ret->refs = NULL;
	133
	134	/* Keep a count of the number of entries created in the hash
	135	table. */
	136	++cref_symcount;
	137	}
	138
	139	return (struct bfd_hash_entry *) ret;
	140	}
	141
	142	/* Add a symbol to the cref hash table. This is called for every
143	symbol that is seen during the link. */
144
252b5132 RH	145	void
	146	add_cref (name, abfd, section, value)
	147	const char *name;
	148	bfd *abfd;
	149	asection *section;
87f2a346	150	bfd_vma value ATTRIBUTE_UNUSED;
252b5132 RH	151	{
	152	struct cref_hash_entry *h;
	153	struct cref_ref *r;
	154
	155	if (! cref_initialized)
	156	{
	157	if (! bfd_hash_table_init (&cref_table.root, cref_hash_newfunc))
	158	einfo (_("%X%P: bfd_hash_table_init of cref table failed: %E\n"));
	159	cref_initialized = true;
	160	}
	161
	162	h = cref_hash_lookup (&cref_table, name, true, false);
	163	if (h == NULL)
	164	einfo (_("%X%P: cref_hash_lookup failed: %E\n"));
	165
	166	for (r = h->refs; r != NULL; r = r->next)
	167	if (r->abfd == abfd)
	168	break;
	169
	170	if (r == NULL)
	171	{
	172	r = (struct cref_ref ) xmalloc (sizeof r);
	173	r->next = h->refs;
	174	h->refs = r;
	175	r->abfd = abfd;
	176	r->def = false;
	177	r->common = false;
	178	r->undef = false;
	179	}
	180
	181	if (bfd_is_und_section (section))
	182	r->undef = true;
	183	else if (bfd_is_com_section (section))
	184	r->common = true;
	185	else
	186	r->def = true;
	187	}
	188
	189	/* Copy the addresses of the hash table entries into an array. This
	190	is called via cref_hash_traverse. We also fill in the demangled
	191	name. */
	192
	193	static boolean
	194	cref_fill_array (h, data)
	195	struct cref_hash_entry *h;
	196	PTR data;
	197	{
	198	struct cref_hash_entry *pph = (struct cref_hash_entry *) data;
	199
	200	ASSERT (h->demangled == NULL);
	201	h->demangled = demangle (h->root.string);
	202
	203	**pph = h;
	204
	205	++*pph;
	206
	207	return true;
	208	}
	209
	210	/* Sort an array of cref hash table entries by name. */
	211
	212	static int
	213	cref_sort_array (a1, a2)
	214	const PTR a1;
215	const PTR a2;
216	{
217	const struct cref_hash_entry p1 = (const struct cref_hash_entry ) a1;
218	const struct cref_hash_entry p2 = (const struct cref_hash_entry ) a2;
219
220	return strcmp ((p1)->demangled, (p2)->demangled);
221	}
222
223	/* Write out the cref table. */
224
225	#define FILECOL (50)
226
227	void
228	output_cref (fp)
229	FILE *fp;
230	{
231	int len;
232	struct cref_hash_entry csyms, csym_fill, csym, csym_end;
233	const char *msg;
234
235	fprintf (fp, _("\nCross Reference Table\n\n"));
236	msg = _("Symbol");
305c7206	237	fprintf (fp, "%s", msg);
252b5132 RH	238	len = strlen (msg);
	239	while (len < FILECOL)
	240	{
4de2d33d	241	putc (' ', fp);
252b5132 RH	242	++len;
	243	}
	244	fprintf (fp, _("File\n"));
	245
	246	if (! cref_initialized)
	247	{
	248	fprintf (fp, _("No symbols\n"));
	249	return;
	250	}
	251
	252	csyms = ((struct cref_hash_entry **)
	253	xmalloc (cref_symcount * sizeof (*csyms)));
	254
	255	csym_fill = csyms;
	256	cref_hash_traverse (&cref_table, cref_fill_array, &csym_fill);
	257	ASSERT ((size_t) (csym_fill - csyms) == cref_symcount);
	258
	259	qsort (csyms, cref_symcount, sizeof (*csyms), cref_sort_array);
	260
	261	csym_end = csyms + cref_symcount;
	262	for (csym = csyms; csym < csym_end; csym++)
	263	output_one_cref (fp, *csym);
	264	}
	265
	266	/* Output one entry in the cross reference table. */
	267
	268	static void
	269	output_one_cref (fp, h)
	270	FILE *fp;
	271	struct cref_hash_entry *h;
	272	{
	273	int len;
	274	struct bfd_link_hash_entry *hl;
	275	struct cref_ref *r;
	276
	277	hl = bfd_link_hash_lookup (link_info.hash, h->root.string, false,
	278	false, true);
	279	if (hl == NULL)
	280	einfo ("%P: symbol `%T' missing from main hash table\n",
	281	h->root.string);
	282	else
	283	{
	284	/* If this symbol is defined in a dynamic object but never
	285	referenced by a normal object, then don't print it. */
	286	if (hl->type == bfd_link_hash_defined)
	287	{
	288	if (hl->u.def.section->output_section == NULL)
	289	return;
	290	if (hl->u.def.section->owner != NULL
	291	&& (hl->u.def.section->owner->flags & DYNAMIC) != 0)
	292	{
	293	for (r = h->refs; r != NULL; r = r->next)
	294	if ((r->abfd->flags & DYNAMIC) == 0)
	295	break;
	296	if (r == NULL)
	297	return;
	298	}
	299	}
	300	}
	301
	302	fprintf (fp, "%s ", h->demangled);
	303	len = strlen (h->demangled) + 1;
	304
	305	for (r = h->refs; r != NULL; r = r->next)
306	{
307	if (r->def)
308	{
309	while (len < FILECOL)
310	{
311	putc (' ', fp);
312	++len;
313	}
314	lfinfo (fp, "%B\n", r->abfd);
315	len = 0;
316	}
317	}
318
319	for (r = h->refs; r != NULL; r = r->next)
320	{
321	if (! r->def)
322	{
323	while (len < FILECOL)
324	{
325	putc (' ', fp);
326	++len;
327	}
328	lfinfo (fp, "%B\n", r->abfd);
329	len = 0;
330	}
331	}
332
333	ASSERT (len == 0);
334	}
335
336	/* Check for prohibited cross references. */
337
338	void
339	check_nocrossrefs ()
340	{
341	if (! cref_initialized)
342	return;
343
344	cref_hash_traverse (&cref_table, check_nocrossref, (PTR) NULL);
e14ec88b AM	345
	346	lang_for_each_file (check_section_sym_xref);
	347	}
	348
	349	/* Checks for prohibited cross references to section symbols. */
	350
	351	static void
	352	check_section_sym_xref (statement)
	353	lang_input_statement_type *statement;
	354	{
	355	bfd *abfd;
	356	asection *sec;
	357
	358	abfd = statement->the_bfd;
	359	if (abfd == NULL)
	360	return;
	361
	362	for (sec = abfd->sections; sec != NULL; sec = sec->next)
	363	{
	364	asection *outsec;
	365
	366	outsec = sec->output_section;
	367	if (outsec != NULL)
	368	{
	369	const char *outsecname;
	370	struct lang_nocrossrefs *ncrs;
	371	struct lang_nocrossref *ncr;
	372
	373	outsecname = outsec->name;
	374	for (ncrs = nocrossref_list; ncrs != NULL; ncrs = ncrs->next)
	375	for (ncr = ncrs->list; ncr != NULL; ncr = ncr->next)
	376	if (strcmp (ncr->name, outsecname) == 0)
	377	check_refs (NULL, sec, abfd, ncrs);
	378	}
	379	}
252b5132 RH	380	}
	381
	382	/* Check one symbol to see if it is a prohibited cross reference. */
	383
252b5132 RH	384	static boolean
	385	check_nocrossref (h, ignore)
	386	struct cref_hash_entry *h;
87f2a346	387	PTR ignore ATTRIBUTE_UNUSED;
252b5132 RH	388	{
	389	struct bfd_link_hash_entry *hl;
	390	asection *defsec;
	391	const char *defsecname;
	392	struct lang_nocrossrefs *ncrs;
	393	struct lang_nocrossref *ncr;
e14ec88b	394	struct cref_ref *ref;
252b5132 RH	395
	396	hl = bfd_link_hash_lookup (link_info.hash, h->root.string, false,
	397	false, true);
	398	if (hl == NULL)
	399	{
	400	einfo (_("%P: symbol `%T' missing from main hash table\n"),
	401	h->root.string);
	402	return true;
	403	}
	404
	405	if (hl->type != bfd_link_hash_defined
	406	&& hl->type != bfd_link_hash_defweak)
	407	return true;
	408
	409	defsec = hl->u.def.section->output_section;
	410	if (defsec == NULL)
	411	return true;
	412	defsecname = bfd_get_section_name (defsec->owner, defsec);
	413
	414	for (ncrs = nocrossref_list; ncrs != NULL; ncrs = ncrs->next)
	415	for (ncr = ncrs->list; ncr != NULL; ncr = ncr->next)
	416	if (strcmp (ncr->name, defsecname) == 0)
e14ec88b AM	417	for (ref = h->refs; ref != NULL; ref = ref->next)
e14ec88b AM	418	check_refs (hl->root.string, hl->u.def.section, ref->abfd, ncrs);
252b5132 RH	419
	420	return true;
	421	}
	422
	423	/* The struct is used to pass information from check_refs to
	424	check_reloc_refs through bfd_map_over_sections. */
	425
89cdebba	426	struct check_refs_info {
e14ec88b	427	const char *sym_name;
252b5132 RH	428	asection *defsec;
	429	struct lang_nocrossrefs *ncrs;
	430	asymbol **asymbols;
252b5132 RH	431	};
	432
	433	/* This function is called for each symbol defined in a section which
	434	prohibits cross references. We need to look through all references
	435	to this symbol, and ensure that the references are not from
	436	prohibited sections. */
	437
	438	static void
e14ec88b AM	439	check_refs (name, sec, abfd, ncrs)
	440	const char *name;
	441	asection *sec;
	442	bfd *abfd;
252b5132 RH	443	struct lang_nocrossrefs *ncrs;
252b5132 RH	444	{
e14ec88b AM	445	lang_input_statement_type *li;
	446	asymbol **asymbols;
	447	struct check_refs_info info;
252b5132	448
e14ec88b AM	449	/* We need to look through the relocations for this BFD, to see
	450	if any of the relocations which refer to this symbol are from
	451	a prohibited section. Note that we need to do this even for
	452	the BFD in which the symbol is defined, since even a single
	453	BFD might contain a prohibited cross reference. */
	454
	455	li = (lang_input_statement_type *) abfd->usrdata;
	456	if (li != NULL && li->asymbols != NULL)
	457	asymbols = li->asymbols;
	458	else
252b5132	459	{
e14ec88b AM	460	long symsize;
	461	long symbol_count;
	462
	463	symsize = bfd_get_symtab_upper_bound (abfd);
	464	if (symsize < 0)
	465	einfo (_("%B%F: could not read symbols; %E\n"), abfd);
	466	asymbols = (asymbol **) xmalloc (symsize);
	467	symbol_count = bfd_canonicalize_symtab (abfd, asymbols);
	468	if (symbol_count < 0)
	469	einfo (_("%B%F: could not read symbols: %E\n"), abfd);
	470	if (li != NULL)
252b5132	471	{
e14ec88b AM	472	li->asymbols = asymbols;
e14ec88b AM	473	li->symbol_count = symbol_count;
252b5132	474	}
252b5132	475	}
e14ec88b AM	476
	477	info.sym_name = name;
	478	info.defsec = sec;
	479	info.ncrs = ncrs;
	480	info.asymbols = asymbols;
	481	bfd_map_over_sections (abfd, check_reloc_refs, (PTR) &info);
	482
	483	if (li == NULL)
	484	free (asymbols);
252b5132 RH	485	}
252b5132 RH	486
e14ec88b	487	/* This is called via bfd_map_over_sections. INFO->SYM_NAME is a symbol
252b5132 RH	488	defined in INFO->DEFSECNAME. If this section maps into any of the
	489	sections listed in INFO->NCRS, other than INFO->DEFSECNAME, then we
	490	look through the relocations. If any of the relocations are to
e14ec88b	491	INFO->SYM_NAME, then we report a prohibited cross reference error. */
252b5132 RH	492
	493	static void
	494	check_reloc_refs (abfd, sec, iarg)
	495	bfd *abfd;
	496	asection *sec;
	497	PTR iarg;
	498	{
	499	struct check_refs_info info = (struct check_refs_info ) iarg;
	500	asection *outsec;
	501	const char *outsecname;
	502	asection *outdefsec;
	503	const char *outdefsecname;
	504	struct lang_nocrossref *ncr;
	505	const char *symname;
	506	long relsize;
	507	arelent **relpp;
	508	long relcount;
	509	arelent p, pend;
	510
	511	outsec = sec->output_section;
	512	outsecname = bfd_get_section_name (outsec->owner, outsec);
	513
	514	outdefsec = info->defsec->output_section;
	515	outdefsecname = bfd_get_section_name (outdefsec->owner, outdefsec);
	516
	517	/* The section where the symbol is defined is permitted. */
	518	if (strcmp (outsecname, outdefsecname) == 0)
	519	return;
	520
	521	for (ncr = info->ncrs->list; ncr != NULL; ncr = ncr->next)
	522	if (strcmp (outsecname, ncr->name) == 0)
	523	break;
	524
	525	if (ncr == NULL)
	526	return;
	527
	528	/* This section is one for which cross references are prohibited.
	529	Look through the relocations, and see if any of them are to
e14ec88b AM	530	INFO->SYM_NAME. If INFO->SYMNAME is NULL, check for relocations
e14ec88b AM	531	against the section symbol. */
252b5132	532
e14ec88b	533	symname = info->sym_name;
252b5132 RH	534
	535	relsize = bfd_get_reloc_upper_bound (abfd, sec);
	536	if (relsize < 0)
	537	einfo (_("%B%F: could not read relocs: %E\n"), abfd);
	538	if (relsize == 0)
	539	return;
	540
	541	relpp = (arelent **) xmalloc (relsize);
	542	relcount = bfd_canonicalize_reloc (abfd, sec, relpp, info->asymbols);
	543	if (relcount < 0)
	544	einfo (_("%B%F: could not read relocs: %E\n"), abfd);
	545
	546	p = relpp;
	547	pend = p + relcount;
	548	for (; p < pend && *p != NULL; p++)
	549	{
	550	arelent q = p;
	551
	552	if (q->sym_ptr_ptr != NULL
	553	&& *q->sym_ptr_ptr != NULL
e14ec88b AM	554	&& (symname != NULL
	555	? strcmp (bfd_asymbol_name (*q->sym_ptr_ptr), symname) == 0
	556	: (((*q->sym_ptr_ptr)->flags & BSF_SECTION_SYM) != 0
	557	&& bfd_get_section (*q->sym_ptr_ptr) == info->defsec)))
252b5132 RH	558	{
	559	/* We found a reloc for the symbol. The symbol is defined
	560	in OUTSECNAME. This reloc is from a section which is
	561	mapped into a section from which references to OUTSECNAME
	562	are prohibited. We must report an error. */
	563	einfo (_("%X%C: prohibited cross reference from %s to `%T' in %s\n"),
	564	abfd, sec, q->address, outsecname,
	565	bfd_asymbol_name (*q->sym_ptr_ptr), outdefsecname);
	566	}
	567	}
	568
	569	free (relpp);
	570	}