/* Read ELF (Executable and Linking Format) object files for GDB.
Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
- 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
+ 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
+ Free Software Foundation, Inc.
Written by Fred Fish at Cygnus Support.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "bfd.h"
#include "gdb_string.h"
#include "elf-bfd.h"
+#include "elf/common.h"
+#include "elf/internal.h"
#include "elf/mips.h"
#include "symtab.h"
#include "symfile.h"
#include "gdb-stabs.h"
#include "complaints.h"
#include "demangle.h"
+#include "psympriv.h"
extern void _initialize_elfread (void);
+/* Forward declaration. */
+static struct sym_fns elf_sym_fns_gdb_index;
+
/* The struct elfinfo is available only during ELF symbol table and
psymtab reading. It is destroyed at the completion of psymtab-reading.
It's local to elf_symfile_read. */
static void free_elfinfo (void *);
+/* Locate the segments in ABFD. */
+
+static struct symfile_segment_data *
+elf_symfile_segments (bfd *abfd)
+{
+ Elf_Internal_Phdr *phdrs, **segments;
+ long phdrs_size;
+ int num_phdrs, num_segments, num_sections, i;
+ asection *sect;
+ struct symfile_segment_data *data;
+
+ phdrs_size = bfd_get_elf_phdr_upper_bound (abfd);
+ if (phdrs_size == -1)
+ return NULL;
+
+ phdrs = alloca (phdrs_size);
+ num_phdrs = bfd_get_elf_phdrs (abfd, phdrs);
+ if (num_phdrs == -1)
+ return NULL;
+
+ num_segments = 0;
+ segments = alloca (sizeof (Elf_Internal_Phdr *) * num_phdrs);
+ for (i = 0; i < num_phdrs; i++)
+ if (phdrs[i].p_type == PT_LOAD)
+ segments[num_segments++] = &phdrs[i];
+
+ if (num_segments == 0)
+ return NULL;
+
+ data = XZALLOC (struct symfile_segment_data);
+ data->num_segments = num_segments;
+ data->segment_bases = XCALLOC (num_segments, CORE_ADDR);
+ data->segment_sizes = XCALLOC (num_segments, CORE_ADDR);
+
+ for (i = 0; i < num_segments; i++)
+ {
+ data->segment_bases[i] = segments[i]->p_vaddr;
+ data->segment_sizes[i] = segments[i]->p_memsz;
+ }
+
+ num_sections = bfd_count_sections (abfd);
+ data->segment_info = XCALLOC (num_sections, int);
+
+ for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next)
+ {
+ int j;
+ CORE_ADDR vma;
+
+ if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0)
+ continue;
+
+ vma = bfd_get_section_vma (abfd, sect);
+
+ for (j = 0; j < num_segments; j++)
+ if (segments[j]->p_memsz > 0
+ && vma >= segments[j]->p_vaddr
+ && (vma - segments[j]->p_vaddr) < segments[j]->p_memsz)
+ {
+ data->segment_info[i] = j + 1;
+ break;
+ }
+
+ /* We should have found a segment for every non-empty section.
+ If we haven't, we will not relocate this section by any
+ offsets we apply to the segments. As an exception, do not
+ warn about SHT_NOBITS sections; in normal ELF execution
+ environments, SHT_NOBITS means zero-initialized and belongs
+ in a segment, but in no-OS environments some tools (e.g. ARM
+ RealView) use SHT_NOBITS for uninitialized data. Since it is
+ uninitialized, it doesn't need a program header. Such
+ binaries are not relocatable. */
+ if (bfd_get_section_size (sect) > 0 && j == num_segments
+ && (bfd_get_section_flags (abfd, sect) & SEC_LOAD) != 0)
+ warning (_("Loadable segment \"%s\" outside of ELF segments"),
+ bfd_section_name (abfd, sect));
+ }
+
+ return data;
+}
+
/* We are called once per section from elf_symfile_read. We
need to examine each section we are passed, check to see
if it is something we are interested in processing, and
}
static struct minimal_symbol *
-record_minimal_symbol (char *name, CORE_ADDR address,
+record_minimal_symbol (const char *name, int name_len, int copy_name,
+ CORE_ADDR address,
enum minimal_symbol_type ms_type,
asection *bfd_section, struct objfile *objfile)
{
+ struct gdbarch *gdbarch = get_objfile_arch (objfile);
+
if (ms_type == mst_text || ms_type == mst_file_text)
- address = SMASH_TEXT_ADDRESS (address);
+ address = gdbarch_smash_text_address (gdbarch, address);
- return prim_record_minimal_symbol_and_info
- (name, address, ms_type, NULL, bfd_section->index, bfd_section, objfile);
+ return prim_record_minimal_symbol_full (name, name_len, copy_name, address,
+ ms_type, bfd_section->index,
+ bfd_section, objfile);
}
/*
SYNOPSIS
- void elf_symtab_read (struct objfile *objfile, int dynamic,
+ void elf_symtab_read (struct objfile *objfile, int type,
long number_of_symbols, asymbol **symbol_table)
DESCRIPTION
Given an objfile, a symbol table, and a flag indicating whether the
- symbol table contains dynamic symbols, add all the global function
- and data symbols to the minimal symbol table.
+ symbol table contains regular, dynamic, or synthetic symbols, add all
+ the global function and data symbols to the minimal symbol table.
In stabs-in-ELF, as implemented by Sun, there are some local symbols
defined in the ELF symbol table, which can be used to locate
*/
+#define ST_REGULAR 0
+#define ST_DYNAMIC 1
+#define ST_SYNTHETIC 2
+
static void
-elf_symtab_read (struct objfile *objfile, int dynamic,
- long number_of_symbols, asymbol **symbol_table)
+elf_symtab_read (struct objfile *objfile, int type,
+ long number_of_symbols, asymbol **symbol_table,
+ int copy_names)
{
- long storage_needed;
+ struct gdbarch *gdbarch = get_objfile_arch (objfile);
asymbol *sym;
long i;
CORE_ADDR symaddr;
/* If filesym is nonzero, it points to a file symbol, but we haven't
seen any section info for it yet. */
asymbol *filesym = 0;
-#ifdef SOFUN_ADDRESS_MAYBE_MISSING
- /* Name of filesym, as saved on the objfile_obstack. */
- char *filesymname = obsavestring ("", 0, &objfile->objfile_obstack);
-#endif
+ /* Name of filesym. This is either a constant string or is saved on
+ the objfile's obstack. */
+ char *filesymname = "";
struct dbx_symfile_info *dbx = objfile->deprecated_sym_stab_info;
int stripped = (bfd_get_symcount (objfile->obfd) == 0);
symbols which do not correspond to objects in the symbol table,
but have some other target-specific meaning. */
if (bfd_is_target_special_symbol (objfile->obfd, sym))
- continue;
+ {
+ if (gdbarch_record_special_symbol_p (gdbarch))
+ gdbarch_record_special_symbol (gdbarch, objfile, sym);
+ continue;
+ }
offset = ANOFFSET (objfile->section_offsets, sym->section->index);
- if (dynamic
+ if (type == ST_DYNAMIC
&& sym->section == &bfd_und_section
&& (sym->flags & BSF_FUNCTION))
{
struct minimal_symbol *msym;
+ bfd *abfd = objfile->obfd;
+ asection *sect;
/* Symbol is a reference to a function defined in
a shared library.
symaddr = sym->value;
if (symaddr == 0)
continue;
- symaddr += offset;
+
+ /* sym->section is the undefined section. However, we want to
+ record the section where the PLT stub resides with the
+ minimal symbol. Search the section table for the one that
+ covers the stub's address. */
+ for (sect = abfd->sections; sect != NULL; sect = sect->next)
+ {
+ if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0)
+ continue;
+
+ if (symaddr >= bfd_get_section_vma (abfd, sect)
+ && symaddr < bfd_get_section_vma (abfd, sect)
+ + bfd_get_section_size (sect))
+ break;
+ }
+ if (!sect)
+ continue;
+
+ symaddr += ANOFFSET (objfile->section_offsets, sect->index);
+
msym = record_minimal_symbol
- ((char *) sym->name, symaddr,
- mst_solib_trampoline, sym->section, objfile);
-#ifdef SOFUN_ADDRESS_MAYBE_MISSING
+ (sym->name, strlen (sym->name), copy_names,
+ symaddr, mst_solib_trampoline, sect, objfile);
if (msym != NULL)
msym->filename = filesymname;
-#endif
continue;
}
/* If it is a nonstripped executable, do not enter dynamic
symbols, as the dynamic symbol table is usually a subset
of the main symbol table. */
- if (dynamic && !stripped)
+ if (type == ST_DYNAMIC && !stripped)
continue;
if (sym->flags & BSF_FILE)
{
sectinfo = NULL;
}
filesym = sym;
-#ifdef SOFUN_ADDRESS_MAYBE_MISSING
filesymname =
obsavestring ((char *) filesym->name, strlen (filesym->name),
&objfile->objfile_obstack);
-#endif
}
else if (sym->flags & BSF_SECTION_SYM)
continue;
interested in will have a section. */
/* Bfd symbols are section relative. */
symaddr = sym->value + sym->section->vma;
- /* Relocate all non-absolute symbols by the section offset. */
- if (sym->section != &bfd_abs_section)
+ /* Relocate all non-absolute and non-TLS symbols by the
+ section offset. */
+ if (sym->section != &bfd_abs_section
+ && !(sym->section->flags & SEC_THREAD_LOCAL))
{
symaddr += offset;
}
{
/* This is a hack to get the minimal symbol type
right for Irix 5, which has absolute addresses
- with special section indices for dynamic symbols. */
- unsigned short shndx =
+ with special section indices for dynamic symbols.
+
+ NOTE: uweigand-20071112: Synthetic symbols do not
+ have an ELF-private part, so do not touch those. */
+ unsigned int shndx = type == ST_SYNTHETIC ? 0 :
((elf_symbol_type *) sym)->internal_elf_sym.st_shndx;
switch (shndx)
/* Named Local variable in a Data section.
Check its name for stabs-in-elf. */
int special_local_sect;
+
if (strcmp ("Bbss.bss", sym->name) == 0)
special_local_sect = SECT_OFF_BSS (objfile);
else if (strcmp ("Ddata.data", sym->name) == 0)
int max_index;
size_t size;
- max_index
- = max (SECT_OFF_BSS (objfile),
- max (SECT_OFF_DATA (objfile),
- SECT_OFF_RODATA (objfile)));
+ max_index = SECT_OFF_BSS (objfile);
+ if (objfile->sect_index_data > max_index)
+ max_index = objfile->sect_index_data;
+ if (objfile->sect_index_rodata > max_index)
+ max_index = objfile->sect_index_rodata;
/* max_index is the largest index we'll
use into this array, so we must
continue; /* Skip this symbol. */
}
msym = record_minimal_symbol
- ((char *) sym->name, symaddr,
+ (sym->name, strlen (sym->name), copy_names, symaddr,
ms_type, sym->section, objfile);
+
if (msym)
{
/* Pass symbol size field in via BFD. FIXME!!! */
- unsigned long size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
- MSYMBOL_SIZE(msym) = size;
+ elf_symbol_type *elf_sym;
+
+ /* NOTE: uweigand-20071112: A synthetic symbol does not have an
+ ELF-private part. However, in some cases (e.g. synthetic
+ 'dot' symbols on ppc64) the udata.p entry is set to point back
+ to the original ELF symbol it was derived from. Get the size
+ from that symbol. */
+ if (type != ST_SYNTHETIC)
+ elf_sym = (elf_symbol_type *) sym;
+ else
+ elf_sym = (elf_symbol_type *) sym->udata.p;
+
+ if (elf_sym)
+ MSYMBOL_SIZE(msym) = elf_sym->internal_elf_sym.st_size;
+
+ msym->filename = filesymname;
+ gdbarch_elf_make_msymbol_special (gdbarch, sym, msym);
}
-#ifdef SOFUN_ADDRESS_MAYBE_MISSING
- if (msym != NULL)
- msym->filename = filesymname;
-#endif
- ELF_MAKE_MSYMBOL_SPECIAL (sym, msym);
+
+ /* For @plt symbols, also record a trampoline to the
+ destination symbol. The @plt symbol will be used in
+ disassembly, and the trampoline will be used when we are
+ trying to find the target. */
+ if (msym && ms_type == mst_text && type == ST_SYNTHETIC)
+ {
+ int len = strlen (sym->name);
+
+ if (len > 4 && strcmp (sym->name + len - 4, "@plt") == 0)
+ {
+ struct minimal_symbol *mtramp;
+
+ mtramp = record_minimal_symbol (sym->name, len - 4, 1,
+ symaddr,
+ mst_solib_trampoline,
+ sym->section, objfile);
+ if (mtramp)
+ {
+ MSYMBOL_SIZE (mtramp) = MSYMBOL_SIZE (msym);
+ mtramp->filename = filesymname;
+ gdbarch_elf_make_msymbol_special (gdbarch, sym, mtramp);
+ }
+ }
+ }
+ }
+ }
+}
+
+struct build_id
+ {
+ size_t size;
+ gdb_byte data[1];
+ };
+
+/* Locate NT_GNU_BUILD_ID from ABFD and return its content. */
+
+static struct build_id *
+build_id_bfd_get (bfd *abfd)
+{
+ struct build_id *retval;
+
+ if (!bfd_check_format (abfd, bfd_object)
+ || bfd_get_flavour (abfd) != bfd_target_elf_flavour
+ || elf_tdata (abfd)->build_id == NULL)
+ return NULL;
+
+ retval = xmalloc (sizeof *retval - 1 + elf_tdata (abfd)->build_id_size);
+ retval->size = elf_tdata (abfd)->build_id_size;
+ memcpy (retval->data, elf_tdata (abfd)->build_id, retval->size);
+
+ return retval;
+}
+
+/* Return if FILENAME has NT_GNU_BUILD_ID matching the CHECK value. */
+
+static int
+build_id_verify (const char *filename, struct build_id *check)
+{
+ bfd *abfd;
+ struct build_id *found = NULL;
+ int retval = 0;
+
+ /* We expect to be silent on the non-existing files. */
+ abfd = bfd_open_maybe_remote (filename);
+ if (abfd == NULL)
+ return 0;
+
+ found = build_id_bfd_get (abfd);
+
+ if (found == NULL)
+ warning (_("File \"%s\" has no build-id, file skipped"), filename);
+ else if (found->size != check->size
+ || memcmp (found->data, check->data, found->size) != 0)
+ warning (_("File \"%s\" has a different build-id, file skipped"), filename);
+ else
+ retval = 1;
+
+ gdb_bfd_close_or_warn (abfd);
+
+ xfree (found);
+
+ return retval;
+}
+
+static char *
+build_id_to_debug_filename (struct build_id *build_id)
+{
+ char *link, *debugdir, *retval = NULL;
+
+ /* DEBUG_FILE_DIRECTORY/.build-id/ab/cdef */
+ link = alloca (strlen (debug_file_directory) + (sizeof "/.build-id/" - 1) + 1
+ + 2 * build_id->size + (sizeof ".debug" - 1) + 1);
+
+ /* Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will
+ cause "/.build-id/..." lookups. */
+
+ debugdir = debug_file_directory;
+ do
+ {
+ char *s, *debugdir_end;
+ gdb_byte *data = build_id->data;
+ size_t size = build_id->size;
+
+ while (*debugdir == DIRNAME_SEPARATOR)
+ debugdir++;
+
+ debugdir_end = strchr (debugdir, DIRNAME_SEPARATOR);
+ if (debugdir_end == NULL)
+ debugdir_end = &debugdir[strlen (debugdir)];
+
+ memcpy (link, debugdir, debugdir_end - debugdir);
+ s = &link[debugdir_end - debugdir];
+ s += sprintf (s, "/.build-id/");
+ if (size > 0)
+ {
+ size--;
+ s += sprintf (s, "%02x", (unsigned) *data++);
+ }
+ if (size > 0)
+ *s++ = '/';
+ while (size-- > 0)
+ s += sprintf (s, "%02x", (unsigned) *data++);
+ strcpy (s, ".debug");
+
+ /* lrealpath() is expensive even for the usually non-existent files. */
+ if (access (link, F_OK) == 0)
+ retval = lrealpath (link);
+
+ if (retval != NULL && !build_id_verify (retval, build_id))
+ {
+ xfree (retval);
+ retval = NULL;
+ }
+
+ if (retval != NULL)
+ break;
+
+ debugdir = debugdir_end;
+ }
+ while (*debugdir != 0);
+
+ return retval;
+}
+
+static char *
+find_separate_debug_file_by_buildid (struct objfile *objfile)
+{
+ struct build_id *build_id;
+
+ build_id = build_id_bfd_get (objfile->obfd);
+ if (build_id != NULL)
+ {
+ char *build_id_name;
+
+ build_id_name = build_id_to_debug_filename (build_id);
+ xfree (build_id);
+ /* Prevent looping on a stripped .debug file. */
+ if (build_id_name != NULL && strcmp (build_id_name, objfile->name) == 0)
+ {
+ warning (_("\"%s\": separate debug info file has no debug info"),
+ build_id_name);
+ xfree (build_id_name);
}
+ else if (build_id_name != NULL)
+ return build_id_name;
}
+ return NULL;
}
/* Scan and build partial symbols for a symbol file.
in each section. We simplify it down to a single offset for all
symbols. FIXME.
- MAINLINE is true if we are reading the main symbol
- table (as opposed to a shared lib or dynamically loaded file).
-
This function only does the minimum work necessary for letting the
user "name" things symbolically; it does not read the entire symtab.
Instead, it reads the external and static symbols and puts them in partial
capability even for files compiled without -g. */
static void
-elf_symfile_read (struct objfile *objfile, int mainline)
+elf_symfile_read (struct objfile *objfile, int symfile_flags)
{
bfd *abfd = objfile->obfd;
struct elfinfo ei;
struct cleanup *back_to;
- CORE_ADDR offset;
long symcount = 0, dynsymcount = 0, synthcount, storage_needed;
asymbol **symbol_table = NULL, **dyn_symbol_table = NULL;
asymbol *synthsyms;
error (_("Can't read symbols from %s: %s"), bfd_get_filename (objfile->obfd),
bfd_errmsg (bfd_get_error ()));
- elf_symtab_read (objfile, 0, symcount, symbol_table);
+ elf_symtab_read (objfile, ST_REGULAR, symcount, symbol_table, 0);
}
/* Add the dynamic symbols. */
error (_("Can't read symbols from %s: %s"), bfd_get_filename (objfile->obfd),
bfd_errmsg (bfd_get_error ()));
- elf_symtab_read (objfile, 1, dynsymcount, dyn_symbol_table);
+ elf_symtab_read (objfile, ST_DYNAMIC, dynsymcount, dyn_symbol_table, 0);
}
/* Add synthetic symbols - for instance, names for any PLT entries. */
for (i = 0; i < synthcount; i++)
synth_symbol_table[i] = synthsyms + i;
make_cleanup (xfree, synth_symbol_table);
- elf_symtab_read (objfile, 0, synthcount, synth_symbol_table);
+ elf_symtab_read (objfile, ST_SYNTHETIC, synthcount, synth_symbol_table, 1);
}
/* Install any minimal symbols that have been collected as the current
/* Now process debugging information, which is contained in
special ELF sections. */
- /* If we are reinitializing, or if we have never loaded syms yet,
- set table to empty. MAINLINE is cleared so that *_read_psymtab
- functions do not all also re-initialize the psymbol table. */
- if (mainline)
- {
- init_psymbol_list (objfile, 0);
- mainline = 0;
- }
-
/* We first have to find them... */
bfd_map_over_sections (abfd, elf_locate_sections, (void *) & ei);
/* FIXME should probably warn about a stab section without a stabstr. */
if (str_sect)
elfstab_build_psymtabs (objfile,
- mainline,
ei.stabsect,
str_sect->filepos,
bfd_section_size (abfd, str_sect));
}
- if (dwarf2_has_info (objfile))
+
+ if (dwarf2_has_info (objfile) && dwarf2_initialize_objfile (objfile))
+ objfile->sf = &elf_sym_fns_gdb_index;
+
+ /* If the file has its own symbol tables it has no separate debug info.
+ `.dynsym'/`.symtab' go to MSYMBOLS, `.debug_info' goes to SYMTABS/PSYMTABS.
+ `.gnu_debuglink' may no longer be present with `.note.gnu.build-id'. */
+ if (!objfile_has_partial_symbols (objfile))
{
- /* DWARF 2 sections */
- dwarf2_build_psymtabs (objfile, mainline);
- }
+ char *debugfile;
- /* FIXME: kettenis/20030504: This still needs to be integrated with
- dwarf2read.c in a better way. */
- dwarf2_build_frame_info (objfile);
+ debugfile = find_separate_debug_file_by_buildid (objfile);
+
+ if (debugfile == NULL)
+ debugfile = find_separate_debug_file_by_debuglink (objfile);
+
+ if (debugfile)
+ {
+ bfd *abfd = symfile_bfd_open (debugfile);
+
+ symbol_file_add_separate (abfd, symfile_flags, objfile);
+ xfree (debugfile);
+ }
+ }
}
/* This cleans up the objfile's deprecated_sym_stab_info pointer, and
{
xfree (objfile->deprecated_sym_stab_info);
}
+
+ dwarf2_free_objfile (objfile);
}
/* ELF specific initialization routine for reading symbols.
elf_symfile_read, /* sym_read: read a symbol file into symtab */
elf_symfile_finish, /* sym_finish: finished with file, cleanup */
default_symfile_offsets, /* sym_offsets: Translate ext. to int. relocation */
+ elf_symfile_segments, /* sym_segments: Get segment information from
+ a file. */
+ NULL, /* sym_read_linetable */
+ default_symfile_relocate, /* sym_relocate: Relocate a debug section. */
+ &psym_functions,
+ NULL /* next: pointer to next struct sym_fns */
+};
+
+/* The same as elf_sym_fns, but not registered and uses the
+ DWARF-specific GNU index rather than psymtab. */
+static struct sym_fns elf_sym_fns_gdb_index =
+{
+ bfd_target_elf_flavour,
+ elf_new_init, /* sym_new_init: init anything gbl to entire symab */
+ elf_symfile_init, /* sym_init: read initial info, setup for sym_red() */
+ elf_symfile_read, /* sym_read: read a symbol file into symtab */
+ elf_symfile_finish, /* sym_finish: finished with file, cleanup */
+ default_symfile_offsets, /* sym_offsets: Translate ext. to int. relocatin */
+ elf_symfile_segments, /* sym_segments: Get segment information from
+ a file. */
+ NULL, /* sym_read_linetable */
+ default_symfile_relocate, /* sym_relocate: Relocate a debug section. */
+ &dwarf2_gdb_index_functions,
NULL /* next: pointer to next struct sym_fns */
};
projects / deliverable / binutils-gdb.git / blobdiff