#include "gdbthread.h"
#include "regcache.h"
#include "bcache.h"
+#include "gdb_bfd.h"
extern void _initialize_elfread (void);
if (ms_type == mst_text || ms_type == mst_file_text
|| ms_type == mst_text_gnu_ifunc)
- address = gdbarch_smash_text_address (gdbarch, address);
+ address = gdbarch_addr_bits_remove (gdbarch, address);
return prim_record_minimal_symbol_full (name, name_len, copy_name, address,
ms_type, bfd_section->index,
offset = ANOFFSET (objfile->section_offsets, sym->section->index);
if (type == ST_DYNAMIC
- && sym->section == &bfd_und_section
+ && sym->section == bfd_und_section_ptr
&& (sym->flags & BSF_FUNCTION))
{
struct minimal_symbol *msym;
}
filesym = sym;
filesymname = bcache (filesym->name, strlen (filesym->name) + 1,
- objfile->filename_cache);
+ objfile->per_bfd->filename_cache);
}
else if (sym->flags & BSF_SECTION_SYM)
continue;
symaddr = sym->value + sym->section->vma;
/* Relocate all non-absolute and non-TLS symbols by the
section offset. */
- if (sym->section != &bfd_abs_section
+ if (sym->section != bfd_abs_section_ptr
&& !(sym->section->flags & SEC_THREAD_LOCAL))
{
symaddr += offset;
/* For non-absolute symbols, use the type of the section
they are relative to, to intuit text/data. Bfd provides
no way of figuring this out for absolute symbols. */
- if (sym->section == &bfd_abs_section)
+ if (sym->section == bfd_abs_section_ptr)
{
/* This is a hack to get the minimal symbol type
right for Irix 5, which has absolute addresses
symaddr = sym->value + sym->section->vma;
/* Relocate non-absolute symbols by the
section offset. */
- if (sym->section != &bfd_abs_section)
+ if (sym->section != bfd_abs_section_ptr)
symaddr += offset;
sectinfo->sections[special_local_sect] = symaddr;
/* The special local symbols don't go in the
elf_sym = (elf_symbol_type *) sym->udata.p;
if (elf_sym)
- MSYMBOL_SIZE(msym) = elf_sym->internal_elf_sym.st_size;
+ SET_MSYMBOL_SIZE (msym, elf_sym->internal_elf_sym.st_size);
msym->filename = filesymname;
gdbarch_elf_make_msymbol_special (gdbarch, sym, msym);
sym->section, objfile);
if (mtramp)
{
- MSYMBOL_SIZE (mtramp) = MSYMBOL_SIZE (msym);
+ SET_MSYMBOL_SIZE (mtramp, MSYMBOL_SIZE (msym));
+ mtramp->created_by_gdb = 1;
mtramp->filename = filesymname;
gdbarch_elf_make_msymbol_special (gdbarch, sym, mtramp);
}
bfd *obfd = objfile->obfd;
const struct elf_backend_data *bed = get_elf_backend_data (obfd);
asection *plt, *relplt, *got_plt;
- unsigned u;
int plt_elf_idx;
bfd_size_type reloc_count, reloc;
char *string_buffer = NULL;
reloc_count = relplt->size / elf_section_data (relplt)->this_hdr.sh_entsize;
for (reloc = 0; reloc < reloc_count; reloc++)
{
- const char *name, *name_got_plt;
+ const char *name;
struct minimal_symbol *msym;
CORE_ADDR address;
const size_t got_suffix_len = strlen (SYMBOL_GOT_PLT_SUFFIX);
1, address, mst_slot_got_plt, got_plt,
objfile);
if (msym)
- MSYMBOL_SIZE (msym) = ptr_size;
+ SET_MSYMBOL_SIZE (msym, ptr_size);
}
do_cleanups (back_to);
struct type *func_func_type = builtin_type (gdbarch)->builtin_func_func;
struct type *value_type = TYPE_TARGET_TYPE (func_func_type);
struct regcache *regcache = get_thread_regcache (inferior_ptid);
+ struct value *func_func;
struct value *value;
CORE_ADDR resolved_address, resolved_pc;
struct symtab_and_line sal;
gdb_assert (b->type == bp_gnu_ifunc_resolver_return);
- value = allocate_value (value_type);
- gdbarch_return_value (gdbarch, func_func_type, value_type, regcache,
- value_contents_raw (value), NULL);
- resolved_address = value_as_address (value);
- resolved_pc = gdbarch_convert_from_func_ptr_addr (gdbarch,
- resolved_address,
- ¤t_target);
-
while (b->related_breakpoint != b)
{
struct breakpoint *b_next = b->related_breakpoint;
b = b_next;
}
gdb_assert (b->type == bp_gnu_ifunc_resolver);
+ gdb_assert (b->loc->next == NULL);
+
+ func_func = allocate_value (func_func_type);
+ set_value_address (func_func, b->loc->related_address);
+
+ value = allocate_value (value_type);
+ gdbarch_return_value (gdbarch, func_func, value_type, regcache,
+ value_contents_raw (value), NULL);
+ resolved_address = value_as_address (value);
+ resolved_pc = gdbarch_convert_from_func_ptr_addr (gdbarch,
+ resolved_address,
+ ¤t_target);
gdb_assert (current_program_space == b->pspace || b->pspace == NULL);
elf_gnu_ifunc_record_cache (b->addr_string, resolved_pc);
int retval = 0;
/* We expect to be silent on the non-existing files. */
- abfd = bfd_open_maybe_remote (filename);
+ abfd = gdb_bfd_open_maybe_remote (filename);
if (abfd == NULL)
return 0;
else
retval = 1;
- gdb_bfd_close_or_warn (abfd);
+ gdb_bfd_unref (abfd);
xfree (found);
asymbol **symbol_table = NULL, **dyn_symbol_table = NULL;
asymbol *synthsyms;
+ if (symtab_create_debug)
+ {
+ fprintf_unfiltered (gdb_stdlog,
+ "Reading minimal symbols of objfile %s ...\n",
+ objfile->name);
+ }
+
init_minimal_symbol_collection ();
back_to = make_cleanup_discard_minimal_symbols ();
if (debugfile)
{
+ struct cleanup *cleanup = make_cleanup (xfree, debugfile);
bfd *abfd = symfile_bfd_open (debugfile);
+ make_cleanup_bfd_unref (abfd);
symbol_file_add_separate (abfd, symfile_flags, objfile);
- xfree (debugfile);
+ do_cleanups (cleanup);
}
}
+
+ if (symtab_create_debug)
+ fprintf_unfiltered (gdb_stdlog, "Done reading minimal symbols.\n");
}
/* Callback to lazily read psymtabs. */
symfile.h. */
static unsigned
-elf_get_probe_argument_count (struct objfile *objfile,
- struct probe *probe)
+elf_get_probe_argument_count (struct probe *probe)
{
- return probe->pops->get_probe_argument_count (probe, objfile);
+ return probe->pops->get_probe_argument_count (probe);
}
/* Implementation of `sym_evaluate_probe_argument', as documented in
symfile.h. */
static struct value *
-elf_evaluate_probe_argument (struct objfile *objfile,
- struct probe *probe,
- unsigned n)
+elf_evaluate_probe_argument (struct probe *probe, unsigned n)
{
- return probe->pops->evaluate_probe_argument (probe, objfile, n);
+ return probe->pops->evaluate_probe_argument (probe, n);
}
/* Implementation of `sym_compile_to_ax', as documented in symfile.h. */
static void
-elf_compile_to_ax (struct objfile *objfile,
- struct probe *probe,
+elf_compile_to_ax (struct probe *probe,
struct agent_expr *expr,
struct axs_value *value,
unsigned n)
{
- probe->pops->compile_to_ax (probe, objfile, expr, value, n);
+ probe->pops->compile_to_ax (probe, expr, value, n);
}
/* Implementation of `sym_relocate_probe', as documented in symfile.h. */
projects / binutils-gdb.git / blobdiff