OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [gdb/] [elfread.c] - Blame information for rev 24

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* Read ELF (Executable and Linking Format) object files for GDB.
2
 
3
   Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
4
   2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
5
   Free Software Foundation, Inc.
6
 
7
   Written by Fred Fish at Cygnus Support.
8
 
9
   This file is part of GDB.
10
 
11
   This program is free software; you can redistribute it and/or modify
12
   it under the terms of the GNU General Public License as published by
13
   the Free Software Foundation; either version 3 of the License, or
14
   (at your option) any later version.
15
 
16
   This program is distributed in the hope that it will be useful,
17
   but WITHOUT ANY WARRANTY; without even the implied warranty of
18
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19
   GNU General Public License for more details.
20
 
21
   You should have received a copy of the GNU General Public License
22
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
23
 
24
#include "defs.h"
25
#include "bfd.h"
26
#include "gdb_string.h"
27
#include "elf-bfd.h"
28
#include "elf/common.h"
29
#include "elf/internal.h"
30
#include "elf/mips.h"
31
#include "symtab.h"
32
#include "symfile.h"
33
#include "objfiles.h"
34
#include "buildsym.h"
35
#include "stabsread.h"
36
#include "gdb-stabs.h"
37
#include "complaints.h"
38
#include "demangle.h"
39
 
40
extern void _initialize_elfread (void);
41
 
42
/* The struct elfinfo is available only during ELF symbol table and
43
   psymtab reading.  It is destroyed at the completion of psymtab-reading.
44
   It's local to elf_symfile_read.  */
45
 
46
struct elfinfo
47
  {
48
    asection *stabsect;         /* Section pointer for .stab section */
49
    asection *stabindexsect;    /* Section pointer for .stab.index section */
50
    asection *mdebugsect;       /* Section pointer for .mdebug section */
51
  };
52
 
53
static void free_elfinfo (void *);
54
 
55
/* Locate the segments in ABFD.  */
56
 
57
static struct symfile_segment_data *
58
elf_symfile_segments (bfd *abfd)
59
{
60
  Elf_Internal_Phdr *phdrs, **segments;
61
  long phdrs_size;
62
  int num_phdrs, num_segments, num_sections, i;
63
  asection *sect;
64
  struct symfile_segment_data *data;
65
 
66
  phdrs_size = bfd_get_elf_phdr_upper_bound (abfd);
67
  if (phdrs_size == -1)
68
    return NULL;
69
 
70
  phdrs = alloca (phdrs_size);
71
  num_phdrs = bfd_get_elf_phdrs (abfd, phdrs);
72
  if (num_phdrs == -1)
73
    return NULL;
74
 
75
  num_segments = 0;
76
  segments = alloca (sizeof (Elf_Internal_Phdr *) * num_phdrs);
77
  for (i = 0; i < num_phdrs; i++)
78
    if (phdrs[i].p_type == PT_LOAD)
79
      segments[num_segments++] = &phdrs[i];
80
 
81
  if (num_segments == 0)
82
    return NULL;
83
 
84
  data = XZALLOC (struct symfile_segment_data);
85
  data->num_segments = num_segments;
86
  data->segment_bases = XCALLOC (num_segments, CORE_ADDR);
87
  data->segment_sizes = XCALLOC (num_segments, CORE_ADDR);
88
 
89
  for (i = 0; i < num_segments; i++)
90
    {
91
      data->segment_bases[i] = segments[i]->p_vaddr;
92
      data->segment_sizes[i] = segments[i]->p_memsz;
93
    }
94
 
95
  num_sections = bfd_count_sections (abfd);
96
  data->segment_info = XCALLOC (num_sections, int);
97
 
98
  for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next)
99
    {
100
      int j;
101
      CORE_ADDR vma;
102
 
103
      if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0)
104
        continue;
105
 
106
      vma = bfd_get_section_vma (abfd, sect);
107
 
108
      for (j = 0; j < num_segments; j++)
109
        if (segments[j]->p_memsz > 0
110
            && vma >= segments[j]->p_vaddr
111
            && vma < segments[j]->p_vaddr + segments[j]->p_memsz)
112
          {
113
            data->segment_info[i] = j + 1;
114
            break;
115
          }
116
 
117
      if (bfd_get_section_size (sect) > 0 && j == num_segments)
