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