gdb/machoread.c

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