118
        warning (_("Loadable segment \"%s\" outside of ELF segments"),
119
                 bfd_section_name (abfd, sect));
120
    }
121
 
122
  return data;
123
}
124
 
125
/* We are called once per section from elf_symfile_read.  We
126
   need to examine each section we are passed, check to see
127
   if it is something we are interested in processing, and
128
   if so, stash away some access information for the section.
129
 
130
   For now we recognize the dwarf debug information sections and
131
   line number sections from matching their section names.  The
132
   ELF definition is no real help here since it has no direct
133
   knowledge of DWARF (by design, so any debugging format can be
134
   used).
135
 
136
   We also recognize the ".stab" sections used by the Sun compilers
137
   released with Solaris 2.
138
 
139
   FIXME: The section names should not be hardwired strings (what
140
   should they be?  I don't think most object file formats have enough
141
   section flags to specify what kind of debug section it is
142
   -kingdon).  */
143
 
144
static void
145
elf_locate_sections (bfd *ignore_abfd, asection *sectp, void *eip)
146
{
147
  struct elfinfo *ei;
148
 
149
  ei = (struct elfinfo *) eip;
150
  if (strcmp (sectp->name, ".stab") == 0)
151
    {
152
      ei->stabsect = sectp;
153
    }
154
  else if (strcmp (sectp->name, ".stab.index") == 0)
155
    {
156
      ei->stabindexsect = sectp;
157
    }
158
  else if (strcmp (sectp->name, ".mdebug") == 0)
159
    {
160
      ei->mdebugsect = sectp;
161
    }
162
}
163
 
164
static struct minimal_symbol *
165
record_minimal_symbol (char *name, CORE_ADDR address,
166
                       enum minimal_symbol_type ms_type,
167
                       asection *bfd_section, struct objfile *objfile)
168
{
169
  if (ms_type == mst_text || ms_type == mst_file_text)
170
    address = gdbarch_smash_text_address (current_gdbarch, address);
171
 
172
  return prim_record_minimal_symbol_and_info
173
    (name, address, ms_type, NULL, bfd_section->index, bfd_section, objfile);
174
}
175
 
176
/*
177
 
178
   LOCAL FUNCTION
179
 
180
   elf_symtab_read -- read the symbol table of an ELF file
181
 
182
   SYNOPSIS
183
 
184
   void elf_symtab_read (struct objfile *objfile, int type,
185
                         long number_of_symbols, asymbol **symbol_table)
186
 
187
   DESCRIPTION
188
 
189
   Given an objfile, a symbol table, and a flag indicating whether the
190
   symbol table contains regular, dynamic, or synthetic symbols, add all
191
   the global function and data symbols to the minimal symbol table.
192
 
193
   In stabs-in-ELF, as implemented by Sun, there are some local symbols
194
   defined in the ELF symbol table, which can be used to locate
195
   the beginnings of sections from each ".o" file that was linked to
196
   form the executable objfile.  We gather any such info and record it
197
   in data structures hung off the objfile's private data.
198
 
199
 */
200
 
201
#define ST_REGULAR 0
202
#define ST_DYNAMIC 1
203
#define ST_SYNTHETIC 2
204
 
205
static void
206
elf_symtab_read (struct objfile *objfile, int type,
207
                 long number_of_symbols, asymbol **symbol_table)
