OpenCores
URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [gdb/] [machoread.c] - Blame information for rev 227

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* Darwin support for GDB, the GNU debugger.
2
   Copyright (C) 2008, 2009, 2010 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
 
22
#include "defs.h"
23
#include "symtab.h"
24
#include "gdbtypes.h"
25
#include "bfd.h"
26
#include "symfile.h"
27
#include "objfiles.h"
28
#include "buildsym.h"
29
#include "gdbcmd.h"
30
#include "gdbcore.h"
31
#include "mach-o.h"
32
#include "gdb_assert.h"
33
#include "aout/stab_gnu.h"
34
#include "vec.h"
35
 
36
#include <string.h>
37
 
38
/* If non-zero displays debugging message.  */
39
static 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.  */
51
  const char *name;
52
 
53
  /* Associated time stamp.  */
54
  unsigned long mtime;
55
 
56
  /* Number of sections.  This is the length of SYMBOLS and OFFSETS array.  */
57
  int num_sections;
58
 
59
  /* Each seaction of the object file is represented by a symbol and its
60
     offset.  If the offset is 0, we assume that the symbol is at offset 0
61
     in the OSO object file and a symbol lookup in the main file is
62
     required to get the offset.  */
63
  asymbol **symbols;
64
  bfd_vma *offsets;
65
}
66
oso_el;
67
 
68
/* Vector of object files to be read after the executable.  This is one
69
   global variable but it's life-time is the one of macho_symfile_read.  */
70
DEF_VEC_O (oso_el);
71
static VEC (oso_el) *oso_vector;
72
 
73
struct macho_oso_data
74
{
75
  /* Per objfile symbol table.  This is used to apply relocation to sections
76
     It is loaded only once, then relocated, and free after sections are
77
     relocated.  */
78
  asymbol **symbol_table;
79
 
80
  /* The offsets for this objfile.  Used to relocate the symbol_table.  */
81
  struct oso_el *oso;
82
 
83
  struct objfile *main_objfile;
84
};
85
 
86
/* Data for OSO being processed.  */
87
 
88
static struct macho_oso_data current_oso;
89
 
90
static void
91
macho_new_init (struct objfile *objfile)
92
{
93
}
94
 
95
static void
96
macho_symfile_init (struct objfile *objfile)
97
{
98
  objfile->flags |= OBJF_REORDERED;
99
  init_entry_point_info (objfile);
100
}
101
 
102
/*  Add a new OSO to the vector of OSO to load.  */
103
 
104
static void
105
macho_register_oso (const asymbol *oso_sym, int nbr_sections,
106
                    asymbol **symbols, bfd_vma *offsets)
107
{
108
  oso_el el;
109
 
110
  el.name = oso_sym->name;
111
  el.mtime = oso_sym->value;
112
  el.num_sections = nbr_sections;
113
  el.symbols = symbols;
114
  el.offsets = offsets;
115
  VEC_safe_push (oso_el, oso_vector, &el);
116
}
117
 
118
/* Build the minimal symbol table from SYMBOL_TABLE of length
119
   NUMBER_OF_SYMBOLS for OBJFILE.
120
   Read OSO files at the end.  */
121
 
122
static void
123
macho_symtab_read (struct objfile *objfile,
124
                   long number_of_symbols, asymbol **symbol_table)
