static bool slurp_symtab(asymbol ***syms, bfd *abfd) {
long symcount;
unsigned int size;
symcount = bfd_read_minisymbols(abfd, FALSE, (void **)syms, &size);
if (symcount == 0) {
symcount = bfd_read_minisymbols(abfd, TRUE /* dynamic */, (void **)syms,
&size);
}
return symcount >= 0;
}
static void slurp_symtab(bfd * abfd) {
long symcount;
unsigned int size;
if ((bfd_get_file_flags(abfd) & HAS_SYMS) == 0)
return;
symcount = bfd_read_minisymbols(abfd, false, (PTR) & syms, &size);
if (symcount == 0)
symcount = bfd_read_minisymbols(abfd, true /* dynamic */, (PTR) & syms, &size);
if (symcount < 0)
bfd_fatal(bfd_get_filename(abfd));
}
void dump_symbols(const char *filename){
bfd *abfd;
asymbol *store;
char *p;
void *minisyms;
int symnum,i;
size_t size;
int dyn=0;
int ret;
abfd=bfd_openr(filename,NULL);
assert(abfd);
ret=bfd_check_format(abfd,bfd_object);
assert(ret);
if(!(bfd_get_file_flags(abfd)&& HAS_SYMS)){
bfd_close(abfd);
return;
}
store = bfd_make_empty_symbol(abfd);
symnum = bfd_read_minisymbols(abfd,dyn,&minisyms,&size);
assert(symnum>=0);
p=(char *)minisyms;
for(i=0;i<symnum;i++){
asymbol *sym = bfd_minisymbol_to_symbol(abfd,dyn,p,store);
const char *name = bfd_asymbol_name(sym);
int value = bfd_asymbol_value(sym);
printf("%08x %s\n",value,name);
p+=size;
}
free(store);
free(minisyms);
bfd_close(abfd);
}
/**
* @brief Sets up the SignalHandler for Linux.
*/
static void debug_sigInit( void )
{
#if HAS_LINUX && defined(DEBUGGING)
char **matching;
struct sigaction sa, so;
bfd_init();
/* Read the executable */
abfd = bfd_openr("/proc/self/exe", NULL);
if (abfd != NULL) {
bfd_check_format_matches(abfd, bfd_object, &matching);
/* Read symbols */
if (bfd_get_file_flags(abfd) & HAS_SYMS) {
long symcount;
unsigned int size;
/* static */
symcount = bfd_read_minisymbols (abfd, FALSE, (void **)&syms, &size);
if (symcount == 0) /* dynamic */
symcount = bfd_read_minisymbols (abfd, TRUE, (void **)&syms, &size);
assert(symcount >= 0);
}
}
/* Set up handler. */
sa.sa_handler = NULL;
sa.sa_sigaction = debug_sigHandler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_SIGINFO;
/* Attach signals. */
sigaction(SIGSEGV, &sa, &so);
if (so.sa_handler == SIG_IGN)
DEBUG("Unable to set up SIGSEGV signal handler.");
sigaction(SIGFPE, &sa, &so);
if (so.sa_handler == SIG_IGN)
DEBUG("Unable to set up SIGFPE signal handler.");
sigaction(SIGABRT, &sa, &so);
if (so.sa_handler == SIG_IGN)
DEBUG("Unable to set up SIGABRT signal handler.");
#else /* HAS_LINUX && defined(DEBUGGING) */
(void) executable;
#endif /* HAS_LINUX && defined(DEBUGGING) */
}
static int
init_bfd_ctx(struct bfd_ctx *bc, struct output_buffer *ob)
{
bc->handle = NULL;
bc->symbol = NULL;
char procname[MAX_PATH];
GetModuleFileNameA(NULL, procname, sizeof procname);
bfd_init();
bfd *b = bfd_openr(procname, 0);
if (!b) {
output_print(ob,"Failed to init bfd\n");
return 1;
}
int r1 = bfd_check_format(b, bfd_object);
int r2 = bfd_check_format_matches(b, bfd_object, NULL);
int r3 = bfd_get_file_flags(b) & HAS_SYMS;
if (!(r1 && r2 && r3)) {
bfd_close(b);
output_print(ob,"Failed to init bfd\n");
return 1;
}
void *symbol_table;
unsigned dummy = 0;
if (bfd_read_minisymbols(b, FALSE, &symbol_table, &dummy) == 0) {
if (bfd_read_minisymbols(b, TRUE, &symbol_table, &dummy) < 0) {
free(symbol_table);
bfd_close(b);
output_print(ob,"Failed to init bfd\n");
return 1;
}
}
bc->handle = b;
bc->symbol = symbol_table;
return 0;
}
int init_bfd_ctx(bfd_ctx * bc, PCWSTR procname)
{
LogTrace();
bc->handle = NULL;
bc->symbol = NULL;
LogTrace();
bfd *b = bfd_openr(Base::w2cp(procname, CP_OEMCP).c_str(), 0);
if (!b) {
LogFatal(L"Failed to open bfd from (%s)\n" , procname);
return 1;
}
int r1 = bfd_check_format(b, bfd_object);
int r2 = bfd_check_format_matches(b, bfd_object, NULL);
int r3 = bfd_get_file_flags(b) & HAS_SYMS;
if (!(r1 && r2 && r3)) {
bfd_close(b);
LogFatal(L"Failed to init bfd from (%s)\n", procname);
return 1;
}
void * symbol_table;
unsigned dummy = 0;
if (bfd_read_minisymbols(b, FALSE, &symbol_table, &dummy) == 0) {
if (bfd_read_minisymbols(b, TRUE, &symbol_table, &dummy) < 0) {
free(symbol_table);
bfd_close(b);
LogFatal(L"Failed to read symbols from (%s)\n", procname);
return 1;
}
}
bc->handle = b;
bc->symbol = (asymbol**)symbol_table;
return 0;
}
traceback::Bfd::Context::Context(const char* image) :
image(cstr::dup(image)),
handle(),
symbol()
{
LogTraceObj("(%s)", image);
bfd* b = bfd_openr(image, 0);
if (!b) {
LogError("Failed to open bfd from (%s)", image);
return;
}
auto r1 = bfd_check_format(b, bfd_object);
auto r2 = bfd_check_format_matches(b, bfd_object, NULL);
auto r3 = bfd_get_file_flags(b) & HAS_SYMS;
if (!(r1 && r2 && r3)) {
bfd_close(b);
LogError("Failed to init bfd from (%d, %d, %d) (%s)", r1, r2, r3, image);
return;
}
void* symbol_table = nullptr;
unsigned dummy = 0;
if (bfd_read_minisymbols(b, FALSE, &symbol_table, &dummy) == 0) {
if (bfd_read_minisymbols(b, TRUE, &symbol_table, &dummy) < 0) {
free(symbol_table);
bfd_close(b);
LogError("Failed to read symbols from (%s)", image);
return;
}
}
handle = b;
symbol = (asymbol**)symbol_table;
}
/* Read in the symbol table. */
static int
_symtab_init (struct symtab *symtab, const char *filename)
{
char **matching;
long symcount;
unsigned int size;
symtab->bfd = NULL;
symtab->syms = NULL;
symtab->bfd = bfd_openr (filename, NULL);
if (symtab->bfd == NULL)
goto BAIL;
if (bfd_check_format (symtab->bfd, bfd_archive))
goto BAIL;
if (! bfd_check_format_matches (symtab->bfd, bfd_object, &matching))
goto BAIL;
symcount = bfd_read_minisymbols (symtab->bfd, false, (PTR) &symtab->syms, &size);
if (symcount == 0) {
symcount = bfd_read_minisymbols (symtab->bfd, true /* dynamic */ ,
(PTR) &symtab->syms, &size);
}
if (symcount < 0)
goto BAIL;
if ((bfd_get_file_flags (symtab->bfd) & HAS_SYMS) == 0)
goto BAIL;
return 1;
BAIL:
_symtab_fini (symtab);
return 0;
}
static void BFDmanager_loadBFDdata (char *file, bfd **image, asymbol ***symbols,
unsigned *nDataSymbols, data_symbol_t **DataSymbols)
{
bfd *bfdImage = NULL;
asymbol **bfdSymbols = NULL;
if (nDataSymbols)
*nDataSymbols = 0;
if (DataSymbols)
*DataSymbols = NULL;
/* Open the binary file in read-only mode */
bfdImage = bfd_openr (file, NULL);
if (bfdImage == NULL)
{
const char *errmsg = bfd_errmsg (bfd_get_error());
fprintf (stderr, "mpi2prv: WARNING! Cannot open binary file '%s': %s.\n"
" Addresses will not be translated into source code references\n",
file, errmsg);
return;
}
/* Check the binary file format */
if (!bfd_check_format (bfdImage, bfd_object))
{
const char *errmsg = bfd_errmsg( bfd_get_error() );
fprintf (stderr, "mpi2prv: WARNING! Binary file format does not match for file '%s' : %s\n"
" Addresses will not be translated into source code references\n",
file, errmsg);
}
/* Load the mini-Symbol Table */
if (bfd_get_file_flags (bfdImage) & HAS_SYMS)
{
long symcount;
size_t size = bfd_get_symtab_upper_bound (bfdImage);
if (size > 0)
{
#if defined(BFD_MANAGER_GENERATE_ADDRESSES)
long s;
unsigned nDataSyms = 0;
data_symbol_t *DataSyms = NULL;
#endif
bfdSymbols = (asymbol**) malloc (size);
if (bfdSymbols == NULL)
FATAL_ERROR ("Cannot allocate memory to translate addresses into source code references\n");
#if 0
/* HSG This is supposed to be space-efficient, but showed some errors .... :( */
symcount = bfd_read_minisymbols (bfdImage, FALSE, (PTR) bfdSymbols, &usize);
if (symcount == 0)
symcount = bfd_read_minisymbols (bfdImage, TRUE, (PTR) bfdSymbols, &usize);
#else
symcount = bfd_canonicalize_symtab (bfdImage, bfdSymbols);
# if defined(BFD_MANAGER_GENERATE_ADDRESSES)
if (nDataSymbols && DataSymbols)
{
for (s = 0; s < symcount; s++)
{
symbol_info syminfo;
bfd_get_symbol_info (bfdImage, bfdSymbols[s], &syminfo);
if (((bfdSymbols[s]->flags & BSF_DEBUGGING) == 0) &&
(syminfo.type == 'R' || syminfo.type == 'r' || /* read-only data */
syminfo.type == 'B' || syminfo.type == 'b' || /* uninited data */
syminfo.type == 'G' || syminfo.type == 'g' || /* inited data */
syminfo.type == 'C')) /* common data*/
{
unsigned long long sz = 0;
if (bfd_get_flavour(bfdImage) == bfd_target_elf_flavour)
sz = ((elf_symbol_type*) bfdSymbols[s])->internal_elf_sym.st_size;
DataSyms = (data_symbol_t*) realloc (DataSyms, sizeof(data_symbol_t)*(nDataSyms+1));
if (DataSyms == NULL)
FATAL_ERROR ("Cannot allocate memory to allocate data symbols\n");
DataSyms[nDataSyms].name = strdup (syminfo.name);
DataSyms[nDataSyms].address = (void*) syminfo.value;
DataSyms[nDataSyms].size = sz;
nDataSyms++;
}
}
*nDataSymbols = nDataSyms;
*DataSymbols = DataSyms;
}
# endif
#endif
if (symcount < 0)
{
/* There aren't symbols! */
const char *errmsg = bfd_errmsg( bfd_get_error() );
fprintf(stderr, "mpi2prv: WARNING! Cannot read symbol table for file '%s' : %s\n"
" Addresses will not be translated into source code references\n",
file, errmsg);
}
}
}
*image = bfdImage;
*symbols = bfdSymbols;
#if defined(DEBUG)
printf ("BFD file=%s bfdImage = %p bfdSymbols = %p\n",
file, bfdImage, bfdSymbols);
#endif
}
/**
* Initialize the bfd context.
*
* @return TRUE if OK.
*/
static bool
bfd_util_open(bfd_ctx_t *bc, const char *path)
{
static mutex_t bfd_library_mtx = MUTEX_INIT;
bfd *b;
void *symbols = NULL;
unsigned size = 0;
long count;
int fd = -1;
const char *libpath = path;
/*
* On Debian systems, there is a debugging version of libraries held
* under /usr/lib/debug. We'll get better symbol resolution by
* opening these instead of the usually stripped runtime versions
* that will only contain externally visible symbols.
*/
if (!is_running_on_mingw() && is_absolute_path(path)) {
static char debugpath[MAX_PATH_LEN];
const char *base = filepath_basename(path);
concat_strings(debugpath, sizeof debugpath,
"/usr/lib/debug/", base, NULL_PTR);
fd = open(debugpath, O_RDONLY);
if (-1 == fd) {
concat_strings(debugpath, sizeof debugpath,
"/usr/lib/debug", path, NULL_PTR);
fd = open(debugpath, O_RDONLY);
}
if (-1 != fd)
libpath = debugpath;
}
if (-1 == fd)
fd = open(libpath, O_RDONLY);
if (-1 == fd) {
s_miniwarn("%s: can't open %s: %m", G_STRFUNC, libpath);
return FALSE;
}
/*
* Protect calls to BFD opening: they don't appear to be fully
* thread-safe and we could enter here concurrently.
*/
mutex_lock_fast(&bfd_library_mtx);
b = bfd_fdopenr(libpath, NULL, fd);
if (NULL == b) {
mutex_unlock_fast(&bfd_library_mtx);
close(fd);
return FALSE;
}
if (!bfd_util_check_format(b, bfd_object, libpath)) {
s_miniwarn("%s: %s is not an object", G_STRFUNC, libpath);
goto failed;
}
if (0 == (bfd_get_file_flags(b) & HAS_SYMS)) {
s_miniwarn("%s: %s has no symbols", G_STRFUNC, libpath);
goto failed;
}
count = bfd_read_minisymbols(b, FALSE, &symbols, &size);
if (count <= 0) {
bc->dynamic = TRUE;
count = bfd_read_minisymbols(b, TRUE, &symbols, &size);
}
if (count >= 0)
goto done;
s_miniwarn("%s: unable to load symbols from %s ", G_STRFUNC, libpath);
symbols = NULL;
/* FALL THROUGH */
/*
* We keep the context on errors to avoid logging them over and over
* each time we attempt to access the same file. The BFD and system
* resources are released though.
*/
failed:
bfd_close(b);
b = NULL;
count = 0;
/* FALL THROUGH */
done:
mutex_unlock_fast(&bfd_library_mtx);
bc->magic = BFD_CTX_MAGIC;
bc->handle = b;
bc->symbols = symbols; /* Allocated by the bfd library */
bc->count = count;
bc->symsize = size;
mutex_init(&bc->lock);
return TRUE;
}
void leaky::ReadSymbols(const char *aFileName, u_long aBaseAddress)
{
int initialSymbols = usefulSymbols;
if (nullptr == externalSymbols) {
externalSymbols = (Symbol**) calloc(sizeof(Symbol*),10000);
Symbol *new_array = new Symbol[10000];
for (int i = 0; i < 10000; i++) {
externalSymbols[i] = &new_array[i];
}
numExternalSymbols = 10000;
}
Symbol** sp = externalSymbols + usefulSymbols;
lastSymbol = externalSymbols + numExternalSymbols;
// Create a dummy symbol for the library so, if it doesn't have any
// symbols, we show it by library.
(*sp)->Init(aFileName, aBaseAddress);
NEXT_SYMBOL;
bfd_boolean kDynamic = (bfd_boolean) false;
static int firstTime = 1;
if (firstTime) {
firstTime = 0;
bfd_init ();
}
bfd* lib = bfd_openr(aFileName, nullptr);
if (nullptr == lib) {
return;
}
if (!bfd_check_format(lib, bfd_object)) {
bfd_close(lib);
return;
}
bfd *symbolFile = find_debug_file(lib, aFileName);
// read mini symbols
PTR minisyms;
unsigned int size;
long symcount = 0;
if (symbolFile) {
symcount = bfd_read_minisymbols(symbolFile, kDynamic, &minisyms, &size);
if (symcount == 0) {
bfd_close(symbolFile);
} else {
bfd_close(lib);
}
}
if (symcount == 0) {
symcount = bfd_read_minisymbols(lib, kDynamic, &minisyms, &size);
if (symcount == 0) {
// symtab is empty; try dynamic symbols
kDynamic = (bfd_boolean) true;
symcount = bfd_read_minisymbols(lib, kDynamic, &minisyms, &size);
}
symbolFile = lib;
}
asymbol* store;
store = bfd_make_empty_symbol(symbolFile);
// Scan symbols
bfd_byte* from = (bfd_byte *) minisyms;
bfd_byte* fromend = from + symcount * size;
for (; from < fromend; from += size) {
asymbol *sym;
sym = bfd_minisymbol_to_symbol(symbolFile, kDynamic, (const PTR) from, store);
symbol_info syminfo;
bfd_get_symbol_info (symbolFile, sym, &syminfo);
// if ((syminfo.type == 'T') || (syminfo.type == 't')) {
const char* nm = bfd_asymbol_name(sym);
if (nm && nm[0]) {
char* dnm = nullptr;
if (strncmp("__thunk", nm, 7)) {
dnm = abi::__cxa_demangle(nm, 0, 0, 0);
}
(*sp)->Init(dnm ? dnm : nm, syminfo.value + aBaseAddress);
if (dnm) {
free(dnm);
}
NEXT_SYMBOL;
}
// }
}
bfd_close(symbolFile);
int interesting = sp - externalSymbols;
if (!quiet) {
printf("%s provided %d symbols\n", aFileName,
interesting - initialSymbols);
}
usefulSymbols = interesting;
}
