gdb/machoread.c

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