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