1 /* Darwin support for GDB, the GNU debugger. 2 Copyright (C) 2008-2016 Free Software Foundation, Inc. 3 4 Contributed by AdaCore. 5 6 This file is part of GDB. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 20 21 #include "defs.h" 22 #include "symtab.h" 23 #include "gdbtypes.h" 24 #include "bfd.h" 25 #include "symfile.h" 26 #include "objfiles.h" 27 #include "buildsym.h" 28 #include "gdbcmd.h" 29 #include "gdbcore.h" 30 #include "mach-o.h" 31 #include "aout/stab_gnu.h" 32 #include "vec.h" 33 #include "psympriv.h" 34 #include "complaints.h" 35 #include "gdb_bfd.h" 36 37 /* If non-zero displays debugging message. */ 38 static unsigned int mach_o_debug_level = 0; 39 40 /* Dwarf debugging information are never in the final executable. They stay 41 in object files and the executable contains the list of object files read 42 during the link. 43 Each time an oso (other source) is found in the executable, the reader 44 creates such a structure. They are read after the processing of the 45 executable. */ 46 47 typedef struct oso_el 48 { 49 /* Object file name. Can also be a member name. */ 50 const char *name; 51 52 /* Associated time stamp. */ 53 unsigned long mtime; 54 55 /* Stab symbols range for this OSO. */ 56 asymbol **oso_sym; 57 asymbol **end_sym; 58 59 /* Number of interesting stabs in the range. */ 60 unsigned int nbr_syms; 61 } 62 oso_el; 63 64 /* Vector of object files to be read after the executable. */ 65 DEF_VEC_O (oso_el); 66 67 static void 68 macho_new_init (struct objfile *objfile) 69 { 70 } 71 72 static void 73 macho_symfile_init (struct objfile *objfile) 74 { 75 objfile->flags |= OBJF_REORDERED; 76 } 77 78 /* Add a new OSO to the vector of OSO to load. */ 79 80 static void 81 macho_register_oso (VEC (oso_el) **oso_vector_ptr, 82 struct objfile *objfile, 83 asymbol **oso_sym, asymbol **end_sym, 84 unsigned int nbr_syms) 85 { 86 oso_el el; 87 88 el.name = (*oso_sym)->name; 89 el.mtime = (*oso_sym)->value; 90 el.oso_sym = oso_sym; 91 el.end_sym = end_sym; 92 el.nbr_syms = nbr_syms; 93 VEC_safe_push (oso_el, *oso_vector_ptr, &el); 94 } 95 96 /* Add symbol SYM to the minimal symbol table of OBJFILE. */ 97 98 static void 99 macho_symtab_add_minsym (struct objfile *objfile, const asymbol *sym) 100 { 101 if (sym->name == NULL || *sym->name == '\0') 102 { 103 /* Skip names that don't exist (shouldn't happen), or names 104 that are null strings (may happen). */ 105 return; 106 } 107 108 if (sym->flags & (BSF_GLOBAL | BSF_LOCAL | BSF_WEAK)) 109 { 110 CORE_ADDR symaddr; 111 enum minimal_symbol_type ms_type; 112 113 /* Bfd symbols are section relative. */ 114 symaddr = sym->value + sym->section->vma; 115 116 if (sym->section == bfd_abs_section_ptr) 117 ms_type = mst_abs; 118 else if (sym->section->flags & SEC_CODE) 119 { 120 if (sym->flags & (BSF_GLOBAL | BSF_WEAK)) 121 ms_type = mst_text; 122 else 123 ms_type = mst_file_text; 124 } 125 else if (sym->section->flags & SEC_ALLOC) 126 { 127 if (sym->flags & (BSF_GLOBAL | BSF_WEAK)) 128 { 129 if (sym->section->flags & SEC_LOAD) 130 ms_type = mst_data; 131 else 132 ms_type = mst_bss; 133 } 134 else if (sym->flags & BSF_LOCAL) 135 { 136 /* Not a special stabs-in-elf symbol, do regular 137 symbol processing. */ 138 if (sym->section->flags & SEC_LOAD) 139 ms_type = mst_file_data; 140 else 141 ms_type = mst_file_bss; 142 } 143 else 144 ms_type = mst_unknown; 145 } 146 else 147 return; /* Skip this symbol. */ 148 149 prim_record_minimal_symbol_and_info 150 (sym->name, symaddr, ms_type, 151 gdb_bfd_section_index (objfile->obfd, sym->section), 152 objfile); 153 } 154 } 155 156 /* Build the minimal symbol table from SYMBOL_TABLE of length 157 NUMBER_OF_SYMBOLS for OBJFILE. Registers OSO filenames found. */ 158 159 static void 160 macho_symtab_read (struct objfile *objfile, 161 long number_of_symbols, asymbol **symbol_table, 162 VEC (oso_el) **oso_vector_ptr) 163 { 164 long i; 165 const asymbol *file_so = NULL; 166 asymbol **oso_file = NULL; 167 unsigned int nbr_syms = 0; 168 169 /* Current state while reading stabs. */ 170 enum 171 { 172 /* Not within an SO part. Only non-debugging symbols should be present, 173 and will be added to the minimal symbols table. */ 174 S_NO_SO, 175 176 /* First SO read. Introduce an SO section, and may be followed by a second 177 SO. The SO section should contain onl debugging symbols. */ 178 S_FIRST_SO, 179 180 /* Second non-null SO found, just after the first one. Means that the first 181 is in fact a directory name. */ 182 S_SECOND_SO, 183 184 /* Non-null OSO found. Debugging info are DWARF in this OSO file. */ 185 S_DWARF_FILE, 186 187 S_STAB_FILE 188 } state = S_NO_SO; 189 190 for (i = 0; i < number_of_symbols; i++) 191 { 192 const asymbol *sym = symbol_table[i]; 193 bfd_mach_o_asymbol *mach_o_sym = (bfd_mach_o_asymbol *)sym; 194 195 switch (state) 196 { 197 case S_NO_SO: 198 if (mach_o_sym->n_type == N_SO) 199 { 200 /* Start of object stab. */ 201 if (sym->name == NULL || sym->name[0] == 0) 202 { 203 /* Unexpected empty N_SO. */ 204 complaint (&symfile_complaints, 205 _("Unexpected empty N_SO stab")); 206 } 207 else 208 { 209 file_so = sym; 210 state = S_FIRST_SO; 211 } 212 } 213 else if (sym->flags & BSF_DEBUGGING) 214 { 215 if (mach_o_sym->n_type == N_OPT) 216 { 217 /* No complaint for OPT. */ 218 break; 219 } 220 221 /* Debugging symbols are not expected here. */ 222 complaint (&symfile_complaints, 223 _("%s: Unexpected debug stab outside SO markers"), 224 objfile_name (objfile)); 225 } 226 else 227 { 228 /* Non-debugging symbols go to the minimal symbol table. */ 229 macho_symtab_add_minsym (objfile, sym); 230 } 231 break; 232 233 case S_FIRST_SO: 234 case S_SECOND_SO: 235 if (mach_o_sym->n_type == N_SO) 236 { 237 if (sym->name == NULL || sym->name[0] == 0) 238 { 239 /* Unexpected empty N_SO. */ 240 complaint (&symfile_complaints, _("Empty SO section")); 241 state = S_NO_SO; 242 } 243 else if (state == S_FIRST_SO) 244 { 245 /* Second SO stab for the file name. */ 246 file_so = sym; 247 state = S_SECOND_SO; 248 } 249 else 250 complaint (&symfile_complaints, _("Three SO in a raw")); 251 } 252 else if (mach_o_sym->n_type == N_OSO) 253 { 254 if (sym->name == NULL || sym->name[0] == 0) 255 { 256 /* Empty OSO. Means that this file was compiled with 257 stabs. */ 258 state = S_STAB_FILE; 259 warning (_("stabs debugging not supported for %s"), 260 file_so->name); 261 } 262 else 263 { 264 /* Non-empty OSO for a Dwarf file. */ 265 oso_file = symbol_table + i; 266 nbr_syms = 0; 267 state = S_DWARF_FILE; 268 } 269 } 270 else 271 complaint (&symfile_complaints, 272 _("Unexpected stab after SO")); 273 break; 274 275 case S_STAB_FILE: 276 case S_DWARF_FILE: 277 if (mach_o_sym->n_type == N_SO) 278 { 279 if (sym->name == NULL || sym->name[0] == 0) 280 { 281 /* End of file. */ 282 if (state == S_DWARF_FILE) 283 macho_register_oso (oso_vector_ptr, objfile, 284 oso_file, symbol_table + i, 285 nbr_syms); 286 state = S_NO_SO; 287 } 288 else 289 { 290 complaint (&symfile_complaints, _("Missing nul SO")); 291 file_so = sym; 292 state = S_FIRST_SO; 293 } 294 } 295 else if (sym->flags & BSF_DEBUGGING) 296 { 297 if (state == S_STAB_FILE) 298 { 299 /* FIXME: to be implemented. */ 300 } 301 else 302 { 303 switch (mach_o_sym->n_type) 304 { 305 case N_FUN: 306 if (sym->name == NULL || sym->name[0] == 0) 307 break; 308 /* Fall through. */ 309 case N_STSYM: 310 /* Interesting symbol. */ 311 nbr_syms++; 312 break; 313 case N_ENSYM: 314 case N_BNSYM: 315 case N_GSYM: 316 break; 317 default: 318 complaint (&symfile_complaints, 319 _("unhandled stab for dwarf OSO file")); 320 break; 321 } 322 } 323 } 324 else 325 complaint (&symfile_complaints, 326 _("non-debugging symbol within SO")); 327 break; 328 } 329 } 330 331 if (state != S_NO_SO) 332 complaint (&symfile_complaints, _("missing nul SO")); 333 } 334 335 /* If NAME describes an archive member (ie: ARCHIVE '(' MEMBER ')'), 336 returns the length of the archive name. 337 Returns -1 otherwise. */ 338 339 static int 340 get_archive_prefix_len (const char *name) 341 { 342 const char *lparen; 343 int name_len = strlen (name); 344 345 if (name_len == 0 || name[name_len - 1] != ')') 346 return -1; 347 348 lparen = strrchr (name, '('); 349 if (lparen == NULL || lparen == name) 350 return -1; 351 return lparen - name; 352 } 353 354 /* Compare function to qsort OSOs, so that members of a library are 355 gathered. */ 356 357 static int 358 oso_el_compare_name (const void *vl, const void *vr) 359 { 360 const oso_el *l = (const oso_el *)vl; 361 const oso_el *r = (const oso_el *)vr; 362 363 return strcmp (l->name, r->name); 364 } 365 366 /* Hash table entry structure for the stabs symbols in the main object file. 367 This is used to speed up lookup for symbols in the OSO. */ 368 369 struct macho_sym_hash_entry 370 { 371 struct bfd_hash_entry base; 372 const asymbol *sym; 373 }; 374 375 /* Routine to create an entry in the hash table. */ 376 377 static struct bfd_hash_entry * 378 macho_sym_hash_newfunc (struct bfd_hash_entry *entry, 379 struct bfd_hash_table *table, 380 const char *string) 381 { 382 struct macho_sym_hash_entry *ret = (struct macho_sym_hash_entry *) entry; 383 384 /* Allocate the structure if it has not already been allocated by a 385 subclass. */ 386 if (ret == NULL) 387 ret = (struct macho_sym_hash_entry *) bfd_hash_allocate (table, 388 sizeof (* ret)); 389 if (ret == NULL) 390 return NULL; 391 392 /* Call the allocation method of the superclass. */ 393 ret = (struct macho_sym_hash_entry *) 394 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string); 395 396 if (ret) 397 { 398 /* Initialize the local fields. */ 399 ret->sym = NULL; 400 } 401 402 return (struct bfd_hash_entry *) ret; 403 } 404 405 /* Get the value of SYM from the minimal symtab of MAIN_OBJFILE. This is used 406 to get the value of global and common symbols. */ 407 408 static CORE_ADDR 409 macho_resolve_oso_sym_with_minsym (struct objfile *main_objfile, asymbol *sym) 410 { 411 /* For common symbol and global symbols, use the min symtab. */ 412 struct bound_minimal_symbol msym; 413 const char *name = sym->name; 414 415 if (name[0] == bfd_get_symbol_leading_char (main_objfile->obfd)) 416 ++name; 417 msym = lookup_minimal_symbol (name, NULL, main_objfile); 418 if (msym.minsym == NULL) 419 { 420 warning (_("can't find symbol '%s' in minsymtab"), name); 421 return 0; 422 } 423 else 424 return BMSYMBOL_VALUE_ADDRESS (msym); 425 } 426 427 /* Add oso file OSO/ABFD as a symbol file. */ 428 429 static void 430 macho_add_oso_symfile (oso_el *oso, bfd *abfd, const char *name, 431 struct objfile *main_objfile, int symfile_flags) 432 { 433 int storage; 434 int i; 435 asymbol **symbol_table; 436 asymbol **symp; 437 struct bfd_hash_table table; 438 int nbr_sections; 439 struct cleanup *cleanup; 440 441 /* Per section flag to mark which section have been rebased. */ 442 unsigned char *sections_rebased; 443 444 if (mach_o_debug_level > 0) 445 printf_unfiltered 446 (_("Loading debugging symbols from oso: %s\n"), oso->name); 447 448 if (!bfd_check_format (abfd, bfd_object)) 449 { 450 warning (_("`%s': can't read symbols: %s."), oso->name, 451 bfd_errmsg (bfd_get_error ())); 452 gdb_bfd_unref (abfd); 453 return; 454 } 455 456 if (abfd->my_archive == NULL && oso->mtime != bfd_get_mtime (abfd)) 457 { 458 warning (_("`%s': file time stamp mismatch."), oso->name); 459 gdb_bfd_unref (abfd); 460 return; 461 } 462 463 if (!bfd_hash_table_init_n (&table, macho_sym_hash_newfunc, 464 sizeof (struct macho_sym_hash_entry), 465 oso->nbr_syms)) 466 { 467 warning (_("`%s': can't create hash table"), oso->name); 468 gdb_bfd_unref (abfd); 469 return; 470 } 471 472 bfd_set_cacheable (abfd, 1); 473 474 /* Read symbols table. */ 475 storage = bfd_get_symtab_upper_bound (abfd); 476 symbol_table = (asymbol **) xmalloc (storage); 477 bfd_canonicalize_symtab (abfd, symbol_table); 478 479 /* Init section flags. */ 480 nbr_sections = bfd_count_sections (abfd); 481 sections_rebased = (unsigned char *) alloca (nbr_sections); 482 for (i = 0; i < nbr_sections; i++) 483 sections_rebased[i] = 0; 484 485 /* Put symbols for the OSO file in the hash table. */ 486 for (symp = oso->oso_sym; symp != oso->end_sym; symp++) 487 { 488 const asymbol *sym = *symp; 489 bfd_mach_o_asymbol *mach_o_sym = (bfd_mach_o_asymbol *)sym; 490 491 switch (mach_o_sym->n_type) 492 { 493 case N_ENSYM: 494 case N_BNSYM: 495 case N_GSYM: 496 sym = NULL; 497 break; 498 case N_FUN: 499 if (sym->name == NULL || sym->name[0] == 0) 500 sym = NULL; 501 break; 502 case N_STSYM: 503 break; 504 default: 505 sym = NULL; 506 break; 507 } 508 if (sym != NULL) 509 { 510 struct macho_sym_hash_entry *ent; 511 512 ent = (struct macho_sym_hash_entry *) 513 bfd_hash_lookup (&table, sym->name, TRUE, FALSE); 514 if (ent->sym != NULL) 515 complaint (&symfile_complaints, 516 _("Duplicated symbol %s in symbol table"), sym->name); 517 else 518 { 519 if (mach_o_debug_level > 4) 520 { 521 struct gdbarch *arch = get_objfile_arch (main_objfile); 522 printf_unfiltered 523 (_("Adding symbol %s (addr: %s)\n"), 524 sym->name, paddress (arch, sym->value)); 525 } 526 ent->sym = sym; 527 } 528 } 529 } 530 531 /* Relocate symbols of the OSO. */ 532 for (i = 0; symbol_table[i]; i++) 533 { 534 asymbol *sym = symbol_table[i]; 535 bfd_mach_o_asymbol *mach_o_sym = (bfd_mach_o_asymbol *)sym; 536 537 if (mach_o_sym->n_type & BFD_MACH_O_N_STAB) 538 continue; 539 if ((mach_o_sym->n_type & BFD_MACH_O_N_TYPE) == BFD_MACH_O_N_UNDF 540 && sym->value != 0) 541 { 542 /* For common symbol use the min symtab and modify the OSO 543 symbol table. */ 544 CORE_ADDR res; 545 546 res = macho_resolve_oso_sym_with_minsym (main_objfile, sym); 547 if (res != 0) 548 { 549 sym->section = bfd_com_section_ptr; 550 sym->value = res; 551 } 552 } 553 else if ((mach_o_sym->n_type & BFD_MACH_O_N_TYPE) == BFD_MACH_O_N_SECT) 554 { 555 /* Normal symbol. */ 556 asection *sec = sym->section; 557 bfd_mach_o_section *msec; 558 unsigned int sec_type; 559 560 /* Skip buggy ones. */ 561 if (sec == NULL || sections_rebased[sec->index] != 0) 562 continue; 563 564 /* Only consider regular, non-debugging sections. */ 565 msec = bfd_mach_o_get_mach_o_section (sec); 566 sec_type = msec->flags & BFD_MACH_O_SECTION_TYPE_MASK; 567 if ((sec_type == BFD_MACH_O_S_REGULAR 568 || sec_type == BFD_MACH_O_S_ZEROFILL) 569 && (msec->flags & BFD_MACH_O_S_ATTR_DEBUG) == 0) 570 { 571 CORE_ADDR addr = 0; 572 573 if ((mach_o_sym->n_type & BFD_MACH_O_N_EXT) != 0) 574 { 575 /* Use the min symtab for global symbols. */ 576 addr = macho_resolve_oso_sym_with_minsym (main_objfile, sym); 577 } 578 else 579 { 580 struct macho_sym_hash_entry *ent; 581 582 ent = (struct macho_sym_hash_entry *) 583 bfd_hash_lookup (&table, sym->name, FALSE, FALSE); 584 if (ent != NULL) 585 addr = bfd_asymbol_value (ent->sym); 586 } 587 588 /* Adjust the section. */ 589 if (addr != 0) 590 { 591 CORE_ADDR res = addr - sym->value; 592 593 if (mach_o_debug_level > 3) 594 { 595 struct gdbarch *arch = get_objfile_arch (main_objfile); 596 printf_unfiltered 597 (_("resolve sect %s with %s (set to %s)\n"), 598 sec->name, sym->name, 599 paddress (arch, res)); 600 } 601 bfd_set_section_vma (abfd, sec, res); 602 sections_rebased[sec->index] = 1; 603 } 604 } 605 else 606 { 607 /* Mark the section as never rebased. */ 608 sections_rebased[sec->index] = 2; 609 } 610 } 611 } 612 613 bfd_hash_table_free (&table); 614 615 /* We need to clear SYMFILE_MAINLINE to avoid interractive question 616 from symfile.c:symbol_file_add_with_addrs_or_offsets. */ 617 cleanup = make_cleanup_bfd_unref (abfd); 618 symbol_file_add_from_bfd 619 (abfd, name, symfile_flags & ~(SYMFILE_MAINLINE | SYMFILE_VERBOSE), NULL, 620 main_objfile->flags & (OBJF_REORDERED | OBJF_SHARED 621 | OBJF_READNOW | OBJF_USERLOADED), 622 main_objfile); 623 do_cleanups (cleanup); 624 } 625 626 /* Read symbols from the vector of oso files. 627 628 Note that this function sorts OSO_VECTOR_PTR. */ 629 630 static void 631 macho_symfile_read_all_oso (VEC (oso_el) **oso_vector_ptr, 632 struct objfile *main_objfile, 633 int symfile_flags) 634 { 635 int ix; 636 VEC (oso_el) *vec = *oso_vector_ptr; 637 oso_el *oso; 638 struct cleanup *cleanup = make_cleanup (null_cleanup, NULL); 639 640 /* Sort oso by name so that files from libraries are gathered. */ 641 qsort (VEC_address (oso_el, vec), VEC_length (oso_el, vec), 642 sizeof (oso_el), oso_el_compare_name); 643 644 for (ix = 0; VEC_iterate (oso_el, vec, ix, oso);) 645 { 646 int pfx_len; 647 648 /* Check if this is a library name. */ 649 pfx_len = get_archive_prefix_len (oso->name); 650 if (pfx_len > 0) 651 { 652 bfd *archive_bfd; 653 bfd *member_bfd; 654 char *archive_name = XNEWVEC (char, pfx_len + 1); 655 int last_ix; 656 oso_el *oso2; 657 int ix2; 658 659 memcpy (archive_name, oso->name, pfx_len); 660 archive_name[pfx_len] = '\0'; 661 662 make_cleanup (xfree, archive_name); 663 664 /* Compute number of oso for this archive. */ 665 for (last_ix = ix; 666 VEC_iterate (oso_el, vec, last_ix, oso2); last_ix++) 667 { 668 if (strncmp (oso2->name, archive_name, pfx_len) != 0) 669 break; 670 } 671 672 /* Open the archive and check the format. */ 673 archive_bfd = gdb_bfd_open (archive_name, gnutarget, -1); 674 if (archive_bfd == NULL) 675 { 676 warning (_("Could not open OSO archive file \"%s\""), 677 archive_name); 678 ix = last_ix; 679 continue; 680 } 681 if (!bfd_check_format (archive_bfd, bfd_archive)) 682 { 683 warning (_("OSO archive file \"%s\" not an archive."), 684 archive_name); 685 gdb_bfd_unref (archive_bfd); 686 ix = last_ix; 687 continue; 688 } 689 690 member_bfd = gdb_bfd_openr_next_archived_file (archive_bfd, NULL); 691 692 if (member_bfd == NULL) 693 { 694 warning (_("Could not read archive members out of " 695 "OSO archive \"%s\""), archive_name); 696 gdb_bfd_unref (archive_bfd); 697 ix = last_ix; 698 continue; 699 } 700 701 /* Load all oso in this library. */ 702 while (member_bfd != NULL) 703 { 704 bfd *prev; 705 const char *member_name = member_bfd->filename; 706 int member_len = strlen (member_name); 707 708 /* If this member is referenced, add it as a symfile. */ 709 for (ix2 = ix; ix2 < last_ix; ix2++) 710 { 711 oso2 = VEC_index (oso_el, vec, ix2); 712 713 if (oso2->name 714 && strlen (oso2->name) == pfx_len + member_len + 2 715 && !memcmp (member_name, oso2->name + pfx_len + 1, 716 member_len)) 717 { 718 macho_add_oso_symfile (oso2, member_bfd, 719 bfd_get_filename (member_bfd), 720 main_objfile, symfile_flags); 721 oso2->name = NULL; 722 break; 723 } 724 } 725 726 prev = member_bfd; 727 member_bfd = gdb_bfd_openr_next_archived_file (archive_bfd, 728 member_bfd); 729 730 /* Free previous member if not referenced by an oso. */ 731 if (ix2 >= last_ix) 732 gdb_bfd_unref (prev); 733 } 734 for (ix2 = ix; ix2 < last_ix; ix2++) 735 { 736 oso_el *oso2 = VEC_index (oso_el, vec, ix2); 737 738 if (oso2->name != NULL) 739 warning (_("Could not find specified archive member " 740 "for OSO name \"%s\""), oso->name); 741 } 742 ix = last_ix; 743 } 744 else 745 { 746 bfd *abfd; 747 748 abfd = gdb_bfd_open (oso->name, gnutarget, -1); 749 if (!abfd) 750 warning (_("`%s': can't open to read symbols: %s."), oso->name, 751 bfd_errmsg (bfd_get_error ())); 752 else 753 macho_add_oso_symfile (oso, abfd, oso->name, main_objfile, 754 symfile_flags); 755 756 ix++; 757 } 758 } 759 760 do_cleanups (cleanup); 761 } 762 763 /* DSYM (debug symbols) files contain the debug info of an executable. 764 This is a separate file created by dsymutil(1) and is similar to debug 765 link feature on ELF. 766 DSYM files are located in a subdirectory. Append DSYM_SUFFIX to the 767 executable name and the executable base name to get the DSYM file name. */ 768 #define DSYM_SUFFIX ".dSYM/Contents/Resources/DWARF/" 769 770 /* Check if a dsym file exists for OBJFILE. If so, returns a bfd for it 771 and return *FILENAMEP with its original xmalloc-ated filename. 772 Return NULL if no valid dsym file is found (FILENAMEP is not used in 773 such case). */ 774 775 static bfd * 776 macho_check_dsym (struct objfile *objfile, char **filenamep) 777 { 778 size_t name_len = strlen (objfile_name (objfile)); 779 size_t dsym_len = strlen (DSYM_SUFFIX); 780 const char *base_name = lbasename (objfile_name (objfile)); 781 size_t base_len = strlen (base_name); 782 char *dsym_filename = (char *) alloca (name_len + dsym_len + base_len + 1); 783 bfd *dsym_bfd; 784 bfd_mach_o_load_command *main_uuid; 785 bfd_mach_o_load_command *dsym_uuid; 786 787 strcpy (dsym_filename, objfile_name (objfile)); 788 strcpy (dsym_filename + name_len, DSYM_SUFFIX); 789 strcpy (dsym_filename + name_len + dsym_len, base_name); 790 791 if (access (dsym_filename, R_OK) != 0) 792 return NULL; 793 794 if (bfd_mach_o_lookup_command (objfile->obfd, 795 BFD_MACH_O_LC_UUID, &main_uuid) == 0) 796 { 797 warning (_("can't find UUID in %s"), objfile_name (objfile)); 798 return NULL; 799 } 800 dsym_bfd = gdb_bfd_openr (dsym_filename, gnutarget); 801 if (dsym_bfd == NULL) 802 { 803 warning (_("can't open dsym file %s"), dsym_filename); 804 return NULL; 805 } 806 807 if (!bfd_check_format (dsym_bfd, bfd_object)) 808 { 809 gdb_bfd_unref (dsym_bfd); 810 warning (_("bad dsym file format: %s"), bfd_errmsg (bfd_get_error ())); 811 return NULL; 812 } 813 814 if (bfd_mach_o_lookup_command (dsym_bfd, 815 BFD_MACH_O_LC_UUID, &dsym_uuid) == 0) 816 { 817 warning (_("can't find UUID in %s"), dsym_filename); 818 gdb_bfd_unref (dsym_bfd); 819 return NULL; 820 } 821 if (memcmp (dsym_uuid->command.uuid.uuid, main_uuid->command.uuid.uuid, 822 sizeof (main_uuid->command.uuid.uuid))) 823 { 824 warning (_("dsym file UUID doesn't match the one in %s"), 825 objfile_name (objfile)); 826 gdb_bfd_unref (dsym_bfd); 827 return NULL; 828 } 829 *filenamep = xstrdup (dsym_filename); 830 return dsym_bfd; 831 } 832 833 static void 834 macho_symfile_read (struct objfile *objfile, int symfile_flags) 835 { 836 bfd *abfd = objfile->obfd; 837 long storage_needed; 838 bfd *dsym_bfd; 839 VEC (oso_el) *oso_vector = NULL; 840 struct cleanup *old_chain = make_cleanup (VEC_cleanup (oso_el), &oso_vector); 841 842 /* Get symbols from the symbol table only if the file is an executable. 843 The symbol table of object files is not relocated and is expected to 844 be in the executable. */ 845 if (bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC)) 846 { 847 char *dsym_filename; 848 849 /* Process the normal symbol table first. */ 850 storage_needed = bfd_get_symtab_upper_bound (objfile->obfd); 851 if (storage_needed < 0) 852 error (_("Can't read symbols from %s: %s"), 853 bfd_get_filename (objfile->obfd), 854 bfd_errmsg (bfd_get_error ())); 855 856 if (storage_needed > 0) 857 { 858 asymbol **symbol_table; 859 long symcount; 860 861 symbol_table = (asymbol **) xmalloc (storage_needed); 862 make_cleanup (xfree, symbol_table); 863 864 init_minimal_symbol_collection (); 865 make_cleanup_discard_minimal_symbols (); 866 867 symcount = bfd_canonicalize_symtab (objfile->obfd, symbol_table); 868 869 if (symcount < 0) 870 error (_("Can't read symbols from %s: %s"), 871 bfd_get_filename (objfile->obfd), 872 bfd_errmsg (bfd_get_error ())); 873 874 macho_symtab_read (objfile, symcount, symbol_table, &oso_vector); 875 876 install_minimal_symbols (objfile); 877 } 878 879 /* Try to read .eh_frame / .debug_frame. */ 880 /* First, locate these sections. We ignore the result status 881 as it only checks for debug info. */ 882 dwarf2_has_info (objfile, NULL); 883 dwarf2_build_frame_info (objfile); 884 885 /* Check for DSYM file. */ 886 dsym_bfd = macho_check_dsym (objfile, &dsym_filename); 887 if (dsym_bfd != NULL) 888 { 889 struct bfd_section *asect, *dsect; 890 891 make_cleanup (xfree, dsym_filename); 892 893 if (mach_o_debug_level > 0) 894 printf_unfiltered (_("dsym file found\n")); 895 896 /* Set dsym section size. */ 897 for (asect = objfile->obfd->sections, dsect = dsym_bfd->sections; 898 asect && dsect; 899 asect = asect->next, dsect = dsect->next) 900 { 901 if (strcmp (asect->name, dsect->name) != 0) 902 break; 903 bfd_set_section_size (dsym_bfd, dsect, 904 bfd_get_section_size (asect)); 905 } 906 907 /* Add the dsym file as a separate file. */ 908 make_cleanup_bfd_unref (dsym_bfd); 909 symbol_file_add_separate (dsym_bfd, dsym_filename, symfile_flags, 910 objfile); 911 912 /* Don't try to read dwarf2 from main file or shared libraries. */ 913 do_cleanups (old_chain); 914 return; 915 } 916 } 917 918 if (dwarf2_has_info (objfile, NULL)) 919 { 920 /* DWARF 2 sections */ 921 dwarf2_build_psymtabs (objfile); 922 } 923 924 /* Then the oso. */ 925 if (oso_vector != NULL) 926 macho_symfile_read_all_oso (&oso_vector, objfile, symfile_flags); 927 928 do_cleanups (old_chain); 929 } 930 931 static bfd_byte * 932 macho_symfile_relocate (struct objfile *objfile, asection *sectp, 933 bfd_byte *buf) 934 { 935 bfd *abfd = objfile->obfd; 936 937 /* We're only interested in sections with relocation 938 information. */ 939 if ((sectp->flags & SEC_RELOC) == 0) 940 return NULL; 941 942 if (mach_o_debug_level > 0) 943 printf_unfiltered (_("Relocate section '%s' of %s\n"), 944 sectp->name, objfile_name (objfile)); 945 946 return bfd_simple_get_relocated_section_contents (abfd, sectp, buf, NULL); 947 } 948 949 static void 950 macho_symfile_finish (struct objfile *objfile) 951 { 952 } 953 954 static void 955 macho_symfile_offsets (struct objfile *objfile, 956 const struct section_addr_info *addrs) 957 { 958 unsigned int i; 959 struct obj_section *osect; 960 961 /* Allocate section_offsets. */ 962 objfile->num_sections = bfd_count_sections (objfile->obfd); 963 objfile->section_offsets = (struct section_offsets *) 964 obstack_alloc (&objfile->objfile_obstack, 965 SIZEOF_N_SECTION_OFFSETS (objfile->num_sections)); 966 memset (objfile->section_offsets, 0, 967 SIZEOF_N_SECTION_OFFSETS (objfile->num_sections)); 968 969 /* This code is run when we first add the objfile with 970 symfile_add_with_addrs_or_offsets, when "addrs" not "offsets" are 971 passed in. The place in symfile.c where the addrs are applied 972 depends on the addrs having section names. But in the dyld code 973 we build an anonymous array of addrs, so that code is a no-op. 974 Because of that, we have to apply the addrs to the sections here. 975 N.B. if an objfile slides after we've already created it, then it 976 goes through objfile_relocate. */ 977 978 for (i = 0; i < addrs->num_sections; i++) 979 { 980 ALL_OBJFILE_OSECTIONS (objfile, osect) 981 { 982 const char *bfd_sect_name = osect->the_bfd_section->name; 983 984 if (strcmp (bfd_sect_name, addrs->other[i].name) == 0) 985 { 986 obj_section_offset (osect) = addrs->other[i].addr; 987 break; 988 } 989 } 990 } 991 992 objfile->sect_index_text = 0; 993 994 ALL_OBJFILE_OSECTIONS (objfile, osect) 995 { 996 const char *bfd_sect_name = osect->the_bfd_section->name; 997 int sect_index = osect - objfile->sections;; 998 999 if (startswith (bfd_sect_name, "LC_SEGMENT.")) 1000 bfd_sect_name += 11; 1001 if (strcmp (bfd_sect_name, "__TEXT") == 0 1002 || strcmp (bfd_sect_name, "__TEXT.__text") == 0) 1003 objfile->sect_index_text = sect_index; 1004 } 1005 } 1006 1007 static const struct sym_fns macho_sym_fns = { 1008 macho_new_init, /* init anything gbl to entire symtab */ 1009 macho_symfile_init, /* read initial info, setup for sym_read() */ 1010 macho_symfile_read, /* read a symbol file into symtab */ 1011 NULL, /* sym_read_psymbols */ 1012 macho_symfile_finish, /* finished with file, cleanup */ 1013 macho_symfile_offsets, /* xlate external to internal form */ 1014 default_symfile_segments, /* Get segment information from a file. */ 1015 NULL, 1016 macho_symfile_relocate, /* Relocate a debug section. */ 1017 NULL, /* sym_get_probes */ 1018 &psym_functions 1019 }; 1020 1021 /* -Wmissing-prototypes */ 1022 extern initialize_file_ftype _initialize_machoread; 1023 1024 void 1025 _initialize_machoread (void) 1026 { 1027 add_symtab_fns (bfd_target_mach_o_flavour, &macho_sym_fns); 1028 1029 add_setshow_zuinteger_cmd ("mach-o", class_obscure, 1030 &mach_o_debug_level, 1031 _("Set if printing Mach-O symbols processing."), 1032 _("Show if printing Mach-O symbols processing."), 1033 NULL, NULL, NULL, 1034 &setdebuglist, &showdebuglist); 1035 } 1036