gdb/machoread.c

   1 /* Darwin support for GDB, the GNU debugger.
   2    Copyright (C) 2008-2022 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.  */
  38 static 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
  51 struct 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
  76 static void
  77 macho_new_init (struct objfile *objfile)
  78 {
  79 }
  80
  81 static void
  82 macho_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
  89 static void
  90 macho_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,
 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
 150 static void
 151 macho_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
 325 static int
 326 get_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
 343 static bool
 344 oso_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
 352 struct 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
 360 static struct bfd_hash_entry *
 361 macho_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
 391 static CORE_ADDR
 392 macho_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))
 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
 412 static void
 413 macho_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.get (), 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
 598 static void
 599 macho_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
 727 static gdb_bfd_ref_ptr
 728 macho_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,
 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
 781 static void
 782 macho_symfile_read (struct objfile *objfile, symfile_add_flags symfile_flags)
 783 {
 784   bfd *abfd = objfile->obfd;
 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);
 800       if (storage_needed < 0)
 801         error (_("Can't read symbols from %s: %s"),
 802                bfd_get_filename (objfile->obfd),
 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,
 814                                               symbol_table.data ());
 815
 816           if (symcount < 0)
 817             error (_("Can't read symbols from %s: %s"),
 818                    bfd_get_filename (objfile->obfd),
 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.get (), 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
 871 static bfd_byte *
 872 macho_symfile_relocate (struct objfile *objfile, asection *sectp,
 873                         bfd_byte *buf)
 874 {
 875   bfd *abfd = objfile->obfd;
 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
 888 static void
 889 macho_symfile_finish (struct objfile *objfile)
 890 {
 891 }
 892
 893 static void
 894 macho_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), 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
 941 static 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
 953 void _initialize_machoread ();
 954 void
 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 }