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