path: root/src/shared-objects.c

/*
   This file is part of odin, a memory profiler with fragmentation analysis.

   Copyright (C) 2007 Chris Wilson <chris@chris-wilson.co.uk>

   odin 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 3 of the
   License, or (at your option) any later version.

   odin is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with odin. If not, see <http://www.gnu.org/licenses/>/

   The GNU General Public License is contained in the file COPYING.
*/

#define _GNU_SOURCE
#include <stdlib.h>
#include <link.h>
#include <string.h>

#include "odin.h"
#include "client.h"
#include "shared-objects.h"

//#define ODIN_USE_BFD

#ifdef ODIN_USE_BFD
#include <bfd.h>
#else
#include "minibfd/binfile.h"
#endif


struct _symbol_offset {
    SymbolOffset *next;
    gulong eip;
    gulong offset;
};

struct _shared_object {
    SharedObjects *objects;
    SharedObject *ht_next;

    SharedObject *pending_next;

    guint key;
    const char *name;

#ifdef ODIN_USE_BFD
    bfd *abfd;
    asymbol **syms;
#else
    BinFile bin_file;
#endif

    SymbolOffset *pending_lookups;
};

#ifdef ODIN_USE_BFD
struct find_address {
    asymbol **syms;
    gulong pc;
    const char *path;
    const char *function;
    unsigned int line;
    gboolean found;
};

static gboolean
slurp_symtab (bfd *abfd, asymbol ***syms)
{
    long symcount;
    unsigned int size;

    if ((bfd_get_file_flags (abfd) & HAS_SYMS) == 0)
	return FALSE;

    symcount = bfd_read_minisymbols (abfd, FALSE, (void *) syms, &size);
    if (symcount == 0)
	symcount = bfd_read_minisymbols (abfd, TRUE, (void *) syms, &size);

    return symcount > 0;
}

static void
find_address_in_section (bfd *abfd, asection *section, void *data)
{
    struct find_address *fa = data;
    bfd_vma vma;
    bfd_size_type size;

    if (fa->found)
	return;

    if ((bfd_get_section_flags (abfd, section) & SEC_ALLOC) == 0)
	return;

    vma = bfd_get_section_vma (abfd, section);
    if (fa->pc < vma)
	return;

    size = bfd_get_section_size (section);
    if (fa->pc >= vma + size)
	return;

    fa->found = bfd_find_nearest_line (abfd, section, fa->syms, fa->pc - vma,
	                               &fa->path,
				       &fa->function,
				       &fa->line);
}

static void
_shared_object_open (SharedObject *so)
{
    if (so->abfd == NULL) {
	so->abfd = bfd_openr (so->name, NULL);
	if (so->abfd == NULL)
	    return;

	if (bfd_check_format (so->abfd, bfd_archive) ||
	    ! bfd_check_format_matches (so->abfd, bfd_object, NULL) ||
	    ! slurp_symtab (so->abfd, &so->syms))
	 {
	    bfd_close (so->abfd);
	    so->abfd = NULL;
	    return;
	}
    }
}


static gboolean
_shared_object_has_symbols (SharedObject *so)
{
    return so->abfd != NULL;
}

static void
_shared_object_lookup_symbol (SharedObject *so,
	                      gulong offset,
			      const char **function,
			      const char **filename,
			      const char **path,
			      guint *line)
{
    struct find_address fa;

    fa.syms = so->syms;
    fa.pc = offset;
    fa.found = FALSE;
    fa.path = NULL;
    fa.function = NULL;
    fa.line = 0;

    bfd_map_over_sections (so->abfd, find_address_in_section, &fa);

    *path = fa.path;
    if (fa.function != NULL && *fa.function != '\0') {
	char *demangled = bfd_demangle (so->abfd, fa.function, 3);
	if (demangled != NULL) {
	    *function = client_add_string (so->objects->client, demangled);
	    g_free (demangled);
	} else
	    *function = fa.function;
    }
    *line = fa.line;
}

static void
_shared_object_close (SharedObject *so)
{
    if (so->abfd != NULL) {
	bfd_close (so->abfd);
	so->abfd = NULL;
    }

    if (so->syms != NULL) {
	free (so->syms);
	so->syms = NULL;
    }
}

#else
extern char *minibfd_demangle (const char *mangled, int options);

static void
_shared_object_open (SharedObject *so)
{
    bin_file_open (&so->bin_file);
}

static gboolean
_shared_object_has_symbols (SharedObject *so)
{
    return so->bin_file.real_filename != NULL;
}

static void
_shared_object_lookup_symbol (SharedObject *so,
	                      gulong offset,
	                      const char **function,
	                      const char **filename,
	                      const char **path,
			      guint *line)
{
    bin_file_lookup_symbol (&so->bin_file, offset,
	                    function,
			    filename,
			    path,
			    line);
    if (*function != NULL) {
	char *demangled = minibfd_demangle (*function, 3);
	if (demangled != NULL) {
	    *function = client_add_string (so->objects->client, demangled);
	    g_free (demangled);
	}
    }
}

