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