125
{
126
  struct gdbarch *gdbarch = get_objfile_arch (objfile);
127
  long storage_needed;
128
  long i, j;
129
  CORE_ADDR offset;
130
  enum minimal_symbol_type ms_type;
131
  unsigned int nbr_sections = bfd_count_sections (objfile->obfd);
132
  asymbol **first_symbol = NULL;
133
  bfd_vma *first_offset = NULL;
134
  const asymbol *oso_file = NULL;
135
 
136
  for (i = 0; i < number_of_symbols; i++)
137
    {
138
      asymbol *sym = symbol_table[i];
139
      bfd_mach_o_asymbol *mach_o_sym = (bfd_mach_o_asymbol *)sym;
140
 
141
      offset = ANOFFSET (objfile->section_offsets, sym->section->index);
142
 
143
      if (sym->flags & BSF_DEBUGGING)
144
        {
145
          bfd_vma addr;
146
 
147
          /* Debugging symbols are used to collect OSO file names as well
148
             as section offsets.  */
149
 
150
          switch (mach_o_sym->n_type)
151
            {
152
            case N_SO:
153
              /* An empty SO entry terminates a chunk for an OSO file.  */
154
              if ((sym->name == NULL || sym->name[0] == 0) && oso_file != NULL)
155
                {
156
                  macho_register_oso (oso_file, nbr_sections,
157
                                      first_symbol, first_offset);
158
                  first_symbol = NULL;
159
                  first_offset = NULL;
160
                  oso_file = NULL;
161
                }
162
              break;
163
            case N_FUN:
164
            case N_STSYM:
165
              if (sym->name == NULL || sym->name[0] == '\0')
166
                break;
167
              /* Fall through.  */
168
            case N_BNSYM:
169
              gdb_assert (oso_file != NULL);
170
              addr = sym->value
171
                + bfd_get_section_vma (sym->section->bfd, sym->section);
172
              if (addr != 0
173
                  && first_symbol[sym->section->index] == NULL)
174
                {
175
                  /* These STAB entries can directly relocate a section.  */
176
                  first_symbol[sym->section->index] = sym;
177
                  first_offset[sym->section->index] = addr + offset;
178
                }
179
              break;
180
            case N_GSYM:
181
              gdb_assert (oso_file != NULL);
182
              if (first_symbol[sym->section->index] == NULL)
183
                {
184
                  /* This STAB entry needs a symbol look-up to relocate
185
                     the section.  */
186
                  first_symbol[sym->section->index] = sym;
187
                  first_offset[sym->section->index] = 0;
188
                }
189
              break;
190
            case N_OSO:
191
              /* New OSO file.  */
192
              gdb_assert (oso_file == NULL);
193
              first_symbol = (asymbol **)xmalloc (nbr_sections
194
                                                  * sizeof (asymbol *));
195
              first_offset = (bfd_vma *)xmalloc (nbr_sections
196
                                                 * sizeof (bfd_vma));
197
              for (j = 0; j < nbr_sections; j++)
198
                first_symbol[j] = NULL;
199
              oso_file = sym;
200
              break;
201
            }
202
          continue;
203
        }
204
 
205
      if (sym->name == NULL || *sym->name == '\0')
206
        {
207
          /* Skip names that don't exist (shouldn't happen), or names
208
             that are null strings (may happen). */
209
          continue;
210
        }
211
 
212
      if (sym->flags & (BSF_GLOBAL | BSF_LOCAL | BSF_WEAK))
213
        {
214
          struct minimal_symbol *msym;
215
          CORE_ADDR symaddr;
216
 
217
          /* Bfd symbols are section relative. */
218
          symaddr = sym->value + sym->section->vma;
219
 
220
          /* Select global/local/weak symbols.  Note that bfd puts abs
221
             symbols in their own section, so all symbols we are
222
             interested in will have a section. */
223
          /* Relocate all non-absolute and non-TLS symbols by the
224
             section offset.  */
225
          if (sym->section != &bfd_abs_section
226
              && !(sym->section->flags & SEC_THREAD_LOCAL))
227
            symaddr += offset;
228
 
229
          if (sym->section == &bfd_abs_section)
230
            ms_type = mst_abs;
231
          else if (sym->section->flags & SEC_CODE)
232
            {
233
              if (sym->flags & (BSF_GLOBAL | BSF_WEAK))
234
                ms_type = mst_text;
235
              else
236
                ms_type = mst_file_text;
237
            }
238
          else if (sym->section->flags & SEC_ALLOC)
239
            {
240
              if (sym->flags & (BSF_GLOBAL | BSF_WEAK))
241
                {
242
                  if (sym->section->flags & SEC_LOAD)
243
                    ms_type = mst_data;
244
                  else
245
                    ms_type = mst_bss;
246
                }
247
              else if (sym->flags & BSF_LOCAL)
248
                {
249
                  /* Not a special stabs-in-elf symbol, do regular
250
                     symbol processing.  */
251
                  if (sym->section->flags & SEC_LOAD)
252
                    ms_type = mst_file_data;
253
                  else
254
                    ms_type = mst_file_bss;
255
                }
256
              else
257
                ms_type = mst_unknown;
258
            }
259
          else
260
            continue;   /* Skip this symbol. */
261
 
262
          gdb_assert (sym->section->index < nbr_sections);
263
          if (oso_file != NULL
264
              && first_symbol[sym->section->index] == NULL)
265
            {
266
              /* Standard symbols can directly relocate sections.  */
267
              first_symbol[sym->section->index] = sym;
268
              first_offset[sym->section->index] = symaddr;
269
            }
270
 
271
          msym = prim_record_minimal_symbol_and_info
272
            (sym->name, symaddr, ms_type, sym->section->index,
273
             sym->section, objfile);
274
        }
275
    }
276
 
277
  /* Just in case there is no trailing SO entry.  */
278
  if (oso_file != NULL)
279
    macho_register_oso (oso_file, nbr_sections, first_symbol, first_offset);
280
}
281
 
