gdb/machoread.c

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