208
{
209
  long storage_needed;
210
  asymbol *sym;
211
  long i;
212
  CORE_ADDR symaddr;
213
  CORE_ADDR offset;
214
  enum minimal_symbol_type ms_type;
215
  /* If sectinfo is nonNULL, it contains section info that should end up
216
     filed in the objfile.  */
217
  struct stab_section_info *sectinfo = NULL;
218
  /* If filesym is nonzero, it points to a file symbol, but we haven't
219
     seen any section info for it yet.  */
220
  asymbol *filesym = 0;
221
  /* Name of filesym, as saved on the objfile_obstack.  */
222
  char *filesymname = obsavestring ("", 0, &objfile->objfile_obstack);
223
  struct dbx_symfile_info *dbx = objfile->deprecated_sym_stab_info;
224
  int stripped = (bfd_get_symcount (objfile->obfd) == 0);
225
 
226
  for (i = 0; i < number_of_symbols; i++)
227
    {
228
      sym = symbol_table[i];
229
      if (sym->name == NULL || *sym->name == '\0')
230
        {
231
          /* Skip names that don't exist (shouldn't happen), or names
232
             that are null strings (may happen). */
233
          continue;
234
        }
235
 
236
      /* Skip "special" symbols, e.g. ARM mapping symbols.  These are
237
         symbols which do not correspond to objects in the symbol table,
238
         but have some other target-specific meaning.  */
239
      if (bfd_is_target_special_symbol (objfile->obfd, sym))
240
        continue;
241
 
242
      offset = ANOFFSET (objfile->section_offsets, sym->section->index);
243
      if (type == ST_DYNAMIC
244
          && sym->section == &bfd_und_section
245
          && (sym->flags & BSF_FUNCTION))
246
        {
247
          struct minimal_symbol *msym;
248
          bfd *abfd = objfile->obfd;
249
          asection *sect;
250
 
251
          /* Symbol is a reference to a function defined in
252
             a shared library.
253
             If its value is non zero then it is usually the address
254
             of the corresponding entry in the procedure linkage table,
255
             plus the desired section offset.
256
             If its value is zero then the dynamic linker has to resolve
257
             the symbol. We are unable to find any meaningful address
258
             for this symbol in the executable file, so we skip it.  */
259
          symaddr = sym->value;
260
          if (symaddr == 0)
261
            continue;
262
 
263
          /* sym->section is the undefined section.  However, we want to
264
             record the section where the PLT stub resides with the
265
             minimal symbol.  Search the section table for the one that
266
             covers the stub's address.  */
267
          for (sect = abfd->sections; sect != NULL; sect = sect->next)
268
            {
269
              if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0)
270
                continue;
271
 
272
              if (symaddr >= bfd_get_section_vma (abfd, sect)
273
                  && symaddr < bfd_get_section_vma (abfd, sect)
274
                               + bfd_get_section_size (sect))
275
                break;
276
            }
277
          if (!sect)
278
            continue;
279
 
280
          symaddr += ANOFFSET (objfile->section_offsets, sect->index);
281
 
282
          msym = record_minimal_symbol
283
            ((char *) sym->name, symaddr, mst_solib_trampoline, sect, objfile);
284
          if (msym != NULL)
285
            msym->filename = filesymname;
286
          continue;
287
        }
288
 
289
      /* If it is a nonstripped executable, do not enter dynamic
290
         symbols, as the dynamic symbol table is usually a subset
291
         of the main symbol table.  */
292
      if (type == ST_DYNAMIC && !stripped)
293
        continue;
294
      if (sym->flags & BSF_FILE)
295
        {
296
          /* STT_FILE debugging symbol that helps stabs-in-elf debugging.
297
             Chain any old one onto the objfile; remember new sym.  */
298
          if (sectinfo != NULL)
299
            {
300
              sectinfo->next = dbx->stab_section_info;
301
              dbx->stab_section_info = sectinfo;
302
              sectinfo = NULL;
303
            }
304
          filesym = sym;
305
          filesymname =
306
            obsavestring ((char *) filesym->name, strlen (filesym->name),
307
                          &objfile->objfile_obstack);
308
        }
309
      else if (sym->flags & BSF_SECTION_SYM)
310
        continue;
311
      else if (sym->flags & (BSF_GLOBAL | BSF_LOCAL | BSF_WEAK))
312
        {
313
          struct minimal_symbol *msym;
314
 
315
          /* Select global/local/weak symbols.  Note that bfd puts abs
316
             symbols in their own section, so all symbols we are
317
             interested in will have a section. */
318
          /* Bfd symbols are section relative. */
319
          symaddr = sym->value + sym->section->vma;
320
          /* Relocate all non-absolute symbols by the section offset.  */
321
          if (sym->section != &bfd_abs_section)
322
            {
323
              symaddr += offset;
324
            }
325
          /* For non-absolute symbols, use the type of the section
326
             they are relative to, to intuit text/data.  Bfd provides
327
             no way of figuring this out for absolute symbols. */
328
          if (sym->section == &bfd_abs_section)
329
            {
330
              /* This is a hack to get the minimal symbol type
331
                 right for Irix 5, which has absolute addresses
332
                 with special section indices for dynamic symbols.
333
 
334
                 NOTE: uweigand-20071112: Synthetic symbols do not
335
                 have an ELF-private part, so do not touch those.  */
336
              unsigned short shndx = type == ST_SYNTHETIC ? 0 :
337
                ((elf_symbol_type *) sym)->internal_elf_sym.st_shndx;
338
 
339
              switch (shndx)
340
                {
341
                case SHN_MIPS_TEXT:
342
                  ms_type = mst_text;
343
                  break;
344
                case SHN_MIPS_DATA:
345
                  ms_type = mst_data;
346
                  break;
347
                case SHN_MIPS_ACOMMON:
348
                  ms_type = mst_bss;
349
                  break;
350
                default:
351
                  ms_type = mst_abs;
352
                }
353
 
354
              /* If it is an Irix dynamic symbol, skip section name
355
                 symbols, relocate all others by section offset. */
356
              if (ms_type != mst_abs)
357
                {
358
                  if (sym->name[0] == '.')
359
                    continue;
360
                  symaddr += offset;
361
                }
362
            }
363
          else if (sym->section->flags & SEC_CODE)
364
            {
365
              if (sym->flags & (BSF_GLOBAL | BSF_WEAK))
366
                {
367
                  ms_type = mst_text;
368
                }
369
              else if ((sym->name[0] == '.' && sym->name[1] == 'L')
370
                       || ((sym->flags & BSF_LOCAL)
371
                           && sym->name[0] == '$'
372
                           && sym->name[1] == 'L'))
373
                /* Looks like a compiler-generated label.  Skip
374
                   it.  The assembler should be skipping these (to
375
                   keep executables small), but apparently with
376
                   gcc on the (deleted) delta m88k SVR4, it loses.
377
                   So to have us check too should be harmless (but
378
                   I encourage people to fix this in the assembler
379
                   instead of adding checks here).  */
380
                continue;
381
              else
382
                {
383
                  ms_type = mst_file_text;
384
                }
385
            }
386
          else if (sym->section->flags & SEC_ALLOC)
387
            {
388
              if (sym->flags & (BSF_GLOBAL | BSF_WEAK))
389
                {
390
                  if (sym->section->flags & SEC_LOAD)
391
                    {
392
                      ms_type = mst_data;
393
                    }
394
                  else
395
                    {
396
                      ms_type = mst_bss;
397
                    }
398
                }
399
              else if (sym->flags & BSF_LOCAL)
400
                {
401
                  /* Named Local variable in a Data section.
402
                     Check its name for stabs-in-elf.  */
403
                  int special_local_sect;
404
                  if (strcmp ("Bbss.bss", sym->name) == 0)
405
                    special_local_sect = SECT_OFF_BSS (objfile);
406
                  else if (strcmp ("Ddata.data", sym->name) == 0)
407
                    special_local_sect = SECT_OFF_DATA (objfile);
408
                  else if (strcmp ("Drodata.rodata", sym->name) == 0)
409
                    special_local_sect = SECT_OFF_RODATA (objfile);
410
                  else
411
                    special_local_sect = -1;
412
                  if (special_local_sect >= 0)
413
                    {
414
                      /* Found a special local symbol.  Allocate a
415
                         sectinfo, if needed, and fill it in.  */
416
                      if (sectinfo == NULL)
417
                        {
418
                          int max_index;
419
                          size_t size;
420
 
421
                          max_index
422
                            = max (SECT_OFF_BSS (objfile),
423
                                   max (SECT_OFF_DATA (objfile),
424
                                        SECT_OFF_RODATA (objfile)));
425
 
426
                          /* max_index is the largest index we'll
427
                             use into this array, so we must
428
                             allocate max_index+1 elements for it.
429
                             However, 'struct stab_section_info'
430
                             already includes one element, so we
431
                             need to allocate max_index aadditional
432
                             elements.  */
433
                          size = (sizeof (struct stab_section_info)
434
                                  + (sizeof (CORE_ADDR)
435
                                     * max_index));
436
                          sectinfo = (struct stab_section_info *)
437
                            xmalloc (size);
438
                          memset (sectinfo, 0, size);
439
                          sectinfo->num_sections = max_index;
440
                          if (filesym == NULL)
441
                            {
442
                              complaint (&symfile_complaints,
443
                                         _("elf/stab section information %s without a preceding file symbol"),
444
                                         sym->name);
445
                            }
446
                          else
447
                            {
448
                              sectinfo->filename =
449
                                (char *) filesym->name;
450
                            }
451
                        }
452
                      if (sectinfo->sections[special_local_sect] != 0)
453
                        complaint (&symfile_complaints,
454
                                   _("duplicated elf/stab section information for %s"),
455
                                   sectinfo->filename);
456
                      /* BFD symbols are section relative.  */
457
                      symaddr = sym->value + sym->section->vma;
458
                      /* Relocate non-absolute symbols by the
459
                         section offset.  */
460
                      if (sym->section != &bfd_abs_section)
461
                        symaddr += offset;
462
                      sectinfo->sections[special_local_sect] = symaddr;
463
                      /* The special local symbols don't go in the
464
                         minimal symbol table, so ignore this one.  */
465
                      continue;
466
                    }
467
                  /* Not a special stabs-in-elf symbol, do regular
468
                     symbol processing.  */
469
                  if (sym->section->flags & SEC_LOAD)
470
                    {
471
                      ms_type = mst_file_data;
472
                    }
473
                  else
474
                    {
475
                      ms_type = mst_file_bss;
476
                    }
477
                }
478
              else
479
                {
480
                  ms_type = mst_unknown;
481
                }
482
            }
483
          else
484
            {
485
              /* FIXME:  Solaris2 shared libraries include lots of
486
                 odd "absolute" and "undefined" symbols, that play
487
                 hob with actions like finding what function the PC
488
                 is in.  Ignore them if they aren't text, data, or bss.  */
489
              /* ms_type = mst_unknown; */
490
              continue; /* Skip this symbol. */
491
            }
492
          msym = record_minimal_symbol
493
            ((char *) sym->name, symaddr,
494
             ms_type, sym->section, objfile);
495
 
496
          if (msym)
497
            {
498
              /* Pass symbol size field in via BFD.  FIXME!!!  */
499
              elf_symbol_type *elf_sym;
500
 
501
              /* NOTE: uweigand-20071112: A synthetic symbol does not have an
502
                 ELF-private part.  However, in some cases (e.g. synthetic
503
                 'dot' symbols on ppc64) the udata.p entry is set to point back
504
                 to the original ELF symbol it was derived from.  Get the size
505
                 from that symbol.  */
506
              if (type != ST_SYNTHETIC)
507
                elf_sym = (elf_symbol_type *) sym;
508
              else
509
                elf_sym = (elf_symbol_type *) sym->udata.p;
510
 
511
              if (elf_sym)
512
                MSYMBOL_SIZE(msym) = elf_sym->internal_elf_sym.st_size;
513
            }
514
          if (msym != NULL)
515
            msym->filename = filesymname;
516
          gdbarch_elf_make_msymbol_special (current_gdbarch, sym, msym);
517
        }
518
    }
