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.1/] [gdb/] [elfread.c] - Blame information for rev 227

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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