282
/* If NAME describes an archive member (ie: ARCHIVE '(' MEMBER ')'),
283
   returns the length of the archive name.
284
   Returns -1 otherwise.  */
285
 
286
static int
287
get_archive_prefix_len (const char *name)
288
{
289
  char *lparen;
290
  int name_len = strlen (name);
291
 
292
  if (name_len == 0 || name[name_len - 1] != ')')
293
    return -1;
294
 
295
  lparen = strrchr (name, '(');
296
  if (lparen == NULL || lparen == name)
297
    return -1;
298
  return lparen - name;
299
}
300
 
301
static int
302
oso_el_compare_name (const void *vl, const void *vr)
303
{
304
  const oso_el *l = (const oso_el *)vl;
305
  const oso_el *r = (const oso_el *)vr;
306
 
307
  return strcmp (l->name, r->name);
308
}
309
 
310
/* Add an oso file as a symbol file.  */
311
 
312
static void
313
macho_add_oso_symfile (oso_el *oso, bfd *abfd,
314
                       struct objfile *main_objfile, int symfile_flags)
315
{
316
  struct objfile *objfile;
317
  int i;
318
  char leading_char;
319
 
320
  if (mach_o_debug_level > 0)
321
    printf_unfiltered (_("Loading symbols from oso: %s\n"), oso->name);
322
 
323
  if (!bfd_check_format (abfd, bfd_object))
324
    {
325
      warning (_("`%s': can't read symbols: %s."), oso->name,
326
               bfd_errmsg (bfd_get_error ()));
327
      bfd_close (abfd);
328
      return;
329
    }
330
 
331
  bfd_set_cacheable (abfd, 1);
332
 
333
  /* Relocate sections.  */
334
 
335
  leading_char = bfd_get_symbol_leading_char (main_objfile->obfd);
336
 
337
  for (i = 0; i < oso->num_sections; i++)
338
    {
339
      asection *sect;
340
      const char *sectname;
341
      bfd_vma vma;
342
 
343
      /* Empty slot.  */
344
      if (oso->symbols[i] == NULL)
345
        continue;
346
 
347
      if (oso->offsets[i])
348
        vma = oso->offsets[i];
349
      else
350
        {
351
          struct minimal_symbol *msym;
352
          const char *name = oso->symbols[i]->name;
353
 
354
          if (name[0] == leading_char)
355
            ++name;
356
 
357
          if (mach_o_debug_level > 3)
358
            printf_unfiltered (_("resolve sect %s with %s\n"),
359
                               oso->symbols[i]->section->name,
360
                               oso->symbols[i]->name);
361
          msym = lookup_minimal_symbol (name, NULL, main_objfile);
362
          if (msym == NULL)
363
            {
364
              warning (_("can't find symbol '%s' in minsymtab"), name);
365
              continue;
366
            }
367
          else
368
            vma = SYMBOL_VALUE_ADDRESS (msym);
369
        }
370
      sectname = (char *)oso->symbols[i]->section->name;
371
 
372
      sect = bfd_get_section_by_name (abfd, sectname);
373
      if (sect == NULL)
374
        {
375
          warning (_("can't find section '%s' in OSO file %s"),
376
                   sectname, oso->name);
377
          continue;
378
        }
379
      bfd_set_section_vma (abfd, sect, vma);
380
 
381
      if (mach_o_debug_level > 1)
382
        printf_unfiltered (_("  %s: %s\n"),
383
                           core_addr_to_string (vma), sectname);
384
    }
385
 
386
  /* Make sure that the filename was malloc'ed.  The current filename comes
387
     either from an OSO symbol name or from an archive name.  Memory for both
388
     is not managed by gdb.  */
389
  abfd->filename = xstrdup (abfd->filename);
390
 
391
  gdb_assert (current_oso.symbol_table == NULL);
392
  current_oso.main_objfile = main_objfile;
393
 
394
  /* We need to clear SYMFILE_MAINLINE to avoid interractive question
395
     from symfile.c:symbol_file_add_with_addrs_or_offsets.  */
396
  objfile = symbol_file_add_from_bfd
397
    (abfd, symfile_flags & ~(SYMFILE_MAINLINE | SYMFILE_VERBOSE), NULL,
398
     main_objfile->flags & (OBJF_REORDERED | OBJF_SHARED
399
                            | OBJF_READNOW | OBJF_USERLOADED));
400
  add_separate_debug_objfile (objfile, main_objfile);
401
 
402
  current_oso.main_objfile = NULL;
403
  if (current_oso.symbol_table)
404
    {
405
      xfree (current_oso.symbol_table);
406
      current_oso.symbol_table = NULL;
407
    }
408
}
409
 
