gdb/machoread.c

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