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

Subversion Repositories openrisc_2011-10-31

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

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 330 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, 2009, 2010
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
#include "psympriv.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
    asection *stabsect;         /* Section pointer for .stab section */
50
    asection *stabindexsect;    /* Section pointer for .stab.index section */
51
    asection *mdebugsect;       /* Section pointer for .mdebug section */
52
  };
53
 
54
static void free_elfinfo (void *);
55
 
56
/* Locate the segments in ABFD.  */
57
 
58
static struct symfile_segment_data *
59
elf_symfile_segments (bfd *abfd)
60
{
61
  Elf_Internal_Phdr *phdrs, **segments;
62
  long phdrs_size;
63
  int num_phdrs, num_segments, num_sections, i;
64
  asection *sect;
65
  struct symfile_segment_data *data;
66
 
67
  phdrs_size = bfd_get_elf_phdr_upper_bound (abfd);
68
  if (phdrs_size == -1)
69
    return NULL;
70
 
71
  phdrs = alloca (phdrs_size);
72
  num_phdrs = bfd_get_elf_phdrs (abfd, phdrs);
73
  if (num_phdrs == -1)
74
    return NULL;
75
 
76
  num_segments = 0;
77
  segments = alloca (sizeof (Elf_Internal_Phdr *) * num_phdrs);
78
  for (i = 0; i < num_phdrs; i++)
79
    if (phdrs[i].p_type == PT_LOAD)
80
      segments[num_segments++] = &phdrs[i];
81
 
82
  if (num_segments == 0)
83
    return NULL;
84
 
85
  data = XZALLOC (struct symfile_segment_data);
86
  data->num_segments = num_segments;
87
  data->segment_bases = XCALLOC (num_segments, CORE_ADDR);
88
  data->segment_sizes = XCALLOC (num_segments, CORE_ADDR);
89
 
90
  for (i = 0; i < num_segments; i++)
91
    {
92
      data->segment_bases[i] = segments[i]->p_vaddr;
93
      data->segment_sizes[i] = segments[i]->p_memsz;
94
    }
95
 
96
  num_sections = bfd_count_sections (abfd);
97
  data->segment_info = XCALLOC (num_sections, int);
98
 
99
  for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next)
100
    {
101
      int j;
102
      CORE_ADDR vma;
103
 
104
      if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0)
105
        continue;
106
 
107
      vma = bfd_get_section_vma (abfd, sect);
108
 
109
      for (j = 0; j < num_segments; j++)
110
        if (segments[j]->p_memsz > 0
111
            && vma >= segments[j]->p_vaddr
112
            && (vma - segments[j]->p_vaddr) < segments[j]->p_memsz)
113
          {
114
            data->segment_info[i] = j + 1;
115
            break;
116
          }
117
 
118
      /* We should have found a segment for every non-empty section.
119
         If we haven't, we will not relocate this section by any
120
         offsets we apply to the segments.  As an exception, do not
121
         warn about SHT_NOBITS sections; in normal ELF execution
122
         environments, SHT_NOBITS means zero-initialized and belongs
123
         in a segment, but in no-OS environments some tools (e.g. ARM
124
         RealView) use SHT_NOBITS for uninitialized data.  Since it is
125
         uninitialized, it doesn't need a program header.  Such
126
         binaries are not relocatable.  */
127
      if (bfd_get_section_size (sect) > 0 && j == num_segments
128
          && (bfd_get_section_flags (abfd, sect) & SEC_LOAD) != 0)
129
        warning (_("Loadable segment \"%s\" outside of ELF segments"),
130
                 bfd_section_name (abfd, sect));
131
    }
132
 
133
  return data;
134
}
135
 
136
/* We are called once per section from elf_symfile_read.  We
137
   need to examine each section we are passed, check to see
138
   if it is something we are interested in processing, and
139
   if so, stash away some access information for the section.
140
 
141
   For now we recognize the dwarf debug information sections and
142
   line number sections from matching their section names.  The
143
   ELF definition is no real help here since it has no direct
144
   knowledge of DWARF (by design, so any debugging format can be
145
   used).
146
 
147
   We also recognize the ".stab" sections used by the Sun compilers
148
   released with Solaris 2.
149
 
150
   FIXME: The section names should not be hardwired strings (what
151
   should they be?  I don't think most object file formats have enough
152
   section flags to specify what kind of debug section it is
153
   -kingdon).  */
154
 
155
static void
156
elf_locate_sections (bfd *ignore_abfd, asection *sectp, void *eip)
157
{
158
  struct elfinfo *ei;
159
 
160
  ei = (struct elfinfo *) eip;
161
  if (strcmp (sectp->name, ".stab") == 0)
162
    {
163
      ei->stabsect = sectp;
164
    }
165
  else if (strcmp (sectp->name, ".stab.index") == 0)
166
    {
167
      ei->stabindexsect = sectp;
168
    }
169
  else if (strcmp (sectp->name, ".mdebug") == 0)
170
    {
171
      ei->mdebugsect = sectp;
172
    }
173
}
174
 
