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