519
}
520
 
521
/* Scan and build partial symbols for a symbol file.
522
   We have been initialized by a call to elf_symfile_init, which
523
   currently does nothing.
524
 
525
   SECTION_OFFSETS is a set of offsets to apply to relocate the symbols
526
   in each section.  We simplify it down to a single offset for all
527
   symbols.  FIXME.
528
 
529
   MAINLINE is true if we are reading the main symbol
530
   table (as opposed to a shared lib or dynamically loaded file).
531
 
532
   This function only does the minimum work necessary for letting the
533
   user "name" things symbolically; it does not read the entire symtab.
534
   Instead, it reads the external and static symbols and puts them in partial
535
   symbol tables.  When more extensive information is requested of a
536
   file, the corresponding partial symbol table is mutated into a full
537
   fledged symbol table by going back and reading the symbols
538
   for real.
539
 
540
   We look for sections with specific names, to tell us what debug
541
   format to look for:  FIXME!!!
542
 
543
   elfstab_build_psymtabs() handles STABS symbols;
544
   mdebug_build_psymtabs() handles ECOFF debugging information.
545
 
546
   Note that ELF files have a "minimal" symbol table, which looks a lot
547
   like a COFF symbol table, but has only the minimal information necessary
548
   for linking.  We process this also, and use the information to
549
   build gdb's minimal symbol table.  This gives us some minimal debugging
550
   capability even for files compiled without -g.  */
