gdb/machoread.c

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