gdb/machoread.c

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