jit->locals = locals;
}
- mono_debug_add_method (method, jit);
+ mono_debug_add_method (method, jit, cfg->domain);
}
*managed = TRUE;
if (trace) {
- source_location = mono_debug_source_location_from_address (ji->method, address, NULL);
- iloffset = mono_debug_il_offset_from_address (ji->method, address);
+ source_location = mono_debug_source_location_from_address (ji->method, address, NULL, domain);
+ iloffset = mono_debug_il_offset_from_address (ji->method, address, domain);
if (iloffset < 0)
tmpaddr = g_strdup_printf ("<0x%05x>", address);
sf->method = mono_method_get_object (domain, ji->method, NULL);
sf->native_offset = (char *)ip - (char *)ji->code_start;
- sf->il_offset = mono_debug_il_offset_from_address (ji->method, sf->native_offset);
+ sf->il_offset = mono_debug_il_offset_from_address (ji->method, sf->native_offset, domain);
if (need_file_info) {
gchar *filename;
- filename = mono_debug_source_location_from_address (ji->method, sf->native_offset, &sf->line);
+ filename = mono_debug_source_location_from_address (ji->method, sf->native_offset, &sf->line, domain);
sf->filename = mono_string_new (domain, filename ? filename : "<unknown>");
sf->column = 0;
if (ji == (gpointer)-1)
return;
- il_offset = mono_debug_il_offset_from_address (ji->method, native_offset);
+ il_offset = mono_debug_il_offset_from_address (ji->method, native_offset, domain);
if (func (ji->method, native_offset, il_offset, managed, user_data))
return;
} while (skip >= 0);
*method = mono_method_get_object (domain, ji->method, NULL);
- *iloffset = mono_debug_il_offset_from_address (ji->method, *native_offset);
+ *iloffset = mono_debug_il_offset_from_address (ji->method, *native_offset, domain);
if (need_file_info) {
gchar *filename;
- filename = mono_debug_source_location_from_address (ji->method, *native_offset, line);
+ filename = mono_debug_source_location_from_address (ji->method, *native_offset, line, domain);
*file = mono_string_new (domain, filename ? filename : "<unknown>");
*column = 0;
guint8 *addr;
GHashTable *jit_code_hash;
+ if (mono_jit_share_code)
+ target_domain = mono_root_domain;
+ else
+ target_domain = domain;
+
if ((method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) ||
(method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL)) {
method->info = mono_compile_method (nm);
if (mono_debug_format != MONO_DEBUG_FORMAT_NONE)
- mono_debug_add_wrapper (method, nm);
+ mono_debug_add_wrapper (method, nm, target_domain);
#ifdef MONO_USE_EXC_TABLES
}
#endif
return method->info;
}
- if (mono_jit_share_code)
- target_domain = mono_root_domain;
- else
- target_domain = domain;
-
jit_code_hash = target_domain->jit_code_hash;
if ((addr = g_hash_table_lookup (jit_code_hash, method))) {
+2003-05-02 Martin Baulig <martin@ximian.com>
+
+ * debug-mono-symfile.h
+ (MonoSymbolFile): Moved declaration into mono-debug.h.
+ (MonoDebugMethodJitInfo): Likewise.
+ (mono_debug_open_mono_symbol_file): Take the MonoDebugHandle as
+ argument.
+ (_mono_debug_address_from_il_offset): Take a
+ MonoDebugMethodJitInfo instead of a MonoDebugMethodInfo.
+
+ * mono-debug.h
+ (MonoDebugDomainData): New struct.
+ (mono_debug_get_domain_data): New function.
+ (mono_debug_add_method): Take an additional `MonoDomain *'
+ argument.
+ (mono_debug_source_location_from_address): Likewise.
+ (mono_debug_il_offset_from_address): Likewise.
+ (mono_debug_address_from_il_offset): Likewise.
Thu May 1 19:40:37 CEST 2003 Paolo Molaro <lupus@ximian.com>
#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 <fcntl.h>
static void
free_method_info (MonoDebugMethodInfo *minfo)
{
- g_free (minfo->jit);
g_free (minfo);
}
}
static int
-load_symfile (MonoSymbolFile *symfile)
+load_symfile (MonoDebugHandle *handle, MonoSymbolFile *symfile)
{
MonoSymbolFileMethodEntry *me;
MonoSymbolFileMethodIndexEntry *ie;
magic = *((guint64 *) ptr)++;
if (magic != MONO_SYMBOL_FILE_MAGIC) {
- g_warning ("Symbol file %s has is not a mono symbol file", symfile->image_file);
+ g_warning ("Symbol file %s has is not a mono symbol file", handle->image_file);
return FALSE;
}
version = *((guint32 *) ptr)++;
if (version != MONO_SYMBOL_FILE_VERSION) {
g_warning ("Symbol file %s has incorrect version "
- "(expected %d, got %ld)", symfile->image_file,
+ "(expected %d, got %ld)", handle->image_file,
MONO_SYMBOL_FILE_VERSION, version);
return FALSE;
}
*/
symfile->method_hash = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL,
- (GDestroyNotify) free_method_info);
+ (GDestroyNotify) free_method_info);
ie = (MonoSymbolFileMethodIndexEntry *)
(symfile->raw_contents + symfile->offset_table->method_table_offset);
me = (MonoSymbolFileMethodEntry *) (symfile->raw_contents + ie->file_offset);
- method = mono_get_method (symfile->image, me->token, NULL);
+ method = mono_get_method (handle->image, me->token, NULL);
if (!method)
continue;
minfo = g_new0 (MonoDebugMethodInfo, 1);
minfo->index = i + 1;
minfo->method = method;
- minfo->symfile = symfile;
+ minfo->handle = handle;
minfo->num_il_offsets = me->num_line_numbers;
minfo->il_offsets = (MonoSymbolFileLineNumberEntry *)
(symfile->raw_contents + me->line_number_table_offset);
}
MonoSymbolFile *
-mono_debug_open_mono_symbol_file (MonoImage *image, gboolean create_symfile)
+mono_debug_open_mono_symbol_file (MonoDebugHandle *handle, gboolean create_symfile)
{
MonoSymbolFile *symfile;
symfile = g_new0 (MonoSymbolFile, 1);
- symfile->dynamic_magic = MONO_SYMBOL_FILE_DYNAMIC_MAGIC;
- symfile->dynamic_version = MONO_SYMBOL_FILE_DYNAMIC_VERSION;
- symfile->image_file = image->name;
- symfile->image = image;
+ symfile->raw_contents = open_symfile (handle->image, &symfile->raw_contents_size);
- symfile->raw_contents = open_symfile (image, &symfile->raw_contents_size);
-
- if (load_symfile (symfile))
+ if (load_symfile (handle, symfile))
return symfile;
else if (!create_symfile) {
mono_debug_close_mono_symbol_file (symfile);
}
gint32
-_mono_debug_address_from_il_offset (MonoDebugMethodInfo *minfo, guint32 il_offset)
+_mono_debug_address_from_il_offset (MonoDebugMethodJitInfo *jit, guint32 il_offset)
{
int i;
- if (!minfo->jit || !minfo->jit->line_numbers)
+ if (!jit || !jit->line_numbers)
return -1;
- for (i = minfo->jit->line_numbers->len - 1; i >= 0; i--) {
+ for (i = jit->line_numbers->len - 1; i >= 0; i--) {
MonoDebugLineNumberEntry lne = g_array_index (
- minfo->jit->line_numbers, MonoDebugLineNumberEntry, i);
+ jit->line_numbers, MonoDebugLineNumberEntry, i);
if (lne.offset <= il_offset)
return lne.address;
#include <glib.h>
#include <mono/metadata/class.h>
#include <mono/metadata/reflection.h>
+#include <mono/metadata/mono-debug.h>
-typedef struct MonoSymbolFile MonoSymbolFile;
typedef struct MonoSymbolFileOffsetTable MonoSymbolFileOffsetTable;
typedef struct MonoSymbolFileLineNumberEntry MonoSymbolFileLineNumberEntry;
typedef struct MonoSymbolFileMethodEntry MonoSymbolFileMethodEntry;
typedef struct MonoSymbolFileLexicalBlockEntry MonoSymbolFileLexicalBlockEntry;
typedef struct MonoDebugMethodInfo MonoDebugMethodInfo;
-typedef struct MonoDebugMethodJitInfo MonoDebugMethodJitInfo;
-typedef struct MonoDebugVarInfo MonoDebugVarInfo;
typedef struct MonoDebugLexicalBlockEntry MonoDebugLexicalBlockEntry;
typedef struct MonoDebugLineNumberEntry MonoDebugLineNumberEntry;
struct MonoDebugMethodInfo {
MonoMethod *method;
- MonoSymbolFile *symfile;
+ MonoDebugHandle *handle;
guint32 index;
guint32 num_il_offsets;
MonoSymbolFileLineNumberEntry *il_offsets;
MonoSymbolFileMethodEntry *entry;
- MonoDebugMethodJitInfo *jit;
- gpointer user_data;
};
struct MonoDebugLexicalBlockEntry {
guint32 address;
};
-struct MonoDebugMethodJitInfo {
- const guint8 *code_start;
- guint32 code_size;
- guint32 prologue_end;
- guint32 epilogue_begin;
- const guint8 *wrapper_addr;
- // Array of MonoDebugLineNumberEntry
- GArray *line_numbers;
- guint32 num_params;
- MonoDebugVarInfo *this_var;
- MonoDebugVarInfo *params;
- guint32 num_locals;
- MonoDebugVarInfo *locals;
-};
-
-/*
- * These bits of the MonoDebugLocalInfo's "index" field are flags specifying
- * where the variable is actually stored.
- *
- * See relocate_variable() in debug-symfile.c for more info.
- */
-#define MONO_DEBUG_VAR_ADDRESS_MODE_FLAGS 0xf0000000
-
-/* If "index" is zero, the variable is at stack offset "offset". */
-#define MONO_DEBUG_VAR_ADDRESS_MODE_STACK 0
-
-/* The variable is in the register whose number is contained in bits 0..4 of the
- * "index" field plus an offset of "offset" (which can be zero).
- */
-#define MONO_DEBUG_VAR_ADDRESS_MODE_REGISTER 0x10000000
-
-/* The variables in in the two registers whose numbers are contained in bits 0..4
- * and 5..9 of the "index" field plus an offset of "offset" (which can be zero).
- */
-#define MONO_DEBUG_VAR_ADDRESS_MODE_TWO_REGISTERS 0x20000000
-
-struct MonoDebugVarInfo {
- guint32 index;
- guint32 offset;
- guint32 size;
- guint32 begin_scope;
- guint32 end_scope;
-};
-
-struct MonoSymbolFile {
- guint64 dynamic_magic;
- guint32 dynamic_version;
- const char *image_file;
- GHashTable *method_hash;
+struct _MonoSymbolFile {
const guint8 *raw_contents;
int raw_contents_size;
- MonoImage *image;
+ GHashTable *method_hash;
MonoSymbolFileOffsetTable *offset_table;
};
#define MONO_SYMBOL_FILE_VERSION 35
#define MONO_SYMBOL_FILE_MAGIC 0x45e82623fd7fa614
-#define MONO_SYMBOL_FILE_DYNAMIC_VERSION 27
-#define MONO_SYMBOL_FILE_DYNAMIC_MAGIC 0x7aff65af4253d427
-
MonoSymbolFile *
-mono_debug_open_mono_symbol_file (MonoImage *image,
+mono_debug_open_mono_symbol_file (MonoDebugHandle *handle,
gboolean create_symfile);
void
guint32 offset,
guint32 *line_number);
+gint32
+_mono_debug_address_from_il_offset (MonoDebugMethodJitInfo *jit,
+ guint32 il_offset);
+
MonoDebugMethodInfo *
mono_debug_find_method (MonoSymbolFile *symfile,
MonoMethod *method);
-gint32
-_mono_debug_address_from_il_offset (MonoDebugMethodInfo *minfo,
- guint32 il_offset);
-
#endif /* __MONO_SYMFILE_H__ */
mono_debugger_lock ();
symbol_table = g_new0 (MonoDebuggerSymbolTable, 1);
- symbol_table->magic = MONO_SYMBOL_FILE_DYNAMIC_MAGIC;
- symbol_table->version = MONO_SYMBOL_FILE_DYNAMIC_VERSION;
+ symbol_table->magic = MONO_DEBUGGER_MAGIC;
+ symbol_table->version = MONO_DEBUGGER_VERSION;
symbol_table->total_size = sizeof (MonoDebuggerSymbolTable);
mono_debugger_symbol_table = symbol_table;
}
MonoDebuggerSymbolFile *
-mono_debugger_add_symbol_file (MonoSymbolFile *symfile)
+mono_debugger_add_symbol_file (MonoDebugHandle *handle)
{
MonoDebuggerSymbolFile *info;
g_assert (mono_debugger_initialized);
info = allocate_symbol_file_entry (mono_debugger_symbol_table);
- info->symfile = symfile;
- info->image_file = symfile->image_file;
+ info->symfile = handle->symfile;
mono_debugger_add_type (info, mono_defaults.object_class);
}
void
-mono_debugger_add_method (MonoDebuggerSymbolFile *symfile, MonoMethod *method)
+mono_debugger_add_method (MonoDebuggerSymbolFile *symfile, MonoDebugMethodInfo *minfo,
+ MonoDebugMethodJitInfo *jit)
{
MonoSymbolFileMethodAddress *address;
MonoSymbolFileLexicalBlockEntry *block;
- MonoDebugMethodInfo *minfo;
MonoDebugVarInfo *var_table;
MonoDebuggerRangeInfo *range;
MonoMethodHeader *header;
if (!symfile->symfile->method_hash)
return;
- header = ((MonoMethodNormal *) method)->header;
-
- minfo = g_hash_table_lookup (symfile->symfile->method_hash, method);
- if (!minfo || !minfo->jit)
- return;
+ header = ((MonoMethodNormal *) minfo->method)->header;
symfile->generation++;
size = sizeof (MonoSymbolFileMethodAddress);
num_variables = minfo->entry->num_parameters + minfo->entry->num_locals;
- has_this = minfo->jit->this_var != NULL;
+ has_this = jit->this_var != NULL;
variable_size = (num_variables + has_this) * sizeof (MonoDebugVarInfo);
variable_offset = size;
type_offset = size;
size += type_size;
- if (minfo->jit->line_numbers) {
+ if (jit->line_numbers) {
line_offset = size;
- line_size = minfo->jit->line_numbers->len * sizeof (MonoDebugLineNumberEntry);
+ line_size = jit->line_numbers->len * sizeof (MonoDebugLineNumberEntry);
size += line_size;
}
block_table = (MonoDebugLexicalBlockEntry *) (ptr + block_offset);
for (i = 0; i < minfo->entry->num_lexical_blocks; i++, block++) {
- block_table [i].start_address = _mono_debug_address_from_il_offset (minfo, block->start_offset);
- block_table [i].end_address = _mono_debug_address_from_il_offset (minfo, block->end_offset);
+ block_table [i].start_address = _mono_debug_address_from_il_offset (jit, block->start_offset);
+ block_table [i].end_address = _mono_debug_address_from_il_offset (jit, block->end_offset);
}
address->size = size;
address->has_this = has_this;
- address->start_address = minfo->jit->code_start;
- address->end_address = minfo->jit->code_start + minfo->jit->code_size;
- address->method_start_address = address->start_address + minfo->jit->prologue_end;
- address->method_end_address = address->start_address + minfo->jit->epilogue_begin;
- address->wrapper_address = minfo->jit->wrapper_addr;
+ address->start_address = jit->code_start;
+ address->end_address = jit->code_start + jit->code_size;
+ address->method_start_address = address->start_address + jit->prologue_end;
+ address->method_end_address = address->start_address + jit->epilogue_begin;
+ address->wrapper_address = jit->wrapper_addr;
address->variable_table_offset = variable_offset;
address->type_table_offset = type_offset;
address->lexical_block_table_offset = block_offset;
- if (minfo->jit->line_numbers) {
- address->num_line_numbers = minfo->jit->line_numbers->len;
+ if (jit->line_numbers) {
+ address->num_line_numbers = jit->line_numbers->len;
address->line_number_offset = line_offset;
line_table = (MonoDebugLineNumberEntry *) (ptr + line_offset);
- memcpy (line_table, minfo->jit->line_numbers->data, line_size);
+ memcpy (line_table, jit->line_numbers->data, line_size);
}
range = allocate_range_entry (symfile);
range->dynamic_data = address;
range->dynamic_size = size;
- if ((method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) ||
- (method->iflags & METHOD_IMPL_ATTRIBUTE_RUNTIME) ||
- (method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL))
+ if ((minfo->method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) ||
+ (minfo->method->iflags & METHOD_IMPL_ATTRIBUTE_RUNTIME) ||
+ (minfo->method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL))
return;
var_table = (MonoDebugVarInfo *) (ptr + variable_offset);
type_index_table = (guint32 *)
(symfile->symfile->raw_contents + minfo->entry->type_index_table_offset);
- if (minfo->jit->this_var)
- *var_table++ = *minfo->jit->this_var;
- *type_table++ = write_type (mono_debugger_symbol_table, &method->klass->this_arg);
+ if (jit->this_var)
+ *var_table++ = *jit->this_var;
+ *type_table++ = write_type (mono_debugger_symbol_table, &minfo->method->klass->this_arg);
- if (minfo->jit->num_params != minfo->entry->num_parameters) {
+ if (jit->num_params != minfo->entry->num_parameters) {
g_warning (G_STRLOC ": Method %s.%s has %d parameters, but symbol file claims it has %d.",
- minfo->method->klass->name, minfo->method->name, minfo->jit->num_params,
+ minfo->method->klass->name, minfo->method->name, jit->num_params,
minfo->entry->num_parameters);
var_table += minfo->entry->num_parameters;
} else {
- for (i = 0; i < minfo->jit->num_params; i++) {
- *var_table++ = minfo->jit->params [i];
- *type_table++ = write_type (mono_debugger_symbol_table, method->signature->params [i]);
+ for (i = 0; i < jit->num_params; i++) {
+ *var_table++ = jit->params [i];
+ *type_table++ = write_type (mono_debugger_symbol_table, minfo->method->signature->params [i]);
}
}
- if (minfo->jit->num_locals < minfo->entry->num_locals) {
+ if (jit->num_locals < minfo->entry->num_locals) {
g_warning (G_STRLOC ": Method %s.%s has %d locals, but symbol file claims it has %d.",
- minfo->method->klass->name, minfo->method->name, minfo->jit->num_locals,
+ minfo->method->klass->name, minfo->method->name, jit->num_locals,
minfo->entry->num_locals);
var_table += minfo->entry->num_locals;
} else {
g_assert ((header != NULL) || (minfo->entry->num_locals == 0));
for (i = 0; i < minfo->entry->num_locals; i++) {
- *var_table++ = minfo->jit->locals [i];
+ *var_table++ = jit->locals [i];
*type_table++ = write_type (mono_debugger_symbol_table, header->locals [i]);
}
}
void mono_debugger_unlock (void);
void mono_debugger_event (MonoDebuggerEvent event, gpointer data, guint32 arg);
-MonoDebuggerSymbolFile *mono_debugger_add_symbol_file (MonoSymbolFile *symfile);
+MonoDebuggerSymbolFile *mono_debugger_add_symbol_file (MonoDebugHandle *handle);
void mono_debugger_add_type (MonoDebuggerSymbolFile *symfile, MonoClass *klass);
-void mono_debugger_add_method (MonoDebuggerSymbolFile *symfile, MonoMethod *method);
+void mono_debugger_add_method (MonoDebuggerSymbolFile *symfile,
+ MonoDebugMethodInfo *minfo,
+ MonoDebugMethodJitInfo *jit);
int mono_debugger_insert_breakpoint_full (MonoMethodDesc *desc);
int mono_debugger_remove_breakpoint (int breakpoint_id);
#include <mono/metadata/assembly.h>
#include <mono/metadata/tabledefs.h>
#include <mono/metadata/tokentype.h>
+#include <mono/metadata/appdomain.h>
#include <mono/metadata/mono-debug.h>
#include <mono/metadata/mono-debug-debugger.h>
struct _MonoDebugHandlePriv
{
- GHashTable *wrapper_info;
MonoDebuggerSymbolFile *debugger_info;
+ MonoDebugDomainData *domain_table;
+};
+
+struct _MonoDebugDomainDataPriv
+{
+ GHashTable *wrapper_info;
+ MonoDebugDomainData *next;
};
MonoDebugFormat mono_debug_format;
handle = g_new0 (MonoDebugHandle, 1);
handle->image = image;
handle->image->ref_count++;
+ handle->image_file = g_strdup (image->name);
handle->_priv = g_new0 (MonoDebugHandlePriv, 1);
- handle->_priv->wrapper_info = g_hash_table_new (g_direct_hash, g_direct_equal);
g_hash_table_insert (mono_debug_handles, image, handle);
if (image->assembly->dynamic)
return handle;
- handle->symfile = mono_debug_open_mono_symbol_file (handle->image, in_the_mono_debugger);
+ handle->symfile = mono_debug_open_mono_symbol_file (handle, in_the_mono_debugger);
if (in_the_mono_debugger)
- handle->_priv->debugger_info = mono_debugger_add_symbol_file (handle->symfile);
+ handle->_priv->debugger_info = mono_debugger_add_symbol_file (handle);
return handle;
}
{
if (handle->symfile)
mono_debug_close_mono_symbol_file (handle->symfile);
- g_hash_table_destroy (handle->_priv->wrapper_info);
handle->image->ref_count--;
g_free (handle->_priv);
g_free (handle);
* wrapper method.
*/
void
-mono_debug_add_wrapper (MonoMethod *method, MonoMethod *wrapper_method)
+mono_debug_add_wrapper (MonoMethod *method, MonoMethod *wrapper_method, MonoDomain *domain)
{
MonoClass *klass = method->klass;
MonoDebugHandle *handle;
MonoDebugMethodInfo *minfo;
MonoDebugMethodJitInfo *jit;
+ MonoDebugDomainData *domain_data;
if (!(method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL))
return;
g_assert (handle);
minfo = _mono_debug_lookup_method (method);
- if (!minfo || minfo->jit)
+ if (!minfo)
return;
- jit = g_hash_table_lookup (handle->_priv->wrapper_info, wrapper_method);
+ domain_data = mono_debug_get_domain_data (handle, domain);
+ g_assert (!domain_data->jit [minfo->index]);
+
+ jit = g_hash_table_lookup (domain_data->_priv->wrapper_info, wrapper_method);
g_assert (jit);
mono_debugger_lock ();
- minfo->jit = jit;
- minfo->jit->wrapper_addr = method->addr;
+ domain_data->jit [minfo->index] = jit;
+ jit->wrapper_addr = method->addr;
if (handle->_priv->debugger_info)
- mono_debugger_add_method (handle->_priv->debugger_info, method);
+ mono_debugger_add_method (handle->_priv->debugger_info, minfo, jit);
mono_debugger_unlock ();
}
* compiled method.
*/
void
-mono_debug_add_method (MonoMethod *method, MonoDebugMethodJitInfo *jit)
+mono_debug_add_method (MonoMethod *method, MonoDebugMethodJitInfo *jit, MonoDomain *domain)
{
MonoClass *klass = method->klass;
+ MonoDebugDomainData *domain_data;
MonoDebugHandle *handle;
MonoDebugMethodInfo *minfo;
handle = _mono_debug_get_image (klass->image);
g_assert (handle);
- if (method->wrapper_type != MONO_WRAPPER_NONE) {
- g_hash_table_insert (handle->_priv->wrapper_info, method, jit);
- return;
- }
-
minfo = _mono_debug_lookup_method (method);
if (!minfo)
return;
mono_debugger_lock ();
- g_assert (!minfo->jit);
- minfo->jit = jit;
+ domain_data = mono_debug_get_domain_data (handle, domain);
+ g_assert (!domain_data->jit [minfo->index]);
+
+ if (method->wrapper_type != MONO_WRAPPER_NONE) {
+ g_hash_table_insert (domain_data->_priv->wrapper_info, method, jit);
+ mono_debugger_unlock ();
+ return;
+ }
+
+ domain_data->jit [minfo->index] = jit;
if (handle->_priv->debugger_info)
- mono_debugger_add_method (handle->_priv->debugger_info, method);
+ mono_debugger_add_method (handle->_priv->debugger_info, minfo, jit);
mono_debugger_unlock ();
}
static gint32
-il_offset_from_address (MonoDebugMethodInfo *minfo, guint32 address)
+il_offset_from_address (MonoDebugMethodJitInfo *jit, guint32 address)
{
int i;
- if (!minfo->jit || !minfo->jit->line_numbers)
+ if (!jit || !jit->line_numbers)
return -1;
- for (i = minfo->jit->line_numbers->len - 1; i >= 0; i--) {
+ for (i = jit->line_numbers->len - 1; i >= 0; i--) {
MonoDebugLineNumberEntry lne = g_array_index (
- minfo->jit->line_numbers, MonoDebugLineNumberEntry, i);
+ jit->line_numbers, MonoDebugLineNumberEntry, i);
if (lne.address <= address)
return lne.offset;
* line number 8 in the variable pointed to by @line_number).
*/
gchar *
-mono_debug_source_location_from_address (MonoMethod *method, guint32 address, guint32 *line_number)
+mono_debug_source_location_from_address (MonoMethod *method, guint32 address, guint32 *line_number,
+ MonoDomain *domain)
{
MonoDebugMethodInfo *minfo = _mono_debug_lookup_method (method);
+ MonoDebugDomainData *domain_data;
if (!minfo)
return NULL;
- if (minfo->symfile) {
- gint32 offset = il_offset_from_address (minfo, address);
+ domain_data = mono_debug_get_domain_data (minfo->handle, domain);
+ if (!domain_data->jit [minfo->index])
+ return NULL;
+
+ if (minfo->handle) {
+ gint32 offset = il_offset_from_address (domain_data->jit [minfo->index], address);
if (offset < 0)
return NULL;
- return mono_debug_find_source_location (minfo->symfile, method, offset, line_number);
+ return mono_debug_find_source_location (minfo->handle->symfile, method, offset, line_number);
}
return NULL;
{
MonoDebugMethodInfo *minfo = _mono_debug_lookup_method (method);
- if (!minfo || !minfo->symfile)
+ if (!minfo || !minfo->handle)
return NULL;
- return mono_debug_find_source_location (minfo->symfile, method, offset, line_number);
+ return mono_debug_find_source_location (minfo->handle->symfile, method, offset, line_number);
}
/*
* relative to the beginning of the method @method.
*/
gint32
-mono_debug_il_offset_from_address (MonoMethod *method, gint32 address)
+mono_debug_il_offset_from_address (MonoMethod *method, gint32 address, MonoDomain *domain)
{
MonoDebugMethodInfo *minfo;
+ MonoDebugDomainData *domain_data;
if (address < 0)
return -1;
if (!minfo || !minfo->il_offsets)
return -1;
- return il_offset_from_address (minfo, address);
+ domain_data = mono_debug_get_domain_data (minfo->handle, domain);
+
+ return il_offset_from_address (domain_data->jit [minfo->index], address);
}
/*
* The returned value is an offset relative to the beginning of the method @method.
*/
gint32
-mono_debug_address_from_il_offset (MonoMethod *method, gint32 il_offset)
+mono_debug_address_from_il_offset (MonoMethod *method, gint32 il_offset, MonoDomain *domain)
{
MonoDebugMethodInfo *minfo;
+ MonoDebugDomainData *domain_data;
if (il_offset < 0)
return -1;
if (!minfo || !minfo->il_offsets)
return -1;
- return _mono_debug_address_from_il_offset (minfo, il_offset);
+ domain_data = mono_debug_get_domain_data (minfo->handle, domain);
+
+ return _mono_debug_address_from_il_offset (domain_data->jit [minfo->index], il_offset);
+}
+
+MonoDebugDomainData *
+mono_debug_get_domain_data (MonoDebugHandle *handle, MonoDomain *domain)
+{
+ MonoDebugDomainData *data;
+
+ for (data = handle->_priv->domain_table; data; data = data->_priv->next)
+ if (data->domain_id == domain->domain_id)
+ return data;
+
+ data = g_new0 (MonoDebugDomainData, 1);
+ data->domain_id = domain->domain_id;
+ data->jit = g_new0 (MonoDebugMethodJitInfo *, handle->symfile->offset_table->method_count + 1);
+
+ data->_priv = g_new0 (MonoDebugDomainDataPriv, 1);
+ data->_priv->next = handle->_priv->domain_table;
+ data->_priv->wrapper_info = g_hash_table_new (g_direct_hash, g_direct_equal);
+ handle->_priv->domain_table = data;
+
+ return data;
}
#define __MONO_DEBUG_H__
#include <glib.h>
-#include <mono/metadata/debug-mono-symfile.h>
+#include <mono/metadata/image.h>
+#include <mono/metadata/appdomain.h>
+
+typedef struct _MonoSymbolFile MonoSymbolFile;
+typedef struct _MonoSymbolFilePriv MonoSymbolFilePriv;
typedef struct _MonoDebugHandle MonoDebugHandle;
typedef struct _MonoDebugHandlePriv MonoDebugHandlePriv;
+typedef struct _MonoDebugDomainData MonoDebugDomainData;
+typedef struct _MonoDebugDomainDataPriv MonoDebugDomainDataPriv;
+
+typedef struct _MonoDebugVarInfo MonoDebugVarInfo;
+typedef struct _MonoDebugMethodJitInfo MonoDebugMethodJitInfo;
typedef enum {
MONO_DEBUG_FORMAT_NONE,
} MonoDebugFormat;
struct _MonoDebugHandle {
+ const char *image_file;
MonoImage *image;
MonoSymbolFile *symfile;
MonoDebugHandlePriv *_priv;
};
+struct _MonoDebugMethodJitInfo {
+ const guint8 *code_start;
+ guint32 code_size;
+ guint32 prologue_end;
+ guint32 epilogue_begin;
+ const guint8 *wrapper_addr;
+ // Array of MonoDebugLineNumberEntry
+ GArray *line_numbers;
+ guint32 num_params;
+ MonoDebugVarInfo *this_var;
+ MonoDebugVarInfo *params;
+ guint32 num_locals;
+ MonoDebugVarInfo *locals;
+};
+
+struct _MonoDebugDomainData {
+ guint32 domain_id;
+ MonoDebugMethodJitInfo **jit;
+ MonoDebugDomainDataPriv *_priv;
+};
+
+/*
+ * These bits of the MonoDebugLocalInfo's "index" field are flags specifying
+ * where the variable is actually stored.
+ *
+ * See relocate_variable() in debug-symfile.c for more info.
+ */
+#define MONO_DEBUG_VAR_ADDRESS_MODE_FLAGS 0xf0000000
+
+/* If "index" is zero, the variable is at stack offset "offset". */
+#define MONO_DEBUG_VAR_ADDRESS_MODE_STACK 0
+
+/* The variable is in the register whose number is contained in bits 0..4 of the
+ * "index" field plus an offset of "offset" (which can be zero).
+ */
+#define MONO_DEBUG_VAR_ADDRESS_MODE_REGISTER 0x10000000
+
+/* The variables in in the two registers whose numbers are contained in bits 0..4
+ * and 5..9 of the "index" field plus an offset of "offset" (which can be zero).
+ */
+#define MONO_DEBUG_VAR_ADDRESS_MODE_TWO_REGISTERS 0x20000000
+
+struct _MonoDebugVarInfo {
+ guint32 index;
+ guint32 offset;
+ guint32 size;
+ guint32 begin_scope;
+ guint32 end_scope;
+};
+
+#define MONO_DEBUGGER_VERSION 28
+#define MONO_DEBUGGER_MAGIC 0x7aff65af4253d427
+
extern MonoDebugFormat mono_debug_format;
extern GHashTable *mono_debug_handles;
void mono_debug_init (MonoDebugFormat format);
void mono_debug_init_2 (MonoAssembly *assembly);
void mono_debug_cleanup (void);
-void mono_debug_add_wrapper (MonoMethod *method, MonoMethod *wrapper_method);
-void mono_debug_add_method (MonoMethod *method, MonoDebugMethodJitInfo *jit);
+MonoDebugDomainData *mono_debug_get_domain_data (MonoDebugHandle *handle, MonoDomain *domain);
+void mono_debug_add_wrapper (MonoMethod *method, MonoMethod *wrapper_method, MonoDomain *domain);
+void mono_debug_add_method (MonoMethod *method, MonoDebugMethodJitInfo *jit, MonoDomain *domain);
gchar *mono_debug_source_location_from_address (MonoMethod *method, guint32 address,
- guint32 *line_number);
+ guint32 *line_number, MonoDomain *domain);
gchar *mono_debug_source_location_from_il_offset (MonoMethod *method, guint32 offset,
guint32 *line_number);
-gint32 mono_debug_il_offset_from_address (MonoMethod *method, gint32 address);
-gint32 mono_debug_address_from_il_offset (MonoMethod *method, gint32 il_offset);
+gint32 mono_debug_il_offset_from_address (MonoMethod *method, gint32 address, MonoDomain *domain);
+gint32 mono_debug_address_from_il_offset (MonoMethod *method, gint32 il_offset, MonoDomain *domain);
#endif /* __MONO_DEBUG_H__ */
for (i = 0; i < jit->num_params; i++)
write_variable (cfg->varinfo [i + method->signature->hasthis], &jit->params [i]);
- mono_debug_add_method (method, jit);
+ mono_debug_add_method (method, jit, cfg->domain);
if (info->breakpoint_id)
mono_debugger_breakpoint_callback (method, info->breakpoint_id);
*managed = TRUE;
if (trace) {
- source_location = mono_debug_source_location_from_address (ji->method, address, NULL);
- iloffset = mono_debug_il_offset_from_address (ji->method, address);
+ source_location = mono_debug_source_location_from_address (ji->method, address, NULL, domain);
+ iloffset = mono_debug_il_offset_from_address (ji->method, address, domain);
if (iloffset < 0)
tmpaddr = g_strdup_printf ("<0x%05x>", address);
sf->method = mono_method_get_object (domain, ji->method, NULL);
sf->native_offset = (char *)ip - (char *)ji->code_start;
- sf->il_offset = mono_debug_il_offset_from_address (ji->method, sf->native_offset);
+ sf->il_offset = mono_debug_il_offset_from_address (ji->method, sf->native_offset, domain);
if (need_file_info) {
gchar *filename;
- filename = mono_debug_source_location_from_address (ji->method, sf->native_offset, &sf->line);
+ filename = mono_debug_source_location_from_address (ji->method, sf->native_offset, &sf->line, domain);
sf->filename = filename? mono_string_new (domain, filename): NULL;
sf->column = 0;
if (ji == (gpointer)-1)
return;
- il_offset = mono_debug_il_offset_from_address (ji->method, native_offset);
+ il_offset = mono_debug_il_offset_from_address (ji->method, native_offset, domain);
if (func (ji->method, native_offset, il_offset, managed, user_data))
return;
} while (skip >= 0);
*method = mono_method_get_object (domain, ji->method, NULL);
- *iloffset = mono_debug_il_offset_from_address (ji->method, *native_offset);
+ *iloffset = mono_debug_il_offset_from_address (ji->method, *native_offset, domain);
if (need_file_info) {
gchar *filename;
- filename = mono_debug_source_location_from_address (ji->method, *native_offset, line);
+ filename = mono_debug_source_location_from_address (ji->method, *native_offset, line, domain);
*file = filename? mono_string_new (domain, filename): NULL;
*column = 0;
projects / mono.git / commitdiff