gdb/machoread.c - gdb

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. /* Darwin support for GDB, the GNU debugger.
  2.    Copyright (C) 2008-2015 Free Software Foundation, Inc.

  4.    Contributed by AdaCore.

  6.    This file is part of GDB.

  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.

  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.

  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/>.  */

  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"

  37. /* If non-zero displays debugging message.  */
  38. ‌static unsigned int mach_o_debug_level = 0;

  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.  */

  47. ‌typedef struct oso_el
  48. {
  49.   /* Object file name.  Can also be a member name.  */
  50.   const char *name;

  52.   /* Associated time stamp.  */
  53.   unsigned long mtime;

  55.   /* Stab symbols range for this OSO.  */
  56.   asymbol **oso_sym;
  57.   asymbol **end_sym;

  59.   /* Number of interesting stabs in the range.  */
  60.   unsigned int nbr_syms;
  61. }
  62. ‌oso_el;

  64. /* Vector of object files to be read after the executable.  */
  65. ‌DEF_VEC_O (oso_el);

  67. static void
  68. ‌macho_new_init (struct objfile *objfile)
  69. {
  70. }

  72. static void
  73. ‌macho_symfile_init (struct objfile *objfile)
  74. {
  75.   objfile->flags |= OBJF_REORDERED;
  76. }

  78. /*  Add a new OSO to the vector of OSO to load.  */

  80. static void
  81. ‌macho_register_oso (VEC (oso_el) **oso_vector_ptr,
  82.                     struct objfile *objfile,
  83.                     asymbol **oso_sym, asymbol **end_sym,
  84.                     unsigned int nbr_syms)
  85. {
  86.   oso_el el;

  88.   el.name = (*oso_sym)->name;
  89.   el.mtime = (*oso_sym)->value;
  90.   el.oso_sym = oso_sym;
  91.   el.end_sym = end_sym;
  92.   el.nbr_syms = nbr_syms;
  93.   VEC_safe_push (oso_el, *oso_vector_ptr, &el);
  94. }

  96. /* Add symbol SYM to the minimal symbol table of OBJFILE.  */

  98. static void
  99. ‌macho_symtab_add_minsym (struct objfile *objfile, const asymbol *sym)
  100. {
  101.   if (sym->name == NULL || *sym->name == '\0')
  102.     {
  103.       /* Skip names that don't exist (shouldn't happen), or names
  104.          that are null strings (may happen).  */
  105.       return;
  106.     }

  108.   if (sym->flags & (BSF_GLOBAL | BSF_LOCAL | BSF_WEAK))
  109.     {
  110.       CORE_ADDR symaddr;
  111.       enum minimal_symbol_type ms_type;

  113.       /* Bfd symbols are section relative.  */
  114.       symaddr = sym->value + sym->section->vma;

  116.       if (sym->section == bfd_abs_section_ptr)
  117.         ms_type = mst_abs;
  118.       else if (sym->section->flags & SEC_CODE)
  119.         {
  120.           if (sym->flags & (BSF_GLOBAL | BSF_WEAK))
  121.             ms_type = mst_text;
  122.           else
  123.             ms_type = mst_file_text;
  124.         }
  125.       else if (sym->section->flags & SEC_ALLOC)
  126.         {
  127.           if (sym->flags & (BSF_GLOBAL | BSF_WEAK))
  128.             {
  129.               if (sym->section->flags & SEC_LOAD)
  130.                 ms_type = mst_data;
  131.               else
  132.                 ms_type = mst_bss;
  133.             }
  134.           else if (sym->flags & BSF_LOCAL)
  135.             {
  136.               /* Not a special stabs-in-elf symbol, do regular
  137.                  symbol processing.  */
  138.               if (sym->section->flags & SEC_LOAD)
  139.                 ms_type = mst_file_data;
  140.               else
  141.                 ms_type = mst_file_bss;
  142.             }
  143.           else
  144.             ms_type = mst_unknown;
  145.         }
  146.       else
  147.         return;        /* Skip this symbol.  */

  149.       prim_record_minimal_symbol_and_info
  150.         (sym->name, symaddr, ms_type,
  151.          gdb_bfd_section_index (objfile->obfd, sym->section),
  152.          objfile);
  153.     }
  154. }

  156. /* Build the minimal symbol table from SYMBOL_TABLE of length
  157.    NUMBER_OF_SYMBOLS for OBJFILE.  Registers OSO filenames found.  */

  159. static void
  160. ‌macho_symtab_read (struct objfile *objfile,
  161.                    long number_of_symbols, asymbol **symbol_table,
  162.                    VEC (oso_el) **oso_vector_ptr)
  163. {
  164.   long i;
  165.   const asymbol *dir_so = NULL;
  166.   const asymbol *file_so = NULL;
  167.   asymbol **oso_file = NULL;
  168.   unsigned int nbr_syms = 0;

  170.   /* Current state while reading stabs.  */
  171.   enum
  172.   {
  173.     /* Not within an SO part.  Only non-debugging symbols should be present,
  174.        and will be added to the minimal symbols table.  */
  175.     S_NO_SO,

  177.     /* First SO read.  Introduce an SO section, and may be followed by a second
  178.        SO.  The SO section should contain onl debugging symbols.  */
  179.     S_FIRST_SO,

  181.     /* Second non-null SO found, just after the first one.  Means that the first
  182.        is in fact a directory name.  */
  183.     S_SECOND_SO,

  185.     /* Non-null OSO found.  Debugging info are DWARF in this OSO file.  */
  186.     S_DWARF_FILE,

  188.     S_STAB_FILE
  189.   } state = S_NO_SO;

  191.   for (i = 0; i < number_of_symbols; i++)
  192.     {
  193.       const asymbol *sym = symbol_table[i];
  194.       bfd_mach_o_asymbol *mach_o_sym = (bfd_mach_o_asymbol *)sym;

  196.       switch (state)
  197.         {
  198.         case S_NO_SO:
  199.           if (mach_o_sym->n_type == N_SO)
  200.             {
  201.               /* Start of object stab.  */
  202.               if (sym->name == NULL || sym->name[0] == 0)
  203.                 {
  204.                   /* Unexpected empty N_SO.  */
  205.                   complaint (&symfile_complaints,
  206.                              _("Unexpected empty N_SO stab"));
  207.                 }
  208.               else
  209.                 {
  210.                   file_so = sym;
  211.                   dir_so = NULL;
  212.                   state = S_FIRST_SO;
  213.                 }
  214.             }
  215.           else if (sym->flags & BSF_DEBUGGING)
  216.             {
  217.               if (mach_o_sym->n_type == N_OPT)
  218.                 {
  219.                   /* No complaint for OPT.  */
  220.                   break;
  221.                 }

  223.               /* Debugging symbols are not expected here.  */
  224.               complaint (&symfile_complaints,
  225.                          _("%s: Unexpected debug stab outside SO markers"),
  226.                          objfile_name (objfile));
  227.             }
  228.           else
  229.             {
  230.               /* Non-debugging symbols go to the minimal symbol table.  */
  231.               macho_symtab_add_minsym (objfile, sym);
  232.             }
  233.           break;

  235.         case S_FIRST_SO:
  236.         case S_SECOND_SO:
  237.           if (mach_o_sym->n_type == N_SO)
  238.             {
  239.               if (sym->name == NULL || sym->name[0] == 0)
  240.                 {
  241.                   /* Unexpected empty N_SO.  */
  242.                   complaint (&symfile_complaints, _("Empty SO section"));
  243.                   state = S_NO_SO;
  244.                 }
  245.               else if (state == S_FIRST_SO)
  246.                 {
  247.                   /* Second SO stab for the file name.  */
  248.                   dir_so = file_so;
  249.                   file_so = sym;
  250.                   state = S_SECOND_SO;
  251.                 }
  252.               else
  253.                 complaint (&symfile_complaints, _("Three SO in a raw"));
  254.             }
  255.           else if (mach_o_sym->n_type == N_OSO)
  256.             {
  257.               if (sym->name == NULL || sym->name[0] == 0)
  258.                 {
  259.                   /* Empty OSO.  Means that this file was compiled with
  260.                      stabs.  */
  261.                   state = S_STAB_FILE;
  262.                   warning (_("stabs debugging not supported for %s"),
  263.                            file_so->name);
  264.                 }
  265.               else
  266.                 {
  267.                   /* Non-empty OSO for a Dwarf file.  */
  268.                   oso_file = symbol_table + i;
  269.                   nbr_syms = 0;
  270.                   state = S_DWARF_FILE;
  271.                 }
  272.             }
  273.           else
  274.             complaint (&symfile_complaints,
  275.                        _("Unexpected stab after SO"));
  276.           break;

  278.         case S_STAB_FILE:
  279.         case S_DWARF_FILE:
  280.           if (mach_o_sym->n_type == N_SO)
  281.             {
  282.               if (sym->name == NULL || sym->name[0] == 0)
  283.                 {
  284.                   /* End of file.  */
  285.                   if (state == S_DWARF_FILE)
  286.                     macho_register_oso (oso_vector_ptr, objfile,
  287.                                         oso_file, symbol_table + i,
  288.                                         nbr_syms);
  289.                   state = S_NO_SO;
  290.                 }
  291.               else
  292.                 {
  293.                   complaint (&symfile_complaints, _("Missing nul SO"));
  294.                   file_so = sym;
  295.                   dir_so = NULL;
  296.                   state = S_FIRST_SO;
  297.                 }
  298.             }
  299.           else if (sym->flags & BSF_DEBUGGING)
  300.             {
  301.               if (state == S_STAB_FILE)
  302.                 {
  303.                   /* FIXME: to be implemented.  */
  304.                 }
  305.               else
  306.                 {
  307.                   switch (mach_o_sym->n_type)
  308.                     {
  309.                     case N_FUN:
  310.                       if (sym->name == NULL || sym->name[0] == 0)
  311.                         break;
  312.                       /* Fall through.  */
  313.                     case N_STSYM:
  314.                       /* Interesting symbol.  */
  315.                       nbr_syms++;
  316.                       break;
  317.                     case N_ENSYM:
  318.                     case N_BNSYM:
  319.                     case N_GSYM:
  320.                       break;
  321.                     default:
  322.                       complaint (&symfile_complaints,
  323.                                  _("unhandled stab for dwarf OSO file"));
  324.                       break;
  325.                     }
  326.                 }
  327.             }
  328.           else
  329.             complaint (&symfile_complaints,
  330.                        _("non-debugging symbol within SO"));
  331.           break;
  332.         }
  333.     }

  335.   if (state != S_NO_SO)
  336.     complaint (&symfile_complaints, _("missing nul SO"));
  337. }

  339. /* If NAME describes an archive member (ie: ARCHIVE '(' MEMBER ')'),
  340.    returns the length of the archive name.
  341.    Returns -1 otherwise.  */

  343. static int
  344. ‌get_archive_prefix_len (const char *name)
  345. {
  346.   char *lparen;
  347.   int name_len = strlen (name);

  349.   if (name_len == 0 || name[name_len - 1] != ')')
  350.     return -1;

  352.   lparen = strrchr (name, '(');
  353.   if (lparen == NULL || lparen == name)
  354.     return -1;
  355.   return lparen - name;
  356. }

  358. /* Compare function to qsort OSOs, so that members of a library are
  359.    gathered.  */

  361. static int
  362. ‌oso_el_compare_name (const void *vl, const void *vr)
  363. {
  364.   const oso_el *l = (const oso_el *)vl;
  365.   const oso_el *r = (const oso_el *)vr;

  367.   return strcmp (l->name, r->name);
  368. }

  370. /* Hash table entry structure for the stabs symbols in the main object file.
  371.    This is used to speed up lookup for symbols in the OSO.  */

  373. ‌struct macho_sym_hash_entry
  374. {
  375.   struct bfd_hash_entry base;
  376.   const asymbol *sym;
  377. };

  379. /* Routine to create an entry in the hash table.  */

  381. static struct bfd_hash_entry *
  382. ‌macho_sym_hash_newfunc (struct bfd_hash_entry *entry,
  383.                         struct bfd_hash_table *table,
  384.                         const char *string)
  385. {
  386.   struct macho_sym_hash_entry *ret = (struct macho_sym_hash_entry *) entry;

  388.   /* Allocate the structure if it has not already been allocated by a
  389.      subclass.  */
  390.   if (ret == NULL)
  391.     ret = (struct macho_sym_hash_entry *) bfd_hash_allocate (table,
  392.                                                              sizeof (* ret));
  393.   if (ret == NULL)
  394.     return NULL;

  396.   /* Call the allocation method of the superclass.  */
  397.   ret = (struct macho_sym_hash_entry *)
  398.          bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string);

  400.   if (ret)
  401.     {
  402.       /* Initialize the local fields.  */
  403.       ret->sym = NULL;
  404.     }

  406.   return (struct bfd_hash_entry *) ret;
  407. }

  409. /* Get the value of SYM from the minimal symtab of MAIN_OBJFILE.  This is used
  410.    to get the value of global and common symbols.  */

  412. static CORE_ADDR
  413. ‌macho_resolve_oso_sym_with_minsym (struct objfile *main_objfile, asymbol *sym)
  414. {
  415.   /* For common symbol and global symbols, use the min symtab.  */
  416.   struct bound_minimal_symbol msym;
  417.   const char *name = sym->name;

  419.   if (name[0] == bfd_get_symbol_leading_char (main_objfile->obfd))
  420.     ++name;
  421.   msym = lookup_minimal_symbol (name, NULL, main_objfile);
  422.   if (msym.minsym == NULL)
  423.     {
  424.       warning (_("can't find symbol '%s' in minsymtab"), name);
  425.       return 0;
  426.     }
  427.   else
  428.     return BMSYMBOL_VALUE_ADDRESS (msym);
  429. }

  431. /* Add oso file OSO/ABFD as a symbol file.  */

  433. static void
  434. ‌macho_add_oso_symfile (oso_el *oso, bfd *abfd, const char *name,
  435.                        struct objfile *main_objfile, int symfile_flags)
  436. {
  437.   int storage;
  438.   int i;
  439.   asymbol **symbol_table;
  440.   asymbol **symp;
  441.   struct bfd_hash_table table;
  442.   int nbr_sections;
  443.   struct cleanup *cleanup;

  445.   /* Per section flag to mark which section have been rebased.  */
  446.   unsigned char *sections_rebased;

  448.   if (mach_o_debug_level > 0)
  449.     printf_unfiltered
  450.       (_("Loading debugging symbols from oso: %s\n"), oso->name);

  452.   if (!bfd_check_format (abfd, bfd_object))
  453.     {
  454.       warning (_("`%s': can't read symbols: %s."), oso->name,
  455.                bfd_errmsg (bfd_get_error ()));
  456.       gdb_bfd_unref (abfd);
  457.       return;
  458.     }

  460.   if (abfd->my_archive == NULL && oso->mtime != bfd_get_mtime (abfd))
  461.     {
  462.       warning (_("`%s': file time stamp mismatch."), oso->name);
  463.       gdb_bfd_unref (abfd);
  464.       return;
  465.     }

  467.   if (!bfd_hash_table_init_n (&table, macho_sym_hash_newfunc,
  468.                               sizeof (struct macho_sym_hash_entry),
  469.                               oso->nbr_syms))
  470.     {
  471.       warning (_("`%s': can't create hash table"), oso->name);
  472.       gdb_bfd_unref (abfd);
  473.       return;
  474.     }

  476.   bfd_set_cacheable (abfd, 1);

  478.   /* Read symbols table.  */
  479.   storage = bfd_get_symtab_upper_bound (abfd);
  480.   symbol_table = (asymbol **) xmalloc (storage);
  481.   bfd_canonicalize_symtab (abfd, symbol_table);

  483.   /* Init section flags.  */
  484.   nbr_sections = bfd_count_sections (abfd);
  485.   sections_rebased = (unsigned char *) alloca (nbr_sections);
  486.   for (i = 0; i < nbr_sections; i++)
  487.     sections_rebased[i] = 0;

  489.   /* Put symbols for the OSO file in the hash table.  */
  490.   for (symp = oso->oso_sym; symp != oso->end_sym; symp++)
  491.     {
  492.       const asymbol *sym = *symp;
  493.       bfd_mach_o_asymbol *mach_o_sym = (bfd_mach_o_asymbol *)sym;

  495.       switch (mach_o_sym->n_type)
  496.         {
  497.         case N_ENSYM:
  498.         case N_BNSYM:
  499.         case N_GSYM:
  500.           sym = NULL;
  501.           break;
  502.         case N_FUN:
  503.           if (sym->name == NULL || sym->name[0] == 0)
  504.             sym = NULL;
  505.           break;
  506.         case N_STSYM:
  507.           break;
  508.         default:
  509.           sym = NULL;
  510.           break;
  511.         }
  512.       if (sym != NULL)
  513.         {
  514.           struct macho_sym_hash_entry *ent;

  516.           ent = (struct macho_sym_hash_entry *)
  517.             bfd_hash_lookup (&table, sym->name, TRUE, FALSE);
  518.           if (ent->sym != NULL)
  519.             complaint (&symfile_complaints,
  520.                        _("Duplicated symbol %s in symbol table"), sym->name);
  521.           else
  522.             {
  523.               if (mach_o_debug_level > 4)
  524.                 {
  525.                   struct gdbarch *arch = get_objfile_arch (main_objfile);
  526.                   printf_unfiltered
  527.                     (_("Adding symbol %s (addr: %s)\n"),
  528.                      sym->name, paddress (arch, sym->value));
  529.                 }
  530.               ent->sym = sym;
  531.             }
  532.         }
  533.     }

  535.   /* Relocate symbols of the OSO.  */
  536.   for (i = 0; symbol_table[i]; i++)
  537.     {
  538.       asymbol *sym = symbol_table[i];
  539.       bfd_mach_o_asymbol *mach_o_sym = (bfd_mach_o_asymbol *)sym;

  541.       if (mach_o_sym->n_type & BFD_MACH_O_N_STAB)
  542.         continue;
  543.       if ((mach_o_sym->n_type & BFD_MACH_O_N_TYPE) == BFD_MACH_O_N_UNDF
  544.            && sym->value != 0)
  545.         {
  546.           /* For common symbol use the min symtab and modify the OSO
  547.              symbol table.  */
  548.           CORE_ADDR res;

  550.           res = macho_resolve_oso_sym_with_minsym (main_objfile, sym);
  551.           if (res != 0)
  552.             {
  553.               sym->section = bfd_com_section_ptr;
  554.               sym->value = res;
  555.             }
  556.         }
  557.       else if ((mach_o_sym->n_type & BFD_MACH_O_N_TYPE) == BFD_MACH_O_N_SECT)
  558.         {
  559.           /* Normal symbol.  */
  560.           asection *sec = sym->section;
  561.           bfd_mach_o_section *msec;
  562.           unsigned int sec_type;

  564.           /* Skip buggy ones.  */
  565.           if (sec == NULL || sections_rebased[sec->index] != 0)
  566.             continue;

  568.           /* Only consider regular, non-debugging sections.  */
  569.           msec = bfd_mach_o_get_mach_o_section (sec);
  570.           sec_type = msec->flags & BFD_MACH_O_SECTION_TYPE_MASK;
  571.           if ((sec_type == BFD_MACH_O_S_REGULAR
  572.                || sec_type == BFD_MACH_O_S_ZEROFILL)
  573.               && (msec->flags & BFD_MACH_O_S_ATTR_DEBUG) == 0)
  574.             {
  575.               CORE_ADDR addr = 0;

  577.               if ((mach_o_sym->n_type & BFD_MACH_O_N_EXT) != 0)
  578.                 {
  579.                   /* Use the min symtab for global symbols.  */
  580.                   addr = macho_resolve_oso_sym_with_minsym (main_objfile, sym);
  581.                 }
  582.               else
  583.                 {
  584.                   struct macho_sym_hash_entry *ent;

  586.                   ent = (struct macho_sym_hash_entry *)
  587.                     bfd_hash_lookup (&table, sym->name, FALSE, FALSE);
  588.                   if (ent != NULL)
  589.                     addr = bfd_asymbol_value (ent->sym);
  590.                 }

  592.               /* Adjust the section.  */
  593.               if (addr != 0)
  594.                 {
  595.                   CORE_ADDR res = addr - sym->value;

  597.                   if (mach_o_debug_level > 3)
  598.                     {
  599.                       struct gdbarch *arch = get_objfile_arch (main_objfile);
  600.                       printf_unfiltered
  601.                         (_("resolve sect %s with %s (set to %s)\n"),
  602.                          sec->name, sym->name,
  603.                          paddress (arch, res));
  604.                     }
  605.                   bfd_set_section_vma (abfd, sec, res);
  606.                   sections_rebased[sec->index] = 1;
  607.                 }
  608.             }
  609.           else
  610.             {
  611.               /* Mark the section as never rebased.  */
  612.               sections_rebased[sec->index] = 2;
  613.             }
  614.         }
  615.     }

  617.   bfd_hash_table_free (&table);

  619.   /* We need to clear SYMFILE_MAINLINE to avoid interractive question
  620.      from symfile.c:symbol_file_add_with_addrs_or_offsets.  */
  621.   cleanup = make_cleanup_bfd_unref (abfd);
  622.   symbol_file_add_from_bfd
  623.     (abfd, name, symfile_flags & ~(SYMFILE_MAINLINE | SYMFILE_VERBOSE), NULL,
  624.      main_objfile->flags & (OBJF_REORDERED | OBJF_SHARED
  625.                             | OBJF_READNOW | OBJF_USERLOADED),
  626.      main_objfile);
  627.   do_cleanups (cleanup);
  628. }

  630. /* Read symbols from the vector of oso files.

  632.    Note that this function sorts OSO_VECTOR_PTR.  */

  634. static void
  635. ‌macho_symfile_read_all_oso (VEC (oso_el) **oso_vector_ptr,
  636.                             struct objfile *main_objfile,
  637.                             int symfile_flags)
  638. {
  639.   int ix;
  640.   VEC (oso_el) *vec = *oso_vector_ptr;
  641.   oso_el *oso;
  642.   struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);

  644.   /* Sort oso by name so that files from libraries are gathered.  */
  645.   qsort (VEC_address (oso_el, vec), VEC_length (oso_el, vec),
  646.          sizeof (oso_el), oso_el_compare_name);

  648.   for (ix = 0; VEC_iterate (oso_el, vec, ix, oso);)
  649.     {
  650.       int pfx_len;

  652.       /* Check if this is a library name.  */
  653.       pfx_len = get_archive_prefix_len (oso->name);
  654.       if (pfx_len > 0)
  655.         {
  656.           bfd *archive_bfd;
  657.           bfd *member_bfd;
  658.           char *archive_name = XNEWVEC (char, pfx_len + 1);
  659.           int last_ix;
  660.           oso_el *oso2;
  661.           int ix2;

  663.           memcpy (archive_name, oso->name, pfx_len);
  664.           archive_name[pfx_len] = '\0';

  666.           make_cleanup (xfree, archive_name);

  668.           /* Compute number of oso for this archive.  */
  669.           for (last_ix = ix;
  670.                VEC_iterate (oso_el, vec, last_ix, oso2); last_ix++)
  671.             {
  672.               if (strncmp (oso2->name, archive_name, pfx_len) != 0)
  673.                 break;
  674.             }

  676.           /* Open the archive and check the format.  */
  677.           archive_bfd = gdb_bfd_open (archive_name, gnutarget, -1);
  678.           if (archive_bfd == NULL)
  679.             {
  680.               warning (_("Could not open OSO archive file \"%s\""),
  681.                        archive_name);
  682.               ix = last_ix;
  683.               continue;
  684.             }
  685.           if (!bfd_check_format (archive_bfd, bfd_archive))
  686.             {
  687.               warning (_("OSO archive file \"%s\" not an archive."),
  688.                        archive_name);
  689.               gdb_bfd_unref (archive_bfd);
  690.               ix = last_ix;
  691.               continue;
  692.             }

  694.           member_bfd = gdb_bfd_openr_next_archived_file (archive_bfd, NULL);

  696.           if (member_bfd == NULL)
  697.             {
  698.               warning (_("Could not read archive members out of "
  699.                          "OSO archive \"%s\""), archive_name);
  700.               gdb_bfd_unref (archive_bfd);
  701.               ix = last_ix;
  702.               continue;
  703.             }

  705.           /* Load all oso in this library.  */
  706.           while (member_bfd != NULL)
  707.             {
  708.               bfd *prev;
  709.               const char *member_name = member_bfd->filename;
  710.               int member_len = strlen (member_name);

  712.               /* If this member is referenced, add it as a symfile.  */
  713.               for (ix2 = ix; ix2 < last_ix; ix2++)
  714.                 {
  715.                   oso2 = VEC_index (oso_el, vec, ix2);

  717.                   if (oso2->name
  718.                       && strlen (oso2->name) == pfx_len + member_len + 2
  719.                       && !memcmp (member_name, oso2->name + pfx_len + 1,
  720.                                   member_len))
  721.                     {
  722.                       macho_add_oso_symfile (oso2, member_bfd,
  723.                                              bfd_get_filename (member_bfd),
  724.                                              main_objfile, symfile_flags);
  725.                       oso2->name = NULL;
  726.                       break;
  727.                     }
  728.                 }

  730.               prev = member_bfd;
  731.               member_bfd = gdb_bfd_openr_next_archived_file (archive_bfd,
  732.                                                              member_bfd);

  734.               /* Free previous member if not referenced by an oso.  */
  735.               if (ix2 >= last_ix)
  736.                 gdb_bfd_unref (prev);
  737.             }
  738.           for (ix2 = ix; ix2 < last_ix; ix2++)
  739.             {
  740.               oso_el *oso2 = VEC_index (oso_el, vec, ix2);

  742.               if (oso2->name != NULL)
  743.                 warning (_("Could not find specified archive member "
  744.                            "for OSO name \"%s\""), oso->name);
  745.             }
  746.           ix = last_ix;
  747.         }
  748.       else
  749.         {
  750.           bfd *abfd;

  752.           abfd = gdb_bfd_open (oso->name, gnutarget, -1);
  753.           if (!abfd)
  754.             warning (_("`%s': can't open to read symbols: %s."), oso->name,
  755.                      bfd_errmsg (bfd_get_error ()));
  756.           else
  757.             macho_add_oso_symfile (oso, abfd, oso->name, main_objfile,
  758.                                    symfile_flags);

  760.           ix++;
  761.         }
  762.     }

  764.   do_cleanups (cleanup);
  765. }

  767. /* DSYM (debug symbols) files contain the debug info of an executable.
  768.    This is a separate file created by dsymutil(1) and is similar to debug
  769.    link feature on ELF.
  770.    DSYM files are located in a subdirectory.  Append DSYM_SUFFIX to the
  771.    executable name and the executable base name to get the DSYM file name.  */
  772. ‌#define DSYM_SUFFIX ".dSYM/Contents/Resources/DWARF/"

  774. /* Check if a dsym file exists for OBJFILE.  If so, returns a bfd for it
  775.    and return *FILENAMEP with its original xmalloc-ated filename.
  776.    Return NULL if no valid dsym file is found (FILENAMEP is not used in
  777.    such case).  */

  779. static bfd *
  780. ‌macho_check_dsym (struct objfile *objfile, char **filenamep)
  781. {
  782.   size_t name_len = strlen (objfile_name (objfile));
  783.   size_t dsym_len = strlen (DSYM_SUFFIX);
  784.   const char *base_name = lbasename (objfile_name (objfile));
  785.   size_t base_len = strlen (base_name);
  786.   char *dsym_filename = alloca (name_len + dsym_len + base_len + 1);
  787.   bfd *dsym_bfd;
  788.   bfd_mach_o_load_command *main_uuid;
  789.   bfd_mach_o_load_command *dsym_uuid;

  791.   strcpy (dsym_filename, objfile_name (objfile));
  792.   strcpy (dsym_filename + name_len, DSYM_SUFFIX);
  793.   strcpy (dsym_filename + name_len + dsym_len, base_name);

  795.   if (access (dsym_filename, R_OK) != 0)
  796.     return NULL;

  798.   if (bfd_mach_o_lookup_command (objfile->obfd,
  799.                                  BFD_MACH_O_LC_UUID, &main_uuid) == 0)
  800.     {
  801.       warning (_("can't find UUID in %s"), objfile_name (objfile));
  802.       return NULL;
  803.     }
  804.   dsym_bfd = gdb_bfd_openr (dsym_filename, gnutarget);
  805.   if (dsym_bfd == NULL)
  806.     {
  807.       warning (_("can't open dsym file %s"), dsym_filename);
  808.       return NULL;
  809.     }

  811.   if (!bfd_check_format (dsym_bfd, bfd_object))
  812.     {
  813.       gdb_bfd_unref (dsym_bfd);
  814.       warning (_("bad dsym file format: %s"), bfd_errmsg (bfd_get_error ()));
  815.       return NULL;
  816.     }

  818.   if (bfd_mach_o_lookup_command (dsym_bfd,
  819.                                  BFD_MACH_O_LC_UUID, &dsym_uuid) == 0)
  820.     {
  821.       warning (_("can't find UUID in %s"), dsym_filename);
  822.       gdb_bfd_unref (dsym_bfd);
  823.       return NULL;
  824.     }
  825.   if (memcmp (dsym_uuid->command.uuid.uuid, main_uuid->command.uuid.uuid,
  826.               sizeof (main_uuid->command.uuid.uuid)))
  827.     {
  828.       warning (_("dsym file UUID doesn't match the one in %s"),
  829.                objfile_name (objfile));
  830.       gdb_bfd_unref (dsym_bfd);
  831.       return NULL;
  832.     }
  833.   *filenamep = xstrdup (dsym_filename);
  834.   return dsym_bfd;
  835. }

  837. static void
  838. ‌macho_symfile_read (struct objfile *objfile, int symfile_flags)
  839. {
  840.   bfd *abfd = objfile->obfd;
  841.   CORE_ADDR offset;
  842.   long storage_needed;
  843.   bfd *dsym_bfd;
  844.   VEC (oso_el) *oso_vector = NULL;
  845.   struct cleanup *old_chain = make_cleanup (VEC_cleanup (oso_el), &oso_vector);

  847.   /* Get symbols from the symbol table only if the file is an executable.
  848.      The symbol table of object files is not relocated and is expected to
  849.      be in the executable.  */
  850.   if (bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC))
  851.     {
  852.       char *dsym_filename;

  854.       /* Process the normal symbol table first.  */
  855.       storage_needed = bfd_get_symtab_upper_bound (objfile->obfd);
  856.       if (storage_needed < 0)
  857.         error (_("Can't read symbols from %s: %s"),
  858.                bfd_get_filename (objfile->obfd),
  859.                bfd_errmsg (bfd_get_error ()));

  861.       if (storage_needed > 0)
  862.         {
  863.           asymbol **symbol_table;
  864.           long symcount;

  866.           symbol_table = (asymbol **) xmalloc (storage_needed);
  867.           make_cleanup (xfree, symbol_table);

  869.           init_minimal_symbol_collection ();
  870.           make_cleanup_discard_minimal_symbols ();

  872.           symcount = bfd_canonicalize_symtab (objfile->obfd, symbol_table);

  874.           if (symcount < 0)
  875.             error (_("Can't read symbols from %s: %s"),
  876.                    bfd_get_filename (objfile->obfd),
  877.                    bfd_errmsg (bfd_get_error ()));

  879.           macho_symtab_read (objfile, symcount, symbol_table, &oso_vector);

  881.           install_minimal_symbols (objfile);
  882.         }

  884.       /* Try to read .eh_frame / .debug_frame.  */
  885.       /* First, locate these sections.  We ignore the result status
  886.          as it only checks for debug info.  */
  887.       dwarf2_has_info (objfile, NULL);
  888.       dwarf2_build_frame_info (objfile);

  890.       /* Check for DSYM file.  */
  891.       dsym_bfd = macho_check_dsym (objfile, &dsym_filename);
  892.       if (dsym_bfd != NULL)
  893.         {
  894.           int ix;
  895.           oso_el *oso;
  896.           struct bfd_section *asect, *dsect;

  898.           make_cleanup (xfree, dsym_filename);

  900.           if (mach_o_debug_level > 0)
  901.             printf_unfiltered (_("dsym file found\n"));

  903.           /* Set dsym section size.  */
  904.           for (asect = objfile->obfd->sections, dsect = dsym_bfd->sections;
  905.                asect && dsect;
  906.                asect = asect->next, dsect = dsect->next)
  907.             {
  908.               if (strcmp (asect->name, dsect->name) != 0)
  909.                 break;
  910.               bfd_set_section_size (dsym_bfd, dsect,
  911.                                     bfd_get_section_size (asect));
  912.             }

  914.           /* Add the dsym file as a separate file.  */
  915.           make_cleanup_bfd_unref (dsym_bfd);
  916.           symbol_file_add_separate (dsym_bfd, dsym_filename, symfile_flags,
  917.                                     objfile);

  919.           /* Don't try to read dwarf2 from main file or shared libraries.  */
  920.           do_cleanups (old_chain);
  921.           return;
  922.         }
  923.     }

  925.   if (dwarf2_has_info (objfile, NULL))
  926.     {
  927.       /* DWARF 2 sections */
  928.       dwarf2_build_psymtabs (objfile);
  929.     }

  931.   /* Then the oso.  */
  932.   if (oso_vector != NULL)
  933.     macho_symfile_read_all_oso (&oso_vector, objfile, symfile_flags);

  935.   do_cleanups (old_chain);
  936. }

  938. static bfd_byte *
  939. ‌macho_symfile_relocate (struct objfile *objfile, asection *sectp,
  940.                         bfd_byte *buf)
  941. {
  942.   bfd *abfd = objfile->obfd;

  944.   /* We're only interested in sections with relocation
  945.      information.  */
  946.   if ((sectp->flags & SEC_RELOC) == 0)
  947.     return NULL;

  949.   if (mach_o_debug_level > 0)
  950.     printf_unfiltered (_("Relocate section '%s' of %s\n"),
  951.                        sectp->name, objfile_name (objfile));

  953.   return bfd_simple_get_relocated_section_contents (abfd, sectp, buf, NULL);
  954. }

  956. static void
  957. ‌macho_symfile_finish (struct objfile *objfile)
  958. {
  959. }

  961. static void
  962. ‌macho_symfile_offsets (struct objfile *objfile,
  963.                        const struct section_addr_info *addrs)
  964. {
  965.   unsigned int i;
  966.   unsigned int num_sections;
  967.   struct obj_section *osect;

  969.   /* Allocate section_offsets.  */
  970.   objfile->num_sections = bfd_count_sections (objfile->obfd);
  971.   objfile->section_offsets = (struct section_offsets *)
  972.     obstack_alloc (&objfile->objfile_obstack,
  973.                    SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));
  974.   memset (objfile->section_offsets, 0,
  975.           SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));

  977.   /* This code is run when we first add the objfile with
  978.      symfile_add_with_addrs_or_offsets, when "addrs" not "offsets" are
  979.      passed in.  The place in symfile.c where the addrs are applied
  980.      depends on the addrs having section names.  But in the dyld code
  981.      we build an anonymous array of addrs, so that code is a no-op.
  982.      Because of that, we have to apply the addrs to the sections here.
  983.      N.B. if an objfile slides after we've already created it, then it
  984.      goes through objfile_relocate.  */

  986.   for (i = 0; i < addrs->num_sections; i++)
  987.     {
  988.       ALL_OBJFILE_OSECTIONS (objfile, osect)
  989.         {
  990.           const char *bfd_sect_name = osect->the_bfd_section->name;

  992.           if (strcmp (bfd_sect_name, addrs->other[i].name) == 0)
  993.             {
  994.               obj_section_offset (osect) = addrs->other[i].addr;
  995.               break;
  996.             }
  997.         }
  998.     }

  1000.   objfile->sect_index_text = 0;

  1002.   ALL_OBJFILE_OSECTIONS (objfile, osect)
  1003.     {
  1004.       const char *bfd_sect_name = osect->the_bfd_section->name;
  1005.       int sect_index = osect - objfile->sections;;

  1007.       if (strncmp (bfd_sect_name, "LC_SEGMENT.", 11) == 0)
  1008.         bfd_sect_name += 11;
  1009.       if (strcmp (bfd_sect_name, "__TEXT") == 0
  1010.           || strcmp (bfd_sect_name, "__TEXT.__text") == 0)
  1011.         objfile->sect_index_text = sect_index;
  1012.     }
  1013. }

  1015. ‌static const struct sym_fns macho_sym_fns = {
  1016.   macho_new_init,               /* init anything gbl to entire symtab */
  1017.   macho_symfile_init,           /* read initial info, setup for sym_read() */
  1018.   macho_symfile_read,           /* read a symbol file into symtab */
  1019.   NULL,                                /* sym_read_psymbols */
  1020.   macho_symfile_finish,         /* finished with file, cleanup */
  1021.   macho_symfile_offsets,        /* xlate external to internal form */
  1022.   default_symfile_segments,        /* Get segment information from a file.  */
  1023.   NULL,
  1024.   macho_symfile_relocate,        /* Relocate a debug section.  */
  1025.   NULL,                                /* sym_get_probes */
  1026.   &psym_functions
  1027. };

  1029. /* -Wmissing-prototypes */
  1030. extern initialize_file_ftype _initialize_machoread;

  1032. void
  1033. ‌_initialize_machoread (void)
  1034. {
  1035.   add_symtab_fns (bfd_target_mach_o_flavour, &macho_sym_fns);

  1037.   add_setshow_zuinteger_cmd ("mach-o", class_obscure,
  1038.                              &mach_o_debug_level,
  1039.                              _("Set if printing Mach-O symbols processing."),
  1040.                              _("Show if printing Mach-O symbols processing."),
  1041.                              NULL, NULL, NULL,
  1042.                              &setdebuglist, &showdebuglist);
  1043. }