175
static struct minimal_symbol *
176
record_minimal_symbol (const char *name, int name_len, int copy_name,
177
                       CORE_ADDR address,
178
                       enum minimal_symbol_type ms_type,
179
                       asection *bfd_section, struct objfile *objfile)
180
{
181
  struct gdbarch *gdbarch = get_objfile_arch (objfile);
182
 
183
  if (ms_type == mst_text || ms_type == mst_file_text)
184
    address = gdbarch_smash_text_address (gdbarch, address);
185
 
186
  return prim_record_minimal_symbol_full (name, name_len, copy_name, address,
187
                                          ms_type, bfd_section->index,
188
                                          bfd_section, objfile);
189
}
190
 
191
/*
192
 
193
   LOCAL FUNCTION
194
 
195
   elf_symtab_read -- read the symbol table of an ELF file
196
 
197
   SYNOPSIS
198
 
199
   void elf_symtab_read (struct objfile *objfile, int type,
200
                         long number_of_symbols, asymbol **symbol_table)
201
 
202
   DESCRIPTION
203
 
204
   Given an objfile, a symbol table, and a flag indicating whether the
205
   symbol table contains regular, dynamic, or synthetic symbols, add all
206
   the global function and data symbols to the minimal symbol table.
207
 
208
   In stabs-in-ELF, as implemented by Sun, there are some local symbols
209
   defined in the ELF symbol table, which can be used to locate
210
   the beginnings of sections from each ".o" file that was linked to
211
   form the executable objfile.  We gather any such info and record it
212
   in data structures hung off the objfile's private data.
213
 
214
 */
215
 
216
#define ST_REGULAR 0
217
#define ST_DYNAMIC 1
218
#define ST_SYNTHETIC 2
219
 
220
static void
221
elf_symtab_read (struct objfile *objfile, int type,
222
                 long number_of_symbols, asymbol **symbol_table,
223
                 int copy_names)
