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

Subversion Repositories openrisc_me

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

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 225 jeremybenn
                 have an ELF-private part, so do not touch those.
336
 
337
                 JPB - updated to use int rather than short for compatiblity
338
                 with latest binutils.  */
339
              unsigned int shndx = type == ST_SYNTHETIC ? 0 :
340 24 jeremybenn
                ((elf_symbol_type *) sym)->internal_elf_sym.st_shndx;
341
 
342
              switch (shndx)
343
                {
344
                case SHN_MIPS_TEXT:
345
                  ms_type = mst_text;
346
                  break;
347
                case SHN_MIPS_DATA:
348
                  ms_type = mst_data;
349
                  break;
350
                case SHN_MIPS_ACOMMON:
351
                  ms_type = mst_bss;
352
                  break;
353
                default:
354
                  ms_type = mst_abs;
355
                }
356
 
357
              /* If it is an Irix dynamic symbol, skip section name
358
                 symbols, relocate all others by section offset. */
359
              if (ms_type != mst_abs)
360
                {
361
                  if (sym->name[0] == '.')
362
                    continue;
363
                  symaddr += offset;
364
                }
365
            }
366
          else if (sym->section->flags & SEC_CODE)
367
            {
368
              if (sym->flags & (BSF_GLOBAL | BSF_WEAK))
369
                {
370
                  ms_type = mst_text;
371
                }
372
              else if ((sym->name[0] == '.' && sym->name[1] == 'L')
373
                       || ((sym->flags & BSF_LOCAL)
374
                           && sym->name[0] == '$'
375
                           && sym->name[1] == 'L'))
376
                /* Looks like a compiler-generated label.  Skip
377
                   it.  The assembler should be skipping these (to
378
                   keep executables small), but apparently with
379
                   gcc on the (deleted) delta m88k SVR4, it loses.
380
                   So to have us check too should be harmless (but
381
                   I encourage people to fix this in the assembler
382
                   instead of adding checks here).  */
383
                continue;
384
              else
385
                {
386
                  ms_type = mst_file_text;
387
                }
388
            }
389
          else if (sym->section->flags & SEC_ALLOC)
390
            {
391
              if (sym->flags & (BSF_GLOBAL | BSF_WEAK))
392
                {
393
                  if (sym->section->flags & SEC_LOAD)
394
                    {
395
                      ms_type = mst_data;
396
                    }
397
                  else
398
                    {
399
                      ms_type = mst_bss;
400
                    }
401
                }
402
              else if (sym->flags & BSF_LOCAL)
403
                {
404
                  /* Named Local variable in a Data section.
405
                     Check its name for stabs-in-elf.  */
406
                  int special_local_sect;
407
                  if (strcmp ("Bbss.bss", sym->name) == 0)
408
                    special_local_sect = SECT_OFF_BSS (objfile);
409
                  else if (strcmp ("Ddata.data", sym->name) == 0)
410
                    special_local_sect = SECT_OFF_DATA (objfile);
411
                  else if (strcmp ("Drodata.rodata", sym->name) == 0)
412
                    special_local_sect = SECT_OFF_RODATA (objfile);
413
                  else
414
                    special_local_sect = -1;
415
                  if (special_local_sect >= 0)
416
                    {
417
                      /* Found a special local symbol.  Allocate a
418
                         sectinfo, if needed, and fill it in.  */
419
                      if (sectinfo == NULL)
420
                        {
421
                          int max_index;
422
                          size_t size;
423
 
424
                          max_index
425
                            = max (SECT_OFF_BSS (objfile),
426
                                   max (SECT_OFF_DATA (objfile),
427
                                        SECT_OFF_RODATA (objfile)));
428
 
429
                          /* max_index is the largest index we'll
430
                             use into this array, so we must
431
                             allocate max_index+1 elements for it.
432
                             However, 'struct stab_section_info'
433
                             already includes one element, so we
434
                             need to allocate max_index aadditional
435
                             elements.  */
436
                          size = (sizeof (struct stab_section_info)
437
                                  + (sizeof (CORE_ADDR)
438
                                     * max_index));
439
                          sectinfo = (struct stab_section_info *)
440
                            xmalloc (size);
441
                          memset (sectinfo, 0, size);
442
                          sectinfo->num_sections = max_index;
443
                          if (filesym == NULL)
444
                            {
445
                              complaint (&symfile_complaints,
446
                                         _("elf/stab section information %s without a preceding file symbol"),
447
                                         sym->name);
448
                            }
449
                          else
450
                            {
451
                              sectinfo->filename =
452
                                (char *) filesym->name;
453
                            }
454
                        }
455
                      if (sectinfo->sections[special_local_sect] != 0)
456
                        complaint (&symfile_complaints,
457
                                   _("duplicated elf/stab section information for %s"),
458
                                   sectinfo->filename);
459
                      /* BFD symbols are section relative.  */
460
                      symaddr = sym->value + sym->section->vma;
461
                      /* Relocate non-absolute symbols by the
462
                         section offset.  */
463
                      if (sym->section != &bfd_abs_section)
464
                        symaddr += offset;
465
                      sectinfo->sections[special_local_sect] = symaddr;
466
                      /* The special local symbols don't go in the
467
                         minimal symbol table, so ignore this one.  */
468
                      continue;
469
                    }
470
                  /* Not a special stabs-in-elf symbol, do regular
471
                     symbol processing.  */
472
                  if (sym->section->flags & SEC_LOAD)
473
                    {
474
                      ms_type = mst_file_data;
475
                    }
476
                  else
477
                    {
478
                      ms_type = mst_file_bss;
479
                    }
480
                }
481
              else
482
                {
483
                  ms_type = mst_unknown;
484
                }
485
            }
