/*
* mono_debug_lookup_locals:
*
* Return information about the local variables of MINFO.
* The result should be freed using mono_debug_free_locals ().
*/
MonoDebugLocalsInfo*
mono_debug_lookup_locals (MonoMethod *method)
{
MonoDebugMethodInfo *minfo;
MonoDebugLocalsInfo *res;
if (mono_debug_format == MONO_DEBUG_FORMAT_NONE)
return NULL;
mono_debugger_lock ();
minfo = mono_debug_lookup_method_internal (method);
if (!minfo || !minfo->handle) {
mono_debugger_unlock ();
return NULL;
}
if (minfo->handle->ppdb) {
res = mono_ppdb_lookup_locals (minfo);
} else {
if (!minfo->handle->symfile || !mono_debug_symfile_is_loaded (minfo->handle->symfile))
res = NULL;
else
res = mono_debug_symfile_lookup_locals (minfo);
}
mono_debugger_unlock ();
return res;
}
/**
* mono_debug_lookup_source_location_by_il:
*
* Same as mono_debug_lookup_source_location but take an IL_OFFSET argument.
*/
MonoDebugSourceLocation *
mono_debug_lookup_source_location_by_il (MonoMethod *method, guint32 il_offset, MonoDomain *domain)
{
MonoDebugMethodInfo *minfo;
MonoDebugSourceLocation *location;
if (mono_debug_format == MONO_DEBUG_FORMAT_NONE)
return NULL;
mono_debugger_lock ();
minfo = mono_debug_lookup_method_internal (method);
if (!minfo || !minfo->handle) {
mono_debugger_unlock ();
return NULL;
}
if (!minfo->handle->ppdb && (!minfo->handle->symfile || !mono_debug_symfile_is_loaded (minfo->handle->symfile))) {
mono_debugger_unlock ();
return NULL;
}
if (minfo->handle->ppdb)
location = mono_ppdb_lookup_location (minfo, il_offset);
else
location = mono_debug_symfile_lookup_location (minfo, il_offset);
mono_debugger_unlock ();
return location;
}
/**
* mono_debug_lookup_source_location:
* @address: Native offset within the @method's machine code.
*
* Lookup the source code corresponding to the machine instruction located at
* native offset @address within @method.
*
* The returned `MonoDebugSourceLocation' contains both file / line number
* information and the corresponding IL offset. It must be freed by
* mono_debug_free_source_location().
*/
MonoDebugSourceLocation *
mono_debug_lookup_source_location (MonoMethod *method, guint32 address, MonoDomain *domain)
{
MonoDebugMethodInfo *minfo;
MonoDebugSourceLocation *location;
gint32 offset;
if (mono_debug_format == MONO_DEBUG_FORMAT_NONE)
return NULL;
mono_debugger_lock ();
minfo = mono_debug_lookup_method_internal (method);
if (!minfo || !minfo->handle || !minfo->handle->symfile || !mono_debug_symfile_is_loaded (minfo->handle->symfile)) {
mono_debugger_unlock ();
return NULL;
}
offset = il_offset_from_address (method, domain, address);
if (offset < 0) {
mono_debugger_unlock ();
return NULL;
}
location = mono_debug_symfile_lookup_location (minfo, offset);
mono_debugger_unlock ();
return location;
}
/**
* mono_debug_lookup_method:
*
* Lookup symbol file information for the method @method. The returned
* `MonoDebugMethodInfo' is a private structure, but it can be passed to
* mono_debug_symfile_lookup_location().
*/
MonoDebugMethodInfo *
mono_debug_lookup_method (MonoMethod *method)
{
MonoDebugMethodInfo *minfo;
mono_debugger_lock ();
minfo = mono_debug_lookup_method_internal (method);
mono_debugger_unlock ();
return minfo;
}
/**
* mono_debug_lookup_method:
*
* Lookup symbol file information for the method \p method. The returned
* \c MonoDebugMethodInfo is a private structure, but it can be passed to
* \c mono_debug_symfile_lookup_location.
*/
MonoDebugMethodInfo *
mono_debug_lookup_method (MonoMethod *method)
{
MonoDebugMethodInfo *minfo;
if (mono_debug_format == MONO_DEBUG_FORMAT_NONE)
return NULL;
mono_debugger_lock ();
minfo = mono_debug_lookup_method_internal (method);
mono_debugger_unlock ();
return minfo;
}
/*
* mono_debug_lookup_method_async_debug_info:
*
* Return information about the async stepping information of method.
* The result should be freed using mono_debug_free_async_debug_info ().
*/
MonoDebugMethodAsyncInfo*
mono_debug_lookup_method_async_debug_info (MonoMethod *method)
{
MonoDebugMethodInfo *minfo;
MonoDebugMethodAsyncInfo *res = NULL;
if (mono_debug_format == MONO_DEBUG_FORMAT_NONE)
return NULL;
mono_debugger_lock ();
minfo = mono_debug_lookup_method_internal (method);
if (!minfo || !minfo->handle) {
mono_debugger_unlock ();
return NULL;
}
if (minfo->handle->ppdb)
res = mono_ppdb_lookup_method_async_debug_info (minfo);
mono_debugger_unlock ();
return res;
}
MonoDebugMethodAddress *
mono_debug_add_method (MonoMethod *method, MonoDebugMethodJitInfo *jit, MonoDomain *domain)
{
MonoDebugDataTable *table;
MonoDebugMethodAddress *address;
MonoDebugMethodInfo *minfo;
MonoDebugHandle *handle;
guint8 buffer [BUFSIZ];
guint8 *ptr, *oldptr;
guint32 i, size, total_size, max_size;
mono_debugger_lock ();
table = lookup_data_table (domain);
handle = mono_debug_get_image (method->klass->image);
minfo = mono_debug_lookup_method_internal (method);
max_size = (5 * 5) + 1 + (10 * jit->num_line_numbers) +
(25 + sizeof (gpointer)) * (1 + jit->num_params + jit->num_locals);
if (max_size > BUFSIZ)
ptr = oldptr = g_malloc (max_size);
else
ptr = oldptr = buffer;
write_leb128 (jit->prologue_end, ptr, &ptr);
write_leb128 (jit->epilogue_begin, ptr, &ptr);
write_leb128 (jit->num_line_numbers, ptr, &ptr);
for (i = 0; i < jit->num_line_numbers; i++) {
MonoDebugLineNumberEntry *lne = &jit->line_numbers [i];
write_sleb128 (lne->il_offset, ptr, &ptr);
write_sleb128 (lne->native_offset, ptr, &ptr);
}
*ptr++ = jit->this_var ? 1 : 0;
if (jit->this_var)
write_variable (jit->this_var, ptr, &ptr);
write_leb128 (jit->num_params, ptr, &ptr);
for (i = 0; i < jit->num_params; i++)
write_variable (&jit->params [i], ptr, &ptr);
write_leb128 (jit->num_locals, ptr, &ptr);
for (i = 0; i < jit->num_locals; i++)
write_variable (&jit->locals [i], ptr, &ptr);
*ptr++ = jit->gsharedvt_info_var ? 1 : 0;
if (jit->gsharedvt_info_var) {
write_variable (jit->gsharedvt_info_var, ptr, &ptr);
write_variable (jit->gsharedvt_locals_var, ptr, &ptr);
}
size = ptr - oldptr;
g_assert (size < max_size);
total_size = size + sizeof (MonoDebugMethodAddress);
if (method_is_dynamic (method)) {
address = g_malloc0 (total_size);
} else {
address = mono_mempool_alloc (table->mp, total_size);
}
address->code_start = jit->code_start;
address->code_size = jit->code_size;
memcpy (&address->data, oldptr, size);
if (max_size > BUFSIZ)
g_free (oldptr);
g_hash_table_insert (table->method_address_hash, method, address);
mono_debugger_unlock ();
return address;
}