224
{
225
  struct gdbarch *gdbarch = get_objfile_arch (objfile);
226
  asymbol *sym;
227
  long i;
228
  CORE_ADDR symaddr;
229
  CORE_ADDR offset;
230
  enum minimal_symbol_type ms_type;
231
  /* If sectinfo is nonNULL, it contains section info that should end up
232
     filed in the objfile.  */
233
  struct stab_section_info *sectinfo = NULL;
234
  /* If filesym is nonzero, it points to a file symbol, but we haven't
235
     seen any section info for it yet.  */
236
  asymbol *filesym = 0;
237
  /* Name of filesym.  This is either a constant string or is saved on
238
     the objfile's obstack.  */
239
  char *filesymname = "";
240
  struct dbx_symfile_info *dbx = objfile->deprecated_sym_stab_info;
241
  int stripped = (bfd_get_symcount (objfile->obfd) == 0);
242
 
243
  for (i = 0; i < number_of_symbols; i++)
244
    {
245
      sym = symbol_table[i];
246
      if (sym->name == NULL || *sym->name == '\0')
247
        {
248
          /* Skip names that don't exist (shouldn't happen), or names
249
             that are null strings (may happen). */
250
          continue;
251
        }
252
 
253
      /* Skip "special" symbols, e.g. ARM mapping symbols.  These are
254
         symbols which do not correspond to objects in the symbol table,
255
         but have some other target-specific meaning.  */
256
      if (bfd_is_target_special_symbol (objfile->obfd, sym))
257
        {
258
          if (gdbarch_record_special_symbol_p (gdbarch))
259
            gdbarch_record_special_symbol (gdbarch, objfile, sym);
260
          continue;
261
        }
262
 
263
      offset = ANOFFSET (objfile->section_offsets, sym->section->index);
264
      if (type == ST_DYNAMIC
265
          && sym->section == &bfd_und_section
266
          && (sym->flags & BSF_FUNCTION))
267
        {
268
          struct minimal_symbol *msym;
269
          bfd *abfd = objfile->obfd;
270
          asection *sect;
271
 
272
          /* Symbol is a reference to a function defined in
273
             a shared library.
274
             If its value is non zero then it is usually the address
275
             of the corresponding entry in the procedure linkage table,
276
             plus the desired section offset.
277
             If its value is zero then the dynamic linker has to resolve
278
             the symbol. We are unable to find any meaningful address
279
             for this symbol in the executable file, so we skip it.  */
280
          symaddr = sym->value;
281
          if (symaddr == 0)
282
            continue;
283
 
284
          /* sym->section is the undefined section.  However, we want to
285
             record the section where the PLT stub resides with the
286
             minimal symbol.  Search the section table for the one that
287
             covers the stub's address.  */
288
          for (sect = abfd->sections; sect != NULL; sect = sect->next)
289
            {
290
              if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0)
291
                continue;
292
 
293
              if (symaddr >= bfd_get_section_vma (abfd, sect)
294
                  && symaddr < bfd_get_section_vma (abfd, sect)
295
                               + bfd_get_section_size (sect))
296
                break;
297
            }
298
          if (!sect)
299
            continue;
300
 
301
          symaddr += ANOFFSET (objfile->section_offsets, sect->index);
302
 
303
          msym = record_minimal_symbol
304
            (sym->name, strlen (sym->name), copy_names,
305
             symaddr, mst_solib_trampoline, sect, objfile);
306
          if (msym != NULL)
307
            msym->filename = filesymname;
308
          continue;
309
        }
310
 
311
      /* If it is a nonstripped executable, do not enter dynamic
312
         symbols, as the dynamic symbol table is usually a subset
313
         of the main symbol table.  */
314
      if (type == ST_DYNAMIC && !stripped)
315
        continue;
316
      if (sym->flags & BSF_FILE)
317
        {
318
          /* STT_FILE debugging symbol that helps stabs-in-elf debugging.
319
             Chain any old one onto the objfile; remember new sym.  */
320
          if (sectinfo != NULL)
321
            {
322
              sectinfo->next = dbx->stab_section_info;
323
              dbx->stab_section_info = sectinfo;
324
              sectinfo = NULL;
325
            }
326
          filesym = sym;
327
          filesymname =
328
            obsavestring ((char *) filesym->name, strlen (filesym->name),
329
                          &objfile->objfile_obstack);
330
        }
331
      else if (sym->flags & BSF_SECTION_SYM)
332
        continue;
333
      else if (sym->flags & (BSF_GLOBAL | BSF_LOCAL | BSF_WEAK))
334
        {
335
          struct minimal_symbol *msym;
336
 
337
          /* Select global/local/weak symbols.  Note that bfd puts abs
338
             symbols in their own section, so all symbols we are
339
             interested in will have a section. */
340
          /* Bfd symbols are section relative. */
341
          symaddr = sym->value + sym->section->vma;
342
          /* Relocate all non-absolute and non-TLS symbols by the
343
             section offset.  */
344
          if (sym->section != &bfd_abs_section
345
              && !(sym->section->flags & SEC_THREAD_LOCAL))
346
            {
347
              symaddr += offset;
348
            }
349
          /* For non-absolute symbols, use the type of the section
350
             they are relative to, to intuit text/data.  Bfd provides
351
             no way of figuring this out for absolute symbols. */
352
          if (sym->section == &bfd_abs_section)
353
            {
354
              /* This is a hack to get the minimal symbol type
355
                 right for Irix 5, which has absolute addresses
356
                 with special section indices for dynamic symbols.
357
 
358
                 NOTE: uweigand-20071112: Synthetic symbols do not
359
                 have an ELF-private part, so do not touch those.  */
360
              unsigned int shndx = type == ST_SYNTHETIC ? 0 :
361
                ((elf_symbol_type *) sym)->internal_elf_sym.st_shndx;
362
 
363
              switch (shndx)
364
                {
365
                case SHN_MIPS_TEXT:
366
                  ms_type = mst_text;
367
                  break;
368
                case SHN_MIPS_DATA:
369
                  ms_type = mst_data;
370
                  break;
371
                case SHN_MIPS_ACOMMON:
372
                  ms_type = mst_bss;
373
                  break;
374
                default:
375
                  ms_type = mst_abs;
376
                }
377
 
378
              /* If it is an Irix dynamic symbol, skip section name
379
                 symbols, relocate all others by section offset. */
380
              if (ms_type != mst_abs)
381
                {
382
                  if (sym->name[0] == '.')
383
                    continue;
384
                  symaddr += offset;
385
                }
386
            }
387
          else if (sym->section->flags & SEC_CODE)
388
            {
389
              if (sym->flags & (BSF_GLOBAL | BSF_WEAK))
390
                {
391
                  ms_type = mst_text;
392
                }
393
              else if ((sym->name[0] == '.' && sym->name[1] == 'L')
394
                       || ((sym->flags & BSF_LOCAL)
395
                           && sym->name[0] == '$'
396
                           && sym->name[1] == 'L'))
397
                /* Looks like a compiler-generated label.  Skip
398
                   it.  The assembler should be skipping these (to
399
                   keep executables small), but apparently with
400
                   gcc on the (deleted) delta m88k SVR4, it loses.
401
                   So to have us check too should be harmless (but
402
                   I encourage people to fix this in the assembler
403
                   instead of adding checks here).  */
404
                continue;
405
              else
406
                {
407
                  ms_type = mst_file_text;
408
                }
409
            }
410
          else if (sym->section->flags & SEC_ALLOC)
411
            {
412
              if (sym->flags & (BSF_GLOBAL | BSF_WEAK))
413
                {
414
                  if (sym->section->flags & SEC_LOAD)
415
                    {
416
                      ms_type = mst_data;
417
                    }
418
                  else
419
                    {
420
                      ms_type = mst_bss;
421
                    }
422
                }
423
              else if (sym->flags & BSF_LOCAL)
424
                {
425
                  /* Named Local variable in a Data section.
426
                     Check its name for stabs-in-elf.  */
427
                  int special_local_sect;
428
 
429
                  if (strcmp ("Bbss.bss", sym->name) == 0)
430
                    special_local_sect = SECT_OFF_BSS (objfile);
431
                  else if (strcmp ("Ddata.data", sym->name) == 0)
432
                    special_local_sect = SECT_OFF_DATA (objfile);
433
                  else if (strcmp ("Drodata.rodata", sym->name) == 0)
434
                    special_local_sect = SECT_OFF_RODATA (objfile);
435
                  else
436
                    special_local_sect = -1;
437
                  if (special_local_sect >= 0)
438
                    {
439
                      /* Found a special local symbol.  Allocate a
440
                         sectinfo, if needed, and fill it in.  */
441
                      if (sectinfo == NULL)
442
                        {
443
                          int max_index;
444
                          size_t size;
445
 
446
                          max_index = SECT_OFF_BSS (objfile);
447
                          if (objfile->sect_index_data > max_index)
448
                            max_index = objfile->sect_index_data;
449
                          if (objfile->sect_index_rodata > max_index)
450
                            max_index = objfile->sect_index_rodata;
451
 
452
                          /* max_index is the largest index we'll
453
                             use into this array, so we must
454
                             allocate max_index+1 elements for it.
455
                             However, 'struct stab_section_info'
456
                             already includes one element, so we
457
                             need to allocate max_index aadditional
458
                             elements.  */
459
                          size = (sizeof (struct stab_section_info)
460
                                  + (sizeof (CORE_ADDR)
461
                                     * max_index));
462
                          sectinfo = (struct stab_section_info *)
463
                            xmalloc (size);
464
                          memset (sectinfo, 0, size);
465
                          sectinfo->num_sections = max_index;
466
                          if (filesym == NULL)
467
                            {
468
                              complaint (&symfile_complaints,
469
                                         _("elf/stab section information %s without a preceding file symbol"),
470
                                         sym->name);
471
                            }
472
                          else
473
                            {
474
                              sectinfo->filename =
475
                                (char *) filesym->name;
476
                            }
477
                        }
478
                      if (sectinfo->sections[special_local_sect] != 0)
479
                        complaint (&symfile_complaints,
480
                                   _("duplicated elf/stab section information for %s"),
481
                                   sectinfo->filename);
482
                      /* BFD symbols are section relative.  */
483
                      symaddr = sym->value + sym->section->vma;
484
                      /* Relocate non-absolute symbols by the
485
                         section offset.  */
486
                      if (sym->section != &bfd_abs_section)
487
                        symaddr += offset;
488
                      sectinfo->sections[special_local_sect] = symaddr;
489
                      /* The special local symbols don't go in the
490
                         minimal symbol table, so ignore this one.  */
491
                      continue;
492
                    }
493
                  /* Not a special stabs-in-elf symbol, do regular
494
                     symbol processing.  */
495
                  if (sym->section->flags & SEC_LOAD)
496
                    {
497
                      ms_type = mst_file_data;
498
                    }
499
                  else
500
                    {
501
                      ms_type = mst_file_bss;
502
                    }
503
                }
504
              else
505
                {
506
                  ms_type = mst_unknown;
507
                }
508
            }
509
          else
510
            {
511
              /* FIXME:  Solaris2 shared libraries include lots of
512
                 odd "absolute" and "undefined" symbols, that play
513
                 hob with actions like finding what function the PC
514
                 is in.  Ignore them if they aren't text, data, or bss.  */
515
              /* ms_type = mst_unknown; */
516
              continue; /* Skip this symbol. */
517
            }
518
          msym = record_minimal_symbol
519
            (sym->name, strlen (sym->name), copy_names, symaddr,
520
             ms_type, sym->section, objfile);
521
 
522
          if (msym)
523
            {
524
              /* Pass symbol size field in via BFD.  FIXME!!!  */
525
              elf_symbol_type *elf_sym;
526
 
527
              /* NOTE: uweigand-20071112: A synthetic symbol does not have an
528
                 ELF-private part.  However, in some cases (e.g. synthetic
529
                 'dot' symbols on ppc64) the udata.p entry is set to point back
530
                 to the original ELF symbol it was derived from.  Get the size
531
                 from that symbol.  */
532
              if (type != ST_SYNTHETIC)
533
                elf_sym = (elf_symbol_type *) sym;
534
              else
535
                elf_sym = (elf_symbol_type *) sym->udata.p;
536
 
537
              if (elf_sym)
538
                MSYMBOL_SIZE(msym) = elf_sym->internal_elf_sym.st_size;
539
 
540
              msym->filename = filesymname;
541
              gdbarch_elf_make_msymbol_special (gdbarch, sym, msym);
542
            }
543
 
544
          /* For @plt symbols, also record a trampoline to the
545
             destination symbol.  The @plt symbol will be used in
546
             disassembly, and the trampoline will be used when we are
547
             trying to find the target.  */
548
          if (msym && ms_type == mst_text && type == ST_SYNTHETIC)
549
            {
550
              int len = strlen (sym->name);
551
 
552
              if (len > 4 && strcmp (sym->name + len - 4, "@plt") == 0)
553
                {
554
                  struct minimal_symbol *mtramp;
555
 
556
                  mtramp = record_minimal_symbol (sym->name, len - 4, 1,
557
                                                  symaddr,
558
                                                  mst_solib_trampoline,
559
                                                  sym->section, objfile);
560
                  if (mtramp)
561
                    {
562
                      MSYMBOL_SIZE (mtramp) = MSYMBOL_SIZE (msym);
563
                      mtramp->filename = filesymname;
564
                      gdbarch_elf_make_msymbol_special (gdbarch, sym, mtramp);
565
                    }
566
                }
567
            }
568
        }
569
    }
