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