486
          else
487
            {
488
              /* FIXME:  Solaris2 shared libraries include lots of
489
                 odd "absolute" and "undefined" symbols, that play
490
                 hob with actions like finding what function the PC
491
                 is in.  Ignore them if they aren't text, data, or bss.  */
492
              /* ms_type = mst_unknown; */
493
              continue; /* Skip this symbol. */
494
            }
495
          msym = record_minimal_symbol
496
            ((char *) sym->name, symaddr,
497
             ms_type, sym->section, objfile);
498
 
499
          if (msym)
500
            {
501
              /* Pass symbol size field in via BFD.  FIXME!!!  */
502
              elf_symbol_type *elf_sym;
503
 
504
              /* NOTE: uweigand-20071112: A synthetic symbol does not have an
505
                 ELF-private part.  However, in some cases (e.g. synthetic
506
                 'dot' symbols on ppc64) the udata.p entry is set to point back
507
                 to the original ELF symbol it was derived from.  Get the size
508
                 from that symbol.  */
509
              if (type != ST_SYNTHETIC)
510
                elf_sym = (elf_symbol_type *) sym;
511
              else
512
                elf_sym = (elf_symbol_type *) sym->udata.p;
513
 
514
              if (elf_sym)
515
                MSYMBOL_SIZE(msym) = elf_sym->internal_elf_sym.st_size;
516
            }
517
          if (msym != NULL)
518
            msym->filename = filesymname;
519
          gdbarch_elf_make_msymbol_special (current_gdbarch, sym, msym);
520
        }
521
    }
522
}
523
 
524
/* Scan and build partial symbols for a symbol file.
525
   We have been initialized by a call to elf_symfile_init, which
526
   currently does nothing.
527
 
528
   SECTION_OFFSETS is a set of offsets to apply to relocate the symbols
529
   in each section.  We simplify it down to a single offset for all
530
   symbols.  FIXME.
531
 
532
   MAINLINE is true if we are reading the main symbol
533
   table (as opposed to a shared lib or dynamically loaded file).
534
 
535
   This function only does the minimum work necessary for letting the
536
   user "name" things symbolically; it does not read the entire symtab.
537
   Instead, it reads the external and static symbols and puts them in partial
538
   symbol tables.  When more extensive information is requested of a
539
   file, the corresponding partial symbol table is mutated into a full
540
   fledged symbol table by going back and reading the symbols
541
   for real.
542
 
543
   We look for sections with specific names, to tell us what debug
544
   format to look for:  FIXME!!!
545
 
546
   elfstab_build_psymtabs() handles STABS symbols;
547
   mdebug_build_psymtabs() handles ECOFF debugging information.
548
 
549
   Note that ELF files have a "minimal" symbol table, which looks a lot
550
   like a COFF symbol table, but has only the minimal information necessary
551
   for linking.  We process this also, and use the information to
552
   build gdb's minimal symbol table.  This gives us some minimal debugging
553
   capability even for files compiled without -g.  */