551
 
552
static void
553
elf_symfile_read (struct objfile *objfile, int mainline)
554
{
555
  bfd *abfd = objfile->obfd;
556
  struct elfinfo ei;
557
  struct cleanup *back_to;
558
  CORE_ADDR offset;
559
  long symcount = 0, dynsymcount = 0, synthcount, storage_needed;
560
  asymbol **symbol_table = NULL, **dyn_symbol_table = NULL;
561
  asymbol *synthsyms;
562
 
563
  init_minimal_symbol_collection ();
564
  back_to = make_cleanup_discard_minimal_symbols ();
565
 
566
  memset ((char *) &ei, 0, sizeof (ei));
567
 
568
  /* Allocate struct to keep track of the symfile */
569
  objfile->deprecated_sym_stab_info = (struct dbx_symfile_info *)
570
    xmalloc (sizeof (struct dbx_symfile_info));
571
  memset ((char *) objfile->deprecated_sym_stab_info, 0, sizeof (struct dbx_symfile_info));
572
  make_cleanup (free_elfinfo, (void *) objfile);
573
 
574
  /* Process the normal ELF symbol table first.  This may write some
575
     chain of info into the dbx_symfile_info in objfile->deprecated_sym_stab_info,
576
     which can later be used by elfstab_offset_sections.  */
577
 
578
  storage_needed = bfd_get_symtab_upper_bound (objfile->obfd);
579
  if (storage_needed < 0)
580
    error (_("Can't read symbols from %s: %s"), bfd_get_filename (objfile->obfd),
581
           bfd_errmsg (bfd_get_error ()));
582
 
583
  if (storage_needed > 0)
584
    {
585
      symbol_table = (asymbol **) xmalloc (storage_needed);
586
      make_cleanup (xfree, symbol_table);
587
      symcount = bfd_canonicalize_symtab (objfile->obfd, symbol_table);
588
 
589
      if (symcount < 0)
590
        error (_("Can't read symbols from %s: %s"), bfd_get_filename (objfile->obfd),
591
               bfd_errmsg (bfd_get_error ()));
592
 
593
      elf_symtab_read (objfile, ST_REGULAR, symcount, symbol_table);
594
    }
595
 
596
  /* Add the dynamic symbols.  */
597
 
598
  storage_needed = bfd_get_dynamic_symtab_upper_bound (objfile->obfd);
599
 
600
  if (storage_needed > 0)
601
    {
602
      dyn_symbol_table = (asymbol **) xmalloc (storage_needed);
603
      make_cleanup (xfree, dyn_symbol_table);
604
      dynsymcount = bfd_canonicalize_dynamic_symtab (objfile->obfd,
605
                                                     dyn_symbol_table);
606
 
607
      if (dynsymcount < 0)
608
        error (_("Can't read symbols from %s: %s"), bfd_get_filename (objfile->obfd),
609
               bfd_errmsg (bfd_get_error ()));
610
 
611
      elf_symtab_read (objfile, ST_DYNAMIC, dynsymcount, dyn_symbol_table);
612
    }
613
 
614
  /* Add synthetic symbols - for instance, names for any PLT entries.  */
615
 
616
  synthcount = bfd_get_synthetic_symtab (abfd, symcount, symbol_table,
617
                                         dynsymcount, dyn_symbol_table,
618
                                         &synthsyms);
619
  if (synthcount > 0)
620
    {
621
      asymbol **synth_symbol_table;
622
      long i;
623
 
624
      make_cleanup (xfree, synthsyms);
625
      synth_symbol_table = xmalloc (sizeof (asymbol *) * synthcount);
626
      for (i = 0; i < synthcount; i++)
627
        synth_symbol_table[i] = synthsyms + i;
628
      make_cleanup (xfree, synth_symbol_table);
629
      elf_symtab_read (objfile, ST_SYNTHETIC, synthcount, synth_symbol_table);
630
    }
631
 
632
  /* Install any minimal symbols that have been collected as the current
633
     minimal symbols for this objfile.  The debug readers below this point
634
     should not generate new minimal symbols; if they do it's their
635
     responsibility to install them.  "mdebug" appears to be the only one
636
     which will do this.  */
637
 
638
  install_minimal_symbols (objfile);
639
  do_cleanups (back_to);
640
 
641
  /* Now process debugging information, which is contained in
642
     special ELF sections. */
643
 
644
  /* If we are reinitializing, or if we have never loaded syms yet,
645
     set table to empty.  MAINLINE is cleared so that *_read_psymtab
646
     functions do not all also re-initialize the psymbol table. */
647
  if (mainline)
648
    {
649
      init_psymbol_list (objfile, 0);
650
      mainline = 0;
651
    }
652
 
653
  /* We first have to find them... */
654
  bfd_map_over_sections (abfd, elf_locate_sections, (void *) & ei);
655
 
656
  /* ELF debugging information is inserted into the psymtab in the
657
     order of least informative first - most informative last.  Since
658
     the psymtab table is searched `most recent insertion first' this
659
     increases the probability that more detailed debug information
660
     for a section is found.
661
 
662
     For instance, an object file might contain both .mdebug (XCOFF)
663
     and .debug_info (DWARF2) sections then .mdebug is inserted first
664
     (searched last) and DWARF2 is inserted last (searched first).  If
665
     we don't do this then the XCOFF info is found first - for code in
666
     an included file XCOFF info is useless. */
667
 
668
  if (ei.mdebugsect)
669
    {
670
      const struct ecoff_debug_swap *swap;
671
 
672
      /* .mdebug section, presumably holding ECOFF debugging
673
         information.  */
674
      swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
675
      if (swap)
676
        elfmdebug_build_psymtabs (objfile, swap, ei.mdebugsect);
677
    }
678
  if (ei.stabsect)
679
    {
680
      asection *str_sect;
681
 
682
      /* Stab sections have an associated string table that looks like
683
         a separate section.  */
684
      str_sect = bfd_get_section_by_name (abfd, ".stabstr");
685
 
686
      /* FIXME should probably warn about a stab section without a stabstr.  */
687
      if (str_sect)
688
        elfstab_build_psymtabs (objfile,
689
                                mainline,
690
                                ei.stabsect,
691
                                str_sect->filepos,
692
                                bfd_section_size (abfd, str_sect));
693
    }
694
  if (dwarf2_has_info (objfile))
695
    {
696
      /* DWARF 2 sections */
697
      dwarf2_build_psymtabs (objfile, mainline);
698
    }
699
 
700
  /* FIXME: kettenis/20030504: This still needs to be integrated with
701
     dwarf2read.c in a better way.  */
702
  dwarf2_build_frame_info (objfile);
703
}
704
 
