gdb/machoread.c

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