← Back to branch summary

~ubuntu-branches/ubuntu/utopic/crash/utopic-proposed

« back to all changes in this revision

Viewing changes to gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb-6.1/gdb/elfread.c

  • Committer: Bazaar Package Importer
  • Author(s): Mario Limonciello
  • Date: 2008-06-11 17:00:07 UTC
  • Revision ID: james.westby@ubuntu.com-20080611170007-alatagy5pjxy8dm3
Tags: 4.0-6.3-1ubuntu2
* debian/control:
  - Enable lpia builds.

Show diffs side-by-side

added added

removed removed

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