705
/* This cleans up the objfile's deprecated_sym_stab_info pointer, and
706
   the chain of stab_section_info's, that might be dangling from
707
   it.  */
708
 
709
static void
710
free_elfinfo (void *objp)
711
{
712
  struct objfile *objfile = (struct objfile *) objp;
713
  struct dbx_symfile_info *dbxinfo = objfile->deprecated_sym_stab_info;
714
  struct stab_section_info *ssi, *nssi;
715
 
716
  ssi = dbxinfo->stab_section_info;
717
  while (ssi)
718
    {
719
      nssi = ssi->next;
720
      xfree (ssi);
721
      ssi = nssi;
722
    }
723
 
724
  dbxinfo->stab_section_info = 0;        /* Just say No mo info about this.  */
725
}
726
 
727
 
728
/* Initialize anything that needs initializing when a completely new symbol
729
   file is specified (not just adding some symbols from another file, e.g. a
730
   shared library).
731
 
732
   We reinitialize buildsym, since we may be reading stabs from an ELF file.  */
733
 
734
static void
735
elf_new_init (struct objfile *ignore)
736
{
737
  stabsread_new_init ();
738
  buildsym_new_init ();
739
}
740
 
741
/* Perform any local cleanups required when we are done with a particular
742
   objfile.  I.E, we are in the process of discarding all symbol information
743
   for an objfile, freeing up all memory held for it, and unlinking the
744
   objfile struct from the global list of known objfiles. */