570
}
571
 
572
struct build_id
573
  {
574
    size_t size;
575
    gdb_byte data[1];
576
  };
577
 
578
/* Locate NT_GNU_BUILD_ID from ABFD and return its content.  */
579
 
580
static struct build_id *
581
build_id_bfd_get (bfd *abfd)
582
{
583
  struct build_id *retval;
584
 
585
  if (!bfd_check_format (abfd, bfd_object)
586
      || bfd_get_flavour (abfd) != bfd_target_elf_flavour
587
      || elf_tdata (abfd)->build_id == NULL)
588
    return NULL;
589
 
590
  retval = xmalloc (sizeof *retval - 1 + elf_tdata (abfd)->build_id_size);
591
  retval->size = elf_tdata (abfd)->build_id_size;
592
  memcpy (retval->data, elf_tdata (abfd)->build_id, retval->size);
593
 
594
  return retval;
595
}
596
 
597
/* Return if FILENAME has NT_GNU_BUILD_ID matching the CHECK value.  */
598
 
599
static int
600
build_id_verify (const char *filename, struct build_id *check)
601
{
602
  bfd *abfd;
603
  struct build_id *found = NULL;
604
  int retval = 0;
605
 
606
  /* We expect to be silent on the non-existing files.  */
607
  abfd = bfd_open_maybe_remote (filename);
608
  if (abfd == NULL)
609
    return 0;
610
 
611
  found = build_id_bfd_get (abfd);
612
 
613
  if (found == NULL)
614
    warning (_("File \"%s\" has no build-id, file skipped"), filename);
615
  else if (found->size != check->size
616
           || memcmp (found->data, check->data, found->size) != 0)
617
    warning (_("File \"%s\" has a different build-id, file skipped"), filename);
618
  else
619
    retval = 1;
620
 
621
  gdb_bfd_close_or_warn (abfd);
622
 
623
  xfree (found);
624
 
625
  return retval;
626
}
627
 
