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,
 120                          gdb_bfd_section_index (objfile->obfd, sym->section));
 121
 122       /* Bfd symbols are section relative.  */
 123       symaddr = sym->value + sym->section->vma;
 124
 125       /* Select global/local/weak symbols.  Note that bfd puts abs
 126          symbols in their own section, so all symbols we are
 127          interested in will have a section.  */
 128       /* Relocate all non-absolute and non-TLS symbols by the
 129          section offset.  */
 130       if (sym->section != bfd_abs_section_ptr
 131           && !(sym->section->flags & SEC_THREAD_LOCAL))
 132         symaddr += offset;
 133
 134       if (sym->section == bfd_abs_section_ptr)
 135         ms_type = mst_abs;
 136       else if (sym->section->flags & SEC_CODE)
 137         {
 138           if (sym->flags & (BSF_GLOBAL | BSF_WEAK))
 139             ms_type = mst_text;
 140           else
 141             ms_type = mst_file_text;
 142         }
 143       else if (sym->section->flags & SEC_ALLOC)
 144         {
 145           if (sym->flags & (BSF_GLOBAL | BSF_WEAK))
 146             {
 147               if (sym->section->flags & SEC_LOAD)
 148                 ms_type = mst_data;
 149               else
 150                 ms_type = mst_bss;
 151             }
 152           else if (sym->flags & BSF_LOCAL)
 153             {
 154               /* Not a special stabs-in-elf symbol, do regular
 155                  symbol processing.  */
 156               if (sym->section->flags & SEC_LOAD)
 157                 ms_type = mst_file_data;
 158               else
 159                 ms_type = mst_file_bss;
 160             }
 161           else
 162             ms_type = mst_unknown;
 163         }
 164       else
 165         return; /* Skip this symbol.  */
 166
 167       prim_record_minimal_symbol_and_info
 168         (sym->name, symaddr, ms_type,
 169          gdb_bfd_section_index (objfile->obfd, sym->section),
 170          objfile);
 171     }
 172 }
 173
 174 /* Build the minimal symbol table from SYMBOL_TABLE of length
 175    NUMBER_OF_SYMBOLS for OBJFILE.  Registers OSO filenames found.  */
 176
 177 static void
 178 macho_symtab_read (struct objfile *objfile,
 179                    long number_of_symbols, asymbol **symbol_table)
 180 {
 181   long i;
 182   const asymbol *dir_so = NULL;
 183   const asymbol *file_so = NULL;
 184   asymbol **oso_file = NULL;
 185   unsigned int nbr_syms = 0;
 186
 187   /* Current state while reading stabs.  */
 188   enum
 189   {
 190     /* Not within an SO part.  Only non-debugging symbols should be present,
 191        and will be added to the minimal symbols table.  */
 192     S_NO_SO,
 193
 194     /* First SO read.  Introduce an SO section, and may be followed by a second
 195        SO.  The SO section should contain onl debugging symbols.  */
 196     S_FIRST_SO,
 197
 198     /* Second non-null SO found, just after the first one.  Means that the first
 199        is in fact a directory name.  */
 200     S_SECOND_SO,
 201
 202     /* Non-null OSO found.  Debugging info are DWARF in this OSO file.  */
 203     S_DWARF_FILE,
 204
 205     S_STAB_FILE
 206   } state = S_NO_SO;
 207
 208   for (i = 0; i < number_of_symbols; i++)
 209     {
 210       const asymbol *sym = symbol_table[i];
 211       bfd_mach_o_asymbol *mach_o_sym = (bfd_mach_o_asymbol *)sym;
 212
 213       switch (state)
 214         {
 215         case S_NO_SO:
 216           if (mach_o_sym->n_type == N_SO)
 217             {
 218               /* Start of object stab.  */
 219               if (sym->name == NULL || sym->name[0] == 0)
 220                 {
 221                   /* Unexpected empty N_SO.  */
 222                   complaint (&symfile_complaints,
 223                              _("Unexpected empty N_SO stab"));
 224                 }
 225               else
 226                 {
 227                   file_so = sym;
 228                   dir_so = NULL;
 229                   state = S_FIRST_SO;
 230                 }
 231             }
 232           else if (sym->flags & BSF_DEBUGGING)
 233             {
 234               if (mach_o_sym->n_type == N_OPT)
 235                 {
 236                   /* No complaint for OPT.  */
 237                   break;
 238                 }
 239
 240               /* Debugging symbols are not expected here.  */
 241               complaint (&symfile_complaints,
 242                          _("%s: Unexpected debug stab outside SO markers"),
 243                          objfile->name);
 244             }
 245           else
 246             {
 247               /* Non-debugging symbols go to the minimal symbol table.  */
 248               macho_symtab_add_minsym (objfile, sym);
 249             }
 250           break;
 251
 252         case S_FIRST_SO:
 253         case S_SECOND_SO:
 254           if (mach_o_sym->n_type == N_SO)
 255             {
 256               if (sym->name == NULL || sym->name[0] == 0)
 257                 {
 258                   /* Unexpected empty N_SO.  */
 259                   complaint (&symfile_complaints, _("Empty SO section"));
 260                   state = S_NO_SO;
 261                 }
 262               else if (state == S_FIRST_SO)
 263                 {
 264                   /* Second SO stab for the file name.  */
 265                   dir_so = file_so;
 266                   file_so = sym;
 267                   state = S_SECOND_SO;
 268                 }
 269               else
 270                 complaint (&symfile_complaints, _("Three SO in a raw"));
 271             }
 272           else if (mach_o_sym->n_type == N_OSO)
 273             {
 274               if (sym->name == NULL || sym->name[0] == 0)
 275                 {
 276                   /* Empty OSO.  Means that this file was compiled with
 277                      stabs.  */
 278                   state = S_STAB_FILE;
 279                   warning (_("stabs debugging not supported for %s"),
 280                            file_so->name);
 281                 }
 282               else
 283                 {
 284                   /* Non-empty OSO for a Dwarf file.  */
 285                   oso_file = symbol_table + i;
 286                   nbr_syms = 0;
 287                   state = S_DWARF_FILE;
 288                 }
 289             }
 290           else
 291             complaint (&symfile_complaints,
 292                        _("Unexpected stab after SO"));
 293           break;
 294
 295         case S_STAB_FILE:
 296         case S_DWARF_FILE:
 297           if (mach_o_sym->n_type == N_SO)
 298             {
 299               if (sym->name == NULL || sym->name[0] == 0)
 300                 {
 301                   /* End of file.  */
 302                   if (state == S_DWARF_FILE)
 303                     macho_register_oso (objfile, 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 static void
 649 macho_symfile_read_all_oso (struct objfile *main_objfile, int symfile_flags)
 650 {
 651   int ix;
 652   VEC (oso_el) *vec;
 653   oso_el *oso;
 654   struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
 655
 656   vec = oso_vector;
 657   oso_vector = NULL;
 658
 659   /* Sort oso by name so that files from libraries are gathered.  */
 660   qsort (VEC_address (oso_el, vec), VEC_length (oso_el, vec),
 661          sizeof (oso_el), oso_el_compare_name);
 662
 663   for (ix = 0; VEC_iterate (oso_el, vec, ix, oso);)
 664     {
 665       int pfx_len;
 666
 667       /* Check if this is a library name.  */
 668       pfx_len = get_archive_prefix_len (oso->name);
 669       if (pfx_len > 0)
 670         {
 671           bfd *archive_bfd;
 672           bfd *member_bfd;
 673           char *archive_name = XNEWVEC (char, pfx_len + 1);
 674           int last_ix;
 675           oso_el *oso2;
 676           int ix2;
 677
 678           memcpy (archive_name, oso->name, pfx_len);
 679           archive_name[pfx_len] = '\0';
 680
 681           make_cleanup (xfree, archive_name);
 682
 683           /* Compute number of oso for this archive.  */
 684           for (last_ix = ix;
 685                VEC_iterate (oso_el, vec, last_ix, oso2); last_ix++)
 686             {
 687               if (strncmp (oso2->name, archive_name, pfx_len) != 0)
 688                 break;
 689             }
 690
 691           /* Open the archive and check the format.  */
 692           archive_bfd = gdb_bfd_open (archive_name, gnutarget, -1);
 693           if (archive_bfd == NULL)
 694             {
 695               warning (_("Could not open OSO archive file \"%s\""),
 696                        archive_name);
 697               ix = last_ix;
 698               continue;
 699             }
 700           if (!bfd_check_format (archive_bfd, bfd_archive))
 701             {
 702               warning (_("OSO archive file \"%s\" not an archive."),
 703                        archive_name);
 704               gdb_bfd_unref (archive_bfd);
 705               ix = last_ix;
 706               continue;
 707             }
 708
 709           member_bfd = gdb_bfd_openr_next_archived_file (archive_bfd, NULL);
 710
 711           if (member_bfd == NULL)
 712             {
 713               warning (_("Could not read archive members out of "
 714                          "OSO archive \"%s\""), archive_name);
 715               gdb_bfd_unref (archive_bfd);
 716               ix = last_ix;
 717               continue;
 718             }
 719
 720           /* Load all oso in this library.  */
 721           while (member_bfd != NULL)
 722             {
 723               bfd *prev;
 724               const char *member_name = member_bfd->filename;
 725               int member_len = strlen (member_name);
 726
 727               /* If this member is referenced, add it as a symfile.  */
 728               for (ix2 = ix; ix2 < last_ix; ix2++)
 729                 {
 730                   oso2 = VEC_index (oso_el, vec, ix2);
 731
 732                   if (oso2->name
 733                       && strlen (oso2->name) == pfx_len + member_len + 2
 734                       && !memcmp (member_name, oso2->name + pfx_len + 1,
 735                                   member_len))
 736                     {
 737                       macho_add_oso_symfile (oso2, member_bfd,
 738                                              main_objfile, symfile_flags);
 739                       oso2->name = NULL;
 740                       break;
 741                     }
 742                 }
 743
 744               prev = member_bfd;
 745               member_bfd = gdb_bfd_openr_next_archived_file (archive_bfd,
 746                                                              member_bfd);
 747
 748               /* Free previous member if not referenced by an oso.  */
 749               if (ix2 >= last_ix)
 750                 gdb_bfd_unref (prev);
 751             }
 752           for (ix2 = ix; ix2 < last_ix; ix2++)
 753             {
 754               oso_el *oso2 = VEC_index (oso_el, vec, ix2);
 755
 756               if (oso2->name != NULL)
 757                 warning (_("Could not find specified archive member "
 758                            "for OSO name \"%s\""), oso->name);
 759             }
 760           ix = last_ix;
 761         }
 762       else
 763         {
 764           bfd *abfd;
 765
 766           abfd = gdb_bfd_open (oso->name, gnutarget, -1);
 767           if (!abfd)
 768             warning (_("`%s': can't open to read symbols: %s."), oso->name,
 769                      bfd_errmsg (bfd_get_error ()));
 770           else
 771             macho_add_oso_symfile (oso, abfd, main_objfile, symfile_flags);
 772
 773           ix++;
 774         }
 775     }
 776
 777   VEC_free (oso_el, vec);
 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
 855   /* Get symbols from the symbol table only if the file is an executable.
 856      The symbol table of object files is not relocated and is expected to
 857      be in the executable.  */
 858   if (bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC))
 859     {
 860       /* Process the normal symbol table first.  */
 861       storage_needed = bfd_get_symtab_upper_bound (objfile->obfd);
 862       if (storage_needed < 0)
 863         error (_("Can't read symbols from %s: %s"),
 864                bfd_get_filename (objfile->obfd),
 865                bfd_errmsg (bfd_get_error ()));
 866
 867       if (storage_needed > 0)
 868         {
 869           asymbol **symbol_table;
 870           long symcount;
 871           struct cleanup *back_to;
 872
 873           symbol_table = (asymbol **) xmalloc (storage_needed);
 874           make_cleanup (xfree, symbol_table);
 875
 876           init_minimal_symbol_collection ();
 877           back_to = make_cleanup_discard_minimal_symbols ();
 878
 879           symcount = bfd_canonicalize_symtab (objfile->obfd, symbol_table);
 880
 881           if (symcount < 0)
 882             error (_("Can't read symbols from %s: %s"),
 883                    bfd_get_filename (objfile->obfd),
 884                    bfd_errmsg (bfd_get_error ()));
 885
 886           macho_symtab_read (objfile, symcount, symbol_table);
 887
 888           install_minimal_symbols (objfile);
 889           do_cleanups (back_to);
 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           struct cleanup *cleanup;
 906
 907           if (mach_o_debug_level > 0)
 908             printf_unfiltered (_("dsym file found\n"));
 909
 910           /* Remove oso.  They won't be used.  */
 911           VEC_free (oso_el, oso_vector);
 912           oso_vector = NULL;
 913
 914           /* Set dsym section size.  */
 915           for (asect = objfile->obfd->sections, dsect = dsym_bfd->sections;
 916                asect && dsect;
 917                asect = asect->next, dsect = dsect->next)
 918             {
 919               if (strcmp (asect->name, dsect->name) != 0)
 920                 break;
 921               bfd_set_section_size (dsym_bfd, dsect,
 922                                     bfd_get_section_size (asect));
 923             }
 924
 925           /* Add the dsym file as a separate file.  */
 926           cleanup = make_cleanup_bfd_unref (dsym_bfd);
 927           symbol_file_add_separate (dsym_bfd, symfile_flags, objfile);
 928           do_cleanups (cleanup);
 929
 930           /* Don't try to read dwarf2 from main file or shared libraries.  */
 931           return;
 932         }
 933     }
 934
 935   if (dwarf2_has_info (objfile, NULL))
 936     {
 937       /* DWARF 2 sections */
 938       dwarf2_build_psymtabs (objfile);
 939     }
 940
 941   /* Then the oso.  */
 942   if (oso_vector != NULL)
 943     macho_symfile_read_all_oso (objfile, symfile_flags);
 944 }
 945
 946 static bfd_byte *
 947 macho_symfile_relocate (struct objfile *objfile, asection *sectp,
 948                         bfd_byte *buf)
 949 {
 950   bfd *abfd = objfile->obfd;
 951
 952   /* We're only interested in sections with relocation
 953      information.  */
 954   if ((sectp->flags & SEC_RELOC) == 0)
 955     return NULL;
 956
 957   if (mach_o_debug_level > 0)
 958     printf_unfiltered (_("Relocate section '%s' of %s\n"),
 959                        sectp->name, objfile->name);
 960
 961   return bfd_simple_get_relocated_section_contents (abfd, sectp, buf, NULL);
 962 }
 963
 964 static void
 965 macho_symfile_finish (struct objfile *objfile)
 966 {
 967 }
 968
 969 static void
 970 macho_symfile_offsets (struct objfile *objfile,
 971                        struct section_addr_info *addrs)
 972 {
 973   unsigned int i;
 974   unsigned int num_sections;
 975   struct obj_section *osect;
 976
 977   /* Allocate section_offsets.  */
 978   objfile->num_sections = bfd_count_sections (objfile->obfd);
 979   objfile->section_offsets = (struct section_offsets *)
 980     obstack_alloc (&objfile->objfile_obstack,
 981                    SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));
 982   memset (objfile->section_offsets, 0,
 983           SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));
 984
 985   /* This code is run when we first add the objfile with
 986      symfile_add_with_addrs_or_offsets, when "addrs" not "offsets" are
 987      passed in.  The place in symfile.c where the addrs are applied
 988      depends on the addrs having section names.  But in the dyld code
 989      we build an anonymous array of addrs, so that code is a no-op.
 990      Because of that, we have to apply the addrs to the sections here.
 991      N.B. if an objfile slides after we've already created it, then it
 992      goes through objfile_relocate.  */
 993
 994   for (i = 0; i < addrs->num_sections; i++)
 995     {
 996       ALL_OBJFILE_OSECTIONS (objfile, osect)
 997         {
 998           const char *bfd_sect_name = osect->the_bfd_section->name;
 999
1000           if (strcmp (bfd_sect_name, addrs->other[i].name) == 0)
1001             {
1002               obj_section_offset (osect) = addrs->other[i].addr;
1003               break;
1004             }
1005         }
1006     }
1007
1008   objfile->sect_index_text = 0;
1009
1010   ALL_OBJFILE_OSECTIONS (objfile, osect)
1011     {
1012       const char *bfd_sect_name = osect->the_bfd_section->name;
1013       int sect_index = osect - objfile->sections;;
1014
1015       if (strncmp (bfd_sect_name, "LC_SEGMENT.", 11) == 0)
1016         bfd_sect_name += 11;
1017       if (strcmp (bfd_sect_name, "__TEXT") == 0
1018           || strcmp (bfd_sect_name, "__TEXT.__text") == 0)
1019         objfile->sect_index_text = sect_index;
1020     }
1021 }
1022
1023 static const struct sym_fns macho_sym_fns = {
1024   bfd_target_mach_o_flavour,
1025
1026   macho_new_init,               /* init anything gbl to entire symtab */
1027   macho_symfile_init,           /* read initial info, setup for sym_read() */
1028   macho_symfile_read,           /* read a symbol file into symtab */
1029   NULL,                         /* sym_read_psymbols */
1030   macho_symfile_finish,         /* finished with file, cleanup */
1031   macho_symfile_offsets,        /* xlate external to internal form */
1032   default_symfile_segments,     /* Get segment information from a file.  */
1033   NULL,
1034   macho_symfile_relocate,       /* Relocate a debug section.  */
1035   NULL,                         /* sym_get_probes */
1036   &psym_functions
1037 };
1038
1039 /* -Wmissing-prototypes */
1040 extern initialize_file_ftype _initialize_machoread;
1041
1042 void
1043 _initialize_machoread ()
1044 {
1045   add_symtab_fns (&macho_sym_fns);
1046
1047   add_setshow_zuinteger_cmd ("mach-o", class_obscure,
1048                              &mach_o_debug_level,
1049                              _("Set if printing Mach-O symbols processing."),
1050                              _("Show if printing Mach-O symbols processing."),
1051                              NULL, NULL, NULL,
1052                              &setdebuglist, &showdebuglist);
1053 }