554
 
555
static void
556
elf_symfile_read (struct objfile *objfile, int mainline)
557
{
558
  bfd *abfd = objfile->obfd;
559
  struct elfinfo ei;
560
  struct cleanup *back_to;
561
  CORE_ADDR offset;
562
  long symcount = 0, dynsymcount = 0, synthcount, storage_needed;
563
  asymbol **symbol_table = NULL, **dyn_symbol_table = NULL;
564
  asymbol *synthsyms;
565
 
566
  init_minimal_symbol_collection ();
567
  back_to = make_cleanup_discard_minimal_symbols ();
568
 
569
  memset ((char *) &ei, 0, sizeof (ei));
570
 
571
  /* Allocate struct to keep track of the symfile */
572
  objfile->deprecated_sym_stab_info = (struct dbx_symfile_info *)
573
    xmalloc (sizeof (struct dbx_symfile_info));
574
  memset ((char *) objfile->deprecated_sym_stab_info, 0, sizeof (struct dbx_symfile_info));
575
  make_cleanup (free_elfinfo, (void *) objfile);
576
 
577
  /* Process the normal ELF symbol table first.  This may write some
578
     chain of info into the dbx_symfile_info in objfile->deprecated_sym_stab_info,
579
     which can later be used by elfstab_offset_sections.  */
580
 
581
  storage_needed = bfd_get_symtab_upper_bound (objfile->obfd);
582
  if (storage_needed < 0)
583
    error (_("Can't read symbols from %s: %s"), bfd_get_filename (objfile->obfd),
584
           bfd_errmsg (bfd_get_error ()));
585
 
586
  if (storage_needed > 0)
587
    {
588
      symbol_table = (asymbol **) xmalloc (storage_needed);
589
      make_cleanup (xfree, symbol_table);
590
      symcount = bfd_canonicalize_symtab (objfile->obfd, symbol_table);
591
 
592
      if (symcount < 0)
593
        error (_("Can't read symbols from %s: %s"), bfd_get_filename (objfile->obfd),
594
               bfd_errmsg (bfd_get_error ()));
595
 
596
      elf_symtab_read (objfile, ST_REGULAR, symcount, symbol_table);
597
    }
598
 
599
  /* Add the dynamic symbols.  */
600
 
601
  storage_needed = bfd_get_dynamic_symtab_upper_bound (objfile->obfd);
602
 
603
  if (storage_needed > 0)
604
    {
605
      dyn_symbol_table = (asymbol **) xmalloc (storage_needed);
606
      make_cleanup (xfree, dyn_symbol_table);
607
      dynsymcount = bfd_canonicalize_dynamic_symtab (objfile->obfd,
608
                                                     dyn_symbol_table);
609
 
610
      if (dynsymcount < 0)
611
        error (_("Can't read symbols from %s: %s"), bfd_get_filename (objfile->obfd),
612
               bfd_errmsg (bfd_get_error ()));
613
 
614
      elf_symtab_read (objfile, ST_DYNAMIC, dynsymcount, dyn_symbol_table);
615
    }
616
 
617
  /* Add synthetic symbols - for instance, names for any PLT entries.  */
618
 
619
  synthcount = bfd_get_synthetic_symtab (abfd, symcount, symbol_table,
620
                                         dynsymcount, dyn_symbol_table,
621
                                         &synthsyms);
622
  if (synthcount > 0)
623
    {
624
      asymbol **synth_symbol_table;
625
      long i;
626
 
627
      make_cleanup (xfree, synthsyms);
628
      synth_symbol_table = xmalloc (sizeof (asymbol *) * synthcount);
629
      for (i = 0; i < synthcount; i++)
630
        synth_symbol_table[i] = synthsyms + i;
631
      make_cleanup (xfree, synth_symbol_table);
632
      elf_symtab_read (objfile, ST_SYNTHETIC, synthcount, synth_symbol_table);
633
    }
634
 
635
  /* Install any minimal symbols that have been collected as the current
636
     minimal symbols for this objfile.  The debug readers below this point
637
     should not generate new minimal symbols; if they do it's their
638
     responsibility to install them.  "mdebug" appears to be the only one
639
     which will do this.  */
640
 
641
  install_minimal_symbols (objfile);
642
  do_cleanups (back_to);
643
 
644
  /* Now process debugging information, which is contained in
645
     special ELF sections. */
646
 
647
  /* If we are reinitializing, or if we have never loaded syms yet,
648
     set table to empty.  MAINLINE is cleared so that *_read_psymtab
649
     functions do not all also re-initialize the psymbol table. */
650
  if (mainline)
651
    {
652
      init_psymbol_list (objfile, 0);
653
      mainline = 0;
654
    }
655
 
656
  /* We first have to find them... */
657
  bfd_map_over_sections (abfd, elf_locate_sections, (void *) & ei);
658
 
659
  /* ELF debugging information is inserted into the psymtab in the
660
     order of least informative first - most informative last.  Since
661
     the psymtab table is searched `most recent insertion first' this
662
     increases the probability that more detailed debug information
663
     for a section is found.
664
 
665
     For instance, an object file might contain both .mdebug (XCOFF)
666
     and .debug_info (DWARF2) sections then .mdebug is inserted first
667
     (searched last) and DWARF2 is inserted last (searched first).  If
668
     we don't do this then the XCOFF info is found first - for code in
669
     an included file XCOFF info is useless. */
670
 
671
  if (ei.mdebugsect)
672
    {
673
      const struct ecoff_debug_swap *swap;
674
 
675
      /* .mdebug section, presumably holding ECOFF debugging
676
         information.  */
677
      swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
678
      if (swap)
679
        elfmdebug_build_psymtabs (objfile, swap, ei.mdebugsect);
680
    }
681
  if (ei.stabsect)
682
    {
683
      asection *str_sect;
684
 
685
      /* Stab sections have an associated string table that looks like
686
         a separate section.  */
687
      str_sect = bfd_get_section_by_name (abfd, ".stabstr");
688
 
689
      /* FIXME should probably warn about a stab section without a stabstr.  */
690
      if (str_sect)
691
        elfstab_build_psymtabs (objfile,
692
                                mainline,
693
                                ei.stabsect,
694
                                str_sect->filepos,
695
                                bfd_section_size (abfd, str_sect));
696
    }
697
  if (dwarf2_has_info (objfile))
698
    {
699
      /* DWARF 2 sections */
700
      dwarf2_build_psymtabs (objfile, mainline);
701
    }
702
 
703
  /* FIXME: kettenis/20030504: This still needs to be integrated with
704
     dwarf2read.c in a better way.  */
705
  dwarf2_build_frame_info (objfile);
706
}
707
 
