varun-r-mallya/sysprof
1
0
Fork 0
mirror of https://github.com/varun-r-mallya/sysprof.git synced 2025-12-31 20:36:25 +00:00
Code Issues Packages Projects Releases Wiki Activity

New file, made out of files from libiberty in binutils.

Browse Source 
2006-08-20  Soren Sandmann  <sandmann@redhat.com>

	* Makefile.am, demangle.c: New file, made out of files from
	libiberty in binutils.

	* binfile.c: Use the new sysprof_cplus_demangle() function

	* elfparser.[ch]: Add code to lookup symbols. Add demangling
	function

	* testelf.c: Various tests
This commit is contained in:
Soren Sandmann
2006-08-20 04:32:12 +00:00
committed by Søren Sandmann Pedersen
parent 8967b3148c
commit 6c7afad3ff
7 changed files with 9780 additions and 167 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
ChangeLog
View File

@ -1,3 +1,15 @@
2006-08-20 Soren Sandmann <sandmann@redhat.com>
* Makefile.am, demangle.c: New file, made out of files from
libiberty in binutils.
* binfile.c: Use the new sysprof_cplus_demangle() function
* elfparser.[ch]: Add code to lookup symbols. Add demangling
function
* testelf.c: Various tests
2006-08-19 Soren Sandmann <sandmann@redhat.com>
* elfparser.c: Many cleanups.

3
Makefile.am
View File

@ -4,7 +4,7 @@ DIST_SUBDIRS = module
bin_PROGRAMS = sysprof-text
noinst_PROGRAMS = testelf
testelf_SOURCES = testelf.c elfparser.c elfparser.h binparser.c binparser.h
testelf_SOURCES = testelf.c demangle.c elfparser.c elfparser.h binparser.c binparser.h
testelf_CPPFLAGS = \
$(CORE_DEP_CFLAGS)
testelf_LDADD = $(CORE_DEP_LIBS)
@ -18,6 +18,7 @@ SYSPROF_CORE = \
binfile.c \
collector.c \
collector.h \
demangle.c \
process.h \
process.c \
profile.h \

4
binfile.c
View File

@ -267,7 +267,7 @@ slurp_symtab (bfd *abfd, long *symcount)
return sy;
}
extern char *cplus_demangle (const char *mangled, int options);
extern char *sysprof_cplus_demangle (const char *mangled, int options);
#define DMGL_PARAMS (1 << 0) /* Include function args */
#define DMGL_ANSI (1 << 1) /* Include const, volatile, etc */
@ -280,7 +280,7 @@ demangle (bfd *bfd, const char *name)
if (bfd_get_symbol_leading_char (bfd) == *name)
++name;
demangled = cplus_demangle (name, DMGL_ANSI | DMGL_PARAMS);
demangled = sysprof_cplus_demangle (name, DMGL_ANSI | DMGL_PARAMS);
return demangled ? demangled : g_strdup (name);
}

9575
demangle.c Normal file
View File

File diff suppressed because it is too large Load Diff

296
elfparser.c
View File

