contrib/gdb-7/gdb/machoread.c

   1 /* Darwin support for GDB, the GNU debugger.
   2    Copyright (C) 2008-2013 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 }
  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   struct cleanup *cleanup;
 458
 459   /* Per section flag to mark which section have been rebased.  */
 460   unsigned char *sections_rebased;
 461
 462   if (mach_o_debug_level > 0)
 463     printf_unfiltered
 464       (_("Loading debugging symbols from oso: %s\n"), oso->name);
 465
 466   if (!bfd_check_format (abfd, bfd_object))
 467     {
 468       warning (_("`%s': can't read symbols: %s."), oso->name,
 469                bfd_errmsg (bfd_get_error ()));
 470       gdb_bfd_unref (abfd);
 471       return;
 472     }
 473
 474   if (abfd->my_archive == NULL && oso->mtime != bfd_get_mtime (abfd))
 475     {
 476       warning (_("`%s': file time stamp mismatch."), oso->name);
 477       gdb_bfd_unref (abfd);
 478       return;
 479     }
 480
 481   if (!bfd_hash_table_init_n (&table, macho_sym_hash_newfunc,
 482                               sizeof (struct macho_sym_hash_entry),
 483                               oso->nbr_syms))
 484     {
 485       warning (_("`%s': can't create hash table"), oso->name);
 486       gdb_bfd_unref (abfd);
 487       return;
 488     }
 489
 490   bfd_set_cacheable (abfd, 1);
 491
 492   /* Read symbols table.  */
 493   storage = bfd_get_symtab_upper_bound (abfd);
 494   symbol_table = (asymbol **) xmalloc (storage);
 495   bfd_canonicalize_symtab (abfd, symbol_table);
 496
 497   /* Init section flags.  */
 498   nbr_sections = bfd_count_sections (abfd);
 499   sections_rebased = (unsigned char *) alloca (nbr_sections);
 500   for (i = 0; i < nbr_sections; i++)
 501     sections_rebased[i] = 0;
 502
 503   /* Put symbols for the OSO file in the hash table.  */
 504   for (symp = oso->oso_sym; symp != oso->end_sym; symp++)
 505     {
 506       const asymbol *sym = *symp;
 507       bfd_mach_o_asymbol *mach_o_sym = (bfd_mach_o_asymbol *)sym;
 508
 509       switch (mach_o_sym->n_type)
 510         {
 511         case N_ENSYM:
 512         case N_BNSYM:
 513         case N_GSYM:
 514           sym = NULL;
 515           break;
 516         case N_FUN:
 517           if (sym->name == NULL || sym->name[0] == 0)
 518             sym = NULL;
 519           break;
 520         case N_STSYM:
 521           break;
 522         default:
 523           sym = NULL;
 524           break;
 525         }
 526       if (sym != NULL)
 527         {
 528           struct macho_sym_hash_entry *ent;
 529
 530           ent = (struct macho_sym_hash_entry *)
 531             bfd_hash_lookup (&table, sym->name, TRUE, FALSE);
 532           if (ent->sym != NULL)
 533             complaint (&symfile_complaints,
 534                        _("Duplicated symbol %s in symbol table"), sym->name);
 535           else
 536             {
 537               if (mach_o_debug_level > 4)
 538                 {
 539                   struct gdbarch *arch = get_objfile_arch (main_objfile);
 540                   printf_unfiltered
 541                     (_("Adding symbol %s (addr: %s)\n"),
 542                      sym->name, paddress (arch, sym->value));
 543                 }
 544               ent->sym = sym;
 545             }
 546         }
 547     }
 548
 549   /* Relocate symbols of the OSO.  */
 550   for (i = 0; symbol_table[i]; i++)
 551     {
 552       asymbol *sym = symbol_table[i];
 553       bfd_mach_o_asymbol *mach_o_sym = (bfd_mach_o_asymbol *)sym;
 554
 555       if (mach_o_sym->n_type & BFD_MACH_O_N_STAB)
 556         continue;
 557       if ((mach_o_sym->n_type & BFD_MACH_O_N_TYPE) == BFD_MACH_O_N_UNDF
 558            && sym->value != 0)
 559         {
 560           /* For common symbol use the min symtab and modify the OSO
 561              symbol table.  */
 562           CORE_ADDR res;
 563
 564           res = macho_resolve_oso_sym_with_minsym (main_objfile, sym);
 565           if (res != 0)
 566             {
 567               sym->section = bfd_com_section_ptr;
 568               sym->value = res;
 569             }
 570         }
 571       else if ((mach_o_sym->n_type & BFD_MACH_O_N_TYPE) == BFD_MACH_O_N_SECT)
 572         {
 573           /* Normal symbol.  */
 574           asection *sec = sym->section;
 575           bfd_mach_o_section *msec;
 576           unsigned int sec_type;
 577
 578           /* Skip buggy ones.  */
 579           if (sec == NULL || sections_rebased[sec->index] != 0)
 580             continue;
 581
 582           /* Only consider regular, non-debugging sections.  */
 583           msec = bfd_mach_o_get_mach_o_section (sec);
 584           sec_type = msec->flags & BFD_MACH_O_SECTION_TYPE_MASK;
 585           if ((sec_type == BFD_MACH_O_S_REGULAR
 586                || sec_type == BFD_MACH_O_S_ZEROFILL)
 587               && (msec->flags & BFD_MACH_O_S_ATTR_DEBUG) == 0)
 588             {
 589               CORE_ADDR addr = 0;
 590
 591               if ((mach_o_sym->n_type & BFD_MACH_O_N_EXT) != 0)
 592                 {
 593                   /* Use the min symtab for global symbols.  */
 594                   addr = macho_resolve_oso_sym_with_minsym (main_objfile, sym);
 595                 }
 596               else
 597                 {
 598                   struct macho_sym_hash_entry *ent;
 599
 600                   ent = (struct macho_sym_hash_entry *)
 601                     bfd_hash_lookup (&table, sym->name, FALSE, FALSE);
 602                   if (ent != NULL)
 603                     addr = bfd_asymbol_value (ent->sym);
 604                 }
 605
 606               /* Adjust the section.  */
 607               if (addr != 0)
 608                 {
 609                   CORE_ADDR res = addr - sym->value;
 610
 611                   if (mach_o_debug_level > 3)
 612                     {
 613                       struct gdbarch *arch = get_objfile_arch (main_objfile);
 614                       printf_unfiltered
 615                         (_("resolve sect %s with %s (set to %s)\n"),
 616                          sec->name, sym->name,
 617                          paddress (arch, res));
 618                     }
 619                   bfd_set_section_vma (abfd, sec, res);
 620                   sections_rebased[sec->index] = 1;
 621                 }
 622             }
 623           else
 624             {
 625               /* Mark the section as never rebased.  */
 626               sections_rebased[sec->index] = 2;
 627             }
 628         }
 629     }
 630
 631   bfd_hash_table_free (&table);
 632
 633   /* We need to clear SYMFILE_MAINLINE to avoid interractive question
 634      from symfile.c:symbol_file_add_with_addrs_or_offsets.  */
 635   cleanup = make_cleanup_bfd_unref (abfd);
 636   symbol_file_add_from_bfd
 637     (abfd, symfile_flags & ~(SYMFILE_MAINLINE | SYMFILE_VERBOSE), NULL,
 638      main_objfile->flags & (OBJF_REORDERED | OBJF_SHARED
 639                             | OBJF_READNOW | OBJF_USERLOADED),
 640      main_objfile);
 641   do_cleanups (cleanup);
 642 }
 643
 644 /* Read symbols from the vector of oso files.  */
 645
 646 static void
 647 macho_symfile_read_all_oso (struct objfile *main_objfile, int symfile_flags)
 648 {
 649   int ix;
 650   VEC (oso_el) *vec;
 651   oso_el *oso;
 652   struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
 653
 654   vec = oso_vector;
 655   oso_vector = NULL;
 656
 657   /* Sort oso by name so that files from libraries are gathered.  */
 658   qsort (VEC_address (oso_el, vec), VEC_length (oso_el, vec),
 659          sizeof (oso_el), oso_el_compare_name);
 660
 661   for (ix = 0; VEC_iterate (oso_el, vec, ix, oso);)
 662     {
 663       int pfx_len;
 664
 665       /* Check if this is a library name.  */
 666       pfx_len = get_archive_prefix_len (oso->name);
 667       if (pfx_len > 0)
 668         {
 669           bfd *archive_bfd;
 670           bfd *member_bfd;
 671           char *archive_name = XNEWVEC (char, pfx_len + 1);
 672           int last_ix;
 673           oso_el *oso2;
 674           int ix2;
 675
 676           memcpy (archive_name, oso->name, pfx_len);
 677           archive_name[pfx_len] = '\0';
 678
 679           make_cleanup (xfree, archive_name);
 680
 681           /* Compute number of oso for this archive.  */
 682           for (last_ix = ix;
 683                VEC_iterate (oso_el, vec, last_ix, oso2); last_ix++)
 684             {
 685               if (strncmp (oso2->name, archive_name, pfx_len) != 0)
 686                 break;
 687             }
 688
 689           /* Open the archive and check the format.  */
 690           archive_bfd = gdb_bfd_open (archive_name, gnutarget, -1);
 691           if (archive_bfd == NULL)
 692             {
 693               warning (_("Could not open OSO archive file \"%s\""),
 694                        archive_name);
 695               ix = last_ix;
 696               continue;
 697             }
 698           if (!bfd_check_format (archive_bfd, bfd_archive))
 699             {
 700               warning (_("OSO archive file \"%s\" not an archive."),
 701                        archive_name);
 702               gdb_bfd_unref (archive_bfd);
 703               ix = last_ix;
 704               continue;
 705             }
 706
 707           member_bfd = gdb_bfd_openr_next_archived_file (archive_bfd, NULL);
 708
 709           if (member_bfd == NULL)
 710             {
 711               warning (_("Could not read archive members out of "
 712                          "OSO archive \"%s\""), archive_name);
 713               gdb_bfd_unref (archive_bfd);
 714               ix = last_ix;
 715               continue;
 716             }
 717
 718           /* Load all oso in this library.  */
 719           while (member_bfd != NULL)
 720             {
 721               bfd *prev;
 722               const char *member_name = member_bfd->filename;
 723               int member_len = strlen (member_name);
 724
 725               /* If this member is referenced, add it as a symfile.  */
 726               for (ix2 = ix; ix2 < last_ix; ix2++)
 727                 {
 728                   oso2 = VEC_index (oso_el, vec, ix2);
 729
 730                   if (oso2->name
 731                       && strlen (oso2->name) == pfx_len + member_len + 2
 732                       && !memcmp (member_name, oso2->name + pfx_len + 1,
 733                                   member_len))
 734                     {
 735                       macho_add_oso_symfile (oso2, member_bfd,
 736                                              main_objfile, symfile_flags);
 737                       oso2->name = NULL;
 738                       break;
 739                     }
 740                 }
 741
 742               prev = member_bfd;
 743               member_bfd = gdb_bfd_openr_next_archived_file (archive_bfd,
 744                                                              member_bfd);
 745
 746               /* Free previous member if not referenced by an oso.  */
 747               if (ix2 >= last_ix)
 748                 gdb_bfd_unref (prev);
 749             }
 750           for (ix2 = ix; ix2 < last_ix; ix2++)
 751             {
 752               oso_el *oso2 = VEC_index (oso_el, vec, ix2);
 753
 754               if (oso2->name != NULL)
 755                 warning (_("Could not find specified archive member "
 756                            "for OSO name \"%s\""), oso->name);
 757             }
 758           ix = last_ix;
 759         }
 760       else
 761         {
 762           bfd *abfd;
 763
 764           abfd = gdb_bfd_open (oso->name, gnutarget, -1);
 765           if (!abfd)
 766             warning (_("`%s': can't open to read symbols: %s."), oso->name,
 767                      bfd_errmsg (bfd_get_error ()));
 768           else
 769             macho_add_oso_symfile (oso, abfd, main_objfile, symfile_flags);
 770
 771           ix++;
 772         }
 773     }
 774
 775   VEC_free (oso_el, vec);
 776   do_cleanups (cleanup);
 777 }
 778
 779 /* DSYM (debug symbols) files contain the debug info of an executable.
 780    This is a separate file created by dsymutil(1) and is similar to debug
 781    link feature on ELF.
 782    DSYM files are located in a subdirectory.  Append DSYM_SUFFIX to the
 783    executable name and the executable base name to get the DSYM file name.  */
 784 #define DSYM_SUFFIX ".dSYM/Contents/Resources/DWARF/"
 785
 786 /* Check if a dsym file exists for OBJFILE.  If so, returns a bfd for it.
 787    Return NULL if no valid dsym file is found.  */
 788
 789 static bfd *
 790 macho_check_dsym (struct objfile *objfile)
 791 {
 792   size_t name_len = strlen (objfile->name);
 793   size_t dsym_len = strlen (DSYM_SUFFIX);
 794   const char *base_name = lbasename (objfile->name);
 795   size_t base_len = strlen (base_name);
 796   char *dsym_filename = alloca (name_len + dsym_len + base_len + 1);
 797   bfd *dsym_bfd;
 798   bfd_mach_o_load_command *main_uuid;
 799   bfd_mach_o_load_command *dsym_uuid;
 800
 801   strcpy (dsym_filename, objfile->name);
 802   strcpy (dsym_filename + name_len, DSYM_SUFFIX);
 803   strcpy (dsym_filename + name_len + dsym_len, base_name);
 804
 805   if (access (dsym_filename, R_OK) != 0)
 806     return NULL;
 807
 808   if (bfd_mach_o_lookup_command (objfile->obfd,
 809                                  BFD_MACH_O_LC_UUID, &main_uuid) == 0)
 810     {
 811       warning (_("can't find UUID in %s"), objfile->name);
 812       return NULL;
 813     }
 814   dsym_bfd = gdb_bfd_openr (dsym_filename, gnutarget);
 815   if (dsym_bfd == NULL)
 816     {
 817       warning (_("can't open dsym file %s"), dsym_filename);
 818       return NULL;
 819     }
 820
 821   if (!bfd_check_format (dsym_bfd, bfd_object))
 822     {
 823       gdb_bfd_unref (dsym_bfd);
 824       warning (_("bad dsym file format: %s"), bfd_errmsg (bfd_get_error ()));
 825       return NULL;
 826     }
 827
 828   if (bfd_mach_o_lookup_command (dsym_bfd,
 829                                  BFD_MACH_O_LC_UUID, &dsym_uuid) == 0)
 830     {
 831       warning (_("can't find UUID in %s"), dsym_filename);
 832       gdb_bfd_unref (dsym_bfd);
 833       return NULL;
 834     }
 835   if (memcmp (dsym_uuid->command.uuid.uuid, main_uuid->command.uuid.uuid,
 836               sizeof (main_uuid->command.uuid.uuid)))
 837     {
 838       warning (_("dsym file UUID doesn't match the one in %s"), objfile->name);
 839       gdb_bfd_unref (dsym_bfd);
 840       return NULL;
 841     }
 842   return dsym_bfd;
 843 }
 844
 845 static void
 846 macho_symfile_read (struct objfile *objfile, int symfile_flags)
 847 {
 848   bfd *abfd = objfile->obfd;
 849   CORE_ADDR offset;
 850   long storage_needed;
 851   bfd *dsym_bfd;
 852
 853   /* Get symbols from the symbol table only if the file is an executable.
 854      The symbol table of object files is not relocated and is expected to
 855      be in the executable.  */
 856   if (bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC))
 857     {
 858       /* Process the normal symbol table first.  */
 859       storage_needed = bfd_get_symtab_upper_bound (objfile->obfd);
 860       if (storage_needed < 0)
 861         error (_("Can't read symbols from %s: %s"),
 862                bfd_get_filename (objfile->obfd),
 863                bfd_errmsg (bfd_get_error ()));
 864
 865       if (storage_needed > 0)
 866         {
 867           asymbol **symbol_table;
 868           long symcount;
 869           struct cleanup *back_to;
 870
 871           symbol_table = (asymbol **) xmalloc (storage_needed);
 872           make_cleanup (xfree, symbol_table);
 873
 874           init_minimal_symbol_collection ();
 875           back_to = make_cleanup_discard_minimal_symbols ();
 876
 877           symcount = bfd_canonicalize_symtab (objfile->obfd, symbol_table);
 878
 879           if (symcount < 0)
 880             error (_("Can't read symbols from %s: %s"),
 881                    bfd_get_filename (objfile->obfd),
 882                    bfd_errmsg (bfd_get_error ()));
 883
 884           macho_symtab_read (objfile, symcount, symbol_table);
 885
 886           install_minimal_symbols (objfile);
 887           do_cleanups (back_to);
 888         }
 889
 890       /* Try to read .eh_frame / .debug_frame.  */
 891       /* First, locate these sections.  We ignore the result status
 892          as it only checks for debug info.  */
 893       dwarf2_has_info (objfile, NULL);
 894       dwarf2_build_frame_info (objfile);
 895
 896       /* Check for DSYM file.  */
 897       dsym_bfd = macho_check_dsym (objfile);
 898       if (dsym_bfd != NULL)
 899         {
 900           int ix;
 901           oso_el *oso;
 902           struct bfd_section *asect, *dsect;
 903           struct cleanup *cleanup;
 904
 905           if (mach_o_debug_level > 0)
 906             printf_unfiltered (_("dsym file found\n"));
 907
 908           /* Remove oso.  They won't be used.  */
 909           VEC_free (oso_el, oso_vector);
 910           oso_vector = NULL;
 911
 912           /* Set dsym section size.  */
 913           for (asect = objfile->obfd->sections, dsect = dsym_bfd->sections;
 914                asect && dsect;
 915                asect = asect->next, dsect = dsect->next)
 916             {
 917               if (strcmp (asect->name, dsect->name) != 0)
 918                 break;
 919               bfd_set_section_size (dsym_bfd, dsect,
 920                                     bfd_get_section_size (asect));
 921             }
 922
 923           /* Add the dsym file as a separate file.  */
 924           cleanup = make_cleanup_bfd_unref (dsym_bfd);
 925           symbol_file_add_separate (dsym_bfd, symfile_flags, objfile);
 926           do_cleanups (cleanup);
 927
 928           /* Don't try to read dwarf2 from main file or shared libraries.  */
 929           return;
 930         }
 931     }
 932
 933   if (dwarf2_has_info (objfile, NULL))
 934     {
 935       /* DWARF 2 sections */
 936       dwarf2_build_psymtabs (objfile);
 937     }
 938
 939   /* Then the oso.  */
 940   if (oso_vector != NULL)
 941     macho_symfile_read_all_oso (objfile, symfile_flags);
 942 }
 943
 944 static bfd_byte *
 945 macho_symfile_relocate (struct objfile *objfile, asection *sectp,
 946                         bfd_byte *buf)
 947 {
 948   bfd *abfd = objfile->obfd;
 949
 950   /* We're only interested in sections with relocation
 951      information.  */
 952   if ((sectp->flags & SEC_RELOC) == 0)
 953     return NULL;
 954
 955   if (mach_o_debug_level > 0)
 956     printf_unfiltered (_("Relocate section '%s' of %s\n"),
 957                        sectp->name, objfile->name);
 958
 959   return bfd_simple_get_relocated_section_contents (abfd, sectp, buf, NULL);
 960 }
 961
 962 static void
 963 macho_symfile_finish (struct objfile *objfile)
 964 {
 965 }
 966
 967 static void
 968 macho_symfile_offsets (struct objfile *objfile,
 969                        struct section_addr_info *addrs)
 970 {
 971   unsigned int i;
 972   unsigned int num_sections;
 973   struct obj_section *osect;
 974
 975   /* Allocate section_offsets.  */
 976   objfile->num_sections = bfd_count_sections (objfile->obfd);
 977   objfile->section_offsets = (struct section_offsets *)
 978     obstack_alloc (&objfile->objfile_obstack,
 979                    SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));
 980   memset (objfile->section_offsets, 0,
 981           SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));
 982
 983   /* This code is run when we first add the objfile with
 984      symfile_add_with_addrs_or_offsets, when "addrs" not "offsets" are
 985      passed in.  The place in symfile.c where the addrs are applied
 986      depends on the addrs having section names.  But in the dyld code
 987      we build an anonymous array of addrs, so that code is a no-op.
 988      Because of that, we have to apply the addrs to the sections here.
 989      N.B. if an objfile slides after we've already created it, then it
 990      goes through objfile_relocate.  */
 991
 992   for (i = 0; i < addrs->num_sections; i++)
 993     {
 994       if (addrs->other[i].name == NULL)
 995         continue;
 996
 997       ALL_OBJFILE_OSECTIONS (objfile, osect)
 998         {
 999           const char *bfd_sect_name = osect->the_bfd_section->name;
1000
1001           if (strcmp (bfd_sect_name, addrs->other[i].name) == 0)
1002             {
1003               obj_section_offset (osect) = addrs->other[i].addr;
1004               break;
1005             }
1006         }
1007     }
1008
1009   objfile->sect_index_text = 0;
1010
1011   ALL_OBJFILE_OSECTIONS (objfile, osect)
1012     {
1013       const char *bfd_sect_name = osect->the_bfd_section->name;
1014       int sect_index = osect->the_bfd_section->index;
1015
1016       if (strncmp (bfd_sect_name, "LC_SEGMENT.", 11) == 0)
1017         bfd_sect_name += 11;
1018       if (strcmp (bfd_sect_name, "__TEXT") == 0
1019           || strcmp (bfd_sect_name, "__TEXT.__text") == 0)
1020         objfile->sect_index_text = sect_index;
1021     }
1022 }
1023
1024 static const struct sym_fns macho_sym_fns = {
1025   bfd_target_mach_o_flavour,
1026
1027   macho_new_init,               /* init anything gbl to entire symtab */
1028   macho_symfile_init,           /* read initial info, setup for sym_read() */
1029   macho_symfile_read,           /* read a symbol file into symtab */
1030   NULL,                         /* sym_read_psymbols */
1031   macho_symfile_finish,         /* finished with file, cleanup */
1032   macho_symfile_offsets,        /* xlate external to internal form */
1033   default_symfile_segments,     /* Get segment information from a file.  */
1034   NULL,
1035   macho_symfile_relocate,       /* Relocate a debug section.  */
1036   NULL,                         /* sym_get_probes */
1037   &psym_functions
1038 };
1039
1040 /* -Wmissing-prototypes */
1041 extern initialize_file_ftype _initialize_machoread;
1042
1043 void
1044 _initialize_machoread ()
1045 {
1046   add_symtab_fns (&macho_sym_fns);
1047
1048   add_setshow_zuinteger_cmd ("mach-o", class_obscure,
1049                              &mach_o_debug_level,
1050                              _("Set if printing Mach-O symbols processing."),
1051                              _("Show if printing Mach-O symbols processing."),
1052                              NULL, NULL, NULL,
1053                              &setdebuglist, &showdebuglist);
1054 }