708
/* This cleans up the objfile's deprecated_sym_stab_info pointer, and
709
   the chain of stab_section_info's, that might be dangling from
710
   it.  */
711
 
712
static void
713
free_elfinfo (void *objp)
714
{
715
  struct objfile *objfile = (struct objfile *) objp;
716
  struct dbx_symfile_info *dbxinfo = objfile->deprecated_sym_stab_info;
717
  struct stab_section_info *ssi, *nssi;
718
 
719
  ssi = dbxinfo->stab_section_info;
720
  while (ssi)
721
    {
722
      nssi = ssi->next;
723
      xfree (ssi);
724
      ssi = nssi;
725
    }
726
 
727
  dbxinfo->stab_section_info = 0;        /* Just say No mo info about this.  */
728
}
729
 
730
 
731
/* Initialize anything that needs initializing when a completely new symbol
732
   file is specified (not just adding some symbols from another file, e.g. a
733
   shared library).
734
 
735
   We reinitialize buildsym, since we may be reading stabs from an ELF file.  */
736
 
737
static void
738
elf_new_init (struct objfile *ignore)
739
{
740
  stabsread_new_init ();
741
  buildsym_new_init ();
742
}
743
 
744
/* Perform any local cleanups required when we are done with a particular
745
   objfile.  I.E, we are in the process of discarding all symbol information
746
   for an objfile, freeing up all memory held for it, and unlinking the
747
   objfile struct from the global list of known objfiles. */
748
 
749
static void
750
elf_symfile_finish (struct objfile *objfile)
751
{
752
  if (objfile->deprecated_sym_stab_info != NULL)
753
    {
754
      xfree (objfile->deprecated_sym_stab_info);
755
    }
756
 
757
  dwarf2_free_objfile (objfile);
758
}
759
 
