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