410
/* Read symbols from the vector of oso files.  */
411
 
412
static void
413
macho_symfile_read_all_oso (struct objfile *main_objfile, int symfile_flags)
414
{
415
  int ix;
416
  VEC (oso_el) *vec;
417
  oso_el *oso;
418
 
419
  vec = oso_vector;
420
  oso_vector = NULL;
421
 
422
  /* Sort oso by name so that files from libraries are gathered.  */
423
  qsort (VEC_address (oso_el, vec), VEC_length (oso_el, vec),
424
         sizeof (oso_el), oso_el_compare_name);
425
 
426
  for (ix = 0; VEC_iterate (oso_el, vec, ix, oso);)
427
    {
428
      int pfx_len;
429
 
430
      /* Check if this is a library name.  */
431
      pfx_len = get_archive_prefix_len (oso->name);
432
      if (pfx_len > 0)
433
        {
434
          bfd *archive_bfd;
435
          bfd *member_bfd;
436
          char *archive_name = XNEWVEC (char, pfx_len + 1);
437
          int last_ix;
438
          oso_el *oso2;
439
          int ix2;
440
 
441
          memcpy (archive_name, oso->name, pfx_len);
442
          archive_name[pfx_len] = '\0';
443
 
444
          /* Compute number of oso for this archive.  */
445
          for (last_ix = ix;
446
               VEC_iterate (oso_el, vec, last_ix, oso2); last_ix++)
447
            {
448
              if (strncmp (oso2->name, archive_name, pfx_len) != 0)
449
                break;
450
            }
451
 
452
          /* Open the archive and check the format.  */
453
          archive_bfd = bfd_openr (archive_name, gnutarget);
454
          if (archive_bfd == NULL)
455
            {
456
              warning (_("Could not open OSO archive file \"%s\""),
457
                       archive_name);
458
              ix = last_ix;
459
              continue;
460
            }
461
          if (!bfd_check_format (archive_bfd, bfd_archive))
462
            {
463
              warning (_("OSO archive file \"%s\" not an archive."),
464
                       archive_name);
465
              bfd_close (archive_bfd);
466
              ix = last_ix;
467
              continue;
468
            }
469
          member_bfd = bfd_openr_next_archived_file (archive_bfd, NULL);
470
 
471
          if (member_bfd == NULL)
472
            {
473
              warning (_("Could not read archive members out of "
474
                         "OSO archive \"%s\""), archive_name);
475
              bfd_close (archive_bfd);
476
              ix = last_ix;
477
              continue;
478
            }
479
 
480
          /* Load all oso in this library.  */
481
          while (member_bfd != NULL)
482
            {
483
              bfd *prev;
484
              const char *member_name = member_bfd->filename;
485
              int member_len = strlen (member_name);
486
 
487
              /* If this member is referenced, add it as a symfile.  */
488
              for (ix2 = ix; ix2 < last_ix; ix2++)
489
                {
490
                  oso2 = VEC_index (oso_el, vec, ix2);
491
 
492
                  if (oso2->name
493
                      && strlen (oso2->name) == pfx_len + member_len + 2
494
                      && !memcmp (member_name, oso2->name + pfx_len + 1,
495
                                  member_len))
496
                    {
497
                      macho_add_oso_symfile (oso2, member_bfd,
498
                                             main_objfile, symfile_flags);
499
                      oso2->name = NULL;
500
                      break;
501
                    }
502
                }
503
 
504
              prev = member_bfd;
505
              member_bfd = bfd_openr_next_archived_file
506
                (archive_bfd, member_bfd);
507
 
508
              /* Free previous member if not referenced by an oso.  */
509
              if (ix2 >= last_ix)
510
                bfd_close (prev);
511
            }
512
          for (ix2 = ix; ix2 < last_ix; ix2++)
513
            {
514
              oso_el *oso2 = VEC_index (oso_el, vec, ix2);
515
 
516
              if (oso2->name != NULL)
517
                warning (_("Could not find specified archive member "
518
                           "for OSO name \"%s\""), oso->name);
519
            }
520
          ix = last_ix;
521
        }
522
      else
523
        {
524
          bfd *abfd;
525
 
526
          abfd = bfd_openr (oso->name, gnutarget);
527
          if (!abfd)
528
            warning (_("`%s': can't open to read symbols: %s."), oso->name,
529
                     bfd_errmsg (bfd_get_error ()));
530
          else
531
            macho_add_oso_symfile (oso, abfd, main_objfile, symfile_flags);
532
 
533
          ix++;
534
        }
535
    }
536
 
537
  for (ix = 0; VEC_iterate (oso_el, vec, ix, oso); ix++)
538
    {
539
      xfree (oso->symbols);
540
      xfree (oso->offsets);
541
    }
542
  VEC_free (oso_el, vec);
543
}
544
 