760
/* ELF specific initialization routine for reading symbols.
761
 
762
   It is passed a pointer to a struct sym_fns which contains, among other
763
   things, the BFD for the file whose symbols are being read, and a slot for
764
   a pointer to "private data" which we can fill with goodies.
765
 
766
   For now at least, we have nothing in particular to do, so this function is
767
   just a stub. */
768
 
769
static void
770
elf_symfile_init (struct objfile *objfile)
771
{
772
  /* ELF objects may be reordered, so set OBJF_REORDERED.  If we
773
     find this causes a significant slowdown in gdb then we could
774
     set it in the debug symbol readers only when necessary.  */
775
  objfile->flags |= OBJF_REORDERED;
776
}
777
 
778
/* When handling an ELF file that contains Sun STABS debug info,
779
   some of the debug info is relative to the particular chunk of the
780
   section that was generated in its individual .o file.  E.g.
781
   offsets to static variables are relative to the start of the data
782
   segment *for that module before linking*.  This information is
783
   painfully squirreled away in the ELF symbol table as local symbols
784
   with wierd names.  Go get 'em when needed.  */
785
 
786
void
787
elfstab_offset_sections (struct objfile *objfile, struct partial_symtab *pst)
788
{
789
  char *filename = pst->filename;
790
  struct dbx_symfile_info *dbx = objfile->deprecated_sym_stab_info;
791
  struct stab_section_info *maybe = dbx->stab_section_info;
792
  struct stab_section_info *questionable = 0;
793
  int i;
794
  char *p;
795
 
796
  /* The ELF symbol info doesn't include path names, so strip the path
797
     (if any) from the psymtab filename.  */
798
  while (0 != (p = strchr (filename, '/')))
799
    filename = p + 1;
800
 
801
  /* FIXME:  This linear search could speed up significantly
802
     if it was chained in the right order to match how we search it,
803
     and if we unchained when we found a match. */
804
  for (; maybe; maybe = maybe->next)
805
    {
806
      if (filename[0] == maybe->filename[0]
807
          && strcmp (filename, maybe->filename) == 0)
808
        {
809
          /* We found a match.  But there might be several source files
810
             (from different directories) with the same name.  */
811
          if (0 == maybe->found)
812
            break;
813
          questionable = maybe; /* Might use it later.  */
814
        }
815
    }
816
 
817
  if (maybe == 0 && questionable != 0)
818
    {
819
      complaint (&symfile_complaints,
820
                 _("elf/stab section information questionable for %s"), filename);
821
      maybe = questionable;
822
    }
823
 
824
  if (maybe)
825
    {
826
      /* Found it!  Allocate a new psymtab struct, and fill it in.  */
827
      maybe->found++;
828
      pst->section_offsets = (struct section_offsets *)
829
        obstack_alloc (&objfile->objfile_obstack,
830
                       SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));
831
      for (i = 0; i < maybe->num_sections; i++)
832
        (pst->section_offsets)->offsets[i] = maybe->sections[i];
833
      return;
834
    }
835
 
836
  /* We were unable to find any offsets for this file.  Complain.  */
837
  if (dbx->stab_section_info)   /* If there *is* any info, */
838
    complaint (&symfile_complaints,
839
               _("elf/stab section information missing for %s"), filename);
840
}
841
 
842
/* Register that we are able to handle ELF object file formats.  */
843
 
844
static struct sym_fns elf_sym_fns =
845
{
846
  bfd_target_elf_flavour,
847
  elf_new_init,                 /* sym_new_init: init anything gbl to entire symtab */
848
  elf_symfile_init,             /* sym_init: read initial info, setup for sym_read() */
849
  elf_symfile_read,             /* sym_read: read a symbol file into symtab */
850
  elf_symfile_finish,           /* sym_finish: finished with file, cleanup */
851
  default_symfile_offsets,      /* sym_offsets:  Translate ext. to int. relocation */
852
  elf_symfile_segments,         /* sym_segments: Get segment information from
853
                                   a file.  */
854
  NULL,                         /* sym_read_linetable */
855
  NULL                          /* next: pointer to next struct sym_fns */
856
};
857
 
858
void
859
_initialize_elfread (void)
860
{
861
  add_symtab_fns (&elf_sym_fns);
862
}

powered by: WebSVN 2.1.0

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