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