628
static char *
629
build_id_to_debug_filename (struct build_id *build_id)
630
{
631
  char *link, *debugdir, *retval = NULL;
632
 
633
  /* DEBUG_FILE_DIRECTORY/.build-id/ab/cdef */
634
  link = alloca (strlen (debug_file_directory) + (sizeof "/.build-id/" - 1) + 1
635
                 + 2 * build_id->size + (sizeof ".debug" - 1) + 1);
636
 
637
  /* Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will
638
     cause "/.build-id/..." lookups.  */
639
 
640
  debugdir = debug_file_directory;
641
  do
642
    {
643
      char *s, *debugdir_end;
644
      gdb_byte *data = build_id->data;
645
      size_t size = build_id->size;
646
 
647
      while (*debugdir == DIRNAME_SEPARATOR)
648
        debugdir++;
649
 
650
      debugdir_end = strchr (debugdir, DIRNAME_SEPARATOR);
651
      if (debugdir_end == NULL)
652
        debugdir_end = &debugdir[strlen (debugdir)];
653
 
654
      memcpy (link, debugdir, debugdir_end - debugdir);
655
      s = &link[debugdir_end - debugdir];
656
      s += sprintf (s, "/.build-id/");
657
      if (size > 0)
658
        {
659
          size--;
660
          s += sprintf (s, "%02x", (unsigned) *data++);
661
        }
662
      if (size > 0)
663
        *s++ = '/';
664
      while (size-- > 0)
665
        s += sprintf (s, "%02x", (unsigned) *data++);
666
      strcpy (s, ".debug");
667
 
668
      /* lrealpath() is expensive even for the usually non-existent files.  */
669
      if (access (link, F_OK) == 0)
670
        retval = lrealpath (link);
671
 
672
      if (retval != NULL && !build_id_verify (retval, build_id))
673
        {
674
          xfree (retval);
675
          retval = NULL;
676
        }
677
 
678
      if (retval != NULL)
679
        break;
680
 
681
      debugdir = debugdir_end;
682
    }
683
  while (*debugdir != 0);
684
 
685
  return retval;
686
}
687
 
