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 (objfile));
 243             }
 244           else
 245             {
 246               /* Non-debugging symbols go to the minimal symbol table.  */
 247               macho_symtab_add_minsym (objfile, sym);
 248             }
 249           break;
 250
 251         case S_FIRST_SO:
 252         case S_SECOND_SO:
 253           if (mach_o_sym->n_type == N_SO)
 254             {
 255               if (sym->name == NULL || sym->name[0] == 0)
 256                 {
 257                   /* Unexpected empty N_SO.  */
 258                   complaint (&symfile_complaints, _("Empty SO section"));
 259                   state = S_NO_SO;
 260                 }
 261               else if (state == S_FIRST_SO)
 262                 {
 263                   /* Second SO stab for the file name.  */
 264                   dir_so = file_so;
 265                   file_so = sym;
 266                   state = S_SECOND_SO;
 267                 }
 268               else
 269                 complaint (&symfile_complaints, _("Three SO in a raw"));
 270             }
 271           else if (mach_o_sym->n_type == N_OSO)
 272             {
 273               if (sym->name == NULL || sym->name[0] == 0)
 274                 {
 275                   /* Empty OSO.  Means that this file was compiled with
 276                      stabs.  */
 277                   state = S_STAB_FILE;
 278                   warning (_("stabs debugging not supported for %s"),
 279                            file_so->name);
 280                 }
 281               else
 282                 {
 283                   /* Non-empty OSO for a Dwarf file.  */
 284                   oso_file = symbol_table + i;
 285                   nbr_syms = 0;
 286                   state = S_DWARF_FILE;
 287                 }
 288             }
 289           else
 290             complaint (&symfile_complaints,
 291                        _("Unexpected stab after SO"));
 292           break;
 293
 294         case S_STAB_FILE:
 295         case S_DWARF_FILE:
 296           if (mach_o_sym->n_type == N_SO)
 297             {
 298               if (sym->name == NULL || sym->name[0] == 0)
 299                 {
 300                   /* End of file.  */
 301                   if (state == S_DWARF_FILE)
 302                     macho_register_oso (oso_vector_ptr, objfile,
 303                                         oso_file, symbol_table + i,
 304                                         nbr_syms);
 305                   state = S_NO_SO;
 306                 }
 307               else
 308                 {
 309                   complaint (&symfile_complaints, _("Missing nul SO"));
 310                   file_so = sym;
 311                   dir_so = NULL;
 312                   state = S_FIRST_SO;
 313                 }
 314             }
 315           else if (sym->flags & BSF_DEBUGGING)
 316             {
 317               if (state == S_STAB_FILE)
 318                 {
 319                   /* FIXME: to be implemented.  */
 320                 }
 321               else
 322                 {
 323                   switch (mach_o_sym->n_type)
 324                     {
 325                     case N_FUN:
 326                       if (sym->name == NULL || sym->name[0] == 0)
 327                         break;
 328                       /* Fall through.  */
 329                     case N_STSYM:
 330                       /* Interesting symbol.  */
 331                       nbr_syms++;
 332                       break;
 333                     case N_ENSYM:
 334                     case N_BNSYM:
 335                     case N_GSYM:
 336                       break;
 337                     default:
 338                       complaint (&symfile_complaints,
 339                                  _("unhandled stab for dwarf OSO file"));
 340                       break;
 341                     }
 342                 }
 343             }
 344           else
 345             complaint (&symfile_complaints,
 346                        _("non-debugging symbol within SO"));
 347           break;
 348         }
 349     }
 350
 351   if (state != S_NO_SO)
 352     complaint (&symfile_complaints, _("missing nul SO"));
 353 }
 354
 355 /* If NAME describes an archive member (ie: ARCHIVE '(' MEMBER ')'),
 356    returns the length of the archive name.
 357    Returns -1 otherwise.  */
 358
 359 static int
 360 get_archive_prefix_len (const char *name)
 361 {
 362   char *lparen;
 363   int name_len = strlen (name);
 364
 365   if (name_len == 0 || name[name_len - 1] != ')')
 366     return -1;
 367
 368   lparen = strrchr (name, '(');
 369   if (lparen == NULL || lparen == name)
 370     return -1;
 371   return lparen - name;
 372 }
 373
 374 /* Compare function to qsort OSOs, so that members of a library are
 375    gathered.  */
 376
 377 static int
 378 oso_el_compare_name (const void *vl, const void *vr)
 379 {
 380   const oso_el *l = (const oso_el *)vl;
 381   const oso_el *r = (const oso_el *)vr;
 382
 383   return strcmp (l->name, r->name);
 384 }
 385
 386 /* Hash table entry structure for the stabs symbols in the main object file.
 387    This is used to speed up lookup for symbols in the OSO.  */
 388
 389 struct macho_sym_hash_entry
 390 {
 391   struct bfd_hash_entry base;
 392   const asymbol *sym;
 393 };
 394
 395 /* Routine to create an entry in the hash table.  */
 396
 397 static struct bfd_hash_entry *
 398 macho_sym_hash_newfunc (struct bfd_hash_entry *entry,
 399                         struct bfd_hash_table *table,
 400                         const char *string)
 401 {
 402   struct macho_sym_hash_entry *ret = (struct macho_sym_hash_entry *) entry;
 403
 404   /* Allocate the structure if it has not already been allocated by a
 405      subclass.  */
 406   if (ret == NULL)
 407     ret = (struct macho_sym_hash_entry *) bfd_hash_allocate (table,
 408                                                              sizeof (* ret));
 409   if (ret == NULL)
 410     return NULL;
 411
 412   /* Call the allocation method of the superclass.  */
 413   ret = (struct macho_sym_hash_entry *)
 414          bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string);
 415
 416   if (ret)
 417     {
 418       /* Initialize the local fields.  */
 419       ret->sym = NULL;
 420     }
 421
 422   return (struct bfd_hash_entry *) ret;
 423 }
 424
 425 /* Get the value of SYM from the minimal symtab of MAIN_OBJFILE.  This is used
 426    to get the value of global and common symbols.  */
 427
 428 static CORE_ADDR
 429 macho_resolve_oso_sym_with_minsym (struct objfile *main_objfile, asymbol *sym)
 430 {
 431   /* For common symbol and global symbols, use the min symtab.  */
 432   struct 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 (objfile));
 795   size_t dsym_len = strlen (DSYM_SUFFIX);
 796   const char *base_name = lbasename (objfile_name (objfile));
 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 (objfile));
 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 (objfile));
 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"),
 841                objfile_name (objfile));
 842       gdb_bfd_unref (dsym_bfd);
 843       return NULL;
 844     }
 845   return dsym_bfd;
 846 }
 847
 848 static void
 849 macho_symfile_read (struct objfile *objfile, int symfile_flags)
 850 {
 851   bfd *abfd = objfile->obfd;
 852   CORE_ADDR offset;
 853   long storage_needed;
 854   bfd *dsym_bfd;
 855   VEC (oso_el) *oso_vector = NULL;
 856   struct cleanup *old_chain = make_cleanup (VEC_cleanup (oso_el), &oso_vector);
 857
 858   /* Get symbols from the symbol table only if the file is an executable.
 859      The symbol table of object files is not relocated and is expected to
 860      be in the executable.  */
 861   if (bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC))
 862     {
 863       /* Process the normal symbol table first.  */
 864       storage_needed = bfd_get_symtab_upper_bound (objfile->obfd);
 865       if (storage_needed < 0)
 866         error (_("Can't read symbols from %s: %s"),
 867                bfd_get_filename (objfile->obfd),
 868                bfd_errmsg (bfd_get_error ()));
 869
 870       if (storage_needed > 0)
 871         {
 872           asymbol **symbol_table;
 873           long symcount;
 874
 875           symbol_table = (asymbol **) xmalloc (storage_needed);
 876           make_cleanup (xfree, symbol_table);
 877
 878           init_minimal_symbol_collection ();
 879           make_cleanup_discard_minimal_symbols ();
 880
 881           symcount = bfd_canonicalize_symtab (objfile->obfd, symbol_table);
 882
 883           if (symcount < 0)
 884             error (_("Can't read symbols from %s: %s"),
 885                    bfd_get_filename (objfile->obfd),
 886                    bfd_errmsg (bfd_get_error ()));
 887
 888           macho_symtab_read (objfile, symcount, symbol_table, &oso_vector);
 889
 890           install_minimal_symbols (objfile);
 891         }
 892
 893       /* Try to read .eh_frame / .debug_frame.  */
 894       /* First, locate these sections.  We ignore the result status
 895          as it only checks for debug info.  */
 896       dwarf2_has_info (objfile, NULL);
 897       dwarf2_build_frame_info (objfile);
 898
 899       /* Check for DSYM file.  */
 900       dsym_bfd = macho_check_dsym (objfile);
 901       if (dsym_bfd != NULL)
 902         {
 903           int ix;
 904           oso_el *oso;
 905           struct bfd_section *asect, *dsect;
 906
 907           if (mach_o_debug_level > 0)
 908             printf_unfiltered (_("dsym file found\n"));
 909
 910           /* Set dsym section size.  */
 911           for (asect = objfile->obfd->sections, dsect = dsym_bfd->sections;
 912                asect && dsect;
 913                asect = asect->next, dsect = dsect->next)
 914             {
 915               if (strcmp (asect->name, dsect->name) != 0)
 916                 break;
 917               bfd_set_section_size (dsym_bfd, dsect,
 918                                     bfd_get_section_size (asect));
 919             }
 920
 921           /* Add the dsym file as a separate file.  */
 922           make_cleanup_bfd_unref (dsym_bfd);
 923           symbol_file_add_separate (dsym_bfd, symfile_flags, objfile);
 924
 925           /* Don't try to read dwarf2 from main file or shared libraries.  */
 926           do_cleanups (old_chain);
 927           return;
 928         }
 929     }
 930
 931   if (dwarf2_has_info (objfile, NULL))
 932     {
 933       /* DWARF 2 sections */
 934       dwarf2_build_psymtabs (objfile);
 935     }
 936
 937   /* Then the oso.  */
 938   if (oso_vector != NULL)
 939     macho_symfile_read_all_oso (&oso_vector, objfile, symfile_flags);
 940
 941   do_cleanups (old_chain);
 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 (objfile));
 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                        const 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       ALL_OBJFILE_OSECTIONS (objfile, osect)
 995         {
 996           const char *bfd_sect_name = osect->the_bfd_section->name;
 997
 998           if (strcmp (bfd_sect_name, addrs->other[i].name) == 0)
 999             {
1000               obj_section_offset (osect) = addrs->other[i].addr;
1001               break;
1002             }
1003         }
1004     }
1005
1006   objfile->sect_index_text = 0;
1007
1008   ALL_OBJFILE_OSECTIONS (objfile, osect)
1009     {
1010       const char *bfd_sect_name = osect->the_bfd_section->name;
1011       int sect_index = osect - objfile->sections;;
1012
1013       if (strncmp (bfd_sect_name, "LC_SEGMENT.", 11) == 0)
1014         bfd_sect_name += 11;
1015       if (strcmp (bfd_sect_name, "__TEXT") == 0
1016           || strcmp (bfd_sect_name, "__TEXT.__text") == 0)
1017         objfile->sect_index_text = sect_index;
1018     }
1019 }
1020
1021 static const struct sym_fns macho_sym_fns = {
1022   bfd_target_mach_o_flavour,
1023
1024   macho_new_init,               /* init anything gbl to entire symtab */
1025   macho_symfile_init,           /* read initial info, setup for sym_read() */
1026   macho_symfile_read,           /* read a symbol file into symtab */
1027   NULL,                         /* sym_read_psymbols */
1028   macho_symfile_finish,         /* finished with file, cleanup */
1029   macho_symfile_offsets,        /* xlate external to internal form */
1030   default_symfile_segments,     /* Get segment information from a file.  */
1031   NULL,
1032   macho_symfile_relocate,       /* Relocate a debug section.  */
1033   NULL,                         /* sym_get_probes */
1034   &psym_functions
1035 };
1036
1037 /* -Wmissing-prototypes */
1038 extern initialize_file_ftype _initialize_machoread;
1039
1040 void
1041 _initialize_machoread (void)
1042 {
1043   add_symtab_fns (&macho_sym_fns);
1044
1045   add_setshow_zuinteger_cmd ("mach-o", class_obscure,
1046                              &mach_o_debug_level,
1047                              _("Set if printing Mach-O symbols processing."),
1048                              _("Show if printing Mach-O symbols processing."),
1049                              NULL, NULL, NULL,
1050                              &setdebuglist, &showdebuglist);
1051 }