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