#include "mini.h"
#include "jit.h"
+#include "config.h"
#include <mono/metadata/verify.h>
#include <mono/metadata/mono-config.h>
#include <mono/metadata/mono-debug.h>
#include <mono/metadata/appdomain.h>
-/* mono-debug-debugger.h needs config.h to work... */
-#include "config.h"
#include <mono/metadata/mono-debug-debugger.h>
#ifdef HAVE_VALGRIND_H
#include <valgrind/valgrind.h>
#endif
-static inline void
-record_line_number (MonoDebugMethodJitInfo *jit, guint32 address, guint32 offset)
-{
- MonoDebugLineNumberEntry lne;
-
- lne.address = address;
- lne.offset = offset;
-
- g_array_append_val (jit->line_numbers, lne);
-}
-
typedef struct
{
MonoDebugMethodJitInfo *jit;
+ GArray *line_numbers;
guint32 has_line_numbers;
guint32 breakpoint_id;
} MiniDebugMethodInfo;
+static inline void
+record_line_number (MiniDebugMethodInfo *info, guint32 address, guint32 offset)
+{
+ MonoDebugLineNumberEntry lne;
+
+ lne.native_offset = address;
+ lne.il_offset = offset;
+
+ g_array_append_val (info->line_numbers, lne);
+}
+
void
mono_debug_init_method (MonoCompile *cfg, MonoBasicBlock *start_block, guint32 breakpoint_id)
{
- MonoMethod *method = cfg->method;
MiniDebugMethodInfo *info;
if (mono_debug_format == MONO_DEBUG_FORMAT_NONE)
return;
- if ((method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) ||
- (method->iflags & METHOD_IMPL_ATTRIBUTE_RUNTIME) ||
- (method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) ||
- (method->flags & METHOD_ATTRIBUTE_ABSTRACT) ||
- (method->wrapper_type != MONO_WRAPPER_NONE))
- return;
-
info = g_new0 (MiniDebugMethodInfo, 1);
info->breakpoint_id = breakpoint_id;
mono_class_init (cfg->method->klass);
- g_assert (((MonoMethodNormal*)cfg->method)->header);
- header = ((MonoMethodNormal*)cfg->method)->header;
-
+ header = mono_method_get_header (cfg->method);
+ g_assert (header);
+
info->jit = jit = g_new0 (MonoDebugMethodJitInfo, 1);
- jit->line_numbers = g_array_new (FALSE, TRUE, sizeof (MonoDebugLineNumberEntry));
+ info->line_numbers = g_array_new (FALSE, TRUE, sizeof (MonoDebugLineNumberEntry));
jit->num_locals = header->num_locals;
jit->locals = g_new0 (MonoDebugVarInfo, jit->num_locals);
}
if (!RUNNING_ON_VALGRIND)
return;
- header = ((MonoMethodNormal*)method)->header;
+ header = mono_method_get_header (method);
full_name = mono_method_full_name (method, TRUE);
}
/* Create address->offset mapping */
- for (i = 0; i < jit->line_numbers->len; ++i) {
- MonoDebugLineNumberEntry *lne = &g_array_index (jit->line_numbers, MonoDebugLineNumberEntry, i);
+ for (i = 0; i < jit->num_line_numbers; ++i) {
+ MonoDebugLineNumberEntry *lne = jit->line_numbers [i];
g_assert (lne->offset <= header->code_size);
MiniDebugMethodInfo *info;
MonoDebugMethodJitInfo *jit;
MonoMethodHeader *header;
+ MonoMethodSignature *sig;
MonoMethod *method;
int i;
info = (MiniDebugMethodInfo *) cfg->debug_info;
- if (!info || !info->jit)
+ if (!info || !info->jit) {
+ if (info)
+ g_free (info);
return;
+ }
method = cfg->method;
- header = ((MonoMethodNormal*)method)->header;
+ header = mono_method_get_header (method);
+ sig = mono_method_signature (method);
jit = info->jit;
jit->code_start = cfg->native_code;
jit->epilogue_begin = cfg->epilog_begin;
jit->code_size = cfg->code_len;
- record_line_number (jit, jit->epilogue_begin, header->code_size);
+ record_line_number (info, jit->epilogue_begin, header->code_size);
- jit->num_params = method->signature->param_count;
+ jit->num_params = sig->param_count;
jit->params = g_new0 (MonoDebugVarInfo, jit->num_params);
for (i = 0; i < jit->num_locals; i++)
write_variable (cfg->varinfo [cfg->locals_start + i], &jit->locals [i]);
- if (method->signature->hasthis) {
+ if (sig->hasthis) {
jit->this_var = g_new0 (MonoDebugVarInfo, 1);
write_variable (cfg->varinfo [0], jit->this_var);
}
for (i = 0; i < jit->num_params; i++)
- write_variable (cfg->varinfo [i + method->signature->hasthis], &jit->params [i]);
+ write_variable (cfg->varinfo [i + sig->hasthis], &jit->params [i]);
+
+ jit->num_line_numbers = info->line_numbers->len;
+ jit->line_numbers = g_new0 (MonoDebugLineNumberEntry, jit->num_line_numbers);
+
+ for (i = 0; i < jit->num_line_numbers; i++)
+ jit->line_numbers [i] = g_array_index (info->line_numbers, MonoDebugLineNumberEntry, i);
mono_debug_add_method (method, jit, cfg->domain);
if (info->breakpoint_id)
mono_debugger_breakpoint_callback (method, info->breakpoint_id);
+
+ mono_debug_free_method_jit_info (jit);
+ g_array_free (info->line_numbers, TRUE);
+ g_free (info);
}
void
if (!info || !info->jit || !ins->cil_code)
return;
- g_assert (((MonoMethodNormal*)cfg->method)->header);
- header = ((MonoMethodNormal*)cfg->method)->header;
+ header = mono_method_get_header (cfg->method);
+ g_assert (header);
if ((ins->cil_code < header->code) ||
(ins->cil_code > header->code + header->code_size))
info->has_line_numbers = TRUE;
}
- record_line_number (info->jit, address, offset);
+ record_line_number (info, address, offset);
}
static inline void
-encode_value (gint32 value, char *buf, char **endbuf)
+encode_value (gint32 value, guint8 *buf, guint8 **endbuf)
{
- char *p = buf;
+ guint8 *p = buf;
//printf ("ENCODE: %d 0x%x.\n", value, value);
*/
if ((value >= 0) && (value <= 127))
*p++ = value;
- else if ((value >= 0) && (value <= 16384)) {
+ else if ((value >= 0) && (value <= 16383)) {
p [0] = 0x80 | (value >> 8);
p [1] = value & 0xff;
p += 2;
}
static inline gint32
-decode_value (char *_ptr, char **rptr)
+decode_value (guint8 *ptr, guint8 **rptr)
{
- unsigned char *ptr = (unsigned char *) _ptr;
- unsigned char b = *ptr;
+ guint8 b = *ptr;
gint32 len;
if ((b & 0x80) == 0){
}
static void
-serialize_variable (MonoDebugVarInfo *var, char *p, char **endbuf)
+serialize_variable (MonoDebugVarInfo *var, guint8 *p, guint8 **endbuf)
{
guint32 flags = var->index & MONO_DEBUG_VAR_ADDRESS_MODE_FLAGS;
}
void
-mono_debug_serialize_debug_info (MonoCompile *cfg,
- guint8 **out_buf, guint32 *buf_len)
+mono_debug_serialize_debug_info (MonoCompile *cfg, guint8 **out_buf, guint32 *buf_len)
{
MiniDebugMethodInfo *info;
MonoDebugMethodJitInfo *jit;
guint32 size, prev_offset, prev_native_offset;
- char *buf;
- char *p;
+ guint8 *buf, *p;
int i;
info = (MiniDebugMethodInfo *) cfg->debug_info;
}
jit = info->jit;
- size = ((jit->num_params + jit->num_locals + 1) * 10) + (jit->line_numbers->len * 10) + 64;
+ size = ((jit->num_params + jit->num_locals + 1) * 10) + (jit->num_line_numbers * 10) + 64;
p = buf = g_malloc (size);
encode_value (jit->epilogue_begin, p, &p);
- encode_value (jit->prologue_end, p, &p);
+ encode_value (jit->prologue_end, p, &p);
encode_value (jit->code_size, p, &p);
for (i = 0; i < jit->num_params; ++i)
serialize_variable (&jit->params [i], p, &p);
- if (cfg->method->signature->hasthis)
+ if (mono_method_signature (cfg->method)->hasthis)
serialize_variable (jit->this_var, p, &p);
for (i = 0; i < jit->num_locals; i++)
serialize_variable (&jit->locals [i], p, &p);
- encode_value (jit->line_numbers->len, p, &p);
+ encode_value (jit->num_line_numbers, p, &p);
prev_offset = 0;
prev_native_offset = 0;
- for (i = 0; i < jit->line_numbers->len; ++i) {
+ for (i = 0; i < jit->num_line_numbers; ++i) {
/* Sometimes, the offset values are not in increasing order */
- MonoDebugLineNumberEntry *lne = &g_array_index (jit->line_numbers,
- MonoDebugLineNumberEntry,
- i);
- encode_value (lne->offset - prev_offset, p, &p);
- encode_value (lne->address - prev_native_offset, p, &p);
- prev_offset = lne->offset;
- prev_native_offset = lne->address;
+ MonoDebugLineNumberEntry *lne = &jit->line_numbers [i];
+ encode_value (lne->il_offset - prev_offset, p, &p);
+ encode_value (lne->native_offset - prev_native_offset, p, &p);
+ prev_offset = lne->il_offset;
+ prev_native_offset = lne->native_offset;
}
g_assert (p - buf < size);
}
static void
-deserialize_variable (MonoDebugVarInfo *var, char *p, char **endbuf)
+deserialize_variable (MonoDebugVarInfo *var, guint8 *p, guint8 **endbuf)
{
guint32 flags;
}
static MonoDebugMethodJitInfo *
-deserialize_debug_info (MonoMethod *method,
- guint8 *code_start,
- guint8 *buf, guint32 buf_len)
+deserialize_debug_info (MonoMethod *method, guint8 *code_start, guint8 *buf, guint32 buf_len)
{
MonoMethodHeader *header;
+ gint32 offset, native_offset, prev_offset, prev_native_offset;
MonoDebugMethodJitInfo *jit;
- gint32 offset, native_offset, prev_offset, prev_native_offset, len;
- char *p;
+ guint8 *p;
int i;
- g_assert (((MonoMethodNormal*)method)->header);
- header = ((MonoMethodNormal*)method)->header;
+ header = mono_method_get_header (method);
+ g_assert (header);
jit = g_new0 (MonoDebugMethodJitInfo, 1);
jit->code_start = code_start;
- jit->line_numbers = g_array_new (FALSE, TRUE, sizeof (MonoDebugLineNumberEntry));
jit->num_locals = header->num_locals;
jit->locals = g_new0 (MonoDebugVarInfo, jit->num_locals);
- jit->num_params = method->signature->param_count;
+ jit->num_params = mono_method_signature (method)->param_count;
jit->params = g_new0 (MonoDebugVarInfo, jit->num_params);
p = buf;
for (i = 0; i < jit->num_params; ++i)
deserialize_variable (&jit->params [i], p, &p);
- if (method->signature->hasthis) {
+ if (mono_method_signature (method)->hasthis) {
jit->this_var = g_new0 (MonoDebugVarInfo, 1);
deserialize_variable (jit->this_var, p, &p);
}
for (i = 0; i < jit->num_locals; i++)
deserialize_variable (&jit->locals [i], p, &p);
- len = decode_value (p, &p);
+ jit->num_line_numbers = decode_value (p, &p);
+ jit->line_numbers = g_new0 (MonoDebugLineNumberEntry, jit->num_line_numbers);
prev_offset = 0;
prev_native_offset = 0;
- for (i = 0; i < len; ++i) {
+ for (i = 0; i < jit->num_line_numbers; ++i) {
+ MonoDebugLineNumberEntry *lne = &jit->line_numbers [i];
+
offset = prev_offset + decode_value (p, &p);
native_offset = prev_native_offset + decode_value (p, &p);
- record_line_number (jit, native_offset, offset);
+
+ lne->native_offset = native_offset;
+ lne->il_offset = offset;
+
prev_offset = offset;
prev_native_offset = native_offset;
}
}
void
-mono_debug_add_aot_method (MonoDomain *domain,
- MonoMethod *method, guint8 *code_start,
- guint8 *debug_info, guint32 debug_info_len)
+mono_debug_add_aot_method (MonoDomain *domain, MonoMethod *method, guint8 *code_start,
+ guint8 *debug_info, guint32 debug_info_len)
{
MonoDebugMethodJitInfo *jit;
if (debug_info_len == 0)
return;
- jit = deserialize_debug_info (method, code_start,
- debug_info,
- debug_info_len);
+ jit = deserialize_debug_info (method, code_start, debug_info, debug_info_len);
+
+#if 0
+ jit = mono_debug_read_method ((MonoDebugMethodAddress *) debug_info);
+ jit->code_start = code_start;
+ jit->wrapper_addr = NULL;
+#endif
mono_debug_add_method (method, jit, domain);
mono_debug_add_vg_method (method, jit);
+
+ mono_debug_free_method_jit_info (jit);
}
-MonoDomain *
-mono_init_debugger (const char *file, const char *opt_flags)
+void
+mono_debug_add_icall_wrapper (MonoMethod *method, MonoJitICallInfo* callinfo)
{
- MonoDomain *domain;
- const guchar *error;
- int opt;
-
- g_set_prgname (file);
-
- opt = mono_parse_default_optimizations (opt_flags);
- opt |= MONO_OPT_SHARED;
-
- mono_set_defaults (0, opt);
-
- domain = mono_jit_init (file);
-
- mono_config_parse (NULL);
-
- error = mono_check_corlib_version ();
- if (error) {
- fprintf (stderr, "Corlib not in sync with this runtime: %s\n", error);
- fprintf (stderr, "Download a newer corlib or a newer runtime at http://www.go-mono.com/daily.\n");
- exit (1);
- }
+ if (mono_debug_format == MONO_DEBUG_FORMAT_NONE)
+ return;
- return domain;
+ // mono_debug_add_wrapper (method, callinfo->wrapper, callinfo->func);
}
projects / mono.git / blobdiff