1 /* ldcref.c -- output a cross reference table 2 Copyright (C) 1996-2016 Free Software Foundation, Inc. 3 Written by Ian Lance Taylor <ian (at) 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 { 538 if (strcmp (ncr->name, outsecname) == 0) 539 check_refs (symname, FALSE, sym->section, abfd, ncrs); 540 /* The NOCROSSREFS_TO command only checks symbols defined in 541 the first section in the list. */ 542 if (ncrs->onlyfirst) 543 break; 544 } 545 } 546 } 547 } 548 549 /* Check one symbol to see if it is a prohibited cross reference. */ 550 551 static bfd_boolean 552 check_nocrossref (struct cref_hash_entry *h, void *ignore ATTRIBUTE_UNUSED) 553 { 554 struct bfd_link_hash_entry *hl; 555 asection *defsec; 556 const char *defsecname; 557 struct lang_nocrossrefs *ncrs; 558 struct lang_nocrossref *ncr; 559 struct cref_ref *ref; 560 561 hl = bfd_link_hash_lookup (link_info.hash, h->root.string, FALSE, 562 FALSE, TRUE); 563 if (hl == NULL) 564 { 565 einfo (_("%P: symbol `%T' missing from main hash table\n"), 566 h->root.string); 567 return TRUE; 568 } 569 570 if (hl->type != bfd_link_hash_defined 571 && hl->type != bfd_link_hash_defweak) 572 return TRUE; 573 574 defsec = hl->u.def.section->output_section; 575 if (defsec == NULL) 576 return TRUE; 577 defsecname = bfd_get_section_name (defsec->owner, defsec); 578 579 for (ncrs = nocrossref_list; ncrs != NULL; ncrs = ncrs->next) 580 for (ncr = ncrs->list; ncr != NULL; ncr = ncr->next) 581 { 582 if (strcmp (ncr->name, defsecname) == 0) 583 for (ref = h->refs; ref != NULL; ref = ref->next) 584 check_refs (hl->root.string, TRUE, hl->u.def.section, 585 ref->abfd, ncrs); 586 /* The NOCROSSREFS_TO command only checks symbols defined in the first 587 section in the list. */ 588 if (ncrs->onlyfirst) 589 break; 590 } 591 592 return TRUE; 593 } 594 595 /* The struct is used to pass information from check_refs to 596 check_reloc_refs through bfd_map_over_sections. */ 597 598 struct check_refs_info 599 { 600 const char *sym_name; 601 asection *defsec; 602 struct lang_nocrossrefs *ncrs; 603 asymbol **asymbols; 604 bfd_boolean global; 605 }; 606 607 /* This function is called for each symbol defined in a section which 608 prohibits cross references. We need to look through all references 609 to this symbol, and ensure that the references are not from 610 prohibited sections. */ 611 612 static void 613 check_refs (const char *name, 614 bfd_boolean global, 615 asection *sec, 616 bfd *abfd, 617 struct lang_nocrossrefs *ncrs) 618 { 619 struct check_refs_info info; 620 621 /* We need to look through the relocations for this BFD, to see 622 if any of the relocations which refer to this symbol are from 623 a prohibited section. Note that we need to do this even for 624 the BFD in which the symbol is defined, since even a single 625 BFD might contain a prohibited cross reference. */ 626 627 if (!bfd_generic_link_read_symbols (abfd)) 628 einfo (_("%B%F: could not read symbols: %E\n"), abfd); 629 630 info.sym_name = name; 631 info.global = global; 632 info.defsec = sec; 633 info.ncrs = ncrs; 634 info.asymbols = bfd_get_outsymbols (abfd); 635 bfd_map_over_sections (abfd, check_reloc_refs, &info); 636 } 637 638 /* This is called via bfd_map_over_sections. INFO->SYM_NAME is a symbol 639 defined in INFO->DEFSECNAME. If this section maps into any of the 640 sections listed in INFO->NCRS, other than INFO->DEFSECNAME, then we 641 look through the relocations. If any of the relocations are to 642 INFO->SYM_NAME, then we report a prohibited cross reference error. */ 643 644 static void 645 check_reloc_refs (bfd *abfd, asection *sec, void *iarg) 646 { 647 struct check_refs_info *info = (struct check_refs_info *) iarg; 648 asection *outsec; 649 const char *outsecname; 650 asection *outdefsec; 651 const char *outdefsecname; 652 struct lang_nocrossref *ncr; 653 const char *symname; 654 bfd_boolean global; 655 long relsize; 656 arelent **relpp; 657 long relcount; 658 arelent **p, **pend; 659 660 outsec = sec->output_section; 661 outsecname = bfd_get_section_name (outsec->owner, outsec); 662 663 outdefsec = info->defsec->output_section; 664 outdefsecname = bfd_get_section_name (outdefsec->owner, outdefsec); 665 666 /* The section where the symbol is defined is permitted. */ 667 if (strcmp (outsecname, outdefsecname) == 0) 668 return; 669 670 for (ncr = info->ncrs->list; ncr != NULL; ncr = ncr->next) 671 if (strcmp (outsecname, ncr->name) == 0) 672 break; 673 674 if (ncr == NULL) 675 return; 676 677 /* This section is one for which cross references are prohibited. 678 Look through the relocations, and see if any of them are to 679 INFO->SYM_NAME. If INFO->SYMNAME is NULL, check for relocations 680 against the section symbol. If INFO->GLOBAL is TRUE, the 681 definition is global, check for relocations against the global 682 symbols. Otherwise check for relocations against the local and 683 section symbols. */ 684 685 symname = info->sym_name; 686 global = info->global; 687 688 relsize = bfd_get_reloc_upper_bound (abfd, sec); 689 if (relsize < 0) 690 einfo (_("%B%F: could not read relocs: %E\n"), abfd); 691 if (relsize == 0) 692 return; 693 694 relpp = (arelent **) xmalloc (relsize); 695 relcount = bfd_canonicalize_reloc (abfd, sec, relpp, info->asymbols); 696 if (relcount < 0) 697 einfo (_("%B%F: could not read relocs: %E\n"), abfd); 698 699 p = relpp; 700 pend = p + relcount; 701 for (; p < pend && *p != NULL; p++) 702 { 703 arelent *q = *p; 704 705 if (q->sym_ptr_ptr != NULL 706 && *q->sym_ptr_ptr != NULL 707 && ((global 708 && (bfd_is_und_section (bfd_get_section (*q->sym_ptr_ptr)) 709 || bfd_is_com_section (bfd_get_section (*q->sym_ptr_ptr)) 710 || ((*q->sym_ptr_ptr)->flags & (BSF_GLOBAL 711 | BSF_WEAK)) != 0)) 712 || (!global 713 && ((*q->sym_ptr_ptr)->flags & (BSF_LOCAL 714 | BSF_SECTION_SYM)) != 0 715 && bfd_get_section (*q->sym_ptr_ptr) == info->defsec)) 716 && (symname != NULL 717 ? strcmp (bfd_asymbol_name (*q->sym_ptr_ptr), symname) == 0 718 : ((*q->sym_ptr_ptr)->flags & BSF_SECTION_SYM) != 0)) 719 { 720 /* We found a reloc for the symbol. The symbol is defined 721 in OUTSECNAME. This reloc is from a section which is 722 mapped into a section from which references to OUTSECNAME 723 are prohibited. We must report an error. */ 724 einfo (_("%X%C: prohibited cross reference from %s to `%T' in %s\n"), 725 abfd, sec, q->address, outsecname, 726 bfd_asymbol_name (*q->sym_ptr_ptr), outdefsecname); 727 } 728 } 729 730 free (relpp); 731 } 732
