gdb/machoread.c

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