545
/* DSYM (debug symbols) files contain the debug info of an executable.
546
   This is a separate file created by dsymutil(1) and is similar to debug
547
   link feature on ELF.
548
   DSYM files are located in a subdirectory.  Append DSYM_SUFFIX to the
549
   executable name and the executable base name to get the DSYM file name.  */
550
#define DSYM_SUFFIX ".dSYM/Contents/Resources/DWARF/"
551
 
552
/* Check if a dsym file exists for OBJFILE.  If so, returns a bfd for it.
553
   Return NULL if no valid dsym file is found.  */
554
 
555
static bfd *
556
macho_check_dsym (struct objfile *objfile)
557
{
558
  size_t name_len = strlen (objfile->name);
559
  size_t dsym_len = strlen (DSYM_SUFFIX);
560
  const char *base_name = lbasename (objfile->name);
561
  size_t base_len = strlen (base_name);
562
  char *dsym_filename = alloca (name_len + dsym_len + base_len + 1);
563
  bfd *dsym_bfd;
564
  bfd_mach_o_load_command *main_uuid;
565
  bfd_mach_o_load_command *dsym_uuid;
566
 
567
  strcpy (dsym_filename, objfile->name);
568
  strcpy (dsym_filename + name_len, DSYM_SUFFIX);
569
  strcpy (dsym_filename + name_len + dsym_len, base_name);
570
 
571
  if (access (dsym_filename, R_OK) != 0)
572
    return NULL;
573
 
574
  if (bfd_mach_o_lookup_command (objfile->obfd,
575
                                 BFD_MACH_O_LC_UUID, &main_uuid) == 0)
576
    {
577
      warning (_("can't find UUID in %s"), objfile->name);
578
      return NULL;
579
    }
580
  dsym_filename = xstrdup (dsym_filename);
581
  dsym_bfd = bfd_openr (dsym_filename, gnutarget);
582
  if (dsym_bfd == NULL)
583
    {
584
      warning (_("can't open dsym file %s"), dsym_filename);
585
      xfree (dsym_filename);
586
      return NULL;
587
    }
588
 
589
  if (!bfd_check_format (dsym_bfd, bfd_object))
590
    {
591
      bfd_close (dsym_bfd);
592
      warning (_("bad dsym file format: %s"), bfd_errmsg (bfd_get_error ()));
593
      xfree (dsym_filename);
594
      return NULL;
595
    }
596
 
597
  if (bfd_mach_o_lookup_command (dsym_bfd,
598
                                 BFD_MACH_O_LC_UUID, &dsym_uuid) == 0)
599
    {
600
      warning (_("can't find UUID in %s"), dsym_filename);
601
      bfd_close (dsym_bfd);
602
      xfree (dsym_filename);
603
      return NULL;
604
    }
605
  if (memcmp (dsym_uuid->command.uuid.uuid, main_uuid->command.uuid.uuid,
606
              sizeof (main_uuid->command.uuid.uuid)))
607
    {
608
      warning (_("dsym file UUID doesn't match the one in %s"), objfile->name);
609
      bfd_close (dsym_bfd);
610
      xfree (dsym_filename);
611
      return NULL;
612
    }
613
  return dsym_bfd;
614
}
615
 