745
 
746
static void
747
elf_symfile_finish (struct objfile *objfile)
748
{
749
  if (objfile->deprecated_sym_stab_info != NULL)
750
    {
751
      xfree (objfile->deprecated_sym_stab_info);
752
    }
753
 
754
  dwarf2_free_objfile (objfile);
755
}
756
 
757
/* ELF specific initialization routine for reading symbols.
758
 
759
   It is passed a pointer to a struct sym_fns which contains, among other
760
   things, the BFD for the file whose symbols are being read, and a slot for
761
   a pointer to "private data" which we can fill with goodies.
762
 
763
   For now at least, we have nothing in particular to do, so this function is
764
   just a stub. */
765
 
766
static void
767
elf_symfile_init (struct objfile *objfile)
768
{
769
  /* ELF objects may be reordered, so set OBJF_REORDERED.  If we
770
     find this causes a significant slowdown in gdb then we could
771
     set it in the debug symbol readers only when necessary.  */
772
  objfile->flags |= OBJF_REORDERED;
773
}
774
 
775
/* When handling an ELF file that contains Sun STABS debug info,
776
   some of the debug info is relative to the particular chunk of the
777
   section that was generated in its individual .o file.  E.g.
778
   offsets to static variables are relative to the start of the data
779
   segment *for that module before linking*.  This information is
780
   painfully squirreled away in the ELF symbol table as local symbols
781
   with wierd names.  Go get 'em when needed.  */
