#include <config.h>
#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
#include <string.h>
#include <signal.h>
+#include <sys/param.h>
+#include <sys/stat.h>
#include <mono/metadata/metadata.h>
+#include <mono/metadata/tabledefs.h>
#include <mono/metadata/rawbuffer.h>
#include <mono/metadata/tokentype.h>
#include <mono/metadata/appdomain.h>
#include <mono/metadata/exception.h>
+#include <mono/metadata/debug-helpers.h>
+#include <mono/metadata/mono-debug.h>
#include <mono/metadata/debug-mono-symfile.h>
+#include <mono/metadata/mono-endian.h>
+#include <mono/metadata/metadata-internals.h>
+#include <mono/metadata/class-internals.h>
+#include <mono/metadata/mono-debug-debugger.h>
#include <fcntl.h>
#include <unistd.h>
+#define RANGE_TABLE_CHUNK_SIZE 256
+#define CLASS_TABLE_CHUNK_SIZE 256
+#define TYPE_TABLE_PTR_CHUNK_SIZE 256
+#define TYPE_TABLE_CHUNK_SIZE 65536
+
+static void
+free_method_info (MonoDebugMethodInfo *minfo)
+{
+ g_free (minfo);
+}
+
+static gchar *
+get_class_name (MonoClass *klass)
+{
+ MonoClass *nested_in = mono_class_get_nesting_type (klass);
+ const char *name_space;
+ if (nested_in) {
+ gchar *parent_name = get_class_name (nested_in);
+ gchar *name = g_strdup_printf ("%s.%s", parent_name, mono_class_get_name (klass));
+ g_free (parent_name);
+ return name;
+ }
+
+ name_space = mono_class_get_namespace (klass);
+ return g_strdup_printf ("%s%s%s", name_space,
+ name_space [0] ? "." : "", mono_class_get_name (klass));
+}
static int
-load_symfile (MonoSymbolFile *symfile)
+load_symfile (MonoDebugHandle *handle, MonoSymbolFile *symfile)
{
- MonoSymbolFileMethodEntry *me, *me_end;
- const char *ptr, *start, *end;
+ const char *ptr, *start;
+ gchar *guid;
guint64 magic;
long version;
ptr = start = symfile->raw_contents;
+ if (!ptr)
+ return FALSE;
- magic = *((guint64 *) ptr)++;
+ magic = read64(ptr);
+ ptr += sizeof(guint64);
if (magic != MONO_SYMBOL_FILE_MAGIC) {
- g_warning ("Symbol file %s has is not a mono symbol file", symfile->file_name);
+ g_warning ("Symbol file %s is not a mono symbol file", symfile->filename);
return FALSE;
}
- version = *((guint32 *) ptr)++;
+ version = read32(ptr);
+ ptr += sizeof(guint32);
if (version != MONO_SYMBOL_FILE_VERSION) {
- g_warning ("Symbol file %s has incorrect line number table version "
- "(expected %d, got %ld)", symfile->file_name,
+ g_warning ("Symbol file %s has incorrect version "
+ "(expected %d, got %ld)", symfile->filename,
MONO_SYMBOL_FILE_VERSION, version);
return FALSE;
}
- symfile->offset_table = (MonoSymbolFileOffsetTable *) ptr;
-
- /*
- * Read method table.
- *
- */
-
- symfile->method_table = g_hash_table_new_full (g_direct_hash, g_direct_equal,
- NULL, (GDestroyNotify) g_free);
+ guid = mono_guid_to_string ((const guint8 *) ptr);
+ ptr += 16;
- ptr = symfile->raw_contents + symfile->offset_table->method_table_offset;
- end = ptr + symfile->offset_table->method_table_size;
-
- me = (MonoSymbolFileMethodEntry *) ptr;
- me_end = ((MonoSymbolFileMethodEntry *) end);
+ if (strcmp (handle->image->guid, guid)) {
+ g_warning ("Symbol file %s doesn't match image %s", symfile->filename,
+ handle->image_file);
+ return FALSE;
+ }
- for (; me < me_end; me++) {
- MonoMethod *method = mono_get_method (symfile->image, me->token, NULL);
+ symfile->offset_table = (MonoSymbolFileOffsetTable *) ptr;
- if (!method)
- continue;
-
- g_hash_table_insert (symfile->method_table, method, me);
- }
+ symfile->method_hash = g_hash_table_new_full (
+ g_direct_hash, g_direct_equal, NULL, (GDestroyNotify) free_method_info);
return TRUE;
}
MonoSymbolFile *
-mono_debug_open_mono_symbol_file (MonoImage *image, const char *filename, gboolean emit_warnings)
+mono_debug_open_mono_symbol_file (MonoDebugHandle *handle, gboolean create_symfile)
{
MonoSymbolFile *symfile;
- off_t file_size;
- void *ptr;
- int fd;
-
- fd = open (filename, O_RDONLY);
- if (fd == -1) {
- if (emit_warnings)
- g_warning ("Can't open symbol file: %s", filename);
- return NULL;
- }
+ FILE* f;
- file_size = lseek (fd, 0, SEEK_END);
- lseek (fd, 0, SEEK_SET);
+ mono_loader_lock ();
+ symfile = g_new0 (MonoSymbolFile, 1);
- if (file_size == (off_t) -1) {
- if (emit_warnings)
- g_warning ("Can't get size of symbol file: %s", filename);
- return NULL;
- }
+ symfile->filename = g_strdup_printf ("%s.mdb", mono_image_get_filename (handle->image));
- ptr = mono_raw_buffer_load (fd, TRUE, FALSE, 0, file_size);
- if (!ptr) {
- if (emit_warnings)
- g_warning ("Can't read symbol file: %s", filename);
- return NULL;
+ if ((f = fopen (symfile->filename, "rb")) > 0) {
+ struct stat stat_buf;
+
+ if (fstat (fileno (f), &stat_buf) < 0) {
+ g_warning ("stat of %s failed: %s", symfile->filename, g_strerror (errno));
+ } else {
+ symfile->raw_contents_size = stat_buf.st_size;
+ symfile->raw_contents = mono_raw_buffer_load (fileno (f), FALSE, 0, stat_buf.st_size);
+ }
+
+ fclose (f);
}
-
- symfile = g_new0 (MonoSymbolFile, 1);
- symfile->fd = fd;
- symfile->file_name = g_strdup (filename);
- symfile->image = image;
- symfile->raw_contents = ptr;
- symfile->raw_contents_size = file_size;
-
- if (!load_symfile (symfile)) {
+
+ if (load_symfile (handle, symfile)) {
+ mono_loader_unlock ();
+ return symfile;
+ } else if (!create_symfile) {
mono_debug_close_mono_symbol_file (symfile);
+ mono_loader_unlock ();
return NULL;
}
+ mono_loader_unlock ();
return symfile;
}
if (!symfile)
return;
- if (symfile->raw_contents)
- mono_raw_buffer_free (symfile->raw_contents);
- if (symfile->fd)
- close (symfile->fd);
+ mono_loader_lock ();
+ if (symfile->method_hash)
+ g_hash_table_destroy (symfile->method_hash);
- g_free (symfile->file_name);
+ if (symfile->raw_contents)
+ mono_raw_buffer_free ((gpointer) symfile->raw_contents);
+
g_free (symfile);
+ mono_loader_unlock ();
+}
+
+static int
+read_leb128 (const char *ptr, const char **rptr)
+{
+ int ret = 0;
+ int shift = 0;
+ char b;
+
+ do {
+ b = *ptr++;
+
+ ret = ret | ((b & 0x7f) << shift);
+ shift += 7;
+ } while ((b & 0x80) == 0x80);
+
+ if (rptr)
+ *rptr = ptr;
+
+ return ret;
+}
+
+static gchar *
+read_string (const char *ptr)
+{
+ int len = read_leb128 (ptr, &ptr);
+ return g_filename_from_utf8 (ptr, len, NULL, NULL, NULL);
}
gchar *
mono_debug_find_source_location (MonoSymbolFile *symfile, MonoMethod *method, guint32 offset,
guint32 *line_number)
{
- MonoSymbolFileMethodEntry *me;
- MonoSymbolFileLineNumberEntry *lne, *lne_end;
- const char *ptr, *end, *source_file;
-
- if (!symfile->method_table)
+ MonoSymbolFileLineNumberEntry *lne;
+ MonoDebugMethodInfo *minfo;
+ gchar *source_file = NULL;
+ const char *ptr;
+ int i;
+
+ mono_loader_lock ();
+ if (!symfile->method_hash) {
+ mono_loader_unlock ();
return NULL;
+ }
- me = g_hash_table_lookup (symfile->method_table, method);
- if (!me)
+ minfo = g_hash_table_lookup (symfile->method_hash, method);
+ if (!minfo) {
+ mono_loader_unlock ();
return NULL;
+ }
- source_file = symfile->raw_contents + me->source_file_offset;
+ if (read32(&(minfo->entry->_source_index))) {
+ int offset = read32(&(symfile->offset_table->_source_table_offset)) +
+ (read32(&(minfo->entry->_source_index)) - 1) * sizeof (MonoSymbolFileSourceEntry);
+ MonoSymbolFileSourceEntry *se = (MonoSymbolFileSourceEntry *) (symfile->raw_contents + offset);
- ptr = symfile->raw_contents + me->line_number_table_offset;
- end = symfile->raw_contents + symfile->offset_table->line_number_table_offset +
- symfile->offset_table->line_number_table_size;
+ source_file = read_string (symfile->raw_contents + read32(&(se->_name_offset)));
+ }
+
+ ptr = symfile->raw_contents + read32(&(minfo->entry->_line_number_table_offset));
lne = (MonoSymbolFileLineNumberEntry *) ptr;
- lne_end = ((MonoSymbolFileLineNumberEntry *) end);
- for (; (lne < lne_end) && lne->row; lne++) {
- if (lne->offset < offset)
+ for (i = 0; i < read32(&(minfo->entry->_num_line_numbers)); i++, lne++) {
+ if (read32(&(lne->_offset)) < offset)
continue;
if (line_number) {
- *line_number = lne->row;
- return g_strdup (source_file);
- } else
- return g_strdup_printf ("%s:%d", source_file, lne->row);
+ *line_number = read32(&(lne->_row));
+ mono_loader_unlock ();
+ if (source_file)
+ return source_file;
+ else
+ return NULL;
+ } else if (source_file) {
+ gchar *retval = g_strdup_printf ("%s:%d", source_file, read32(&(lne->_row)));
+ g_free (source_file);
+ mono_loader_unlock ();
+ return retval;
+ } else {
+ gchar* retval = g_strdup_printf ("%d", read32(&(lne->_row)));
+ mono_loader_unlock ();
+ return retval;
+ }
}
+ mono_loader_unlock ();
return NULL;
}
-struct MyData
+gint32
+_mono_debug_address_from_il_offset (MonoDebugMethodJitInfo *jit, guint32 il_offset)
{
- MonoSymbolFile *symfile;
- MonoDebugGetMethodFunc get_method_func;
- gpointer user_data;
-};
+ int i;
-static void
-update_method_func (gpointer key, gpointer value, gpointer user_data)
-{
- struct MyData *mydata = (struct MyData *) user_data;
- MonoSymbolFileMethodEntry *me = (MonoSymbolFileMethodEntry *) value;
- MonoMethod *method = (MonoMethod *) key;
- MonoSymbolFileLineNumberEntry *lne, *lne_end;
- const char *ptr, *end;
- int first = TRUE;
+ if (!jit || !jit->line_numbers)
+ return -1;
- MonoDebugMethodInfo *minfo = mydata->get_method_func
- (mydata->symfile, method, mydata->user_data);
+ for (i = jit->line_numbers->len - 1; i >= 0; i--) {
+ MonoDebugLineNumberEntry lne = g_array_index (
+ jit->line_numbers, MonoDebugLineNumberEntry, i);
- if (!minfo)
- return;
+ if (lne.il_offset <= il_offset)
+ return lne.native_offset;
+ }
- me->start_address = minfo->code_start;
- me->end_address = minfo->code_start + minfo->code_size;
+ return -1;
+}
- ptr = mydata->symfile->raw_contents + me->line_number_table_offset;
- end = mydata->symfile->raw_contents + mydata->symfile->offset_table->line_number_table_offset +
- mydata->symfile->offset_table->line_number_table_size;
+static int
+compare_method (const void *key, const void *object)
+{
+ guint32 token = GPOINTER_TO_UINT (key);
+ MonoSymbolFileMethodIndexEntry *me = (MonoSymbolFileMethodIndexEntry*)object;
- lne = (MonoSymbolFileLineNumberEntry *) ptr;
- lne_end = ((MonoSymbolFileLineNumberEntry *) end);
+ return token - read32(&(me->_token));
+}
- for (; (lne < lne_end) && lne->row; lne++) {
- guint32 address;
- int i;
+MonoDebugMethodInfo *
+mono_debug_find_method (MonoDebugHandle *handle, MonoMethod *method)
+{
+ MonoSymbolFileMethodEntry *me;
+ MonoSymbolFileMethodIndexEntry *first_ie, *ie;
+ MonoDebugMethodInfo *minfo;
+ MonoSymbolFile *symfile = handle->symfile;
- if (first) {
- lne->address = 0;
- first = FALSE;
- continue;
- } else if (lne->offset == 0) {
- lne->address = minfo->prologue_end;
- continue;
- }
+ if (!symfile->method_hash)
+ return NULL;
- address = minfo->code_size;
+ if (handle->image != mono_class_get_image (mono_method_get_class (method)))
+ return NULL;
- for (i = 0; i < minfo->num_il_offsets; i++) {
- MonoDebugILOffsetInfo *il = &minfo->il_offsets [i];
+ mono_loader_lock ();
+ first_ie = (MonoSymbolFileMethodIndexEntry *)
+ (symfile->raw_contents + read32(&(symfile->offset_table->_method_table_offset)));
- if (il->offset >= lne->offset) {
- address = il->address;
- break;
- }
- }
+ ie = bsearch (GUINT_TO_POINTER (mono_method_get_token (method)), first_ie,
+ read32(&(symfile->offset_table->_method_count)),
+ sizeof (MonoSymbolFileMethodIndexEntry), compare_method);
- lne->address = address;
+ if (!ie) {
+ mono_loader_unlock ();
+ return NULL;
}
-}
+ me = (MonoSymbolFileMethodEntry *) (symfile->raw_contents + read32(&(ie->_file_offset)));
-void
-mono_debug_update_mono_symbol_file (MonoSymbolFile *symfile,
- MonoDebugGetMethodFunc get_method_func,
- gpointer user_data)
-{
- if (symfile->method_table) {
- struct MyData mydata = { symfile, get_method_func, user_data };
- g_hash_table_foreach (symfile->method_table, update_method_func, &mydata);
- }
+ minfo = g_new0 (MonoDebugMethodInfo, 1);
+ minfo->index = (ie - first_ie) + 1;
+ minfo->method = method;
+ minfo->handle = handle;
+ minfo->num_il_offsets = read32(&(me->_num_line_numbers));
+ minfo->il_offsets = (MonoSymbolFileLineNumberEntry *)
+ (symfile->raw_contents + read32(&(me->_line_number_table_offset)));
+ minfo->entry = me;
+
+ g_hash_table_insert (symfile->method_hash, method, minfo);
- mono_raw_buffer_update (symfile->raw_contents, symfile->raw_contents_size);
+ mono_loader_unlock ();
+ return minfo;
}
projects / mono.git / blobdiff