static void
_shared_object_close (SharedObject *so)
{
    bin_file_close (&so->bin_file);
}
#endif

void
shared_object_queue_lookup_symbol (SharedObject *so, gulong eip, gulong offset)
{
    SymbolOffset *symbol;

    if (so->pending_lookups == NULL) {
	so->pending_next = so->objects->pending_lookups;
	so->objects->pending_lookups = so;
    }

    symbol = so->objects->symbol_offset_free_list;
    if (symbol != NULL)
	so->objects->symbol_offset_free_list = symbol->next;
    else
	symbol = client_perm_alloc (so->objects->client, sizeof (SymbolOffset));

    symbol->eip = eip;
    symbol->offset = offset;
    symbol->next = so->pending_lookups;
    so->pending_lookups = symbol;

}

void
shared_objects_lookup_symbols (SharedObjects *objects)
{
    Frames *frames = &objects->client->frames;
    SharedObject *so;

    for (so = objects->pending_lookups; so != NULL; so = so->pending_next) {
	SymbolOffset *symbol = so->pending_lookups, *next;

	_shared_object_open (so);

	do {
	    const gchar *function, *path, *filename;
	    guint lineno;

	    g_assert (frames_get (frames, symbol->eip) == NULL);

	    function = NULL;
	    filename = NULL;
	    path = NULL;
	    lineno = 0;

	    if (_shared_object_has_symbols (so)) {
		_shared_object_lookup_symbol (so, symbol->offset,
					      &function,
					      &filename,
					      &path,
					      &lineno);
		if (filename == NULL && (path != NULL && *path != '\0')) {
		    const char *slash = strrchr (path, '/');
		    if (slash)
			filename = slash + 1;
		    else
			filename = path;
		}
	    }

	    frames_add (frames, symbol->eip, so->name,
		        function, filename, path, lineno);

	    next = symbol->next;
	    symbol->next = objects->symbol_offset_free_list;
	    objects->symbol_offset_free_list = symbol;
	} while ((symbol = next));

	so->pending_lookups = NULL;
	_shared_object_close (so);
    }
    objects->pending_lookups = NULL;
}

SharedObject *
shared_object_add (SharedObjects *objects, guint key, const char *name)
{
    SharedObject *so;
    guint index;

    g_assert (shared_object_get (objects, key) == NULL);

    if (++objects->ht.nnodes > 3 * objects->ht.size) {
	SharedObject **new_nodes;
	SharedObject *node, *next;
	guint n, new_size;

	new_size = g_spaced_primes_closest (objects->ht.nnodes);
	new_nodes = g_new0 (SharedObject *, new_size);
	for (n = 0; n < objects->ht.size ; n++) {
	    for (node = objects->ht.nodes[n];
		 node != NULL;
		 node = next)
	    {
		next = node->ht_next;
		index = node->key % new_size;
		node->ht_next = new_nodes[index];
		new_nodes[index] = node;
	    }
	}
	g_free (objects->ht.nodes);
	objects->ht.nodes = new_nodes;
	objects->ht.size  = new_size;
    }

    so = client_perm_alloc (objects->client, sizeof (SharedObject));
    so->objects = objects;
    so->pending_next = NULL;
    so->key = key;
    so->name = client_add_string (objects->client, name);
#ifdef ODIN_USE_BFD
    so->abfd = NULL;
    so->syms = NULL;
#else
    bin_file_init (&so->bin_file, so->name);
#endif
    so->pending_lookups = NULL;

    index = key % objects->ht.size;
    so->ht_next = objects->ht.nodes[index];
    objects->ht.nodes[index] = so;
    g_assert (shared_object_get (objects, key) == so);

    return so;
}

SharedObject *
shared_object_get (SharedObjects *objects,
		   guint key)
{
    guint index = key % objects->ht.size;
    SharedObject *so = objects->ht.nodes[index];
    while (so != NULL) {
	if (so->key == key)
	    return so;

	so = so->ht_next;
    }

    return NULL;
}

void
shared_objects_init (SharedObjects *objects, Client *client)
{
    objects->client = client;

    objects->ht.size = 673;
    objects->ht.nnodes = 0;
    objects->ht.nodes = g_new0 (SharedObject *, objects->ht.size);

    objects->pending_lookups = NULL;

    objects->symbol_offset_free_list = NULL;
}

void
shared_objects_fini (SharedObjects *objects)
{
    guint index;
    SharedObject *so;

    for (index = 0; index < objects->ht.size; index++) {
	for (so = objects->ht.nodes[index]; so != NULL; so = so->ht_next)
	    _shared_object_close (so);
    }
    g_free (objects->ht.nodes);
}