gdb/machoread.c

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