1 /* Darwin support for GDB, the GNU debugger. 2 Copyright (C) 2008-2017 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 #include <string> 37 38 /* If non-zero displays debugging message. */ 39 static unsigned int mach_o_debug_level = 0; 40 41 /* Dwarf debugging information are never in the final executable. They stay 42 in object files and the executable contains the list of object files read 43 during the link. 44 Each time an oso (other source) is found in the executable, the reader 45 creates such a structure. They are read after the processing of the 46 executable. */ 47 48 typedef struct oso_el 49 { 50 /* Object file name. Can also be a member name. */ 51 const char *name; 52 53 /* Associated time stamp. */ 54 unsigned long mtime; 55 56 /* Stab symbols range for this OSO. */ 57 asymbol **oso_sym; 58 asymbol **end_sym; 59 60 /* Number of interesting stabs in the range. */ 61 unsigned int nbr_syms; 62 } 63 oso_el; 64 65 /* Vector of object files to be read after the executable. */ 66 DEF_VEC_O (oso_el); 67 68 static void 69 macho_new_init (struct objfile *objfile) 70 { 71 } 72 73 static void 74 macho_symfile_init (struct objfile *objfile) 75 { 76 objfile->flags |= OBJF_REORDERED; 77 } 78 79 /* Add a new OSO to the vector of OSO to load. */ 80 81 static void 82 macho_register_oso (VEC (oso_el) **oso_vector_ptr, 83 struct objfile *objfile, 84 asymbol **oso_sym, asymbol **end_sym, 85 unsigned int nbr_syms) 86 { 87 oso_el el; 88 89 el.name = (*oso_sym)->name; 90 el.mtime = (*oso_sym)->value; 91 el.oso_sym = oso_sym; 92 el.end_sym = end_sym; 93 el.nbr_syms = nbr_syms; 94 VEC_safe_push (oso_el, *oso_vector_ptr, &el); 95 } 96 97 /* Add symbol SYM to the minimal symbol table of OBJFILE. */ 98 99 static void 100 macho_symtab_add_minsym (minimal_symbol_reader &reader, 101 struct objfile *objfile, const asymbol *sym) 102 { 103 if (sym->name == NULL || *sym->name == '\0') 104 { 105 /* Skip names that don't exist (shouldn't happen), or names 106 that are null strings (may happen). */ 107 return; 108 } 109 110 if (sym->flags & (BSF_GLOBAL | BSF_LOCAL | BSF_WEAK)) 111 { 112 CORE_ADDR symaddr; 113 enum minimal_symbol_type ms_type; 114 115 /* Bfd symbols are section relative. */ 116 symaddr = sym->value + sym->section->vma; 117 118 if (sym->section == bfd_abs_section_ptr) 119 ms_type = mst_abs; 120 else if (sym->section->flags & SEC_CODE) 121 { 122 if (sym->flags & (BSF_GLOBAL | BSF_WEAK)) 123 ms_type = mst_text; 124 else 125 ms_type = mst_file_text; 126 } 127 else if (sym->section->flags & SEC_ALLOC) 128 { 129 if (sym->flags & (BSF_GLOBAL | BSF_WEAK)) 130 { 131 if (sym->section->flags & SEC_LOAD) 132 ms_type = mst_data; 133 else 134 ms_type = mst_bss; 135 } 136 else if (sym->flags & BSF_LOCAL) 137 { 138 /* Not a special stabs-in-elf symbol, do regular 139 symbol processing. */ 140 if (sym->section->flags & SEC_LOAD) 141 ms_type = mst_file_data; 142 else 143 ms_type = mst_file_bss; 144 } 145 else 146 ms_type = mst_unknown; 147 } 148 else 149 return; /* Skip this symbol. */ 150 151 reader.record_with_info (sym->name, symaddr, ms_type, 152 gdb_bfd_section_index (objfile->obfd, 153 sym->section)); 154 } 155 } 156 157 /* Build the minimal symbol table from SYMBOL_TABLE of length 158 NUMBER_OF_SYMBOLS for OBJFILE. Registers OSO filenames found. */ 159 160 static void 161 macho_symtab_read (minimal_symbol_reader &reader, 162 struct objfile *objfile, 163 long number_of_symbols, asymbol **symbol_table, 164 VEC (oso_el) **oso_vector_ptr) 165 { 166 long i; 167 const asymbol *file_so = NULL; 168 asymbol **oso_file = NULL; 169 unsigned int nbr_syms = 0; 170 171 /* Current state while reading stabs. */ 172 enum 173 { 174 /* Not within an SO part. Only non-debugging symbols should be present, 175 and will be added to the minimal symbols table. */ 176 S_NO_SO, 177 178 /* First SO read. Introduce an SO section, and may be followed by a second 179 SO. The SO section should contain onl debugging symbols. */ 180 S_FIRST_SO, 181 182 /* Second non-null SO found, just after the first one. Means that the first 183 is in fact a directory name. */ 184 S_SECOND_SO, 185 186 /* Non-null OSO found. Debugging info are DWARF in this OSO file. */ 187 S_DWARF_FILE, 188 189 S_STAB_FILE 190 } state = S_NO_SO; 191 192 for (i = 0; i < number_of_symbols; i++) 193 { 194 const asymbol *sym = symbol_table[i]; 195 bfd_mach_o_asymbol *mach_o_sym = (bfd_mach_o_asymbol *)sym; 196 197 switch (state) 198 { 199 case S_NO_SO: 200 if (mach_o_sym->n_type == N_SO) 201 { 202 /* Start of object stab. */ 203 if (sym->name == NULL || sym->name[0] == 0) 204 { 205 /* Unexpected empty N_SO. */ 206 complaint (&symfile_complaints, 207 _("Unexpected empty N_SO stab")); 208 } 209 else 210 { 211 file_so = sym; 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 (reader, 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 file_so = sym; 249 state = S_SECOND_SO; 250 } 251 else 252 complaint (&symfile_complaints, _("Three SO in a raw")); 253 } 254 else if (mach_o_sym->n_type == N_OSO) 255 { 256 if (sym->name == NULL || sym->name[0] == 0) 257 { 258 /* Empty OSO. Means that this file was compiled with 259 stabs. */ 260 state = S_STAB_FILE; 261 warning (_("stabs debugging not supported for %s"), 262 file_so->name); 263 } 264 else 265 { 266 /* Non-empty OSO for a Dwarf file. */ 267 oso_file = symbol_table + i; 268 nbr_syms = 0; 269 state = S_DWARF_FILE; 270 } 271 } 272 else 273 complaint (&symfile_complaints, 274 _("Unexpected stab after SO")); 275 break; 276 277 case S_STAB_FILE: 278 case S_DWARF_FILE: 279 if (mach_o_sym->n_type == N_SO) 280 { 281 if (sym->name == NULL || sym->name[0] == 0) 282 { 283 /* End of file. */ 284 if (state == S_DWARF_FILE) 285 macho_register_oso (oso_vector_ptr, objfile, 286 oso_file, symbol_table + i, 287 nbr_syms); 288 state = S_NO_SO; 289 } 290 else 291 { 292 complaint (&symfile_complaints, _("Missing nul SO")); 293 file_so = sym; 294 state = S_FIRST_SO; 295 } 296 } 297 else if (sym->flags & BSF_DEBUGGING) 298 { 299 if (state == S_STAB_FILE) 300 { 301 /* FIXME: to be implemented. */ 302 } 303 else 304 { 305 switch (mach_o_sym->n_type) 306 { 307 case N_FUN: 308 if (sym->name == NULL || sym->name[0] == 0) 309 break; 310 /* Fall through. */ 311 case N_STSYM: 312 /* Interesting symbol. */ 313 nbr_syms++; 314 break; 315 case N_ENSYM: 316 case N_BNSYM: 317 case N_GSYM: 318 break; 319 default: 320 complaint (&symfile_complaints, 321 _("unhandled stab for dwarf OSO file")); 322 break; 323 } 324 } 325 } 326 else 327 complaint (&symfile_complaints, 328 _("non-debugging symbol within SO")); 329 break; 330 } 331 } 332 333 if (state != S_NO_SO) 334 complaint (&symfile_complaints, _("missing nul SO")); 335 } 336 337 /* If NAME describes an archive member (ie: ARCHIVE '(' MEMBER ')'), 338 returns the length of the archive name. 339 Returns -1 otherwise. */ 340 341 static int 342 get_archive_prefix_len (const char *name) 343 { 344 const char *lparen; 345 int name_len = strlen (name); 346 347 if (name_len == 0 || name[name_len - 1] != ')') 348 return -1; 349 350 lparen = strrchr (name, '('); 351 if (lparen == NULL || lparen == name) 352 return -1; 353 return lparen - name; 354 } 355 356 /* Compare function to qsort OSOs, so that members of a library are 357 gathered. */ 358 359 static int 360 oso_el_compare_name (const void *vl, const void *vr) 361 { 362 const oso_el *l = (const oso_el *)vl; 363 const oso_el *r = (const oso_el *)vr; 364 365 return strcmp (l->name, r->name); 366 } 367 368 /* Hash table entry structure for the stabs symbols in the main object file. 369 This is used to speed up lookup for symbols in the OSO. */ 370 371 struct macho_sym_hash_entry 372 { 373 struct bfd_hash_entry base; 374 const asymbol *sym; 375 }; 376 377 /* Routine to create an entry in the hash table. */ 378 379 static struct bfd_hash_entry * 380 macho_sym_hash_newfunc (struct bfd_hash_entry *entry, 381 struct bfd_hash_table *table, 382 const char *string) 383 { 384 struct macho_sym_hash_entry *ret = (struct macho_sym_hash_entry *) entry; 385 386 /* Allocate the structure if it has not already been allocated by a 387 subclass. */ 388 if (ret == NULL) 389 ret = (struct macho_sym_hash_entry *) bfd_hash_allocate (table, 390 sizeof (* ret)); 391 if (ret == NULL) 392 return NULL; 393 394 /* Call the allocation method of the superclass. */ 395 ret = (struct macho_sym_hash_entry *) 396 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string); 397 398 if (ret) 399 { 400 /* Initialize the local fields. */ 401 ret->sym = NULL; 402 } 403 404 return (struct bfd_hash_entry *) ret; 405 } 406 407 /* Get the value of SYM from the minimal symtab of MAIN_OBJFILE. This is used 408 to get the value of global and common symbols. */ 409 410 static CORE_ADDR 411 macho_resolve_oso_sym_with_minsym (struct objfile *main_objfile, asymbol *sym) 412 { 413 /* For common symbol and global symbols, use the min symtab. */ 414 struct bound_minimal_symbol msym; 415 const char *name = sym->name; 416 417 if (name[0] == bfd_get_symbol_leading_char (main_objfile->obfd)) 418 ++name; 419 msym = lookup_minimal_symbol (name, NULL, main_objfile); 420 if (msym.minsym == NULL) 421 { 422 warning (_("can't find symbol '%s' in minsymtab"), name); 423 return 0; 424 } 425 else 426 return BMSYMBOL_VALUE_ADDRESS (msym); 427 } 428 429 /* Add oso file OSO/ABFD as a symbol file. */ 430 431 static void 432 macho_add_oso_symfile (oso_el *oso, const gdb_bfd_ref_ptr &abfd, 433 const char *name, 434 struct objfile *main_objfile, 435 symfile_add_flags 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 444 /* Per section flag to mark which section have been rebased. */ 445 unsigned char *sections_rebased; 446 447 if (mach_o_debug_level > 0) 448 printf_unfiltered 449 (_("Loading debugging symbols from oso: %s\n"), oso->name); 450 451 if (!bfd_check_format (abfd.get (), bfd_object)) 452 { 453 warning (_("`%s': can't read symbols: %s."), oso->name, 454 bfd_errmsg (bfd_get_error ())); 455 return; 456 } 457 458 if (abfd->my_archive == NULL && oso->mtime != bfd_get_mtime (abfd.get ())) 459 { 460 warning (_("`%s': file time stamp mismatch."), oso->name); 461 return; 462 } 463 464 if (!bfd_hash_table_init_n (&table, macho_sym_hash_newfunc, 465 sizeof (struct macho_sym_hash_entry), 466 oso->nbr_syms)) 467 { 468 warning (_("`%s': can't create hash table"), oso->name); 469 return; 470 } 471 472 bfd_set_cacheable (abfd.get (), 1); 473 474 /* Read symbols table. */ 475 storage = bfd_get_symtab_upper_bound (abfd.get ()); 476 symbol_table = (asymbol **) xmalloc (storage); 477 bfd_canonicalize_symtab (abfd.get (), symbol_table); 478 479 /* Init section flags. */ 480 nbr_sections = bfd_count_sections (abfd.get ()); 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.get (), 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 symbol_file_add_from_bfd 618 (abfd.get (), name, symfile_flags & ~(SYMFILE_MAINLINE | SYMFILE_VERBOSE), 619 NULL, 620 main_objfile->flags & (OBJF_REORDERED | OBJF_SHARED 621 | OBJF_READNOW | OBJF_USERLOADED), 622 main_objfile); 623 } 624 625 /* Read symbols from the vector of oso files. 626 627 Note that this function sorts OSO_VECTOR_PTR. */ 628 629 static void 630 macho_symfile_read_all_oso (VEC (oso_el) **oso_vector_ptr, 631 struct objfile *main_objfile, 632 symfile_add_flags symfile_flags) 633 { 634 int ix; 635 VEC (oso_el) *vec = *oso_vector_ptr; 636 oso_el *oso; 637 638 /* Sort oso by name so that files from libraries are gathered. */ 639 qsort (VEC_address (oso_el, vec), VEC_length (oso_el, vec), 640 sizeof (oso_el), oso_el_compare_name); 641 642 for (ix = 0; VEC_iterate (oso_el, vec, ix, oso);) 643 { 644 int pfx_len; 645 646 /* Check if this is a library name. */ 647 pfx_len = get_archive_prefix_len (oso->name); 648 if (pfx_len > 0) 649 { 650 int last_ix; 651 oso_el *oso2; 652 int ix2; 653 654 std::string archive_name (oso->name, pfx_len); 655 656 /* Compute number of oso for this archive. */ 657 for (last_ix = ix; 658 VEC_iterate (oso_el, vec, last_ix, oso2); last_ix++) 659 { 660 if (strncmp (oso2->name, archive_name.c_str (), pfx_len) != 0) 661 break; 662 } 663 664 /* Open the archive and check the format. */ 665 gdb_bfd_ref_ptr archive_bfd (gdb_bfd_open (archive_name.c_str (), 666 gnutarget, -1)); 667 if (archive_bfd == NULL) 668 { 669 warning (_("Could not open OSO archive file \"%s\""), 670 archive_name.c_str ()); 671 ix = last_ix; 672 continue; 673 } 674 if (!bfd_check_format (archive_bfd.get (), bfd_archive)) 675 { 676 warning (_("OSO archive file \"%s\" not an archive."), 677 archive_name.c_str ()); 678 ix = last_ix; 679 continue; 680 } 681 682 gdb_bfd_ref_ptr member_bfd 683 (gdb_bfd_openr_next_archived_file (archive_bfd.get (), NULL)); 684 685 if (member_bfd == NULL) 686 { 687 warning (_("Could not read archive members out of " 688 "OSO archive \"%s\""), archive_name.c_str ()); 689 ix = last_ix; 690 continue; 691 } 692 693 /* Load all oso in this library. */ 694 while (member_bfd != NULL) 695 { 696 const char *member_name = member_bfd->filename; 697 int member_len = strlen (member_name); 698 699 /* If this member is referenced, add it as a symfile. */ 700 for (ix2 = ix; ix2 < last_ix; ix2++) 701 { 702 oso2 = VEC_index (oso_el, vec, ix2); 703 704 if (oso2->name 705 && strlen (oso2->name) == pfx_len + member_len + 2 706 && !memcmp (member_name, oso2->name + pfx_len + 1, 707 member_len)) 708 { 709 macho_add_oso_symfile (oso2, member_bfd, 710 bfd_get_filename (member_bfd), 711 main_objfile, symfile_flags); 712 oso2->name = NULL; 713 break; 714 } 715 } 716 717 member_bfd = gdb_bfd_openr_next_archived_file (archive_bfd.get (), 718 member_bfd.get ()); 719 } 720 for (ix2 = ix; ix2 < last_ix; ix2++) 721 { 722 oso_el *oso2 = VEC_index (oso_el, vec, ix2); 723 724 if (oso2->name != NULL) 725 warning (_("Could not find specified archive member " 726 "for OSO name \"%s\""), oso->name); 727 } 728 ix = last_ix; 729 } 730 else 731 { 732 gdb_bfd_ref_ptr abfd (gdb_bfd_open (oso->name, gnutarget, -1)); 733 if (abfd == NULL) 734 warning (_("`%s': can't open to read symbols: %s."), oso->name, 735 bfd_errmsg (bfd_get_error ())); 736 else 737 macho_add_oso_symfile (oso, abfd, oso->name, main_objfile, 738 symfile_flags); 739 740 ix++; 741 } 742 } 743 } 744 745 /* DSYM (debug symbols) files contain the debug info of an executable. 746 This is a separate file created by dsymutil(1) and is similar to debug 747 link feature on ELF. 748 DSYM files are located in a subdirectory. Append DSYM_SUFFIX to the 749 executable name and the executable base name to get the DSYM file name. */ 750 #define DSYM_SUFFIX ".dSYM/Contents/Resources/DWARF/" 751 752 /* Check if a dsym file exists for OBJFILE. If so, returns a bfd for it 753 and return *FILENAMEP with its original xmalloc-ated filename. 754 Return NULL if no valid dsym file is found (FILENAMEP is not used in 755 such case). */ 756 757 static gdb_bfd_ref_ptr 758 macho_check_dsym (struct objfile *objfile, char **filenamep) 759 { 760 size_t name_len = strlen (objfile_name (objfile)); 761 size_t dsym_len = strlen (DSYM_SUFFIX); 762 const char *base_name = lbasename (objfile_name (objfile)); 763 size_t base_len = strlen (base_name); 764 char *dsym_filename = (char *) alloca (name_len + dsym_len + base_len + 1); 765 bfd_mach_o_load_command *main_uuid; 766 bfd_mach_o_load_command *dsym_uuid; 767 768 strcpy (dsym_filename, objfile_name (objfile)); 769 strcpy (dsym_filename + name_len, DSYM_SUFFIX); 770 strcpy (dsym_filename + name_len + dsym_len, base_name); 771 772 if (access (dsym_filename, R_OK) != 0) 773 return NULL; 774 775 if (bfd_mach_o_lookup_command (objfile->obfd, 776 BFD_MACH_O_LC_UUID, &main_uuid) == 0) 777 { 778 warning (_("can't find UUID in %s"), objfile_name (objfile)); 779 return NULL; 780 } 781 gdb_bfd_ref_ptr dsym_bfd (gdb_bfd_openr (dsym_filename, gnutarget)); 782 if (dsym_bfd == NULL) 783 { 784 warning (_("can't open dsym file %s"), dsym_filename); 785 return NULL; 786 } 787 788 if (!bfd_check_format (dsym_bfd.get (), bfd_object)) 789 { 790 warning (_("bad dsym file format: %s"), bfd_errmsg (bfd_get_error ())); 791 return NULL; 792 } 793 794 if (bfd_mach_o_lookup_command (dsym_bfd.get (), 795 BFD_MACH_O_LC_UUID, &dsym_uuid) == 0) 796 { 797 warning (_("can't find UUID in %s"), dsym_filename); 798 return NULL; 799 } 800 if (memcmp (dsym_uuid->command.uuid.uuid, main_uuid->command.uuid.uuid, 801 sizeof (main_uuid->command.uuid.uuid))) 802 { 803 warning (_("dsym file UUID doesn't match the one in %s"), 804 objfile_name (objfile)); 805 return NULL; 806 } 807 *filenamep = xstrdup (dsym_filename); 808 return dsym_bfd; 809 } 810 811 static void 812 macho_symfile_read (struct objfile *objfile, symfile_add_flags symfile_flags) 813 { 814 bfd *abfd = objfile->obfd; 815 long storage_needed; 816 VEC (oso_el) *oso_vector = NULL; 817 struct cleanup *old_chain = make_cleanup (VEC_cleanup (oso_el), &oso_vector); 818 819 /* Get symbols from the symbol table only if the file is an executable. 820 The symbol table of object files is not relocated and is expected to 821 be in the executable. */ 822 if (bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC)) 823 { 824 char *dsym_filename; 825 826 /* Process the normal symbol table first. */ 827 storage_needed = bfd_get_symtab_upper_bound (objfile->obfd); 828 if (storage_needed < 0) 829 error (_("Can't read symbols from %s: %s"), 830 bfd_get_filename (objfile->obfd), 831 bfd_errmsg (bfd_get_error ())); 832 833 if (storage_needed > 0) 834 { 835 asymbol **symbol_table; 836 long symcount; 837 838 symbol_table = (asymbol **) xmalloc (storage_needed); 839 make_cleanup (xfree, symbol_table); 840 841 minimal_symbol_reader reader (objfile); 842 843 symcount = bfd_canonicalize_symtab (objfile->obfd, symbol_table); 844 845 if (symcount < 0) 846 error (_("Can't read symbols from %s: %s"), 847 bfd_get_filename (objfile->obfd), 848 bfd_errmsg (bfd_get_error ())); 849 850 macho_symtab_read (reader, objfile, symcount, symbol_table, 851 &oso_vector); 852 853 reader.install (); 854 } 855 856 /* Try to read .eh_frame / .debug_frame. */ 857 /* First, locate these sections. We ignore the result status 858 as it only checks for debug info. */ 859 dwarf2_has_info (objfile, NULL); 860 dwarf2_build_frame_info (objfile); 861 862 /* Check for DSYM file. */ 863 gdb_bfd_ref_ptr dsym_bfd (macho_check_dsym (objfile, &dsym_filename)); 864 if (dsym_bfd != NULL) 865 { 866 struct bfd_section *asect, *dsect; 867 868 make_cleanup (xfree, dsym_filename); 869 870 if (mach_o_debug_level > 0) 871 printf_unfiltered (_("dsym file found\n")); 872 873 /* Set dsym section size. */ 874 for (asect = objfile->obfd->sections, dsect = dsym_bfd->sections; 875 asect && dsect; 876 asect = asect->next, dsect = dsect->next) 877 { 878 if (strcmp (asect->name, dsect->name) != 0) 879 break; 880 bfd_set_section_size (dsym_bfd.get (), dsect, 881 bfd_get_section_size (asect)); 882 } 883 884 /* Add the dsym file as a separate file. */ 885 symbol_file_add_separate (dsym_bfd.get (), dsym_filename, 886 symfile_flags, objfile); 887 888 /* Don't try to read dwarf2 from main file or shared libraries. */ 889 do_cleanups (old_chain); 890 return; 891 } 892 } 893 894 if (dwarf2_has_info (objfile, NULL)) 895 { 896 /* DWARF 2 sections */ 897 dwarf2_build_psymtabs (objfile); 898 } 899 900 /* Then the oso. */ 901 if (oso_vector != NULL) 902 macho_symfile_read_all_oso (&oso_vector, objfile, symfile_flags); 903 904 do_cleanups (old_chain); 905 } 906 907 static bfd_byte * 908 macho_symfile_relocate (struct objfile *objfile, asection *sectp, 909 bfd_byte *buf) 910 { 911 bfd *abfd = objfile->obfd; 912 913 /* We're only interested in sections with relocation 914 information. */ 915 if ((sectp->flags & SEC_RELOC) == 0) 916 return NULL; 917 918 if (mach_o_debug_level > 0) 919 printf_unfiltered (_("Relocate section '%s' of %s\n"), 920 sectp->name, objfile_name (objfile)); 921 922 return bfd_simple_get_relocated_section_contents (abfd, sectp, buf, NULL); 923 } 924 925 static void 926 macho_symfile_finish (struct objfile *objfile) 927 { 928 } 929 930 static void 931 macho_symfile_offsets (struct objfile *objfile, 932 const struct section_addr_info *addrs) 933 { 934 unsigned int i; 935 struct obj_section *osect; 936 937 /* Allocate section_offsets. */ 938 objfile->num_sections = bfd_count_sections (objfile->obfd); 939 objfile->section_offsets = (struct section_offsets *) 940 obstack_alloc (&objfile->objfile_obstack, 941 SIZEOF_N_SECTION_OFFSETS (objfile->num_sections)); 942 memset (objfile->section_offsets, 0, 943 SIZEOF_N_SECTION_OFFSETS (objfile->num_sections)); 944 945 /* This code is run when we first add the objfile with 946 symfile_add_with_addrs_or_offsets, when "addrs" not "offsets" are 947 passed in. The place in symfile.c where the addrs are applied 948 depends on the addrs having section names. But in the dyld code 949 we build an anonymous array of addrs, so that code is a no-op. 950 Because of that, we have to apply the addrs to the sections here. 951 N.B. if an objfile slides after we've already created it, then it 952 goes through objfile_relocate. */ 953 954 for (i = 0; i < addrs->num_sections; i++) 955 { 956 ALL_OBJFILE_OSECTIONS (objfile, osect) 957 { 958 const char *bfd_sect_name = osect->the_bfd_section->name; 959 960 if (strcmp (bfd_sect_name, addrs->other[i].name) == 0) 961 { 962 obj_section_offset (osect) = addrs->other[i].addr; 963 break; 964 } 965 } 966 } 967 968 objfile->sect_index_text = 0; 969 970 ALL_OBJFILE_OSECTIONS (objfile, osect) 971 { 972 const char *bfd_sect_name = osect->the_bfd_section->name; 973 int sect_index = osect - objfile->sections;; 974 975 if (startswith (bfd_sect_name, "LC_SEGMENT.")) 976 bfd_sect_name += 11; 977 if (strcmp (bfd_sect_name, "__TEXT") == 0 978 || strcmp (bfd_sect_name, "__TEXT.__text") == 0) 979 objfile->sect_index_text = sect_index; 980 } 981 } 982 983 static const struct sym_fns macho_sym_fns = { 984 macho_new_init, /* init anything gbl to entire symtab */ 985 macho_symfile_init, /* read initial info, setup for sym_read() */ 986 macho_symfile_read, /* read a symbol file into symtab */ 987 NULL, /* sym_read_psymbols */ 988 macho_symfile_finish, /* finished with file, cleanup */ 989 macho_symfile_offsets, /* xlate external to internal form */ 990 default_symfile_segments, /* Get segment information from a file. */ 991 NULL, 992 macho_symfile_relocate, /* Relocate a debug section. */ 993 NULL, /* sym_get_probes */ 994 &psym_functions 995 }; 996 997 /* -Wmissing-prototypes */ 998 extern initialize_file_ftype _initialize_machoread; 999 1000 void 1001 _initialize_machoread (void) 1002 { 1003 add_symtab_fns (bfd_target_mach_o_flavour, &macho_sym_fns); 1004 1005 add_setshow_zuinteger_cmd ("mach-o", class_obscure, 1006 &mach_o_debug_level, 1007 _("Set if printing Mach-O symbols processing."), 1008 _("Show if printing Mach-O symbols processing."), 1009 NULL, NULL, NULL, 1010 &setdebuglist, &showdebuglist); 1011 } 1012