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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [elfread.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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