616
static void
617
macho_symfile_read (struct objfile *objfile, int symfile_flags)
618
{
619
  bfd *abfd = objfile->obfd;
620
  struct cleanup *back_to;
621
  CORE_ADDR offset;
622
  long storage_needed;
623
  bfd *dsym_bfd;
624
 
625
  init_minimal_symbol_collection ();
626
  back_to = make_cleanup_discard_minimal_symbols ();
627
 
628
  /* Get symbols from the symbol table only if the file is an executable.
629
     The symbol table of object files is not relocated and is expected to
630
     be in the executable.  */
631
  if (bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC))
632
    {
633
      /* Process the normal symbol table first.  */
634
      storage_needed = bfd_get_symtab_upper_bound (objfile->obfd);
635
      if (storage_needed < 0)
636
        error (_("Can't read symbols from %s: %s"),
637
               bfd_get_filename (objfile->obfd),
638
               bfd_errmsg (bfd_get_error ()));
639
 
640
      if (storage_needed > 0)
641
        {
642
          asymbol **symbol_table;
643
          long symcount;
644
 
645
          symbol_table = (asymbol **) xmalloc (storage_needed);
646
          make_cleanup (xfree, symbol_table);
647
          symcount = bfd_canonicalize_symtab (objfile->obfd, symbol_table);
648
 
649
          if (symcount < 0)
650
            error (_("Can't read symbols from %s: %s"),
651
                   bfd_get_filename (objfile->obfd),
652
                   bfd_errmsg (bfd_get_error ()));
653
 
654
          macho_symtab_read (objfile, symcount, symbol_table);
655
        }
656
 
657
      install_minimal_symbols (objfile);
658
 
659
      /* Try to read .eh_frame / .debug_frame.  */
660
      /* First, locate these sections.  We ignore the result status
661
         as it only checks for debug info.  */
662
      dwarf2_has_info (objfile);
663
      dwarf2_build_frame_info (objfile);
664
 
665
      /* Check for DSYM file.  */
666
      dsym_bfd = macho_check_dsym (objfile);
667
      if (dsym_bfd != NULL)
668
        {
669
          int ix;
670
          oso_el *oso;
671
          struct bfd_section *asect, *dsect;
672
 
673
          if (mach_o_debug_level > 0)
674
            printf_unfiltered (_("dsym file found\n"));
675
 
676
          /* Remove oso.  They won't be used.  */
677
          for (ix = 0; VEC_iterate (oso_el, oso_vector, ix, oso); ix++)
678
            {
679
              xfree (oso->symbols);
680
              xfree (oso->offsets);
681
            }
682
          VEC_free (oso_el, oso_vector);
683
          oso_vector = NULL;
684
 
685
          /* Set dsym section size.  */
686
          for (asect = objfile->obfd->sections, dsect = dsym_bfd->sections;
687
               asect && dsect;
688
               asect = asect->next, dsect = dsect->next)
689
            {
690
              if (strcmp (asect->name, dsect->name) != 0)
691
                break;
692
              bfd_set_section_size (dsym_bfd, dsect,
693
                                    bfd_get_section_size (asect));
694
            }
695
 
696
          /* Add the dsym file as a separate file.  */
697
          symbol_file_add_separate (dsym_bfd, symfile_flags, objfile);
698
 
699
          /* Don't try to read dwarf2 from main file or shared libraries.  */
700
          return;
701
        }
702
    }
