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 #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);
 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 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 == NULL)
 439     {
 440       warning (_("can't find symbol '%s' in minsymtab"), name);
 441       return 0;
 442     }
 443   else
 444     return SYMBOL_VALUE_ADDRESS (msym);
 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,
 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, 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                                              main_objfile, symfile_flags);
 740                       oso2->name = NULL;
 741                       break;
 742                     }
 743                 }
 744
 745               prev = member_bfd;
 746               member_bfd = gdb_bfd_openr_next_archived_file (archive_bfd,
 747                                                              member_bfd);
 748
 749               /* Free previous member if not referenced by an oso.  */
 750               if (ix2 >= last_ix)
 751                 gdb_bfd_unref (prev);
 752             }
 753           for (ix2 = ix; ix2 < last_ix; ix2++)
 754             {
 755               oso_el *oso2 = VEC_index (oso_el, vec, ix2);
 756
 757               if (oso2->name != NULL)
 758                 warning (_("Could not find specified archive member "
 759                            "for OSO name \"%s\""), oso->name);
 760             }
 761           ix = last_ix;
 762         }
 763       else
 764         {
 765           bfd *abfd;
 766
 767           abfd = gdb_bfd_open (oso->name, gnutarget, -1);
 768           if (!abfd)
 769             warning (_("`%s': can't open to read symbols: %s."), oso->name,
 770                      bfd_errmsg (bfd_get_error ()));
 771           else
 772             macho_add_oso_symfile (oso, abfd, main_objfile, symfile_flags);
 773
 774           ix++;
 775         }
 776     }
 777
 778   do_cleanups (cleanup);
 779 }
 780
 781 /* DSYM (debug symbols) files contain the debug info of an executable.
 782    This is a separate file created by dsymutil(1) and is similar to debug
 783    link feature on ELF.
 784    DSYM files are located in a subdirectory.  Append DSYM_SUFFIX to the
 785    executable name and the executable base name to get the DSYM file name.  */
 786 #define DSYM_SUFFIX ".dSYM/Contents/Resources/DWARF/"
 787
 788 /* Check if a dsym file exists for OBJFILE.  If so, returns a bfd for it.
 789    Return NULL if no valid dsym file is found.  */
 790
 791 static bfd *
 792 macho_check_dsym (struct objfile *objfile)
 793 {
 794   size_t name_len = strlen (objfile->name);
 795   size_t dsym_len = strlen (DSYM_SUFFIX);
 796   const char *base_name = lbasename (objfile->name);
 797   size_t base_len = strlen (base_name);
 798   char *dsym_filename = alloca (name_len + dsym_len + base_len + 1);
 799   bfd *dsym_bfd;
 800   bfd_mach_o_load_command *main_uuid;
 801   bfd_mach_o_load_command *dsym_uuid;
 802
 803   strcpy (dsym_filename, objfile->name);
 804   strcpy (dsym_filename + name_len, DSYM_SUFFIX);
 805   strcpy (dsym_filename + name_len + dsym_len, base_name);
 806
 807   if (access (dsym_filename, R_OK) != 0)
 808     return NULL;
 809
 810   if (bfd_mach_o_lookup_command (objfile->obfd,
 811                                  BFD_MACH_O_LC_UUID, &main_uuid) == 0)
 812     {
 813       warning (_("can't find UUID in %s"), objfile->name);
 814       return NULL;
 815     }
 816   dsym_bfd = gdb_bfd_openr (dsym_filename, gnutarget);
 817   if (dsym_bfd == NULL)
 818     {
 819       warning (_("can't open dsym file %s"), dsym_filename);
 820       return NULL;
 821     }
 822
 823   if (!bfd_check_format (dsym_bfd, bfd_object))
 824     {
 825       gdb_bfd_unref (dsym_bfd);
 826       warning (_("bad dsym file format: %s"), bfd_errmsg (bfd_get_error ()));
 827       return NULL;
 828     }
 829
 830   if (bfd_mach_o_lookup_command (dsym_bfd,
 831                                  BFD_MACH_O_LC_UUID, &dsym_uuid) == 0)
 832     {
 833       warning (_("can't find UUID in %s"), dsym_filename);
 834       gdb_bfd_unref (dsym_bfd);
 835       return NULL;
 836     }
 837   if (memcmp (dsym_uuid->command.uuid.uuid, main_uuid->command.uuid.uuid,
 838               sizeof (main_uuid->command.uuid.uuid)))
 839     {
 840       warning (_("dsym file UUID doesn't match the one in %s"), objfile->name);
 841       gdb_bfd_unref (dsym_bfd);
 842       return NULL;
 843     }
 844   return dsym_bfd;
 845 }
 846
 847 static void
 848 macho_symfile_read (struct objfile *objfile, int symfile_flags)
 849 {
 850   bfd *abfd = objfile->obfd;
 851   CORE_ADDR offset;
 852   long storage_needed;
 853   bfd *dsym_bfd;
 854   VEC (oso_el) *oso_vector = NULL;
 855   struct cleanup *old_chain = make_cleanup (VEC_cleanup (oso_el), &oso_vector);
 856
 857   /* Get symbols from the symbol table only if the file is an executable.
 858      The symbol table of object files is not relocated and is expected to
 859      be in the executable.  */
 860   if (bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC))
 861     {
 862       /* Process the normal symbol table first.  */
 863       storage_needed = bfd_get_symtab_upper_bound (objfile->obfd);
 864       if (storage_needed < 0)
 865         error (_("Can't read symbols from %s: %s"),
 866                bfd_get_filename (objfile->obfd),
 867                bfd_errmsg (bfd_get_error ()));
 868
 869       if (storage_needed > 0)
 870         {
 871           asymbol **symbol_table;
 872           long symcount;
 873
 874           symbol_table = (asymbol **) xmalloc (storage_needed);
 875           make_cleanup (xfree, symbol_table);
 876
 877           init_minimal_symbol_collection ();
 878           make_cleanup_discard_minimal_symbols ();
 879
 880           symcount = bfd_canonicalize_symtab (objfile->obfd, symbol_table);
 881
 882           if (symcount < 0)
 883             error (_("Can't read symbols from %s: %s"),
 884                    bfd_get_filename (objfile->obfd),
 885                    bfd_errmsg (bfd_get_error ()));
 886
 887           macho_symtab_read (objfile, symcount, symbol_table, &oso_vector);
 888
 889           install_minimal_symbols (objfile);
 890         }
 891
 892       /* Try to read .eh_frame / .debug_frame.  */
 893       /* First, locate these sections.  We ignore the result status
 894          as it only checks for debug info.  */
 895       dwarf2_has_info (objfile, NULL);
 896       dwarf2_build_frame_info (objfile);
 897
 898       /* Check for DSYM file.  */
 899       dsym_bfd = macho_check_dsym (objfile);
 900       if (dsym_bfd != NULL)
 901         {
 902           int ix;
 903           oso_el *oso;
 904           struct bfd_section *asect, *dsect;
 905
 906           if (mach_o_debug_level > 0)
 907             printf_unfiltered (_("dsym file found\n"));
 908
 909           /* Set dsym section size.  */
 910           for (asect = objfile->obfd->sections, dsect = dsym_bfd->sections;
 911                asect && dsect;
 912                asect = asect->next, dsect = dsect->next)
 913             {
 914               if (strcmp (asect->name, dsect->name) != 0)
 915                 break;
 916               bfd_set_section_size (dsym_bfd, dsect,
 917                                     bfd_get_section_size (asect));
 918             }
 919
 920           /* Add the dsym file as a separate file.  */
 921           make_cleanup_bfd_unref (dsym_bfd);
 922           symbol_file_add_separate (dsym_bfd, symfile_flags, objfile);
 923
 924           /* Don't try to read dwarf2 from main file or shared libraries.  */
 925           do_cleanups (old_chain);
 926           return;
 927         }
 928     }
 929
 930   if (dwarf2_has_info (objfile, NULL))
 931     {
 932       /* DWARF 2 sections */
 933       dwarf2_build_psymtabs (objfile);
 934     }
 935
 936   /* Then the oso.  */
 937   if (oso_vector != NULL)
 938     macho_symfile_read_all_oso (&oso_vector, objfile, symfile_flags);
 939
 940   do_cleanups (old_chain);
 941 }
 942
 943 static bfd_byte *
 944 macho_symfile_relocate (struct objfile *objfile, asection *sectp,
 945                         bfd_byte *buf)
 946 {
 947   bfd *abfd = objfile->obfd;
 948
 949   /* We're only interested in sections with relocation
 950      information.  */
 951   if ((sectp->flags & SEC_RELOC) == 0)
 952     return NULL;
 953
 954   if (mach_o_debug_level > 0)
 955     printf_unfiltered (_("Relocate section '%s' of %s\n"),
 956                        sectp->name, objfile->name);
 957
 958   return bfd_simple_get_relocated_section_contents (abfd, sectp, buf, NULL);
 959 }
 960
 961 static void
 962 macho_symfile_finish (struct objfile *objfile)
 963 {
 964 }
 965
 966 static void
 967 macho_symfile_offsets (struct objfile *objfile,
 968                        const struct section_addr_info *addrs)
 969 {
 970   unsigned int i;
 971   unsigned int num_sections;
 972   struct obj_section *osect;
 973
 974   /* Allocate section_offsets.  */
 975   objfile->num_sections = bfd_count_sections (objfile->obfd);
 976   objfile->section_offsets = (struct section_offsets *)
 977     obstack_alloc (&objfile->objfile_obstack,
 978                    SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));
 979   memset (objfile->section_offsets, 0,
 980           SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));
 981
 982   /* This code is run when we first add the objfile with
 983      symfile_add_with_addrs_or_offsets, when "addrs" not "offsets" are
 984      passed in.  The place in symfile.c where the addrs are applied
 985      depends on the addrs having section names.  But in the dyld code
 986      we build an anonymous array of addrs, so that code is a no-op.
 987      Because of that, we have to apply the addrs to the sections here.
 988      N.B. if an objfile slides after we've already created it, then it
 989      goes through objfile_relocate.  */
 990
 991   for (i = 0; i < addrs->num_sections; i++)
 992     {
 993       ALL_OBJFILE_OSECTIONS (objfile, osect)
 994         {
 995           const char *bfd_sect_name = osect->the_bfd_section->name;
 996
 997           if (strcmp (bfd_sect_name, addrs->other[i].name) == 0)
 998             {
 999               obj_section_offset (osect) = addrs->other[i].addr;
1000               break;
1001             }
1002         }
1003     }
1004
1005   objfile->sect_index_text = 0;
1006
1007   ALL_OBJFILE_OSECTIONS (objfile, osect)
1008     {
1009       const char *bfd_sect_name = osect->the_bfd_section->name;
1010       int sect_index = osect - objfile->sections;;
1011
1012       if (strncmp (bfd_sect_name, "LC_SEGMENT.", 11) == 0)
1013         bfd_sect_name += 11;
1014       if (strcmp (bfd_sect_name, "__TEXT") == 0
1015           || strcmp (bfd_sect_name, "__TEXT.__text") == 0)
1016         objfile->sect_index_text = sect_index;
1017     }
1018 }
1019
1020 static const struct sym_fns macho_sym_fns = {
1021   bfd_target_mach_o_flavour,
1022
1023   macho_new_init,               /* init anything gbl to entire symtab */
1024   macho_symfile_init,           /* read initial info, setup for sym_read() */
1025   macho_symfile_read,           /* read a symbol file into symtab */
1026   NULL,                         /* sym_read_psymbols */
1027   macho_symfile_finish,         /* finished with file, cleanup */
1028   macho_symfile_offsets,        /* xlate external to internal form */
1029   default_symfile_segments,     /* Get segment information from a file.  */
1030   NULL,
1031   macho_symfile_relocate,       /* Relocate a debug section.  */
1032   NULL,                         /* sym_get_probes */
1033   &psym_functions
1034 };
1035
1036 /* -Wmissing-prototypes */
1037 extern initialize_file_ftype _initialize_machoread;
1038
1039 void
1040 _initialize_machoread (void)
1041 {
1042   add_symtab_fns (&macho_sym_fns);
1043
1044   add_setshow_zuinteger_cmd ("mach-o", class_obscure,
1045                              &mach_o_debug_level,
1046                              _("Set if printing Mach-O symbols processing."),
1047                              _("Show if printing Mach-O symbols processing."),
1048                              NULL, NULL, NULL,
1049                              &setdebuglist, &showdebuglist);
1050 }