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