703
 
704
  if (dwarf2_has_info (objfile))
705
    {
706
      /* DWARF 2 sections */
707
      dwarf2_build_psymtabs (objfile);
708
    }
709
 
710
  /* Do not try to read .eh_frame/.debug_frame as they are not relocated
711
     and dwarf2_build_frame_info cannot deal with unrelocated sections.  */
712
 
713
  /* Then the oso.  */
714
  if (oso_vector != NULL)
715
    macho_symfile_read_all_oso (objfile, symfile_flags);
716
}
717
 
718
static bfd_byte *
719
macho_symfile_relocate (struct objfile *objfile, asection *sectp,
720
                        bfd_byte *buf)
721
{
722
  bfd *abfd = objfile->obfd;
723
 
724
  /* We're only interested in sections with relocation
725
     information.  */
726
  if ((sectp->flags & SEC_RELOC) == 0)
727
    return NULL;
728
 
729
  if (mach_o_debug_level > 0)
730
    printf_unfiltered (_("Relocate section '%s' of %s\n"),
731
                       sectp->name, objfile->name);
732
 
733
  if (current_oso.symbol_table == NULL)
734
    {
735
      int storage;
736
      int i;
737
      char leading_char;
738
 
739
      storage = bfd_get_symtab_upper_bound (abfd);
740
      current_oso.symbol_table = (asymbol **) xmalloc (storage);
741
      bfd_canonicalize_symtab (abfd, current_oso.symbol_table);
742
 
743
      leading_char = bfd_get_symbol_leading_char (abfd);
744
 
745
      for (i = 0; current_oso.symbol_table[i]; i++)
746
        {
747
          asymbol *sym = current_oso.symbol_table[i];
748
 
749
          if (bfd_is_com_section (sym->section))
750
            {
751
              /* This one must be solved.  */
752
              struct minimal_symbol *msym;
753
              const char *name = sym->name;
754
 
755
              if (name[0] == leading_char)
756
                name++;
757
 
758
              msym = lookup_minimal_symbol
759
                (name, NULL, current_oso.main_objfile);
760
              if (msym == NULL)
761
                {
762
                  warning (_("can't find symbol '%s' in minsymtab"), name);
763
                  continue;
764
                }
765
              else
766
                {
767
                  sym->section = &bfd_abs_section;
768
                  sym->value = SYMBOL_VALUE_ADDRESS (msym);
769
                }
770
            }
771
        }
772
    }
773
 
774
  return bfd_simple_get_relocated_section_contents (abfd, sectp, buf, NULL);
775
}
776
 