782
 
783
void
784
elfstab_offset_sections (struct objfile *objfile, struct partial_symtab *pst)
785
{
786
  char *filename = pst->filename;
787
  struct dbx_symfile_info *dbx = objfile->deprecated_sym_stab_info;
788
  struct stab_section_info *maybe = dbx->stab_section_info;
789
  struct stab_section_info *questionable = 0;
790
  int i;
791
  char *p;
792
 
793
  /* The ELF symbol info doesn't include path names, so strip the path
794
     (if any) from the psymtab filename.  */
795
  while (0 != (p = strchr (filename, '/')))
796
    filename = p + 1;
797
 
798
  /* FIXME:  This linear search could speed up significantly
799
     if it was chained in the right order to match how we search it,
800
     and if we unchained when we found a match. */
801
  for (; maybe; maybe = maybe->next)
802
    {
803
      if (filename[0] == maybe->filename[0]
804
          && strcmp (filename, maybe->filename) == 0)
805
        {
806
          /* We found a match.  But there might be several source files
807
             (from different directories) with the same name.  */
808
          if (0 == maybe->found)
809
            break;
810
          questionable = maybe; /* Might use it later.  */
811
        }
812
    }
813
 
814
  if (maybe == 0 && questionable != 0)
815
    {
816
      complaint (&symfile_complaints,
817
                 _("elf/stab section information questionable for %s"), filename);
818
      maybe = questionable;
819
    }
820
 
821
  if (maybe)
822
    {
823
      /* Found it!  Allocate a new psymtab struct, and fill it in.  */
824
      maybe->found++;
825
      pst->section_offsets = (struct section_offsets *)
826
        obstack_alloc (&objfile->objfile_obstack,
827
                       SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));
828
      for (i = 0; i < maybe->num_sections; i++)
829
        (pst->section_offsets)->offsets[i] = maybe->sections[i];
830
      return;
831
    }
832
 
833
  /* We were unable to find any offsets for this file.  Complain.  */
834
  if (dbx->stab_section_info)   /* If there *is* any info, */
835
    complaint (&symfile_complaints,
836
               _("elf/stab section information missing for %s"), filename);
837
}
838
 
839
/* Register that we are able to handle ELF object file formats.  */
840
 
841
static struct sym_fns elf_sym_fns =
842
{
843
  bfd_target_elf_flavour,
844
  elf_new_init,                 /* sym_new_init: init anything gbl to entire symtab */
845
  elf_symfile_init,             /* sym_init: read initial info, setup for sym_read() */
846
  elf_symfile_read,             /* sym_read: read a symbol file into symtab */
847
  elf_symfile_finish,           /* sym_finish: finished with file, cleanup */
848
  default_symfile_offsets,      /* sym_offsets:  Translate ext. to int. relocation */
849
  elf_symfile_segments,         /* sym_segments: Get segment information from
850
                                   a file.  */
851
  NULL,                         /* sym_read_linetable */
852
  NULL                          /* next: pointer to next struct sym_fns */
853
};
854
 
855
void
856
_initialize_elfread (void)
857
{
858
  add_symtab_fns (&elf_sym_fns);
859
}

powered by: WebSVN 2.1.0

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