688
static char *
689
find_separate_debug_file_by_buildid (struct objfile *objfile)
690
{
691
  struct build_id *build_id;
692
 
693
  build_id = build_id_bfd_get (objfile->obfd);
694
  if (build_id != NULL)
695
    {
696
      char *build_id_name;
697
 
698
      build_id_name = build_id_to_debug_filename (build_id);
699
      xfree (build_id);
700
      /* Prevent looping on a stripped .debug file.  */
701
      if (build_id_name != NULL && strcmp (build_id_name, objfile->name) == 0)
702
        {
703
          warning (_("\"%s\": separate debug info file has no debug info"),
704
                   build_id_name);
705
          xfree (build_id_name);
706
        }
707
      else if (build_id_name != NULL)
708
        return build_id_name;
709
    }
710
  return NULL;
711
}
712
 
713
/* Scan and build partial symbols for a symbol file.
714
   We have been initialized by a call to elf_symfile_init, which
715
   currently does nothing.
716
 
717
   SECTION_OFFSETS is a set of offsets to apply to relocate the symbols
718
   in each section.  We simplify it down to a single offset for all
719
   symbols.  FIXME.
720
 
721
   This function only does the minimum work necessary for letting the
722
   user "name" things symbolically; it does not read the entire symtab.
723
   Instead, it reads the external and static symbols and puts them in partial
724
   symbol tables.  When more extensive information is requested of a
725
   file, the corresponding partial symbol table is mutated into a full
726
   fledged symbol table by going back and reading the symbols
727
   for real.
728
 
729
   We look for sections with specific names, to tell us what debug
730
   format to look for:  FIXME!!!
731
 
732
   elfstab_build_psymtabs() handles STABS symbols;
733
   mdebug_build_psymtabs() handles ECOFF debugging information.
734
 
735
   Note that ELF files have a "minimal" symbol table, which looks a lot
736
   like a COFF symbol table, but has only the minimal information necessary
737
   for linking.  We process this also, and use the information to
738
   build gdb's minimal symbol table.  This gives us some minimal debugging
739
   capability even for files compiled without -g.  */
740
 