777
static void
778
macho_symfile_finish (struct objfile *objfile)
779
{
780
}
781
 
782
static void
783
macho_symfile_offsets (struct objfile *objfile,
784
                       struct section_addr_info *addrs)
785
{
786
  unsigned int i;
787
  unsigned int num_sections;
788
  struct obj_section *osect;
789
 
790
  /* Allocate section_offsets.  */
791
  objfile->num_sections = bfd_count_sections (objfile->obfd);
792
  objfile->section_offsets = (struct section_offsets *)
793
    obstack_alloc (&objfile->objfile_obstack,
794
                   SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));
795
  memset (objfile->section_offsets, 0,
796
          SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));
797
 
798
  /* This code is run when we first add the objfile with
799
     symfile_add_with_addrs_or_offsets, when "addrs" not "offsets" are
800
     passed in.  The place in symfile.c where the addrs are applied
801
     depends on the addrs having section names.  But in the dyld code
802
     we build an anonymous array of addrs, so that code is a no-op.
803
     Because of that, we have to apply the addrs to the sections here.
804
     N.B. if an objfile slides after we've already created it, then it
805
     goes through objfile_relocate.  */
806
 
807
  for (i = 0; i < addrs->num_sections; i++)
808
    {
809
      if (addrs->other[i].name == NULL)
810
        continue;
811
 
812
      ALL_OBJFILE_OSECTIONS (objfile, osect)
813
        {
814
          const char *bfd_sect_name = osect->the_bfd_section->name;
815
 
816
          if (strcmp (bfd_sect_name, addrs->other[i].name) == 0)
817
            {
818
              obj_section_offset (osect) = addrs->other[i].addr;
819
              break;
820
            }
821
        }
822
    }
823
 
824
  objfile->sect_index_text = 0;
825
 
826
  ALL_OBJFILE_OSECTIONS (objfile, osect)
827
    {
828
      const char *bfd_sect_name = osect->the_bfd_section->name;
829
      int sect_index = osect->the_bfd_section->index;
830
 
831
      if (strncmp (bfd_sect_name, "LC_SEGMENT.", 11) == 0)
832
        bfd_sect_name += 11;
833
      if (strcmp (bfd_sect_name, "__TEXT") == 0
834
          || strcmp (bfd_sect_name, "__TEXT.__text") == 0)
835
        objfile->sect_index_text = sect_index;
836
    }
837
}
838
 
839
static struct sym_fns macho_sym_fns = {
840
  bfd_target_mach_o_flavour,
841
 
842
  macho_new_init,               /* sym_new_init: init anything gbl to entire symtab */
843
  macho_symfile_init,           /* sym_init: read initial info, setup for sym_read() */
844
  macho_symfile_read,           /* sym_read: read a symbol file into symtab */
845
  macho_symfile_finish,         /* sym_finish: finished with file, cleanup */
846
  macho_symfile_offsets,        /* sym_offsets:  xlate external to internal form */
847
  default_symfile_segments,     /* sym_segments: Get segment information from
848
                                   a file.  */
849
  NULL,                         /* sym_read_linetable */
850
  macho_symfile_relocate,       /* sym_relocate: Relocate a debug section.  */
851
 
852
  NULL                          /* next: pointer to next struct sym_fns */
853
};
854
 
855
void
856
_initialize_machoread ()
857
{
858
  add_symtab_fns (&macho_sym_fns);
859
 
860
  add_setshow_zinteger_cmd ("mach-o", class_obscure,
861
                            &mach_o_debug_level, _("\
862
Set if printing Mach-O symbols processing."), _("\
863
Show if printing Mach-O symbols processing."), NULL,
864
                            NULL, NULL,
865
                            &setdebuglist, &showdebuglist);
866
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.