#include <errno.h>
#include <error.h>
#include <fcntl.h>
-#include <gelf.h>
#include <inttypes.h>
-#include <libdw.h>
+#include <libdwfl.h>
+#include <dwarf.h>
#include <libintl.h>
#include <locale.h>
#include <mcheck.h>
/* Definitions of arguments for argp functions. */
static const struct argp_option options[] =
{
- { NULL, 0, NULL, 0, N_("Input Selection:"), 0 },
- { "exe", 'e', "FILE", 0, N_("Find addresses in FILE"), 0 },
-
{ NULL, 0, NULL, 0, N_("Output Selection:"), 0 },
{ "basenames", 's', NULL, 0, N_("Show only base names of source files"), 0 },
{ "functions", 'f', NULL, 0, N_("Additional show function names"), 0 },
/* Prototype for option handler. */
static error_t parse_opt (int key, char *arg, struct argp_state *state);
+static struct argp_child argp_children[2]; /* [0] is set in main. */
+
/* Data structure to communicate with argp functions. */
-static struct argp argp =
+static const struct argp argp =
{
- options, parse_opt, args_doc, doc, NULL, NULL, NULL
+ options, parse_opt, args_doc, doc, argp_children, NULL, NULL
};
/* Handle ADDR. */
-static void handle_address (GElf_Addr addr, Elf *elf, Dwarf *dw);
-
+static void handle_address (GElf_Addr addr, Dwfl *dwfl);
-/* Name of the executable. */
-static const char *executable = "a.out";
/* True if only base names of files should be shown. */
static bool only_basenames;
/* Initialize the message catalog. */
(void) textdomain (PACKAGE);
- /* Parse and process arguments. */
- (void) argp_parse (&argp, argc, argv, 0, &remaining, NULL);
-
- /* Tell the library which version we are expecting. */
- elf_version (EV_CURRENT);
-
- /* Open the file. */
- int fd = open64 (executable, O_RDONLY);
- if (fd == -1)
- error (1, errno, gettext ("cannot open '%s'"), executable);
-
- /* Create the ELF descriptor. */
- Elf *elf = elf_begin (fd, ELF_C_READ_MMAP, NULL);
- if (elf == NULL)
- {
- close (fd);
- error (1, 0, gettext ("cannot create ELF descriptor: %s"),
- elf_errmsg (-1));
- }
-
- /* Try to get a DWARF descriptor. If it fails, we try to locate the
- debuginfo file. */
- Dwarf *dw = dwarf_begin_elf (elf, DWARF_C_READ, NULL);
- int fd2 = -1;
- Elf *elf2 = NULL;
- if (dw == NULL)
- {
- char *canon = canonicalize_file_name (executable);
- GElf_Ehdr ehdr_mem;
- GElf_Ehdr *ehdr = gelf_getehdr (elf, &ehdr_mem);
-
- if (canon != NULL && ehdr != NULL)
- {
- const char *debuginfo_dir;
- if (ehdr->e_ident[EI_CLASS] == ELFCLASS32
- || ehdr->e_machine == EM_IA_64 || ehdr->e_machine == EM_ALPHA)
- debuginfo_dir = "/usr/lib/debug";
- else
- debuginfo_dir = "/usr/lib64/debug";
-
- char *difname = alloca (strlen (debuginfo_dir) + strlen (canon) + 1);
- strcpy (stpcpy (difname, debuginfo_dir), canon);
- fd2 = open64 (difname, O_RDONLY);
- if (fd2 != -1)
- dw = dwarf_begin_elf (elf2, DWARF_C_READ, NULL);
- }
-
- free (canon);
- }
+ /* Parse and process arguments. This includes opening the modules. */
+ argp_children[0].argp = dwfl_standard_argp ();
+ Dwfl *dwfl = NULL;
+ (void) argp_parse (&argp, argc, argv, 0, &remaining, &dwfl);
+ assert (dwfl != NULL);
/* Now handle the addresses. In case none are given on the command
line, read from stdin. */
char *endp;
uintmax_t addr = strtoumax (buf, &endp, 0);
if (endp != buf)
- handle_address (addr, elf2 ?: elf, dw);
+ handle_address (addr, dwfl);
else
result = 1;
}
char *endp;
uintmax_t addr = strtoumax (argv[remaining], &endp, 0);
if (endp != argv[remaining])
- handle_address (addr, elf2 ?: elf, dw);
+ handle_address (addr, dwfl);
else
result = 1;
}
/* Handle program arguments. */
static error_t
-parse_opt (int key, char *arg,
- struct argp_state *state __attribute__ ((unused)))
+parse_opt (int key, char *arg __attribute__ ((unused)),
+ struct argp_state *state)
{
switch (key)
{
+ case ARGP_KEY_INIT:
+ state->child_inputs[0] = state->input;
+ break;
+
case 'b':
case 'C':
case OPT_DEMANGLER:
/* Ignored for compatibility. */
break;
- case 'e':
- executable = arg;
- break;
-
case 's':
only_basenames = true;
break;
}
-struct func_arg
-{
- GElf_Addr addr;
- const char *name;
-};
-
-
-static int
-match_func (Dwarf_Func *func, void *arg)
+static const char *
+dwarf_diename_integrate (Dwarf_Die *die)
{
- struct func_arg *func_arg = (struct func_arg *) arg;
- Dwarf_Addr addr;
-
- if (dwarf_func_lowpc (func, &addr) == 0 && addr <= func_arg->addr
- && dwarf_func_highpc (func, &addr) == 0 && func_arg->addr < addr)
- {
- func_arg->name = dwarf_func_name (func);
- return DWARF_CB_ABORT;
- }
-
- return DWARF_CB_OK;
+ Dwarf_Attribute attr_mem;
+ return dwarf_formstring (dwarf_attr_integrate (die, DW_AT_name, &attr_mem));
}
-
-static const char *
-elf_getname (GElf_Addr addr, Elf *elf)
+static bool
+print_dwarf_function (Dwfl_Module *mod, Dwarf_Addr addr)
{
- /* The DWARF information is not available. Use the ELF
- symbol table. */
- Elf_Scn *scn = NULL;
- Elf_Scn *dynscn = NULL;
-
- while ((scn = elf_nextscn (elf, scn)) != NULL)
- {
- GElf_Shdr shdr_mem;
- GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
- if (shdr != NULL)
+ Dwarf_Addr bias = 0;
+ Dwarf_Die *cudie = dwfl_module_addrdie (mod, addr, &bias);
+
+ Dwarf_Die *scopes;
+ int nscopes = dwarf_getscopes (cudie, addr - bias, &scopes);
+ if (nscopes <= 0)
+ return false;
+
+ for (int i = 0; i < nscopes; ++i)
+ switch (dwarf_tag (&scopes[i]))
+ {
+ case DW_TAG_subprogram:
{
- if (shdr->sh_type == SHT_SYMTAB)
- break;
- if (shdr->sh_type == SHT_DYNSYM)
- dynscn = scn;
+ const char *name = dwarf_diename_integrate (&scopes[i]);
+ if (name == NULL)
+ return false;
+ puts (name);
+ return true;
}
- }
- if (scn == NULL)
- scn = dynscn;
- if (scn != NULL)
- {
- /* Look through the symbol table for a matching symbol. */
- GElf_Shdr shdr_mem;
- GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
- assert (shdr != NULL);
-
- Elf_Data *data = elf_getdata (scn, NULL);
- if (data != NULL)
- for (int cnt = 1; cnt < (int) (shdr->sh_size / shdr->sh_entsize);
- ++cnt)
- {
- GElf_Sym sym_mem;
- GElf_Sym *sym = gelf_getsym (data, cnt, &sym_mem);
- if (sym != NULL
- && sym->st_value <= addr
- && addr < sym->st_value + sym->st_size)
- return elf_strptr (elf, shdr->sh_link, sym->st_name);
- }
- }
+ case DW_TAG_inlined_subroutine:
+ {
+ const char *name = dwarf_diename_integrate (&scopes[i]);
+ if (name == NULL)
+ return false;
+ printf ("%s inlined", name);
+
+ Dwarf_Files *files;
+ if (dwarf_getsrcfiles (cudie, &files, NULL) == 0)
+ {
+ Dwarf_Attribute attr_mem;
+ Dwarf_Word val;
+ if (dwarf_formudata (dwarf_attr (&scopes[i],
+ DW_AT_call_file,
+ &attr_mem), &val) == 0)
+ {
+ const char *file = dwarf_filesrc (files, val, NULL, NULL);
+ int lineno = 0, colno = 0;
+ if (dwarf_formudata (dwarf_attr (&scopes[i],
+ DW_AT_call_line,
+ &attr_mem), &val) == 0)
+ lineno = val;
+ if (dwarf_formudata (dwarf_attr (&scopes[i],
+ DW_AT_call_column,
+ &attr_mem), &val) == 0)
+ colno = val;
+ if (lineno == 0)
+ {
+ if (file != NULL)
+ printf (" from %s", file);
+ }
+ else if (colno == 0)
+ printf (" at %s:%u", file, lineno);
+ else
+ printf (" at %s:%u:%u", file, lineno, colno);
+ }
+ }
+ printf (" in ");
+ continue;
+ }
+ }
- return NULL;
+ return false;
}
-
static void
-handle_address (GElf_Addr addr, Elf *elf, Dwarf *dw)
+handle_address (GElf_Addr addr, Dwfl *dwfl)
{
- Dwarf_Die die_mem;
- Dwarf_Die *die = dwarf_addrdie (dw, addr, &die_mem);
+ Dwfl_Module *mod = dwfl_addrmodule (dwfl, addr);
if (show_functions)
{
/* First determine the function name. Use the DWARF information if
possible. */
- struct func_arg arg;
- arg.addr = addr;
- arg.name = NULL;
-
- if (dwarf_getfuncs (die, match_func, &arg, 0) <= 0)
- arg.name = elf_getname (addr, elf);
-
- puts (arg.name ?: "??");
+ if (! print_dwarf_function (mod, addr))
+ puts (dwfl_module_addrname (mod, addr) ?: "??");
}
+ Dwfl_Line *line = dwfl_module_getsrc (mod, addr);
- Dwarf_Line *line;
const char *src;
- if ((line = dwarf_getsrc_die (die, addr)) != NULL
- && (src = dwarf_linesrc (line, NULL, NULL)) != NULL)
+ int lineno, linecol;
+ if (line != NULL && (src = dwfl_lineinfo (line, &addr, &lineno, &linecol,
+ NULL, NULL)) != NULL)
{
if (only_basenames)
src = basename (src);
- int lineno;
- if (dwarf_lineno (line, &lineno) != -1)
- {
- int linecol;
- if (dwarf_linecol (line, &linecol) != -1 && linecol != 0)
- printf ("%s:%d:%d\n", src, lineno, linecol);
- else
- printf ("%s:%d\n", src, lineno);
- }
+ if (linecol != 0)
+ printf ("%s:%d:%d\n", src, lineno, linecol);
else
- printf ("%s:0\n", src);
+ printf ("%s:%d\n", src, lineno);
}
else
puts ("??:0");
size_t fname_len = strlen (fname) + 1;
char *fullname = alloca (prefix_len + 1 + fname_len);
char *cp = fullname;
- Elf *newelf;
Elf *debugelf = NULL;
char *tmp_debug_fname = NULL;
int result = 0;
- GElf_Ehdr ehdr_mem;
- GElf_Ehdr *ehdr;
size_t shstrndx;
- size_t shnum;
struct shdr_info
{
Elf_Scn *scn;
}
/* Get the information from the old file. */
- ehdr = gelf_getehdr (elf, &ehdr_mem);
+ GElf_Ehdr ehdr_mem;
+ GElf_Ehdr *ehdr = gelf_getehdr (elf, &ehdr_mem);
if (ehdr == NULL)
INTERNAL_ERROR (fname);
/* We now create a new ELF descriptor for the same file. We
construct it almost exactly in the same way with some information
dropped. */
+ Elf *newelf;
if (output_fname != NULL)
newelf = elf_begin (fd, ELF_C_WRITE_MMAP, NULL);
else
for (cnt = 0; cnt < ehdr->e_phnum; ++cnt)
{
GElf_Phdr phdr_mem;
- GElf_Phdr *phdr;
-
- phdr = gelf_getphdr (elf, cnt, &phdr_mem);
+ GElf_Phdr *phdr = gelf_getphdr (elf, cnt, &phdr_mem);
if (phdr == NULL
|| unlikely (gelf_update_phdr (newelf, cnt, phdr) == 0))
INTERNAL_ERROR (fname);
for (cnt = 0; cnt < ehdr->e_phnum; ++cnt)
{
GElf_Phdr phdr_mem;
- GElf_Phdr *phdr;
-
- phdr = gelf_getphdr (elf, cnt, &phdr_mem);
+ GElf_Phdr *phdr = gelf_getphdr (elf, cnt, &phdr_mem);
if (phdr == NULL
|| unlikely (gelf_update_phdr (debugelf, cnt, phdr) == 0))
INTERNAL_ERROR (fname);
}
/* Number of sections. */
+ size_t shnum;
if (unlikely (elf_getshnum (elf, &shnum) < 0))
{
error (0, 0, gettext ("cannot determine number of sections: %s"),
}
else if (unlikely (shdr_info[cnt].shdr.sh_type == SHT_GROUP))
{
- Elf32_Word *grpref;
- size_t inner;
-
/* Cross-reference the sections contained in the section
group. */
shdr_info[cnt].data = elf_getdata (shdr_info[cnt].scn, NULL);
INTERNAL_ERROR (fname);
/* XXX Fix for unaligned access. */
- grpref = (Elf32_Word *) shdr_info[cnt].data->d_buf;
+ Elf32_Word *grpref = (Elf32_Word *) shdr_info[cnt].data->d_buf;
+ size_t inner;
for (inner = 1;
inner < shdr_info[cnt].data->d_size / sizeof (Elf32_Word);
++inner)
idx = shdr_info[cnt].group_idx;
while (idx != 0)
{
- /* If the references section group is a normal section
- group and has one element remaining, or if it is an
- empty COMDAT section group it is removed. */
- bool is_comdat;
-
/* The section group data is already loaded. */
assert (shdr_info[idx].data != NULL);
- is_comdat = (((Elf32_Word *) shdr_info[idx].data->d_buf)[0]
- & GRP_COMDAT) != 0;
+ /* If the references section group is a normal section
+ group and has one element remaining, or if it is an
+ empty COMDAT section group it is removed. */
+ bool is_comdat = (((Elf32_Word *) shdr_info[idx].data->d_buf)[0]
+ & GRP_COMDAT) != 0;
--shdr_info[idx].group_cnt;
if ((!is_comdat && shdr_info[idx].group_cnt == 1)
if (shdr_info[cnt].shdr.sh_type == SHT_DYNSYM
|| shdr_info[cnt].shdr.sh_type == SHT_SYMTAB)
{
- Elf_Data *symdata;
- Elf_Data *xndxdata;
- size_t elsize;
-
/* Make sure the data is loaded. */
if (shdr_info[cnt].data == NULL)
{
if (shdr_info[cnt].data == NULL)
INTERNAL_ERROR (fname);
}
- symdata = shdr_info[cnt].data;
+ Elf_Data *symdata = shdr_info[cnt].data;
/* If there is an extended section index table load it
as well. */
if (shdr_info[shdr_info[cnt].symtab_idx].data == NULL)
INTERNAL_ERROR (fname);
}
- xndxdata = shdr_info[shdr_info[cnt].symtab_idx].data;
+ Elf_Data *xndxdata
+ = shdr_info[shdr_info[cnt].symtab_idx].data;
/* Go through all symbols and make sure the section they
reference is not removed. */
- elsize = gelf_fsize (elf, ELF_T_SYM, 1, ehdr->e_version);
+ size_t elsize = gelf_fsize (elf, ELF_T_SYM, 1,
+ ehdr->e_version);
for (size_t inner = 0;
inner < shdr_info[cnt].data->d_size / elsize;
{
GElf_Sym sym_mem;
Elf32_Word xndx;
- GElf_Sym *sym;
- size_t scnidx;
-
- sym = gelf_getsymshndx (symdata, xndxdata, inner,
- &sym_mem, &xndx);
+ GElf_Sym *sym = gelf_getsymshndx (symdata, xndxdata,
+ inner, &sym_mem,
+ &xndx);
if (sym == NULL)
INTERNAL_ERROR (fname);
- scnidx = sym->st_shndx;
+ size_t scnidx = sym->st_shndx;
if (scnidx == SHN_UNDEF || scnidx >= shnum
|| (scnidx >= SHN_LORESERVE
&& scnidx <= SHN_HIRESERVE
{
for (cnt = 1; cnt < shnum; ++cnt)
{
- Elf_Data *debugdata;
- GElf_Shdr debugshdr;
- bool discard_section;
-
scn = elf_newscn (debugelf);
if (scn == NULL)
error (EXIT_FAILURE, 0,
gettext ("while generating output file: %s"),
elf_errmsg (-1));
- discard_section = shdr_info[cnt].idx > 0 && cnt != ehdr->e_shstrndx;
+ bool discard_section = (shdr_info[cnt].idx > 0
+ && cnt != ehdr->e_shstrndx);
/* Set the section header in the new file. */
- debugshdr = shdr_info[cnt].shdr;
+ GElf_Shdr debugshdr = shdr_info[cnt].shdr;
if (discard_section)
debugshdr.sh_type = SHT_NOBITS;
}
/* Set the data. This is done by copying from the old file. */
- debugdata = elf_newdata (scn);
+ Elf_Data *debugdata = elf_newdata (scn);
if (debugdata == NULL)
INTERNAL_ERROR (fname);
/* Create the reference to the file with the debug info. */
if (debug_fname != NULL)
{
- char *debug_basename;
- off_t crc_offset;
-
/* Add the section header string table section name. */
shdr_info[cnt].se = ebl_strtabadd (shst, ".gnu_debuglink", 15);
shdr_info[cnt].idx = idx++;
error (EXIT_FAILURE, 0, gettext ("cannot allocate section data: %s"),
elf_errmsg (-1));
- debug_basename = basename (debug_fname_embed ?: debug_fname);
- crc_offset = strlen (debug_basename) + 1;
+ char *debug_basename = basename (debug_fname_embed ?: debug_fname);
+ off_t crc_offset = strlen (debug_basename) + 1;
/* Align to 4 byte boundary */
crc_offset = ((crc_offset - 1) & ~3) + 4;
projects / thirdparty / elfutils.git / commitdiff
