gdb/machoread.c

   1 /* Darwin support for GDB, the GNU debugger.
   2    Copyright (C) 2008-2024 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 "symtab.h"
  22 #include "gdbtypes.h"
  23 #include "bfd.h"
  24 #include "symfile.h"
  25 #include "objfiles.h"
  26 #include "cli/cli-cmds.h"
  27 #include "gdbcore.h"
  28 #include "mach-o.h"
  29 #include "aout/stab_gnu.h"
  30 #include "complaints.h"
  31 #include "gdb_bfd.h"
  32 #include <string>
  33 #include <algorithm>
  34 #include "dwarf2/public.h"
  35
  36 /* If non-zero displays debugging message.  */
  37 static unsigned int mach_o_debug_level = 0;
  38
  39 #define macho_debug(LEVEL, FMT, ...) \
  40   debug_prefixed_printf_cond_nofunc (mach_o_debug_level > LEVEL, \
  41                                      "machoread", FMT, ## __VA_ARGS__)
  42
  43 /* Dwarf debugging information are never in the final executable.  They stay
  44    in object files and the executable contains the list of object files read
  45    during the link.
  46    Each time an oso (other source) is found in the executable, the reader
  47    creates such a structure.  They are read after the processing of the
  48    executable.  */
  49
  50 struct oso_el
  51 {
  52   oso_el (asymbol **oso_sym_, asymbol **end_sym_, unsigned int nbr_syms_)
  53     : name((*oso_sym_)->name),
  54       mtime((*oso_sym_)->value),
  55       oso_sym(oso_sym_),
  56       end_sym(end_sym_),
  57       nbr_syms(nbr_syms_)
  58   {
  59   }
  60
  61   /* Object file name.  Can also be a member name.  */
  62   const char *name;
  63
  64   /* Associated time stamp.  */
  65   unsigned long mtime;
  66
  67   /* Stab symbols range for this OSO.  */
  68   asymbol **oso_sym;
  69   asymbol **end_sym;
  70
  71   /* Number of interesting stabs in the range.  */
  72   unsigned int nbr_syms;
  73 };
  74
  75 static void
  76 macho_new_init (struct objfile *objfile)
  77 {
  78 }
  79
  80 static void
  81 macho_symfile_init (struct objfile *objfile)
  82 {
  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       unrelocated_addr symaddr;
 101       enum minimal_symbol_type ms_type;
 102
 103       /* Bfd symbols are section relative.  */
 104       symaddr = unrelocated_addr (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.get (),
 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                       [[fallthrough]];
 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'
 397       && *name == bfd_get_symbol_leading_char (main_objfile->obfd.get ()))
 398     ++name;
 399   msym = lookup_minimal_symbol (name, NULL, main_objfile);
 400   if (msym.minsym == NULL)
 401     {
 402       warning (_("can't find symbol '%s' in minsymtab"), name);
 403       return 0;
 404     }
 405   else
 406     return msym.value_address ();
 407 }
 408
 409 /* Add oso file OSO/ABFD as a symbol file.  */
 410
 411 static void
 412 macho_add_oso_symfile (oso_el *oso, const gdb_bfd_ref_ptr &abfd,
 413                        const char *name,
 414                        struct objfile *main_objfile,
 415                        symfile_add_flags symfile_flags)
 416 {
 417   int storage;
 418   int i;
 419   asymbol **symbol_table;
 420   asymbol **symp;
 421   struct bfd_hash_table table;
 422   int nbr_sections;
 423
 424   /* Per section flag to mark which section have been rebased.  */
 425   unsigned char *sections_rebased;
 426
 427   macho_debug (0, _("Loading debugging symbols from oso: %s\n"), oso->name);
 428
 429   if (!bfd_check_format (abfd.get (), bfd_object))
 430     {
 431       warning (_("`%s': can't read symbols: %s."), oso->name,
 432                bfd_errmsg (bfd_get_error ()));
 433       return;
 434     }
 435
 436   if (abfd->my_archive == NULL && oso->mtime != bfd_get_mtime (abfd.get ()))
 437     {
 438       warning (_("`%s': file time stamp mismatch."), oso->name);
 439       return;
 440     }
 441
 442   if (!bfd_hash_table_init_n (&table, macho_sym_hash_newfunc,
 443                               sizeof (struct macho_sym_hash_entry),
 444                               oso->nbr_syms))
 445     {
 446       warning (_("`%s': can't create hash table"), oso->name);
 447       return;
 448     }
 449
 450   /* Read symbols table.  */
 451   storage = bfd_get_symtab_upper_bound (abfd.get ());
 452   symbol_table = (asymbol **) xmalloc (storage);
 453   bfd_canonicalize_symtab (abfd.get (), symbol_table);
 454
 455   /* Init section flags.  */
 456   nbr_sections = bfd_count_sections (abfd.get ());
 457   sections_rebased = (unsigned char *) alloca (nbr_sections);
 458   for (i = 0; i < nbr_sections; i++)
 459     sections_rebased[i] = 0;
 460
 461   /* Put symbols for the OSO file in the hash table.  */
 462   for (symp = oso->oso_sym; symp != oso->end_sym; symp++)
 463     {
 464       const asymbol *sym = *symp;
 465       bfd_mach_o_asymbol *mach_o_sym = (bfd_mach_o_asymbol *)sym;
 466
 467       switch (mach_o_sym->n_type)
 468         {
 469         case N_ENSYM:
 470         case N_BNSYM:
 471         case N_GSYM:
 472           sym = NULL;
 473           break;
 474         case N_FUN:
 475           if (sym->name == NULL || sym->name[0] == 0)
 476             sym = NULL;
 477           break;
 478         case N_STSYM:
 479           break;
 480         default:
 481           sym = NULL;
 482           break;
 483         }
 484       if (sym != NULL)
 485         {
 486           struct macho_sym_hash_entry *ent;
 487
 488           ent = (struct macho_sym_hash_entry *)
 489             bfd_hash_lookup (&table, sym->name, TRUE, FALSE);
 490           if (ent->sym != NULL)
 491             complaint (_("Duplicated symbol %s in symbol table"), sym->name);
 492           else
 493             {
 494               macho_debug (4, _("Adding symbol %s (addr: %s)\n"),
 495                            sym->name, paddress (main_objfile->arch (),
 496                                                 sym->value));
 497               ent->sym = sym;
 498             }
 499         }
 500     }
 501
 502   /* Relocate symbols of the OSO.  */
 503   for (i = 0; symbol_table[i]; i++)
 504     {
 505       asymbol *sym = symbol_table[i];
 506       bfd_mach_o_asymbol *mach_o_sym = (bfd_mach_o_asymbol *)sym;
 507
 508       if (mach_o_sym->n_type & BFD_MACH_O_N_STAB)
 509         continue;
 510       if ((mach_o_sym->n_type & BFD_MACH_O_N_TYPE) == BFD_MACH_O_N_UNDF
 511            && sym->value != 0)
 512         {
 513           /* For common symbol use the min symtab and modify the OSO
 514              symbol table.  */
 515           CORE_ADDR res;
 516
 517           res = macho_resolve_oso_sym_with_minsym (main_objfile, sym);
 518           if (res != 0)
 519             {
 520               sym->section = bfd_com_section_ptr;
 521               sym->value = res;
 522             }
 523         }
 524       else if ((mach_o_sym->n_type & BFD_MACH_O_N_TYPE) == BFD_MACH_O_N_SECT)
 525         {
 526           /* Normal symbol.  */
 527           asection *sec = sym->section;
 528           bfd_mach_o_section *msec;
 529           unsigned int sec_type;
 530
 531           /* Skip buggy ones.  */
 532           if (sec == NULL || sections_rebased[sec->index] != 0)
 533             continue;
 534
 535           /* Only consider regular, non-debugging sections.  */
 536           msec = bfd_mach_o_get_mach_o_section (sec);
 537           sec_type = msec->flags & BFD_MACH_O_SECTION_TYPE_MASK;
 538           if ((sec_type == BFD_MACH_O_S_REGULAR
 539                || sec_type == BFD_MACH_O_S_ZEROFILL)
 540               && (msec->flags & BFD_MACH_O_S_ATTR_DEBUG) == 0)
 541             {
 542               CORE_ADDR addr = 0;
 543
 544               if ((mach_o_sym->n_type & BFD_MACH_O_N_EXT) != 0)
 545                 {
 546                   /* Use the min symtab for global symbols.  */
 547                   addr = macho_resolve_oso_sym_with_minsym (main_objfile, sym);
 548                 }
 549               else
 550                 {
 551                   struct macho_sym_hash_entry *ent;
 552
 553                   ent = (struct macho_sym_hash_entry *)
 554                     bfd_hash_lookup (&table, sym->name, FALSE, FALSE);
 555                   if (ent != NULL)
 556                     addr = bfd_asymbol_value (ent->sym);
 557                 }
 558
 559               /* Adjust the section.  */
 560               if (addr != 0)
 561                 {
 562                   CORE_ADDR res = addr - sym->value;
 563
 564                   macho_debug (3, _("resolve sect %s with %s (set to %s)\n"),
 565                                sec->name, sym->name,
 566                                paddress (main_objfile->arch (), res));
 567                   bfd_set_section_vma (sec, res);
 568                   sections_rebased[sec->index] = 1;
 569                 }
 570             }
 571           else
 572             {
 573               /* Mark the section as never rebased.  */
 574               sections_rebased[sec->index] = 2;
 575             }
 576         }
 577     }
 578
 579   bfd_hash_table_free (&table);
 580
 581   /* We need to clear SYMFILE_MAINLINE to avoid interactive question
 582      from symfile.c:symbol_file_add_with_addrs_or_offsets.  */
 583   symbol_file_add_from_bfd
 584     (abfd, name, symfile_flags & ~(SYMFILE_MAINLINE | SYMFILE_VERBOSE),
 585      NULL,
 586      main_objfile->flags & (OBJF_SHARED | OBJF_READNOW | OBJF_USERLOADED),
 587      main_objfile);
 588 }
 589
 590 /* Read symbols from the vector of oso files.
 591
 592    Note that this function sorts OSO_VECTOR_PTR.  */
 593
 594 static void
 595 macho_symfile_read_all_oso (std::vector<oso_el> *oso_vector_ptr,
 596                             struct objfile *main_objfile,
 597                             symfile_add_flags symfile_flags)
 598 {
 599   int ix;
 600   oso_el *oso;
 601
 602   /* Sort oso by name so that files from libraries are gathered.  */
 603   std::sort (oso_vector_ptr->begin (), oso_vector_ptr->end (),
 604              oso_el_compare_name);
 605
 606   for (ix = 0; ix < oso_vector_ptr->size ();)
 607     {
 608       int pfx_len;
 609
 610       oso = &(*oso_vector_ptr)[ix];
 611
 612       /* Check if this is a library name.  */
 613       pfx_len = get_archive_prefix_len (oso->name);
 614       if (pfx_len > 0)
 615         {
 616           int last_ix;
 617           oso_el *oso2;
 618           int ix2;
 619
 620           std::string archive_name (oso->name, pfx_len);
 621
 622           /* Compute number of oso for this archive.  */
 623           for (last_ix = ix; last_ix < oso_vector_ptr->size (); last_ix++)
 624             {
 625               oso2 = &(*oso_vector_ptr)[last_ix];
 626               if (strncmp (oso2->name, archive_name.c_str (), pfx_len) != 0)
 627                 break;
 628             }
 629
 630           /* Open the archive and check the format.  */
 631           gdb_bfd_ref_ptr archive_bfd (gdb_bfd_open (archive_name.c_str (),
 632                                                      gnutarget));
 633           if (archive_bfd == NULL)
 634             {
 635               warning (_("Could not open OSO archive file \"%s\""),
 636                        archive_name.c_str ());
 637               ix = last_ix;
 638               continue;
 639             }
 640           if (!bfd_check_format (archive_bfd.get (), bfd_archive))
 641             {
 642               warning (_("OSO archive file \"%s\" not an archive."),
 643                        archive_name.c_str ());
 644               ix = last_ix;
 645               continue;
 646             }
 647
 648           gdb_bfd_ref_ptr member_bfd
 649             (gdb_bfd_openr_next_archived_file (archive_bfd.get (), NULL));
 650
 651           if (member_bfd == NULL)
 652             {
 653               warning (_("Could not read archive members out of "
 654                          "OSO archive \"%s\""), archive_name.c_str ());
 655               ix = last_ix;
 656               continue;
 657             }
 658
 659           /* Load all oso in this library.  */
 660           while (member_bfd != NULL)
 661             {
 662               const char *member_name = bfd_get_filename (member_bfd.get ());
 663               int member_len = strlen (member_name);
 664
 665               /* If this member is referenced, add it as a symfile.  */
 666               for (ix2 = ix; ix2 < last_ix; ix2++)
 667                 {
 668                   oso2 = &(*oso_vector_ptr)[ix2];
 669
 670                   if (oso2->name
 671                       && strlen (oso2->name) == pfx_len + member_len + 2
 672                       && !memcmp (member_name, oso2->name + pfx_len + 1,
 673                                   member_len))
 674                     {
 675                       macho_add_oso_symfile (oso2, member_bfd,
 676                                              bfd_get_filename (member_bfd.get ()),
 677                                              main_objfile, symfile_flags);
 678                       oso2->name = NULL;
 679                       break;
 680                     }
 681                 }
 682
 683               member_bfd = gdb_bfd_openr_next_archived_file (archive_bfd.get (),
 684                                                              member_bfd.get ());
 685             }
 686           for (ix2 = ix; ix2 < last_ix; ix2++)
 687             {
 688               oso2 = &(*oso_vector_ptr)[ix2];
 689
 690               if (oso2->name != NULL)
 691                 warning (_("Could not find specified archive member "
 692                            "for OSO name \"%s\""), oso->name);
 693             }
 694           ix = last_ix;
 695         }
 696       else
 697         {
 698           gdb_bfd_ref_ptr abfd (gdb_bfd_open (oso->name, gnutarget));
 699           if (abfd == NULL)
 700             warning (_("`%s': can't open to read symbols: %s."), oso->name,
 701                      bfd_errmsg (bfd_get_error ()));
 702           else
 703             macho_add_oso_symfile (oso, abfd, oso->name, main_objfile,
 704                                    symfile_flags);
 705
 706           ix++;
 707         }
 708     }
 709 }
 710
 711 /* DSYM (debug symbols) files contain the debug info of an executable.
 712    This is a separate file created by dsymutil(1) and is similar to debug
 713    link feature on ELF.
 714    DSYM files are located in a subdirectory.  Append DSYM_SUFFIX to the
 715    executable name and the executable base name to get the DSYM file name.  */
 716 #define DSYM_SUFFIX ".dSYM/Contents/Resources/DWARF/"
 717
 718 /* Check if a dsym file exists for OBJFILE.  If so, returns a bfd for it
 719    and return *FILENAMEP with its original filename.
 720    Return NULL if no valid dsym file is found (FILENAMEP is not used in
 721    such case).  */
 722
 723 static gdb_bfd_ref_ptr
 724 macho_check_dsym (struct objfile *objfile, std::string *filenamep)
 725 {
 726   size_t name_len = strlen (objfile_name (objfile));
 727   size_t dsym_len = strlen (DSYM_SUFFIX);
 728   const char *base_name = lbasename (objfile_name (objfile));
 729   size_t base_len = strlen (base_name);
 730   char *dsym_filename = (char *) alloca (name_len + dsym_len + base_len + 1);
 731   bfd_mach_o_load_command *main_uuid;
 732   bfd_mach_o_load_command *dsym_uuid;
 733
 734   strcpy (dsym_filename, objfile_name (objfile));
 735   strcpy (dsym_filename + name_len, DSYM_SUFFIX);
 736   strcpy (dsym_filename + name_len + dsym_len, base_name);
 737
 738   if (access (dsym_filename, R_OK) != 0)
 739     return NULL;
 740
 741   if (bfd_mach_o_lookup_command (objfile->obfd.get (),
 742                                  BFD_MACH_O_LC_UUID, &main_uuid) == 0)
 743     {
 744       warning (_("can't find UUID in %s"), objfile_name (objfile));
 745       return NULL;
 746     }
 747   gdb_bfd_ref_ptr dsym_bfd (gdb_bfd_openr (dsym_filename, gnutarget));
 748   if (dsym_bfd == NULL)
 749     {
 750       warning (_("can't open dsym file %s"), dsym_filename);
 751       return NULL;
 752     }
 753
 754   if (!bfd_check_format (dsym_bfd.get (), bfd_object))
 755     {
 756       warning (_("bad dsym file format: %s"), bfd_errmsg (bfd_get_error ()));
 757       return NULL;
 758     }
 759
 760   if (bfd_mach_o_lookup_command (dsym_bfd.get (),
 761                                  BFD_MACH_O_LC_UUID, &dsym_uuid) == 0)
 762     {
 763       warning (_("can't find UUID in %s"), dsym_filename);
 764       return NULL;
 765     }
 766   if (memcmp (dsym_uuid->command.uuid.uuid, main_uuid->command.uuid.uuid,
 767               sizeof (main_uuid->command.uuid.uuid)))
 768     {
 769       warning (_("dsym file UUID doesn't match the one in %s"),
 770                objfile_name (objfile));
 771       return NULL;
 772     }
 773   *filenamep = std::string (dsym_filename);
 774   return dsym_bfd;
 775 }
 776
 777 static void
 778 macho_symfile_read (struct objfile *objfile, symfile_add_flags symfile_flags)
 779 {
 780   bfd *abfd = objfile->obfd.get ();
 781   long storage_needed;
 782   std::vector<oso_el> oso_vector;
 783   /* We have to hold on to the symbol table until the call to
 784      macho_symfile_read_all_oso at the end of this function.  */
 785   gdb::def_vector<asymbol *> symbol_table;
 786
 787   dwarf2_initialize_objfile (objfile);
 788
 789   /* Get symbols from the symbol table only if the file is an executable.
 790      The symbol table of object files is not relocated and is expected to
 791      be in the executable.  */
 792   if (bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC))
 793     {
 794       std::string dsym_filename;
 795
 796       /* Process the normal symbol table first.  */
 797       storage_needed = bfd_get_symtab_upper_bound (objfile->obfd.get ());
 798       if (storage_needed < 0)
 799         error (_("Can't read symbols from %s: %s"),
 800                bfd_get_filename (objfile->obfd.get ()),
 801                bfd_errmsg (bfd_get_error ()));
 802
 803       if (storage_needed > 0)
 804         {
 805           long symcount;
 806
 807           symbol_table.resize (storage_needed / sizeof (asymbol *));
 808
 809           minimal_symbol_reader reader (objfile);
 810
 811           symcount = bfd_canonicalize_symtab (objfile->obfd.get (),
 812                                               symbol_table.data ());
 813
 814           if (symcount < 0)
 815             error (_("Can't read symbols from %s: %s"),
 816                    bfd_get_filename (objfile->obfd.get ()),
 817                    bfd_errmsg (bfd_get_error ()));
 818
 819           macho_symtab_read (reader, objfile, symcount, symbol_table.data (),
 820                              &oso_vector);
 821
 822           reader.install ();
 823         }
 824
 825       /* Try to read .eh_frame / .debug_frame.  */
 826       dwarf2_build_frame_info (objfile);
 827
 828       /* Check for DSYM file.  */
 829       gdb_bfd_ref_ptr dsym_bfd (macho_check_dsym (objfile, &dsym_filename));
 830       if (dsym_bfd != NULL)
 831         {
 832           struct bfd_section *asect, *dsect;
 833
 834           macho_debug (0, _("dsym file found\n"));
 835
 836           /* Set dsym section size.  */
 837           for (asect = objfile->obfd->sections, dsect = dsym_bfd->sections;
 838                asect && dsect;
 839                asect = asect->next, dsect = dsect->next)
 840             {
 841               if (strcmp (asect->name, dsect->name) != 0)
 842                 break;
 843               bfd_set_section_size (dsect, bfd_section_size (asect));
 844             }
 845
 846           /* Add the dsym file as a separate file.  */
 847           symbol_file_add_separate (dsym_bfd, dsym_filename.c_str (),
 848                                     symfile_flags, objfile);
 849
 850           /* Don't try to read dwarf2 from main file or shared libraries.  */
 851           return;
 852         }
 853     }
 854
 855   /* Then the oso.  */
 856   if (!oso_vector.empty ())
 857     macho_symfile_read_all_oso (&oso_vector, objfile, symfile_flags);
 858 }
 859
 860 static bfd_byte *
 861 macho_symfile_relocate (struct objfile *objfile, asection *sectp,
 862                         bfd_byte *buf)
 863 {
 864   bfd *abfd = objfile->obfd.get ();
 865
 866   /* We're only interested in sections with relocation
 867      information.  */
 868   if ((sectp->flags & SEC_RELOC) == 0)
 869     return NULL;
 870
 871   macho_debug (0, _("Relocate section '%s' of %s\n"),
 872                sectp->name, objfile_name (objfile));
 873
 874   return bfd_simple_get_relocated_section_contents (abfd, sectp, buf, NULL);
 875 }
 876
 877 static void
 878 macho_symfile_finish (struct objfile *objfile)
 879 {
 880 }
 881
 882 static void
 883 macho_symfile_offsets (struct objfile *objfile,
 884                        const section_addr_info &addrs)
 885 {
 886   unsigned int i;
 887
 888   /* Allocate section_offsets.  */
 889   objfile->section_offsets.assign (gdb_bfd_count_sections (objfile->obfd.get ()), 0);
 890
 891   /* This code is run when we first add the objfile with
 892      symfile_add_with_addrs_or_offsets, when "addrs" not "offsets" are
 893      passed in.  The place in symfile.c where the addrs are applied
 894      depends on the addrs having section names.  But in the dyld code
 895      we build an anonymous array of addrs, so that code is a no-op.
 896      Because of that, we have to apply the addrs to the sections here.
 897      N.B. if an objfile slides after we've already created it, then it
 898      goes through objfile_relocate.  */
 899
 900   for (i = 0; i < addrs.size (); i++)
 901     {
 902       for (obj_section *osect : objfile->sections ())
 903         {
 904           const char *bfd_sect_name = osect->the_bfd_section->name;
 905
 906           if (bfd_sect_name == addrs[i].name)
 907             {
 908               osect->set_offset (addrs[i].addr);
 909               break;
 910             }
 911         }
 912     }
 913
 914   objfile->sect_index_text = 0;
 915
 916   for (obj_section *osect : objfile->sections ())
 917     {
 918       const char *bfd_sect_name = osect->the_bfd_section->name;
 919       int sect_index = osect - objfile->sections_start;
 920
 921       if (startswith (bfd_sect_name, "LC_SEGMENT."))
 922         bfd_sect_name += 11;
 923       if (strcmp (bfd_sect_name, "__TEXT") == 0
 924           || strcmp (bfd_sect_name, "__TEXT.__text") == 0)
 925         objfile->sect_index_text = sect_index;
 926     }
 927 }
 928
 929 static const struct sym_fns macho_sym_fns = {
 930   macho_new_init,               /* init anything gbl to entire symtab */
 931   macho_symfile_init,           /* read initial info, setup for sym_read() */
 932   macho_symfile_read,           /* read a symbol file into symtab */
 933   macho_symfile_finish,         /* finished with file, cleanup */
 934   macho_symfile_offsets,        /* xlate external to internal form */
 935   default_symfile_segments,     /* Get segment information from a file.  */
 936   NULL,
 937   macho_symfile_relocate,       /* Relocate a debug section.  */
 938   NULL,                         /* sym_get_probes */
 939 };
 940
 941 void _initialize_machoread ();
 942 void
 943 _initialize_machoread ()
 944 {
 945   add_symtab_fns (bfd_target_mach_o_flavour, &macho_sym_fns);
 946
 947   add_setshow_zuinteger_cmd ("mach-o", class_obscure,
 948                              &mach_o_debug_level,
 949                              _("Set if printing Mach-O symbols processing."),
 950                              _("Show if printing Mach-O symbols processing."),
 951                              NULL, NULL, NULL,
 952                              &setdebuglist, &showdebuglist);
 953 }