741
static void
742
elf_symfile_read (struct objfile *objfile, int symfile_flags)
743
{
744
  bfd *abfd = objfile->obfd;
745
  struct elfinfo ei;
746
  struct cleanup *back_to;
747
  long symcount = 0, dynsymcount = 0, synthcount, storage_needed;
748
  asymbol **symbol_table = NULL, **dyn_symbol_table = NULL;
749
  asymbol *synthsyms;
750
 
751
  init_minimal_symbol_collection ();
752
  back_to = make_cleanup_discard_minimal_symbols ();
753
 
754
  memset ((char *) &ei, 0, sizeof (ei));
755
 
756
  /* Allocate struct to keep track of the symfile */
757
  objfile->deprecated_sym_stab_info = (struct dbx_symfile_info *)
758
    xmalloc (sizeof (struct dbx_symfile_info));
759
  memset ((char *) objfile->deprecated_sym_stab_info, 0, sizeof (struct dbx_symfile_info));
760
  make_cleanup (free_elfinfo, (void *) objfile);
761
 
762
  /* Process the normal ELF symbol table first.  This may write some
763
     chain of info into the dbx_symfile_info in objfile->deprecated_sym_stab_info,
764
     which can later be used by elfstab_offset_sections.  */
765
 
766
  storage_needed = bfd_get_symtab_upper_bound (objfile->obfd);
767
  if (storage_needed < 0)
768
    error (_("Can't read symbols from %s: %s"), bfd_get_filename (objfile->obfd),
769
           bfd_errmsg (bfd_get_error ()));
770
 
771
  if (storage_needed > 0)
772
    {
773
      symbol_table = (asymbol **) xmalloc (storage_needed);
774
      make_cleanup (xfree, symbol_table);
775
      symcount = bfd_canonicalize_symtab (objfile->obfd, symbol_table);
776
 
777
      if (symcount < 0)
778
        error (_("Can't read symbols from %s: %s"), bfd_get_filename (objfile->obfd),
779
               bfd_errmsg (bfd_get_error ()));
780
 
781
      elf_symtab_read (objfile, ST_REGULAR, symcount, symbol_table, 0);
782
    }
783
 
784
  /* Add the dynamic symbols.  */
785
 
786
  storage_needed = bfd_get_dynamic_symtab_upper_bound (objfile->obfd);
787
 
788
  if (storage_needed > 0)
789
    {
790
      dyn_symbol_table = (asymbol **) xmalloc (storage_needed);
791
      make_cleanup (xfree, dyn_symbol_table);
792
      dynsymcount = bfd_canonicalize_dynamic_symtab (objfile->obfd,
793
                                                     dyn_symbol_table);
794
 
795
      if (dynsymcount < 0)
796
        error (_("Can't read symbols from %s: %s"), bfd_get_filename (objfile->obfd),
797
               bfd_errmsg (bfd_get_error ()));
798
 
799
      elf_symtab_read (objfile, ST_DYNAMIC, dynsymcount, dyn_symbol_table, 0);
800
    }
801
 
802
  /* Add synthetic symbols - for instance, names for any PLT entries.  */
803
 
804
  synthcount = bfd_get_synthetic_symtab (abfd, symcount, symbol_table,
805
                                         dynsymcount, dyn_symbol_table,
806
                                         &synthsyms);
807
  if (synthcount > 0)
808
    {
809
      asymbol **synth_symbol_table;
810
      long i;
811
 
812
      make_cleanup (xfree, synthsyms);
813
      synth_symbol_table = xmalloc (sizeof (asymbol *) * synthcount);
814
      for (i = 0; i < synthcount; i++)
815
        synth_symbol_table[i] = synthsyms + i;
816
      make_cleanup (xfree, synth_symbol_table);
817
      elf_symtab_read (objfile, ST_SYNTHETIC, synthcount, synth_symbol_table, 1);
818
    }
819
 
820
  /* Install any minimal symbols that have been collected as the current
821
     minimal symbols for this objfile.  The debug readers below this point
822
     should not generate new minimal symbols; if they do it's their
823
     responsibility to install them.  "mdebug" appears to be the only one
824
     which will do this.  */
825
 
826
  install_minimal_symbols (objfile);
827
  do_cleanups (back_to);
828
 
829
  /* Now process debugging information, which is contained in
830
     special ELF sections. */
831
 
832
  /* We first have to find them... */
833
  bfd_map_over_sections (abfd, elf_locate_sections, (void *) & ei);
834
 
835
  /* ELF debugging information is inserted into the psymtab in the
836
     order of least informative first - most informative last.  Since
837
     the psymtab table is searched `most recent insertion first' this
838
     increases the probability that more detailed debug information
839
     for a section is found.
840
 
841
     For instance, an object file might contain both .mdebug (XCOFF)
842
     and .debug_info (DWARF2) sections then .mdebug is inserted first
843
     (searched last) and DWARF2 is inserted last (searched first).  If
844
     we don't do this then the XCOFF info is found first - for code in
845
     an included file XCOFF info is useless. */
846
 
847
  if (ei.mdebugsect)
848
    {
849
      const struct ecoff_debug_swap *swap;
850
 
851
      /* .mdebug section, presumably holding ECOFF debugging
852
         information.  */
853
      swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
854
      if (swap)
855
        elfmdebug_build_psymtabs (objfile, swap, ei.mdebugsect);
856
    }
857
  if (ei.stabsect)
858
    {
859
      asection *str_sect;
860
 
861
      /* Stab sections have an associated string table that looks like
862
         a separate section.  */
863
      str_sect = bfd_get_section_by_name (abfd, ".stabstr");
864
 
865
      /* FIXME should probably warn about a stab section without a stabstr.  */
866
      if (str_sect)
867
        elfstab_build_psymtabs (objfile,
868
                                ei.stabsect,
869
                                str_sect->filepos,
870
                                bfd_section_size (abfd, str_sect));
871
    }
872
  if (dwarf2_has_info (objfile))
873
    {
874
      /* DWARF 2 sections */
875
      dwarf2_build_psymtabs (objfile);
876
    }
877
 
878
  /* If the file has its own symbol tables it has no separate debug info.
879
     `.dynsym'/`.symtab' go to MSYMBOLS, `.debug_info' goes to SYMTABS/PSYMTABS.
880
     `.gnu_debuglink' may no longer be present with `.note.gnu.build-id'.  */
881
  if (!objfile_has_partial_symbols (objfile))
882
    {
883
      char *debugfile;
884
 
885
      debugfile = find_separate_debug_file_by_buildid (objfile);
886
 
887
      if (debugfile == NULL)
888
        debugfile = find_separate_debug_file_by_debuglink (objfile);
889
 
890
      if (debugfile)
891
        {
892
          bfd *abfd = symfile_bfd_open (debugfile);
893
 
894
          symbol_file_add_separate (abfd, symfile_flags, objfile);
895
          xfree (debugfile);
896
        }
897
    }
898
}
899
 
900
/* This cleans up the objfile's deprecated_sym_stab_info pointer, and
901
   the chain of stab_section_info's, that might be dangling from
902
   it.  */
903
 
904
static void
905
free_elfinfo (void *objp)
906
{
907
  struct objfile *objfile = (struct objfile *) objp;
908
  struct dbx_symfile_info *dbxinfo = objfile->deprecated_sym_stab_info;
909
  struct stab_section_info *ssi, *nssi;
910
 
911
  ssi = dbxinfo->stab_section_info;
912
  while (ssi)
913
    {
914
      nssi = ssi->next;
915
      xfree (ssi);
916
      ssi = nssi;
917
    }
918
 
919
  dbxinfo->stab_section_info = 0;        /* Just say No mo info about this.  */
920
}
921
 
922
 
923
/* Initialize anything that needs initializing when a completely new symbol
924
   file is specified (not just adding some symbols from another file, e.g. a
925
   shared library).
926
 
927
   We reinitialize buildsym, since we may be reading stabs from an ELF file.  */
928
 
929
static void
930
elf_new_init (struct objfile *ignore)
931
{
932
  stabsread_new_init ();
933
  buildsym_new_init ();
934
}
935
 
