gdb/machoread.c

   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, -1));
 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, -1));
 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 }