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