936
/* Perform any local cleanups required when we are done with a particular
937
   objfile.  I.E, we are in the process of discarding all symbol information
938
   for an objfile, freeing up all memory held for it, and unlinking the
939
   objfile struct from the global list of known objfiles. */
940
 
941
static void
942
elf_symfile_finish (struct objfile *objfile)
943
{
944
  if (objfile->deprecated_sym_stab_info != NULL)
945
    {
946
      xfree (objfile->deprecated_sym_stab_info);
947
    }
948
 
949
  dwarf2_free_objfile (objfile);
950
}
951
 
952
/* ELF specific initialization routine for reading symbols.
953
 
954
   It is passed a pointer to a struct sym_fns which contains, among other
955
   things, the BFD for the file whose symbols are being read, and a slot for
956
   a pointer to "private data" which we can fill with goodies.
957
 
958
   For now at least, we have nothing in particular to do, so this function is
959
   just a stub. */
960
 
961
static void
962
elf_symfile_init (struct objfile *objfile)
963
{
964
  /* ELF objects may be reordered, so set OBJF_REORDERED.  If we
965
     find this causes a significant slowdown in gdb then we could
966
     set it in the debug symbol readers only when necessary.  */
967
  objfile->flags |= OBJF_REORDERED;
968
}
969
 
970
/* When handling an ELF file that contains Sun STABS debug info,
971
   some of the debug info is relative to the particular chunk of the
972
   section that was generated in its individual .o file.  E.g.
973
   offsets to static variables are relative to the start of the data
974
   segment *for that module before linking*.  This information is
975
   painfully squirreled away in the ELF symbol table as local symbols
976
   with wierd names.  Go get 'em when needed.  */
977
 
978
void
979
elfstab_offset_sections (struct objfile *objfile, struct partial_symtab *pst)
980
{
981
  char *filename = pst->filename;
982
  struct dbx_symfile_info *dbx = objfile->deprecated_sym_stab_info;
983
  struct stab_section_info *maybe = dbx->stab_section_info;
984
  struct stab_section_info *questionable = 0;
985
  int i;
986
  char *p;
987
 
988
  /* The ELF symbol info doesn't include path names, so strip the path
989
     (if any) from the psymtab filename.  */
990
  while (0 != (p = strchr (filename, '/')))
991
    filename = p + 1;
992
 
993
  /* FIXME:  This linear search could speed up significantly
994
     if it was chained in the right order to match how we search it,
995
     and if we unchained when we found a match. */
996
  for (; maybe; maybe = maybe->next)
997
    {
998
      if (filename[0] == maybe->filename[0]
999
          && strcmp (filename, maybe->filename) == 0)
1000
        {
1001
          /* We found a match.  But there might be several source files
1002
             (from different directories) with the same name.  */
1003
          if (0 == maybe->found)
1004
            break;
1005
          questionable = maybe; /* Might use it later.  */
1006
        }
1007
    }
1008
 
1009
  if (maybe == 0 && questionable != 0)
1010
    {
1011
      complaint (&symfile_complaints,
1012
                 _("elf/stab section information questionable for %s"), filename);
1013
      maybe = questionable;
1014
    }
1015
 
1016
  if (maybe)
1017
    {
1018
      /* Found it!  Allocate a new psymtab struct, and fill it in.  */
1019
      maybe->found++;
1020
      pst->section_offsets = (struct section_offsets *)
1021
        obstack_alloc (&objfile->objfile_obstack,
1022
                       SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));
1023
      for (i = 0; i < maybe->num_sections; i++)
1024
        (pst->section_offsets)->offsets[i] = maybe->sections[i];
1025
      return;
1026
    }
1027
 
1028
  /* We were unable to find any offsets for this file.  Complain.  */
1029
  if (dbx->stab_section_info)   /* If there *is* any info, */
1030
    complaint (&symfile_complaints,
1031
               _("elf/stab section information missing for %s"), filename);
1032
}
1033
 
1034
/* Register that we are able to handle ELF object file formats.  */
1035
 
1036
static struct sym_fns elf_sym_fns =
1037
{
1038
  bfd_target_elf_flavour,
1039
  elf_new_init,                 /* sym_new_init: init anything gbl to entire symtab */
1040
  elf_symfile_init,             /* sym_init: read initial info, setup for sym_read() */
1041
  elf_symfile_read,             /* sym_read: read a symbol file into symtab */
1042
  elf_symfile_finish,           /* sym_finish: finished with file, cleanup */
1043
  default_symfile_offsets,      /* sym_offsets:  Translate ext. to int. relocation */
1044
  elf_symfile_segments,         /* sym_segments: Get segment information from
1045
                                   a file.  */
1046
  NULL,                         /* sym_read_linetable */
1047
  default_symfile_relocate,     /* sym_relocate: Relocate a debug section.  */
1048
  &psym_functions,
1049
  NULL                          /* next: pointer to next struct sym_fns */
1050
};
1051
 
1052
void
1053
_initialize_elfread (void)
1054
{
1055
  add_symtab_fns (&elf_sym_fns);
1056
}

powered by: WebSVN 2.1.0

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