ld/ldcref.c

   1 /* ldcref.c -- output a cross reference table
   2    Copyright (C) 1996-2015 Free Software Foundation, Inc.
   3    Written by Ian Lance Taylor <ian@cygnus.com>
   4
   5    This file is part of the GNU Binutils.
   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 3 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., 51 Franklin Street - Fifth Floor, Boston,
  20    MA 02110-1301, USA.  */
  21
  22
  23 /* This file holds routines that manage the cross reference table.
  24    The table is used to generate cross reference reports.  It is also
  25    used to implement the NOCROSSREFS command in the linker script.  */
  26
  27 #include "sysdep.h"
  28 #include "bfd.h"
  29 #include "bfdlink.h"
  30 #include "libiberty.h"
  31 #include "demangle.h"
  32 #include "objalloc.h"
  33
  34 #include "ld.h"
  35 #include "ldmain.h"
  36 #include "ldmisc.h"
  37 #include "ldexp.h"
  38 #include "ldlang.h"
  39
  40 /* We keep an instance of this structure for each reference to a
  41    symbol from a given object.  */
  42
  43 struct cref_ref
  44 {
  45   /* The next reference.  */
  46   struct cref_ref *next;
  47   /* The object.  */
  48   bfd *abfd;
  49   /* True if the symbol is defined.  */
  50   unsigned int def : 1;
  51   /* True if the symbol is common.  */
  52   unsigned int common : 1;
  53   /* True if the symbol is undefined.  */
  54   unsigned int undef : 1;
  55 };
  56
  57 /* We keep a hash table of symbols.  Each entry looks like this.  */
  58
  59 struct cref_hash_entry
  60 {
  61   struct bfd_hash_entry root;
  62   /* The demangled name.  */
  63   const char *demangled;
  64   /* References to and definitions of this symbol.  */
  65   struct cref_ref *refs;
  66 };
  67
  68 /* This is what the hash table looks like.  */
  69
  70 struct cref_hash_table
  71 {
  72   struct bfd_hash_table root;
  73 };
  74
  75 /* Forward declarations.  */
  76
  77 static void output_one_cref (FILE *, struct cref_hash_entry *);
  78 static void check_local_sym_xref (lang_input_statement_type *);
  79 static bfd_boolean check_nocrossref (struct cref_hash_entry *, void *);
  80 static void check_refs (const char *, bfd_boolean, asection *, bfd *,
  81                         struct lang_nocrossrefs *);
  82 static void check_reloc_refs (bfd *, asection *, void *);
  83
  84 /* Look up an entry in the cref hash table.  */
  85
  86 #define cref_hash_lookup(table, string, create, copy)           \
  87   ((struct cref_hash_entry *)                                   \
  88    bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
  89
  90 /* Traverse the cref hash table.  */
  91
  92 #define cref_hash_traverse(table, func, info)                           \
  93   (bfd_hash_traverse                                                    \
  94    (&(table)->root,                                                     \
  95     (bfd_boolean (*) (struct bfd_hash_entry *, void *)) (func),         \
  96     (info)))
  97
  98 /* The cref hash table.  */
  99
 100 static struct cref_hash_table cref_table;
 101
 102 /* Whether the cref hash table has been initialized.  */
 103
 104 static bfd_boolean cref_initialized;
 105
 106 /* The number of symbols seen so far.  */
 107
 108 static size_t cref_symcount;
 109
 110 /* Used to take a snapshot of the cref hash table when starting to
 111    add syms from an as-needed library.  */
 112 static struct bfd_hash_entry **old_table;
 113 static unsigned int old_size;
 114 static unsigned int old_count;
 115 static void * old_tab;
 116 static void * alloc_mark;
 117 static size_t tabsize, entsize, refsize;
 118 static size_t old_symcount;
 119
 120 /* Create an entry in a cref hash table.  */
 121
 122 static struct bfd_hash_entry *
 123 cref_hash_newfunc (struct bfd_hash_entry *entry,
 124                    struct bfd_hash_table *table,
 125                    const char *string)
 126 {
 127   struct cref_hash_entry *ret = (struct cref_hash_entry *) entry;
 128
 129   /* Allocate the structure if it has not already been allocated by a
 130      subclass.  */
 131   if (ret == NULL)
 132     ret = ((struct cref_hash_entry *)
 133            bfd_hash_allocate (table, sizeof (struct cref_hash_entry)));
 134   if (ret == NULL)
 135     return NULL;
 136
 137   /* Call the allocation method of the superclass.  */
 138   ret = ((struct cref_hash_entry *)
 139          bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
 140   if (ret != NULL)
 141     {
 142       /* Set local fields.  */
 143       ret->demangled = NULL;
 144       ret->refs = NULL;
 145
 146       /* Keep a count of the number of entries created in the hash
 147          table.  */
 148       ++cref_symcount;
 149     }
 150
 151   return &ret->root;
 152 }
 153
 154 /* Add a symbol to the cref hash table.  This is called for every
 155    global symbol that is seen during the link.  */
 156
 157 void
 158 add_cref (const char *name,
 159           bfd *abfd,
 160           asection *section,
 161           bfd_vma value ATTRIBUTE_UNUSED)
 162 {
 163   struct cref_hash_entry *h;
 164   struct cref_ref *r;
 165
 166   if (! cref_initialized)
 167     {
 168       if (!bfd_hash_table_init (&cref_table.root, cref_hash_newfunc,
 169                                 sizeof (struct cref_hash_entry)))
 170         einfo (_("%X%P: bfd_hash_table_init of cref table failed: %E\n"));
 171       cref_initialized = TRUE;
 172     }
 173
 174   h = cref_hash_lookup (&cref_table, name, TRUE, FALSE);
 175   if (h == NULL)
 176     einfo (_("%X%P: cref_hash_lookup failed: %E\n"));
 177
 178   for (r = h->refs; r != NULL; r = r->next)
 179     if (r->abfd == abfd)
 180       break;
 181
 182   if (r == NULL)
 183     {
 184       r = (struct cref_ref *) bfd_hash_allocate (&cref_table.root, sizeof *r);
 185       if (r == NULL)
 186         einfo (_("%X%P: cref alloc failed: %E\n"));
 187       r->next = h->refs;
 188       h->refs = r;
 189       r->abfd = abfd;
 190       r->def = FALSE;
 191       r->common = FALSE;
 192       r->undef = FALSE;
 193     }
 194
 195   if (bfd_is_und_section (section))
 196     r->undef = TRUE;
 197   else if (bfd_is_com_section (section))
 198     r->common = TRUE;
 199   else
 200     r->def = TRUE;
 201 }
 202
 203 /* Called before loading an as-needed library to take a snapshot of
 204    the cref hash table, and after we have loaded or found that the
 205    library was not needed.  */
 206
 207 bfd_boolean
 208 handle_asneeded_cref (bfd *abfd ATTRIBUTE_UNUSED,
 209                       enum notice_asneeded_action act)
 210 {
 211   unsigned int i;
 212
 213   if (!cref_initialized)
 214     return TRUE;
 215
 216   if (act == notice_as_needed)
 217     {
 218       char *old_ent, *old_ref;
 219
 220       for (i = 0; i < cref_table.root.size; i++)
 221         {
 222           struct bfd_hash_entry *p;
 223           struct cref_hash_entry *c;
 224           struct cref_ref *r;
 225
 226           for (p = cref_table.root.table[i]; p != NULL; p = p->next)
 227             {
 228               entsize += cref_table.root.entsize;
 229               c = (struct cref_hash_entry *) p;
 230               for (r = c->refs; r != NULL; r = r->next)
 231                 refsize += sizeof (struct cref_ref);
 232             }
 233         }
 234
 235       tabsize = cref_table.root.size * sizeof (struct bfd_hash_entry *);
 236       old_tab = xmalloc (tabsize + entsize + refsize);
 237
 238       alloc_mark = bfd_hash_allocate (&cref_table.root, 1);
 239       if (alloc_mark == NULL)
 240         return FALSE;
 241
 242       memcpy (old_tab, cref_table.root.table, tabsize);
 243       old_ent = (char *) old_tab + tabsize;
 244       old_ref = (char *) old_ent + entsize;
 245       old_table = cref_table.root.table;
 246       old_size = cref_table.root.size;
 247       old_count = cref_table.root.count;
 248       old_symcount = cref_symcount;
 249
 250       for (i = 0; i < cref_table.root.size; i++)
 251         {
 252           struct bfd_hash_entry *p;
 253           struct cref_hash_entry *c;
 254           struct cref_ref *r;
 255
 256           for (p = cref_table.root.table[i]; p != NULL; p = p->next)
 257             {
 258               memcpy (old_ent, p, cref_table.root.entsize);
 259               old_ent = (char *) old_ent + cref_table.root.entsize;
 260               c = (struct cref_hash_entry *) p;
 261               for (r = c->refs; r != NULL; r = r->next)
 262                 {
 263                   memcpy (old_ref, r, sizeof (struct cref_ref));
 264                   old_ref = (char *) old_ref + sizeof (struct cref_ref);
 265                 }
 266             }
 267         }
 268       return TRUE;
 269     }
 270
 271   if (act == notice_not_needed)
 272     {
 273       char *old_ent, *old_ref;
 274
 275       if (old_tab == NULL)
 276         {
 277           /* The only way old_tab can be NULL is if the cref hash table
 278              had not been initialised when notice_as_needed.  */
 279           bfd_hash_table_free (&cref_table.root);
 280           cref_initialized = FALSE;
 281           return TRUE;
 282         }
 283
 284       old_ent = (char *) old_tab + tabsize;
 285       old_ref = (char *) old_ent + entsize;
 286       cref_table.root.table = old_table;
 287       cref_table.root.size = old_size;
 288       cref_table.root.count = old_count;
 289       memcpy (cref_table.root.table, old_tab, tabsize);
 290       cref_symcount = old_symcount;
 291
 292       for (i = 0; i < cref_table.root.size; i++)
 293         {
 294           struct bfd_hash_entry *p;
 295           struct cref_hash_entry *c;
 296           struct cref_ref *r;
 297
 298           for (p = cref_table.root.table[i]; p != NULL; p = p->next)
 299             {
 300               memcpy (p, old_ent, cref_table.root.entsize);
 301               old_ent = (char *) old_ent + cref_table.root.entsize;
 302               c = (struct cref_hash_entry *) p;
 303               for (r = c->refs; r != NULL; r = r->next)
 304                 {
 305                   memcpy (r, old_ref, sizeof (struct cref_ref));
 306                   old_ref = (char *) old_ref + sizeof (struct cref_ref);
 307                 }
 308             }
 309         }
 310
 311       objalloc_free_block ((struct objalloc *) cref_table.root.memory,
 312                            alloc_mark);
 313     }
 314   else if (act != notice_needed)
 315     return FALSE;
 316
 317   free (old_tab);
 318   old_tab = NULL;
 319   return TRUE;
 320 }
 321
 322 /* Copy the addresses of the hash table entries into an array.  This
 323    is called via cref_hash_traverse.  We also fill in the demangled
 324    name.  */
 325
 326 static bfd_boolean
 327 cref_fill_array (struct cref_hash_entry *h, void *data)
 328 {
 329   struct cref_hash_entry ***pph = (struct cref_hash_entry ***) data;
 330
 331   ASSERT (h->demangled == NULL);
 332   h->demangled = bfd_demangle (link_info.output_bfd, h->root.string,
 333                                DMGL_ANSI | DMGL_PARAMS);
 334   if (h->demangled == NULL)
 335     h->demangled = h->root.string;
 336
 337   **pph = h;
 338
 339   ++*pph;
 340
 341   return TRUE;
 342 }
 343
 344 /* Sort an array of cref hash table entries by name.  */
 345
 346 static int
 347 cref_sort_array (const void *a1, const void *a2)
 348 {
 349   const struct cref_hash_entry * const *p1 =
 350       (const struct cref_hash_entry * const *) a1;
 351   const struct cref_hash_entry * const *p2 =
 352       (const struct cref_hash_entry * const *) a2;
 353
 354   if (demangling)
 355     return strcmp ((*p1)->demangled, (*p2)->demangled);
 356   else
 357     return strcmp ((*p1)->root.string, (*p2)->root.string);
 358 }
 359
 360 /* Write out the cref table.  */
 361
 362 #define FILECOL (50)
 363
 364 void
 365 output_cref (FILE *fp)
 366 {
 367   int len;
 368   struct cref_hash_entry **csyms, **csym_fill, **csym, **csym_end;
 369   const char *msg;
 370
 371   fprintf (fp, _("\nCross Reference Table\n\n"));
 372   msg = _("Symbol");
 373   fprintf (fp, "%s", msg);
 374   len = strlen (msg);
 375   while (len < FILECOL)
 376     {
 377       putc (' ', fp);
 378       ++len;
 379     }
 380   fprintf (fp, _("File\n"));
 381
 382   if (! cref_initialized)
 383     {
 384       fprintf (fp, _("No symbols\n"));
 385       return;
 386     }
 387
 388   csyms = (struct cref_hash_entry **) xmalloc (cref_symcount * sizeof (*csyms));
 389
 390   csym_fill = csyms;
 391   cref_hash_traverse (&cref_table, cref_fill_array, &csym_fill);
 392   ASSERT ((size_t) (csym_fill - csyms) == cref_symcount);
 393
 394   qsort (csyms, cref_symcount, sizeof (*csyms), cref_sort_array);
 395
 396   csym_end = csyms + cref_symcount;
 397   for (csym = csyms; csym < csym_end; csym++)
 398     output_one_cref (fp, *csym);
 399 }
 400
 401 /* Output one entry in the cross reference table.  */
 402
 403 static void
 404 output_one_cref (FILE *fp, struct cref_hash_entry *h)
 405 {
 406   int len;
 407   struct bfd_link_hash_entry *hl;
 408   struct cref_ref *r;
 409
 410   hl = bfd_link_hash_lookup (link_info.hash, h->root.string, FALSE,
 411                              FALSE, TRUE);
 412   if (hl == NULL)
 413     einfo ("%P: symbol `%T' missing from main hash table\n",
 414            h->root.string);
 415   else
 416     {
 417       /* If this symbol is defined in a dynamic object but never
 418          referenced by a normal object, then don't print it.  */
 419       if (hl->type == bfd_link_hash_defined)
 420         {
 421           if (hl->u.def.section->output_section == NULL)
 422             return;
 423           if (hl->u.def.section->owner != NULL
 424               && (hl->u.def.section->owner->flags & DYNAMIC) != 0)
 425             {
 426               for (r = h->refs; r != NULL; r = r->next)
 427                 if ((r->abfd->flags & DYNAMIC) == 0)
 428                   break;
 429               if (r == NULL)
 430                 return;
 431             }
 432         }
 433     }
 434
 435   if (demangling)
 436     {
 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;
 444     }
 445
 446   for (r = h->refs; r != NULL; r = r->next)
 447     {
 448       if (r->def)
 449         {
 450           while (len < FILECOL)
 451             {
 452               putc (' ', fp);
 453               ++len;
 454             }
 455           lfinfo (fp, "%B\n", r->abfd);
 456           len = 0;
 457         }
 458     }
 459
 460   for (r = h->refs; r != NULL; r = r->next)
 461     {
 462       if (r->common)
 463         {
 464           while (len < FILECOL)
 465             {
 466               putc (' ', fp);
 467               ++len;
 468             }
 469           lfinfo (fp, "%B\n", r->abfd);
 470           len = 0;
 471         }
 472     }
 473
 474   for (r = h->refs; r != NULL; r = r->next)
 475     {
 476       if (! r->def && ! r->common)
 477         {
 478           while (len < FILECOL)
 479             {
 480               putc (' ', fp);
 481               ++len;
 482             }
 483           lfinfo (fp, "%B\n", r->abfd);
 484           len = 0;
 485         }
 486     }
 487
 488   ASSERT (len == 0);
 489 }
 490
 491 /* Check for prohibited cross references.  */
 492
 493 void
 494 check_nocrossrefs (void)
 495 {
 496   if (! cref_initialized)
 497     return;
 498
 499   cref_hash_traverse (&cref_table, check_nocrossref, NULL);
 500
 501   lang_for_each_file (check_local_sym_xref);
 502 }
 503
 504 /* Check for prohibited cross references to local and section symbols.  */
 505
 506 static void
 507 check_local_sym_xref (lang_input_statement_type *statement)
 508 {
 509   bfd *abfd;
 510   asymbol **syms;
 511
 512   abfd = statement->the_bfd;
 513   if (abfd == NULL)
 514     return;
 515
 516   if (!bfd_generic_link_read_symbols (abfd))
 517     einfo (_("%B%F: could not read symbols: %E\n"), abfd);
 518
 519   for (syms = bfd_get_outsymbols (abfd); *syms; ++syms)
 520     {
 521       asymbol *sym = *syms;
 522       if (sym->flags & (BSF_GLOBAL | BSF_WARNING | BSF_INDIRECT | BSF_FILE))
 523         continue;
 524       if ((sym->flags & (BSF_LOCAL | BSF_SECTION_SYM)) != 0
 525           && sym->section->output_section != NULL)
 526         {
 527           const char *outsecname, *symname;
 528           struct lang_nocrossrefs *ncrs;
 529           struct lang_nocrossref *ncr;
 530
 531           outsecname = sym->section->output_section->name;
 532           symname = NULL;
 533           if ((sym->flags & BSF_SECTION_SYM) == 0)
 534             symname = sym->name;
 535           for (ncrs = nocrossref_list; ncrs != NULL; ncrs = ncrs->next)
 536             for (ncr = ncrs->list; ncr != NULL; ncr = ncr->next)
 537               if (strcmp (ncr->name, outsecname) == 0)
 538                 check_refs (symname, FALSE, sym->section, abfd, ncrs);
 539         }
 540     }
 541 }
 542
 543 /* Check one symbol to see if it is a prohibited cross reference.  */
 544
 545 static bfd_boolean
 546 check_nocrossref (struct cref_hash_entry *h, void *ignore ATTRIBUTE_UNUSED)
 547 {
 548   struct bfd_link_hash_entry *hl;
 549   asection *defsec;
 550   const char *defsecname;
 551   struct lang_nocrossrefs *ncrs;
 552   struct lang_nocrossref *ncr;
 553   struct cref_ref *ref;
 554
 555   hl = bfd_link_hash_lookup (link_info.hash, h->root.string, FALSE,
 556                              FALSE, TRUE);
 557   if (hl == NULL)
 558     {
 559       einfo (_("%P: symbol `%T' missing from main hash table\n"),
 560              h->root.string);
 561       return TRUE;
 562     }
 563
 564   if (hl->type != bfd_link_hash_defined
 565       && hl->type != bfd_link_hash_defweak)
 566     return TRUE;
 567
 568   defsec = hl->u.def.section->output_section;
 569   if (defsec == NULL)
 570     return TRUE;
 571   defsecname = bfd_get_section_name (defsec->owner, defsec);
 572
 573   for (ncrs = nocrossref_list; ncrs != NULL; ncrs = ncrs->next)
 574     for (ncr = ncrs->list; ncr != NULL; ncr = ncr->next)
 575       if (strcmp (ncr->name, defsecname) == 0)
 576         for (ref = h->refs; ref != NULL; ref = ref->next)
 577           check_refs (hl->root.string, TRUE, hl->u.def.section,
 578                       ref->abfd, ncrs);
 579
 580   return TRUE;
 581 }
 582
 583 /* The struct is used to pass information from check_refs to
 584    check_reloc_refs through bfd_map_over_sections.  */
 585
 586 struct check_refs_info {
 587   const char *sym_name;
 588   asection *defsec;
 589   struct lang_nocrossrefs *ncrs;
 590   asymbol **asymbols;
 591   bfd_boolean global;
 592 };
 593
 594 /* This function is called for each symbol defined in a section which
 595    prohibits cross references.  We need to look through all references
 596    to this symbol, and ensure that the references are not from
 597    prohibited sections.  */
 598
 599 static void
 600 check_refs (const char *name,
 601             bfd_boolean global,
 602             asection *sec,
 603             bfd *abfd,
 604             struct lang_nocrossrefs *ncrs)
 605 {
 606   struct check_refs_info info;
 607
 608   /* We need to look through the relocations for this BFD, to see
 609      if any of the relocations which refer to this symbol are from
 610      a prohibited section.  Note that we need to do this even for
 611      the BFD in which the symbol is defined, since even a single
 612      BFD might contain a prohibited cross reference.  */
 613
 614   if (!bfd_generic_link_read_symbols (abfd))
 615     einfo (_("%B%F: could not read symbols: %E\n"), abfd);
 616
 617   info.sym_name = name;
 618   info.global = global;
 619   info.defsec = sec;
 620   info.ncrs = ncrs;
 621   info.asymbols = bfd_get_outsymbols (abfd);
 622   bfd_map_over_sections (abfd, check_reloc_refs, &info);
 623 }
 624
 625 /* This is called via bfd_map_over_sections.  INFO->SYM_NAME is a symbol
 626    defined in INFO->DEFSECNAME.  If this section maps into any of the
 627    sections listed in INFO->NCRS, other than INFO->DEFSECNAME, then we
 628    look through the relocations.  If any of the relocations are to
 629    INFO->SYM_NAME, then we report a prohibited cross reference error.  */
 630
 631 static void
 632 check_reloc_refs (bfd *abfd, asection *sec, void *iarg)
 633 {
 634   struct check_refs_info *info = (struct check_refs_info *) iarg;
 635   asection *outsec;
 636   const char *outsecname;
 637   asection *outdefsec;
 638   const char *outdefsecname;
 639   struct lang_nocrossref *ncr;
 640   const char *symname;
 641   bfd_boolean global;
 642   long relsize;
 643   arelent **relpp;
 644   long relcount;
 645   arelent **p, **pend;
 646
 647   outsec = sec->output_section;
 648   outsecname = bfd_get_section_name (outsec->owner, outsec);
 649
 650   outdefsec = info->defsec->output_section;
 651   outdefsecname = bfd_get_section_name (outdefsec->owner, outdefsec);
 652
 653   /* The section where the symbol is defined is permitted.  */
 654   if (strcmp (outsecname, outdefsecname) == 0)
 655     return;
 656
 657   for (ncr = info->ncrs->list; ncr != NULL; ncr = ncr->next)
 658     if (strcmp (outsecname, ncr->name) == 0)
 659       break;
 660
 661   if (ncr == NULL)
 662     return;
 663
 664   /* This section is one for which cross references are prohibited.
 665      Look through the relocations, and see if any of them are to
 666      INFO->SYM_NAME.  If INFO->SYMNAME is NULL, check for relocations
 667      against the section symbol.  If INFO->GLOBAL is TRUE, the
 668      definition is global, check for relocations against the global
 669      symbols.  Otherwise check for relocations against the local and
 670      section symbols.  */
 671
 672   symname = info->sym_name;
 673   global = info->global;
 674
 675   relsize = bfd_get_reloc_upper_bound (abfd, sec);
 676   if (relsize < 0)
 677     einfo (_("%B%F: could not read relocs: %E\n"), abfd);
 678   if (relsize == 0)
 679     return;
 680
 681   relpp = (arelent **) xmalloc (relsize);
 682   relcount = bfd_canonicalize_reloc (abfd, sec, relpp, info->asymbols);
 683   if (relcount < 0)
 684     einfo (_("%B%F: could not read relocs: %E\n"), abfd);
 685
 686   p = relpp;
 687   pend = p + relcount;
 688   for (; p < pend && *p != NULL; p++)
 689     {
 690       arelent *q = *p;
 691
 692       if (q->sym_ptr_ptr != NULL
 693           && *q->sym_ptr_ptr != NULL
 694           && ((global
 695                && (bfd_is_und_section (bfd_get_section (*q->sym_ptr_ptr))
 696                    || bfd_is_com_section (bfd_get_section (*q->sym_ptr_ptr))
 697                    || ((*q->sym_ptr_ptr)->flags & (BSF_GLOBAL
 698                                                    | BSF_WEAK)) != 0))
 699               || (!global
 700                   && ((*q->sym_ptr_ptr)->flags & (BSF_LOCAL
 701                                                   | BSF_SECTION_SYM)) != 0
 702                   && bfd_get_section (*q->sym_ptr_ptr) == info->defsec))
 703           && (symname != NULL
 704               ? strcmp (bfd_asymbol_name (*q->sym_ptr_ptr), symname) == 0
 705               : ((*q->sym_ptr_ptr)->flags & BSF_SECTION_SYM) != 0))
 706         {
 707           /* We found a reloc for the symbol.  The symbol is defined
 708              in OUTSECNAME.  This reloc is from a section which is
 709              mapped into a section from which references to OUTSECNAME
 710              are prohibited.  We must report an error.  */
 711           einfo (_("%X%C: prohibited cross reference from %s to `%T' in %s\n"),
 712                  abfd, sec, q->address, outsecname,
 713                  bfd_asymbol_name (*q->sym_ptr_ptr), outdefsecname);
 714         }
 715     }
 716
 717   free (relpp);
 718 }