@ -1,3 +1,4 @@
#include <stdlib.h>
#include <string.h>
#include <elf.h>
#include "binparser.h"
@ -12,6 +13,8 @@ struct SymbolTable
struct ElfSym
{
const char *name;
gulong address;
};
struct Section
@ -32,6 +35,9 @@ struct ElfParser
int n_sections;
Section ** sections;
int n_symbols;
ElfSym * symbols;
};
static gboolean parse_elf_signature (const guchar *data, gsize length,
@ -159,128 +165,22 @@ elf_parser_free (ElfParser *parser)
g_free (parser);
}
extern char *sysprof_cplus_demangle (const char *name, int options);
char *
elf_demangle (const char *name)
{
char *demangled = sysprof_cplus_demangle (name, 0);
if (demangled)
return demangled;
else
return g_strdup (name);
}
/*
* Looking up symbols
*/
#if 0
static int lookup_function_symbol (ElfParser *parser,
int begin,
int end,
gulong address);
static gboolean
check_symbol (ElfParser *parser,
int index,
gulong address)
{
bin_parser_index (parser->parser, index);
/* FIXME */
return FALSE;
}
static gboolean
is_function (ElfParser *parser, int index)
{
return FALSE;
}
static gulong
get_address (ElfParser *parser, int index)
{
return 0;
}
static int
do_check (ElfParser *parser,
int begin,
int current,
int other,
int end,
gulong address)
{
int first = current > other ? current : other;
int last = current > other ? other : current;
/* The invariant here is that nothing between first
* and last is a function
*/
if (is_function (parser, current))
{
gulong addr = get_address (parser, current);
if (addr == address)
{
return current;
}
else if (addr > address)
{
return lookup_function_symbol (
parser, begin, first, address);
}
else
{
return lookup_function_symbol (
parser, last, end, address);
}
}
return -1;
}
static int
lookup_function_symbol (ElfParser *parser,
int begin,
int end,
gulong address)
{
g_assert (end - begin > 0);
if (end - begin < 10)
{
int i;
for (i = 0; i < end - begin; ++i)
{
bin_parser_index (parser->parser, i);
if (is_function (parser, i) &&
get_address (parser, i == address))
{
return i;
}
}
}
else
{
int mid1, mid2;
mid1 = mid2 = (end - begin) / 2;
while (mid1 >= begin &&
mid2 < end)
{
int res;
res = do_check (parser, begin, mid1, mid2, end, address);
if (res > 0)
return res;
res = do_check (parser, begin, mid2, mid1, end, address);
if (res > 0)
return res;
mid1--;
mid2++;
}
}
return -1;
}
#endif
#if 0
#define ELF32_ST_BIND(val) (((unsigned char) (val)) >> 4)
#define ELF32_ST_TYPE(val) ((val) & 0xf)
@ -292,61 +192,155 @@ lookup_function_symbol (ElfParser *parser,
#define ELF64_ST_INFO(bind, type) ELF32_ST_INFO ((bind), (type))
#endif
static ElfSym *
lookup_symbol (ElfParser *parser,
const Section *sym_table,
const Section *str_table,
gulong address)
static int
compare_sym (const void *a, const void *b)
{
int n_symbols = sym_table->size / bin_format_get_size (parser->sym_format);
int i;
const ElfSym *sym_a = a;
const ElfSym *sym_b = b;
g_print ("\ndumping %d symbols from %s\n", n_symbols, sym_table->name);
if (sym_a->address < sym_b->address)
return -1;
else if (sym_a->address == sym_b->address)
return 0;
else
return 1;
}
static void
read_table (ElfParser *parser,
const Section *sym_table,
const Section *str_table)
{
int sym_size = bin_format_get_size (parser->sym_format);
int i;
int n_functions;
parser->n_symbols = sym_table->size / sym_size;
parser->symbols = g_new (ElfSym, parser->n_symbols);
g_print ("\nreading %d symbols from %s\n",
parser->n_symbols, sym_table->name);
bin_parser_begin (parser->parser, parser->sym_format, sym_table->offset);
for (i = 0; i < n_symbols; ++i)
n_functions = 0;
for (i = 0; i < parser->n_symbols; ++i)
{
const char *name;
gulong addr;
guint info;
gulong addr;
const char *name;
bin_parser_index (parser->parser, i);
name = get_string (parser->parser, str_table->offset, "st_name");
info = bin_parser_get_uint (parser->parser, "st_info");
addr = bin_parser_get_uint (parser->parser, "st_value");
if ((info & 0xf) == STT_FUNC)
g_print ("symbol: %8lx, %s\n", addr, name);
name = get_string (parser->parser, str_table->offset, "st_name");
if (addr != 0 &&
(info & 0xf) == STT_FUNC &&
((info >> 4) == STB_GLOBAL ||
(info >> 4) == STB_LOCAL))
{
parser->symbols[n_functions].name = name;
parser->symbols[n_functions].address = addr;
n_functions++;
}
}
bin_parser_end (parser->parser);
return NULL;
g_print ("found %d functions\n", n_functions);
parser->n_symbols = n_functions;
parser->symbols = g_renew (ElfSym, parser->symbols, parser->n_symbols);
qsort (parser->symbols, parser->n_symbols, sizeof (ElfSym), compare_sym);
}
static void
read_symbols (ElfParser *parser)
{
const Section *symtab = find_section (parser, ".symtab");
const Section *strtab = find_section (parser, ".strtab");
const Section *dynsym = find_section (parser, ".dynsym");
const Section *dynstr = find_section (parser, ".dynstr");
if (symtab && strtab)
{
read_table (parser, symtab, strtab);
}
else if (dynsym && dynstr)
{
read_table (parser, dynsym, dynstr);
}
else
{
/* To make sure parser->symbols is non-NULL */
parser->n_symbols = 0;
parser->symbols = g_new (ElfSym, 1);
}
}
static ElfSym *
do_lookup (ElfSym *symbols, gulong address, int first, int last)
{
if (address >= symbols[last].address)
{
return &(symbols[last]);
}
else if (last - first < 3)
{
while (last >= first)
{
if (address >= symbols[last].address)
return &(symbols[last]);
last--;
}
return NULL;
}
else
{
int mid = (first + last) / 2;
if (symbols[mid].address > address)
{
return do_lookup (symbols, address, first, mid);
}
else
{
return do_lookup (symbols, address, mid, last);
}
}
}
const ElfSym *
elf_parser_lookup_symbol (ElfParser *parser,
gulong address)
{
const Section *symtab = find_section (parser, ".symtab");
const Section *dynsym = find_section (parser, ".dynsym");
const Section *strtab = find_section (parser, ".strtab");
const Section *dynstr = find_section (parser, ".dynstr");
if (!parser->symbols)
read_symbols (parser);
if (strtab && symtab)
{
lookup_symbol (parser, symtab, strtab, address);
}
if (parser->n_symbols == 0)
return NULL;
if (dynsym && dynstr)
{
lookup_symbol (parser, dynsym, dynstr, address);
}
/* FIXME: we should offset address based on the files load address */
g_print ("HELLO!!\n");
return NULL;
return do_lookup (parser->symbols, address, 0, parser->n_symbols - 1);
}
const char *
elf_sym_get_name (const ElfSym *sym)
{
return sym->name;
}
gulong
elf_sym_get_address (const ElfSym *sym)
{
return sym->address;
}
/*

18
elfparser.h
View File

@ -1,8 +1,26 @@
#include <glib.h>
typedef struct ElfSym ElfSym;
typedef struct ElfParser ElfParser;
ElfParser *elf_parser_new (const guchar *data,
gsize length);
/* Lookup a symbol in the file.
*
* The symbol returned is const, so don't free it it or anything. It
* will be valid until elf_parser_free() is called on the parser.
*
*
* The address should be given in "file coordinates". This means that
* if the file is mapped at address m and offset o, then an address a
* should be looked up as "a - (m - o)". (m - o) is where the start
* of the file would have been mapped, so a - (m - o) is the position
* in the file of a.
*/
const ElfSym *elf_parser_lookup_symbol (ElfParser *parser,
gulong address);
const char *elf_sym_get_name (const ElfSym *sym);
gulong elf_sym_get_address (const ElfSym *sym);
char *elf_demangle (const char *name);

39
testelf.c
View File

@ -1,24 +1,37 @@
#include <glib.h>
#include "elfparser.h"
static void
check (ElfParser *elf, gulong addr)
{
const ElfSym *sym = elf_parser_lookup_symbol (elf, addr);
g_print ("%p => ", addr);
if (sym)
{
g_print ("found: %s (%p)\n",
elf_sym_get_name (sym),
elf_sym_get_address (sym));
}
else
{
g_print ("not found\n");
}
}
int
main ()
{
int i;
GMappedFile *libgtk = g_mapped_file_new ("/usr/lib/libgtk-x11-2.0.so",
FALSE, NULL);
ElfParser *elf = elf_parser_new (
g_mapped_file_get_contents (libgtk),
g_mapped_file_get_length (libgtk));
#if 0
for (i = 0; i < 50000; ++i)
#endif
{
ElfParser *elf = elf_parser_new (
g_mapped_file_get_contents (libgtk),
g_mapped_file_get_length (libgtk));
elf_parser_lookup_symbol (elf, 1000);
}
check (elf, 0x3e7ef20); /* gtk_handle_box_end_drag */
check (elf, 0x3e7ef25); /* same */
return 0;
}