gdb/machoread.c

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