void
mono_debug_open_block (MonoCompile *cfg, MonoBasicBlock *bb, guint32 address)
{
MiniDebugMethodInfo *info;
MonoMethodHeader *header;
guint32 offset;
info = (MiniDebugMethodInfo *) cfg->debug_info;
if (!info || !info->jit || !bb->cil_code)
return;
header = mono_method_get_header (cfg->method);
g_assert (header);
if ((bb->cil_code < header->code) ||
(bb->cil_code > header->code + header->code_size))
return;
offset = bb->cil_code - header->code;
if (!info->has_line_numbers) {
info->jit->prologue_end = address;
info->has_line_numbers = TRUE;
}
record_line_number (info, address, offset);
}
void
mono_debug_close_method (MonoCompile *cfg)
{
MiniDebugMethodInfo *info;
MonoDebugMethodJitInfo *jit;
MonoMethodHeader *header;
MonoMethodSignature *sig;
MonoDebugMethodAddress *debug_info;
MonoMethod *method;
int i;
info = (MiniDebugMethodInfo *) cfg->debug_info;
if (!info || !info->jit) {
if (info)
g_free (info);
return;
}
method = cfg->method;
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;
if (jit->epilogue_begin)
record_line_number (info, jit->epilogue_begin, header->code_size);
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->locals [i], &jit->locals [i]);
if (sig->hasthis) {
jit->this_var = g_new0 (MonoDebugVarInfo, 1);
write_variable (cfg->args [0], jit->this_var);
}
for (i = 0; i < jit->num_params; i++)
write_variable (cfg->args [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);
debug_info = mono_debug_add_method (cfg->method_to_register, jit, cfg->domain);
mono_debug_add_vg_method (method, jit);
mono_debugger_check_breakpoints (method, debug_info);
mono_debug_free_method_jit_info (jit);
g_array_free (info->line_numbers, TRUE);
g_free (info);
}
void CPipeServer::DisassembleMethod()
{
void *method=(void *)ReadQword();
void *methodheader=mono_method_get_header(method);
UINT32 codesize, maxstack;
void *ilcode=mono_method_header_get_code(methodheader, &codesize, &maxstack);
char *disassembly=mono_disasm_code(NULL, method, ilcode, (void *)((UINT_PTR)ilcode+codesize));
WriteWord(strlen(disassembly));
Write(disassembly, strlen(disassembly));
g_free(disassembly);
}
/**
* mono_profiler_coverage_get:
* @prof: The profiler handle, installed with mono_profiler_install
* @method: the method to gather information from.
* @func: A routine that will be called back with the results
*
* If the MONO_PROFILER_INS_COVERAGE flag was active during JIT compilation
* it is posisble to obtain coverage information about a give method.
*
* The function @func will be invoked repeatedly with instances of the
* MonoProfileCoverageEntry structure.
*/
void
mono_profiler_coverage_get (MonoProfiler *prof, MonoMethod *method, MonoProfileCoverageFunc func)
{
MonoProfileCoverageInfo* info = NULL;
int i, offset;
guint32 code_size;
const unsigned char *start, *end, *cil_code;
MonoMethodHeader *header;
MonoProfileCoverageEntry entry;
MonoDebugMethodInfo *debug_minfo;
mono_profiler_coverage_lock ();
if (coverage_hash)
info = g_hash_table_lookup (coverage_hash, method);
mono_profiler_coverage_unlock ();
if (!info)
return;
header = mono_method_get_header (method);
start = mono_method_header_get_code (header, &code_size, NULL);
debug_minfo = mono_debug_lookup_method (method);
end = start + code_size;
for (i = 0; i < info->entries; ++i) {
cil_code = info->data [i].cil_code;
if (cil_code && cil_code >= start && cil_code < end) {
char *fname = NULL;
offset = cil_code - start;
entry.iloffset = offset;
entry.method = method;
entry.counter = info->data [i].count;
entry.line = entry.col = 1;
entry.filename = NULL;
if (debug_minfo) {
MonoDebugSourceLocation *location;
location = mono_debug_symfile_lookup_location (debug_minfo, offset);
if (location) {
entry.line = location->row;
entry.col = location->column;
entry.filename = fname = g_strdup (location->source_file);
mono_debug_free_source_location (location);
}
}
func (prof, &entry);
g_free (fname);
}
}
mono_metadata_free_mh (header);
}
/*
* mono_basic_block_split:
*
* Return the list of basic blocks of method. Return NULL on failure and set @error.
*/
MonoSimpleBasicBlock*
mono_basic_block_split (MonoMethod *method, MonoError *error)
{
MonoSimpleBasicBlock *bb, *root;
const unsigned char *start, *end;
MonoMethodHeader *header = mono_method_get_header (method);
mono_error_init (error);
if (!header) {
mono_error_set_not_verifiable (error, method, "Could not decode header");
return NULL;
}
start = header->code;
end = start + header->code_size;
bb = g_new0 (MonoSimpleBasicBlock, 1);
bb->start = 0;
bb->end = end - start;
bb->colour = BLACK;
bb->dead = FALSE;
root = bb;
bb_formation_il_pass (start, end, bb, &root, method, error);
if (!mono_error_ok (error))
goto fail;
bb_formation_eh_pass (header, bb, &root, method, error);
if (!mono_error_ok (error))
goto fail;
bb_liveness (bb);
#if DEBUG_BB
dump_bb_list (bb, &root, g_strdup_printf("AFTER LIVENESS %s", mono_method_full_name (method, TRUE)));
#endif
mono_metadata_free_mh (header);
return bb;
fail:
mono_metadata_free_mh (header);
mono_basic_block_free (bb);
return NULL;
}
void
mono_debug_open_method (MonoCompile *cfg)
{
MiniDebugMethodInfo *info;
MonoDebugMethodJitInfo *jit;
MonoMethodHeader *header;
info = (MiniDebugMethodInfo *) cfg->debug_info;
if (!info)
return;
mono_class_init (cfg->method->klass);
header = mono_method_get_header (cfg->method);
g_assert (header);
info->jit = jit = g_new0 (MonoDebugMethodJitInfo, 1);
info->line_numbers = g_array_new (FALSE, TRUE, sizeof (MonoDebugLineNumberEntry));
jit->num_locals = header->num_locals;
jit->locals = g_new0 (MonoDebugVarInfo, jit->num_locals);
}
static void
output_method (MonoMethod *method, gpointer dummy, MonoProfiler *prof)
{
MonoMethodHeader *header;
char *classname;
char *tmpsig;
char *tmpname;
FILE *outfile;
MonoClass *klass;
MonoImage *image;
outfile = prof->outfile;
header = mono_method_get_header (method);
tmpsig = mono_signature_get_desc (mono_method_signature (method), TRUE);
tmpsig = g_markup_escape_text (tmpsig, strlen (tmpsig));
klass = mono_method_get_class (method);
classname = mono_type_get_name (mono_class_get_type (klass));
image = mono_class_get_image (klass);
tmpname = mono_method_get_name (method);
tmpname = g_markup_escape_text (tmpname, strlen (tmpname));
fprintf (outfile, "\t<method assembly=\"%s\" class=\"%s\" name=\"%s (%s)\" token=\"%d\">\n",
mono_image_get_name (image),
classname, tmpname,
tmpsig, mono_method_get_token (method));
g_free (tmpsig);
g_free (tmpname);
fprintf (outfile, "\t\t");
count = 0;
prev_offset = 0;
mono_profiler_coverage_get (prof, method, output_entry);
fprintf (outfile, "\n");
fprintf (outfile, "\t</method>\n");
}
static void disasm_method (Package *pkg) {
xmono::DisasmMethodReq req;
xmono::DisasmMethodRsp rsp;
std::string str((char*)pkg->body, pkg->all_len - sizeof (Package)); //Fixme : 修复头部all_len是总长的问题
if (!req.ParseFromString (str)) {
LOGD ("xmono::DisasmMethodReq ParseFromString err!");
return;
}
std::string err("");
MonoMethod *method = get_method_with_token (req.image_name ().c_str (), req.method_token ());
if (!method) err += helper_last_err ();
MonoImage *image = mono_image_loaded (req.image_name ().c_str ());
if (!image) err += " image : " + req.image_name () + " can not be find!";
if (image && method) {
MemWriter writer(4096);
char const *mname = mono_method_full_name (method, 1);
if (mname) {
writer.sprintf ("//[%s]%s[%08X]\n", get_method_image_name (method), mname, mono_method_get_token (method));
g_free (mname);
}
MonoMethodHeader *header = mono_method_get_header (method);
disassemble_cil (image, header, &writer); /*Fixme : disassemble_cil需要在失败时返回更多信息*/
rsp.set_err (true);
LOGD ("writer : %s", writer.getBuffPtr ());
std::string s((char*)writer.getBuffPtr (), writer.getBuffSize ());
rsp.set_disasm_code (s);
//这部分只是测试用的
uint32_t asm_size = 0;
uint8_t const *p = mono_method_header_get_code (header, &asm_size, 0);
std::string asm_code ((char const*)p, asm_size);
rsp.set_asm_code (asm_code);
} else {
rsp.set_err (false);
rsp.set_err_str (err);
}
std::string out;
rsp.SerializeToString (&out);
ecmd_send (XMONO_ID_DISASM_METHOD_RSP, (uint8_t const*)out.c_str (), out.size ());
return;
}
/* FIXME: Do this in the JIT, where specialized allocation sequences can be created
* for each class. This is currently not easy to do, as it is hard to generate basic
* blocks + branches, but it is easy with the linear IL codebase.
*
* For this to work we'd need to solve the TLAB race, first. Now we
* require the allocator to be in a few known methods to make sure
* that they are executed atomically via the restart mechanism.
*/
static MonoMethod*
create_allocator (int atype)
{
int p_var, size_var;
guint32 slowpath_branch, max_size_branch;
MonoMethodBuilder *mb;
MonoMethod *res;
MonoMethodSignature *csig;
static gboolean registered = FALSE;
int tlab_next_addr_var, new_next_var;
int num_params, i;
const char *name = NULL;
AllocatorWrapperInfo *info;
#ifdef HAVE_KW_THREAD
int tlab_next_addr_offset = -1;
int tlab_temp_end_offset = -1;
MONO_THREAD_VAR_OFFSET (tlab_next_addr, tlab_next_addr_offset);
MONO_THREAD_VAR_OFFSET (tlab_temp_end, tlab_temp_end_offset);
g_assert (tlab_next_addr_offset != -1);
g_assert (tlab_temp_end_offset != -1);
#endif
if (!registered) {
mono_register_jit_icall (mono_gc_alloc_obj, "mono_gc_alloc_obj", mono_create_icall_signature ("object ptr int"), FALSE);
mono_register_jit_icall (mono_gc_alloc_vector, "mono_gc_alloc_vector", mono_create_icall_signature ("object ptr int int"), FALSE);
registered = TRUE;
}
if (atype == ATYPE_SMALL) {
num_params = 1;
name = "AllocSmall";
} else if (atype == ATYPE_NORMAL) {
num_params = 1;
name = "Alloc";
} else if (atype == ATYPE_VECTOR) {
num_params = 2;
name = "AllocVector";
} else {
g_assert_not_reached ();
}
csig = mono_metadata_signature_alloc (mono_defaults.corlib, num_params);
csig->ret = &mono_defaults.object_class->byval_arg;
for (i = 0; i < num_params; ++i)
csig->params [i] = &mono_defaults.int_class->byval_arg;
mb = mono_mb_new (mono_defaults.object_class, name, MONO_WRAPPER_ALLOC);
size_var = mono_mb_add_local (mb, &mono_defaults.int32_class->byval_arg);
if (atype == ATYPE_NORMAL || atype == ATYPE_SMALL) {
/* size = vtable->klass->instance_size; */
mono_mb_emit_ldarg (mb, 0);
mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoVTable, klass));
mono_mb_emit_byte (mb, CEE_ADD);
mono_mb_emit_byte (mb, CEE_LDIND_I);
mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoClass, instance_size));
mono_mb_emit_byte (mb, CEE_ADD);
/* FIXME: assert instance_size stays a 4 byte integer */
mono_mb_emit_byte (mb, CEE_LDIND_U4);
mono_mb_emit_stloc (mb, size_var);
} else if (atype == ATYPE_VECTOR) {
MonoExceptionClause *clause;
int pos, pos_leave;
MonoClass *oom_exc_class;
MonoMethod *ctor;
/* n > MONO_ARRAY_MAX_INDEX -> OverflowException */
mono_mb_emit_ldarg (mb, 1);
mono_mb_emit_icon (mb, MONO_ARRAY_MAX_INDEX);
pos = mono_mb_emit_short_branch (mb, CEE_BLE_UN_S);
mono_mb_emit_exception (mb, "OverflowException", NULL);
mono_mb_patch_short_branch (mb, pos);
clause = mono_image_alloc0 (mono_defaults.corlib, sizeof (MonoExceptionClause));
clause->try_offset = mono_mb_get_label (mb);
/* vtable->klass->sizes.element_size */
mono_mb_emit_ldarg (mb, 0);
mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoVTable, klass));
mono_mb_emit_byte (mb, CEE_ADD);
mono_mb_emit_byte (mb, CEE_LDIND_I);
mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoClass, sizes.element_size));
mono_mb_emit_byte (mb, CEE_ADD);
mono_mb_emit_byte (mb, CEE_LDIND_U4);
/* * n */
mono_mb_emit_ldarg (mb, 1);
mono_mb_emit_byte (mb, CEE_MUL_OVF_UN);
/* + sizeof (MonoArray) */
mono_mb_emit_icon (mb, sizeof (MonoArray));
mono_mb_emit_byte (mb, CEE_ADD_OVF_UN);
mono_mb_emit_stloc (mb, size_var);
pos_leave = mono_mb_emit_branch (mb, CEE_LEAVE);
/* catch */
clause->flags = MONO_EXCEPTION_CLAUSE_NONE;
clause->try_len = mono_mb_get_pos (mb) - clause->try_offset;
clause->data.catch_class = mono_class_from_name (mono_defaults.corlib,
"System", "OverflowException");
g_assert (clause->data.catch_class);
clause->handler_offset = mono_mb_get_label (mb);
oom_exc_class = mono_class_from_name (mono_defaults.corlib,
"System", "OutOfMemoryException");
g_assert (oom_exc_class);
ctor = mono_class_get_method_from_name (oom_exc_class, ".ctor", 0);
g_assert (ctor);
mono_mb_emit_byte (mb, CEE_POP);
mono_mb_emit_op (mb, CEE_NEWOBJ, ctor);
mono_mb_emit_byte (mb, CEE_THROW);
clause->handler_len = mono_mb_get_pos (mb) - clause->handler_offset;
mono_mb_set_clauses (mb, 1, clause);
mono_mb_patch_branch (mb, pos_leave);
/* end catch */
} else {
g_assert_not_reached ();
}
/* size += ALLOC_ALIGN - 1; */
mono_mb_emit_ldloc (mb, size_var);
mono_mb_emit_icon (mb, ALLOC_ALIGN - 1);
mono_mb_emit_byte (mb, CEE_ADD);
/* size &= ~(ALLOC_ALIGN - 1); */
mono_mb_emit_icon (mb, ~(ALLOC_ALIGN - 1));
mono_mb_emit_byte (mb, CEE_AND);
mono_mb_emit_stloc (mb, size_var);
/* if (size > MAX_SMALL_OBJ_SIZE) goto slowpath */
if (atype != ATYPE_SMALL) {
mono_mb_emit_ldloc (mb, size_var);
mono_mb_emit_icon (mb, MAX_SMALL_OBJ_SIZE);
max_size_branch = mono_mb_emit_short_branch (mb, MONO_CEE_BGT_UN_S);
}
/*
* We need to modify tlab_next, but the JIT only supports reading, so we read
* another tls var holding its address instead.
*/
/* tlab_next_addr (local) = tlab_next_addr (TLS var) */
tlab_next_addr_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
EMIT_TLS_ACCESS (mb, tlab_next_addr, tlab_next_addr_offset);
mono_mb_emit_stloc (mb, tlab_next_addr_var);
/* p = (void**)tlab_next; */
p_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
mono_mb_emit_ldloc (mb, tlab_next_addr_var);
mono_mb_emit_byte (mb, CEE_LDIND_I);
mono_mb_emit_stloc (mb, p_var);
/* new_next = (char*)p + size; */
new_next_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
mono_mb_emit_ldloc (mb, p_var);
mono_mb_emit_ldloc (mb, size_var);
mono_mb_emit_byte (mb, CEE_CONV_I);
mono_mb_emit_byte (mb, CEE_ADD);
mono_mb_emit_stloc (mb, new_next_var);
/* if (G_LIKELY (new_next < tlab_temp_end)) */
mono_mb_emit_ldloc (mb, new_next_var);
EMIT_TLS_ACCESS (mb, tlab_temp_end, tlab_temp_end_offset);
slowpath_branch = mono_mb_emit_short_branch (mb, MONO_CEE_BLT_UN_S);
/* Slowpath */
if (atype != ATYPE_SMALL)
mono_mb_patch_short_branch (mb, max_size_branch);
mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
mono_mb_emit_byte (mb, CEE_MONO_NOT_TAKEN);
/* FIXME: mono_gc_alloc_obj takes a 'size_t' as an argument, not an int32 */
mono_mb_emit_ldarg (mb, 0);
mono_mb_emit_ldloc (mb, size_var);
if (atype == ATYPE_NORMAL || atype == ATYPE_SMALL) {
mono_mb_emit_icall (mb, mono_gc_alloc_obj);
} else if (atype == ATYPE_VECTOR) {
mono_mb_emit_ldarg (mb, 1);
mono_mb_emit_icall (mb, mono_gc_alloc_vector);
} else {
g_assert_not_reached ();
}
mono_mb_emit_byte (mb, CEE_RET);
/* Fastpath */
mono_mb_patch_short_branch (mb, slowpath_branch);
/* FIXME: Memory barrier */
/* tlab_next = new_next */
mono_mb_emit_ldloc (mb, tlab_next_addr_var);
mono_mb_emit_ldloc (mb, new_next_var);
mono_mb_emit_byte (mb, CEE_STIND_I);
/*The tlab store must be visible before the the vtable store. This could be replaced with a DDS but doing it with IL would be tricky. */
mono_mb_emit_byte ((mb), MONO_CUSTOM_PREFIX);
mono_mb_emit_op (mb, CEE_MONO_MEMORY_BARRIER, StoreStoreBarrier);
/* *p = vtable; */
mono_mb_emit_ldloc (mb, p_var);
mono_mb_emit_ldarg (mb, 0);
mono_mb_emit_byte (mb, CEE_STIND_I);
if (atype == ATYPE_VECTOR) {
/* arr->max_length = max_length; */
mono_mb_emit_ldloc (mb, p_var);
mono_mb_emit_ldflda (mb, G_STRUCT_OFFSET (MonoArray, max_length));
mono_mb_emit_ldarg (mb, 1);
#ifdef MONO_BIG_ARRAYS
mono_mb_emit_byte (mb, CEE_STIND_I);
#else
mono_mb_emit_byte (mb, CEE_STIND_I4);
#endif
}
/*
We must make sure both vtable and max_length are globaly visible before returning to managed land.
*/
mono_mb_emit_byte ((mb), MONO_CUSTOM_PREFIX);
mono_mb_emit_op (mb, CEE_MONO_MEMORY_BARRIER, StoreStoreBarrier);
/* return p */
mono_mb_emit_ldloc (mb, p_var);
mono_mb_emit_byte (mb, CEE_RET);
res = mono_mb_create_method (mb, csig, 8);
mono_mb_free (mb);
mono_method_get_header (res)->init_locals = FALSE;
info = mono_image_alloc0 (mono_defaults.corlib, sizeof (AllocatorWrapperInfo));
info->gc_name = "sgen";
info->alloc_type = atype;
mono_marshal_set_wrapper_info (res, info);
return res;
}
static MonoMethod*
create_allocator (int atype, int offset)
{
int index_var, bytes_var, my_fl_var, my_entry_var;
guint32 no_freelist_branch, not_small_enough_branch = 0;
guint32 size_overflow_branch = 0;
MonoMethodBuilder *mb;
MonoMethod *res;
MonoMethodSignature *csig;
AllocatorWrapperInfo *info;
if (atype == ATYPE_STRING) {
csig = mono_metadata_signature_alloc (mono_defaults.corlib, 2);
csig->ret = &mono_defaults.string_class->byval_arg;
csig->params [0] = &mono_defaults.int_class->byval_arg;
csig->params [1] = &mono_defaults.int32_class->byval_arg;
} else {
csig = mono_metadata_signature_alloc (mono_defaults.corlib, 1);
csig->ret = &mono_defaults.object_class->byval_arg;
csig->params [0] = &mono_defaults.int_class->byval_arg;
}
mb = mono_mb_new (mono_defaults.object_class, "Alloc", MONO_WRAPPER_ALLOC);
bytes_var = mono_mb_add_local (mb, &mono_defaults.int32_class->byval_arg);
if (atype == ATYPE_STRING) {
/* a string alloator method takes the args: (vtable, len) */
/* bytes = (sizeof (MonoString) + ((len + 1) * 2)); */
mono_mb_emit_ldarg (mb, 1);
mono_mb_emit_icon (mb, 1);
mono_mb_emit_byte (mb, MONO_CEE_ADD);
mono_mb_emit_icon (mb, 1);
mono_mb_emit_byte (mb, MONO_CEE_SHL);
// sizeof (MonoString) might include padding
mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoString, chars));
mono_mb_emit_byte (mb, MONO_CEE_ADD);
mono_mb_emit_stloc (mb, bytes_var);
} else {
/* bytes = vtable->klass->instance_size */
mono_mb_emit_ldarg (mb, 0);
mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoVTable, klass));
mono_mb_emit_byte (mb, MONO_CEE_ADD);
mono_mb_emit_byte (mb, MONO_CEE_LDIND_I);
mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoClass, instance_size));
mono_mb_emit_byte (mb, MONO_CEE_ADD);
/* FIXME: assert instance_size stays a 4 byte integer */
mono_mb_emit_byte (mb, MONO_CEE_LDIND_U4);
mono_mb_emit_stloc (mb, bytes_var);
}
/* this is needed for strings/arrays only as the other big types are never allocated with this method */
if (atype == ATYPE_STRING) {
/* check for size */
/* if (!SMALL_ENOUGH (bytes)) jump slow_path;*/
mono_mb_emit_ldloc (mb, bytes_var);
mono_mb_emit_icon (mb, (NFREELISTS-1) * GRANULARITY);
not_small_enough_branch = mono_mb_emit_short_branch (mb, MONO_CEE_BGT_UN_S);
/* check for overflow */
mono_mb_emit_ldloc (mb, bytes_var);
mono_mb_emit_icon (mb, sizeof (MonoString));
size_overflow_branch = mono_mb_emit_short_branch (mb, MONO_CEE_BLE_UN_S);
}
/* int index = INDEX_FROM_BYTES(bytes); */
index_var = mono_mb_add_local (mb, &mono_defaults.int32_class->byval_arg);
mono_mb_emit_ldloc (mb, bytes_var);
mono_mb_emit_icon (mb, GRANULARITY - 1);
mono_mb_emit_byte (mb, MONO_CEE_ADD);
mono_mb_emit_icon (mb, shift_amount (GRANULARITY));
mono_mb_emit_byte (mb, MONO_CEE_SHR_UN);
mono_mb_emit_icon (mb, shift_amount (sizeof (gpointer)));
mono_mb_emit_byte (mb, MONO_CEE_SHL);
/* index var is already adjusted into bytes */
mono_mb_emit_stloc (mb, index_var);
my_fl_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
my_entry_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
/* my_fl = ((GC_thread)tsd) -> ptrfree_freelists + index; */
mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
mono_mb_emit_byte (mb, 0x0D); /* CEE_MONO_TLS */
mono_mb_emit_i4 (mb, offset);
if (atype == ATYPE_FREEPTR || atype == ATYPE_FREEPTR_FOR_BOX || atype == ATYPE_STRING)
mono_mb_emit_icon (mb, G_STRUCT_OFFSET (struct GC_Thread_Rep, ptrfree_freelists));
else if (atype == ATYPE_NORMAL)
mono_mb_emit_icon (mb, G_STRUCT_OFFSET (struct GC_Thread_Rep, normal_freelists));
else if (atype == ATYPE_GCJ)
mono_mb_emit_icon (mb, G_STRUCT_OFFSET (struct GC_Thread_Rep, gcj_freelists));
else
g_assert_not_reached ();
mono_mb_emit_byte (mb, MONO_CEE_ADD);
mono_mb_emit_ldloc (mb, index_var);
mono_mb_emit_byte (mb, MONO_CEE_ADD);
mono_mb_emit_stloc (mb, my_fl_var);
/* my_entry = *my_fl; */
mono_mb_emit_ldloc (mb, my_fl_var);
mono_mb_emit_byte (mb, MONO_CEE_LDIND_I);
mono_mb_emit_stloc (mb, my_entry_var);
/* if (EXPECT((word)my_entry >= HBLKSIZE, 1)) { */
mono_mb_emit_ldloc (mb, my_entry_var);
mono_mb_emit_icon (mb, HBLKSIZE);
no_freelist_branch = mono_mb_emit_short_branch (mb, MONO_CEE_BLT_UN_S);
/* ptr_t next = obj_link(my_entry); *my_fl = next; */
mono_mb_emit_ldloc (mb, my_fl_var);
mono_mb_emit_ldloc (mb, my_entry_var);
mono_mb_emit_byte (mb, MONO_CEE_LDIND_I);
mono_mb_emit_byte (mb, MONO_CEE_STIND_I);
/* set the vtable and clear the words in the object */
mono_mb_emit_ldloc (mb, my_entry_var);
mono_mb_emit_ldarg (mb, 0);
mono_mb_emit_byte (mb, MONO_CEE_STIND_I);
if (atype == ATYPE_FREEPTR) {
int start_var, end_var, start_loop;
/* end = my_entry + bytes; start = my_entry + sizeof (gpointer);
*/
start_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
end_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
mono_mb_emit_ldloc (mb, my_entry_var);
mono_mb_emit_ldloc (mb, bytes_var);
mono_mb_emit_byte (mb, MONO_CEE_ADD);
mono_mb_emit_stloc (mb, end_var);
mono_mb_emit_ldloc (mb, my_entry_var);
mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoObject, synchronisation));
mono_mb_emit_byte (mb, MONO_CEE_ADD);
mono_mb_emit_stloc (mb, start_var);
/*
* do {
* *start++ = NULL;
* } while (start < end);
*/
start_loop = mono_mb_get_label (mb);
mono_mb_emit_ldloc (mb, start_var);
mono_mb_emit_icon (mb, 0);
mono_mb_emit_byte (mb, MONO_CEE_STIND_I);
mono_mb_emit_ldloc (mb, start_var);
mono_mb_emit_icon (mb, sizeof (gpointer));
mono_mb_emit_byte (mb, MONO_CEE_ADD);
mono_mb_emit_stloc (mb, start_var);
mono_mb_emit_ldloc (mb, start_var);
mono_mb_emit_ldloc (mb, end_var);
mono_mb_emit_byte (mb, MONO_CEE_BLT_UN_S);
mono_mb_emit_byte (mb, start_loop - (mono_mb_get_label (mb) + 1));
} else if (atype == ATYPE_FREEPTR_FOR_BOX || atype == ATYPE_STRING) {
/* need to clear just the sync pointer */
mono_mb_emit_ldloc (mb, my_entry_var);
mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoObject, synchronisation));
mono_mb_emit_byte (mb, MONO_CEE_ADD);
mono_mb_emit_icon (mb, 0);
mono_mb_emit_byte (mb, MONO_CEE_STIND_I);
}
if (atype == ATYPE_STRING) {
/* need to set length and clear the last char */
/* s->length = len; */
mono_mb_emit_ldloc (mb, my_entry_var);
mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoString, length));
mono_mb_emit_byte (mb, MONO_CEE_ADD);
mono_mb_emit_ldarg (mb, 1);
mono_mb_emit_byte (mb, MONO_CEE_STIND_I4);
/* s->chars [len] = 0; */
mono_mb_emit_ldloc (mb, my_entry_var);
mono_mb_emit_ldloc (mb, bytes_var);
mono_mb_emit_icon (mb, 2);
mono_mb_emit_byte (mb, MONO_CEE_SUB);
mono_mb_emit_byte (mb, MONO_CEE_ADD);
mono_mb_emit_icon (mb, 0);
mono_mb_emit_byte (mb, MONO_CEE_STIND_I2);
}
/* return my_entry; */
mono_mb_emit_ldloc (mb, my_entry_var);
mono_mb_emit_byte (mb, MONO_CEE_RET);
mono_mb_patch_short_branch (mb, no_freelist_branch);
if (not_small_enough_branch > 0)
mono_mb_patch_short_branch (mb, not_small_enough_branch);
if (size_overflow_branch > 0)
mono_mb_patch_short_branch (mb, size_overflow_branch);
/* the slow path: we just call back into the runtime */
if (atype == ATYPE_STRING) {
mono_mb_emit_ldarg (mb, 1);
mono_mb_emit_icall (mb, mono_string_alloc);
} else {
mono_mb_emit_ldarg (mb, 0);
mono_mb_emit_icall (mb, mono_object_new_specific);
}
mono_mb_emit_byte (mb, MONO_CEE_RET);
res = mono_mb_create_method (mb, csig, 8);
mono_mb_free (mb);
mono_method_get_header (res)->init_locals = FALSE;
info = mono_image_alloc0 (mono_defaults.corlib, sizeof (AllocatorWrapperInfo));
info->gc_name = "boehm";
info->alloc_type = atype;
mono_marshal_set_wrapper_info (res, info);
return res;
}
static void
add_types_from_method (MonoMethod *method) {
const MonoOpcode *opcode;
MonoMethodHeader *header;
const unsigned char *ip, *il_code_end;
gpointer val = NULL, oldkey = NULL;
int i, n;
guint32 token;
MonoClass *klass;
MonoClassField *field;
MonoCustomAttrInfo* cattrs;
MonoType** locals;
gpointer exc_iter;
MonoExceptionClause clause;
if (g_hash_table_lookup_extended (method_table, method, &oldkey, &val))
return;
g_hash_table_insert (method_table, method, NULL);
g_assert (method->klass);
if (verbose > 1)
g_print ("#processing method: %s\n", mono_method_full_name (method, TRUE));
mono_class_init (method->klass);
cattrs = mono_custom_attrs_from_method (method);
handle_cattrs (cattrs);
add_type (method->klass);
add_types_from_signature (mono_method_signature (method));
for (i = 0; i < mono_method_signature (method)->param_count + 1; ++i) {
cattrs = mono_custom_attrs_from_param (method, i);
handle_cattrs (cattrs);
}
if (method->flags & METHOD_ATTRIBUTE_VIRTUAL)
virtual_methods = g_list_prepend (virtual_methods, method);
/* if no IL code to parse, return */
if (method->iflags & (METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL | METHOD_IMPL_ATTRIBUTE_RUNTIME))
return;
if (method->flags & (METHOD_ATTRIBUTE_PINVOKE_IMPL | METHOD_ATTRIBUTE_ABSTRACT))
return;
header = mono_method_get_header (method);
locals = mono_method_header_get_locals (header, &n, NULL);
for (i = 0; i < n; ++i) {
klass = mono_class_from_mono_type (locals [i]);
add_type (klass);
}
for (exc_iter = NULL; mono_method_header_get_clauses (header, method, &exc_iter, &clause);) {
if (clause.flags == MONO_EXCEPTION_CLAUSE_NONE)
add_type (clause.data.catch_class);
}
ip = mono_method_header_get_code (header, &n, NULL);
il_code_end = ip + n;
while (ip < il_code_end) {
if (verbose > 2)
g_print ("#%s", mono_disasm_code_one (NULL, method, ip, NULL));
if (*ip == 0xfe) {
++ip;
i = *ip + 256;
} else {
i = *ip;
}
opcode = &mono_opcodes [i];
switch (opcode->argument) {
case MonoInlineNone:
ip++;
break;
case MonoInlineType:
token = read32 (ip + 1);
add_type (mono_class_get (method->klass->image, token));
ip += 5;
break;
case MonoInlineField: {
token = read32 (ip + 1);
field = mono_field_from_token (method->klass->image, token, &klass, NULL);
add_field (field);
add_type (klass);
ip += 5;
break;
}
case MonoInlineTok:
case MonoInlineSig:
/* FIXME */
case MonoInlineString:
case MonoShortInlineR:
case MonoInlineBrTarget:
case MonoInlineI:
ip += 5;
break;
case MonoInlineVar:
ip += 3;
break;
case MonoShortInlineVar:
case MonoShortInlineI:
case MonoShortInlineBrTarget:
ip += 2;
break;
case MonoInlineSwitch:
++ip;
n = read32 (ip);
ip += 4;
ip += 4 * n;
break;
case MonoInlineI8:
case MonoInlineR:
ip += 9;
break;
case MonoInlineMethod:
{
MonoMethod *cm = mono_get_method (method->klass->image, read32 (ip + 1), NULL);
add_type (cm->klass);
add_types_from_method (cm);
}
ip += 5;
break;
default:
g_assert_not_reached ();
}
}
}
MonoDebugMethodAddress *
mono_debug_add_method (MonoMethod *method, MonoDebugMethodJitInfo *jit, MonoDomain *domain)
{
MonoMethod *declaring;
MonoDebugDataTable *table;
MonoDebugMethodHeader *header;
MonoDebugMethodAddress *address;
MonoDebugMethodInfo *minfo;
MonoDebugHandle *handle;
guint8 buffer [BUFSIZ];
guint8 *ptr, *oldptr;
guint32 i, size, total_size, max_size;
gboolean is_wrapper = FALSE;
mono_debugger_lock ();
table = lookup_data_table (domain);
handle = _mono_debug_get_image (method->klass->image);
minfo = _mono_debug_lookup_method (method);
if (!minfo || (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)) {
is_wrapper = TRUE;
}
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);
size = ptr - oldptr;
g_assert (size < max_size);
total_size = size + sizeof (MonoDebugMethodAddress);
address = (MonoDebugMethodAddress *) allocate_data_item (
table, MONO_DEBUG_DATA_ITEM_METHOD, total_size);
address->header.size = total_size;
address->header.symfile_id = handle ? handle->index : 0;
address->header.domain_id = mono_domain_get_id (domain);
address->header.method_id = is_wrapper ? 0 : minfo->index;
address->header.method = method;
address->code_start = jit->code_start;
address->code_size = jit->code_size;
memcpy (&address->data, oldptr, size);
if (max_size > BUFSIZ)
g_free (oldptr);
declaring = method->is_inflated ? ((MonoMethodInflated *) method)->declaring : method;
header = g_hash_table_lookup (table->method_hash, declaring);
if (!header) {
header = &address->header;
g_hash_table_insert (table->method_hash, declaring, header);
if (is_wrapper) {
const unsigned char* il_code;
MonoMethodHeader *mheader;
MonoDebugWrapperData *wrapper;
guint32 il_codesize;
mheader = mono_method_get_header (declaring);
il_code = mono_method_header_get_code (mheader, &il_codesize, NULL);
header->wrapper_data = wrapper = g_new0 (MonoDebugWrapperData, 1);
wrapper->wrapper_type = method->wrapper_type;
wrapper->method_name = mono_method_full_name (declaring, TRUE);
wrapper->cil_code = mono_disasm_code (
NULL, declaring, il_code, il_code + il_codesize);
}
} else {
address->header.wrapper_data = header->wrapper_data;
header->address_list = g_slist_prepend (header->address_list, address);
}
g_hash_table_insert (table->method_address_hash, method, address);
write_data_item (table, (guint8 *) address);
mono_debugger_unlock ();
return address;
}
static gboolean
collect_coverage_for (MonoProfiler *prof, MonoMethod *method)
{
int i;
char *classname;
char *fqn;
MonoMethodHeader *header;
gboolean has_positive, found;
guint32 iflags, flags, code_size;
MonoClass *klass;
MonoImage *image;
flags = mono_method_get_flags (method, &iflags);
if ((iflags & 0x1000 /*METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL*/) ||
(flags & 0x2000 /*METHOD_ATTRIBUTE_PINVOKE_IMPL*/))
return FALSE;
//if (method->wrapper_type != MONO_WRAPPER_NONE)
// return FALSE;
klass = mono_method_get_class (method);
image = mono_class_get_image (klass);
/* Hacky way of determining the executing assembly */
if (! prof->outfile_name && (strcmp (mono_method_get_name (method), "Main") == 0)) {
prof->outfile_name = g_strdup_printf ("%s.cov", mono_image_get_filename (image));
}
/* Check filters */
if (prof->filters) {
/* Check already filtered classes first */
if (g_hash_table_lookup (prof->filtered_classes, klass))
return FALSE;
classname = mono_type_get_name (mono_class_get_type (klass));
fqn = g_strdup_printf ("[%s]%s", mono_image_get_name (image), classname);
// Check positive filters first
has_positive = FALSE;
found = FALSE;
for (i = 0; i < prof->filters->len; ++i) {
char *filter = g_ptr_array_index (prof->filters_as_str, i);
if (filter [0] == '+') {
filter = &filter [1];
if (strstr (fqn, filter) != NULL)
found = TRUE;
has_positive = TRUE;
}
}
if (has_positive && !found)
return FALSE;
for (i = 0; i < prof->filters->len; ++i) {
// Is substring search suffices ???
// GPatternSpec *spec = g_ptr_array_index (filters, i);
// if (g_pattern_match_string (spec, classname)) {
char *filter = g_ptr_array_index (prof->filters_as_str, i);
if (filter [0] == '+')
continue;
// Skip '-'
filter = &filter [1];
if (strstr (fqn, filter) != NULL) {
g_hash_table_insert (prof->filtered_classes, klass, klass);
return FALSE;
}
}
g_free (fqn);
g_free (classname);
}
header = mono_method_get_header (method);
mono_method_header_get_code (header, &code_size, NULL);
if (code_size > 20000) {
exit (1);
g_warning ("Unable to instrument method %s:%s since it is too complex.", mono_class_get_name (klass), mono_method_get_name (method));
return FALSE;
}
g_hash_table_insert (prof->methods, method, method);
g_hash_table_insert (prof->classes, klass, klass);
g_hash_table_insert (prof->assemblies, mono_image_get_assembly (image), mono_image_get_assembly (image));
return TRUE;
}
static void replace_method (Package *pkg) {
xmono::ReplaceMethodReq req;
xmono::ReplaceMethodRsp rsp;
std::string str((char*)pkg->body, pkg->all_len - sizeof (Package));
if (!req.ParseFromString (str)) {
LOGD ("xmono::ReplaceMethodReq ParseFromString err!");
return;
}
std::string err;
void *p, *old_p;
uint8_t *code;
int code_size;
MonoMethodHeader *mh;
MonoThread *thread;
MonoMethod *new_method;
MonoDomain *domain;
MonoMethod * method = get_method_with_token (req.image_name ().c_str (), req.method_token ());
if (!method) {
rsp.set_err (false);
rsp.set_msg (helper_last_err ());
goto replace_method_end;
}
domain = mono_domain_get_by_id (req.domain_id ());
if (!domain) {
rsp.set_err (false);
rsp.set_msg ("can not get the domain from id");
goto replace_method_end;
}
mh = mono_method_get_header (method);
if (req.ex_size () != mono_method_header_get_num_clauses (mh)) {
rsp.set_err (false);
rsp.set_msg ("ex size != mono_method_header_clauses size!");
goto replace_method_end;
}
for (int i = 0; i < req.ex_size (); i++) {
xmono::ReplaceMethodReq_ExceptionClause const &e = req.ex (i);
void *iter = 0;
MonoExceptionClause *clauses = &mh->clauses[i];
MonoExceptionClause *old_e = (MonoExceptionClause*)iter;
old_e->try_offset = e.try_offset ();
old_e->try_len = e.try_len ();
old_e->handler_offset = e.handler_offset ();
old_e->handler_len = e.handler_len ();
}
code = new uint8_t[req.new_code ().size ()];
memcpy (code, req.new_code ().c_str (), req.new_code ().size ());
mh->code = code;
mh->code_size = req.new_code ().size ();
thread = mono_thread_attach (domain);
/*128 是一个估计值, 在未来可能不稳定, 但当前只能如此*/
new_method = (MonoMethod*)calloc (128, 1); /*这个地方用malloc优于用new*/
memcpy (new_method, method, 128);
pthread_mutex_lock (&replace_mutex);
replace_method_dict[new_method] = true;
pthread_mutex_unlock (&replace_mutex);
p = mono_compile_method (new_method);
memcpy (hooked_method_dict[method]->specific_hook + 4, &p, 4);
pthread_mutex_lock (&hooked_mutex);
old_p = mono_jit_info_get_code_start (hooked_method_dict[method]->jinfo);
pthread_mutex_unlock (&hooked_mutex);
mono_thread_detach (thread);
LOGD ("compile method, new ptr : %p, old ptr : %p", p, old_p);
rsp.set_err (true);
rsp.set_msg ("replace_method successful.");
replace_method_end:
std::string out;
rsp.SerializeToString (&out);
ecmd_send (XMONO_ID_REPLACE_METHOD_RSP, (uint8_t const*)out.c_str (), out.size ());
return;
}
/*反汇编method的IL*/
static char const *disil_method (MonoMethod *method) {
MonoMethodHeader *header = mono_method_get_header (method);
uint32_t len = 0;
uint8_t const *code = mono_method_header_get_code (header, &len, 0);
return mono_disasm_code (0, method, code, code + len);
}
static const unsigned char*
dis_one (GString *str, MonoDisHelper *dh, MonoMethod *method, const unsigned char *ip, const unsigned char *end)
{
MonoMethodHeader *header = mono_method_get_header (method);
const MonoOpcode *opcode;
guint32 label, token;
gint32 sval;
int i;
char *tmp;
const unsigned char* il_code = mono_method_header_get_code (header, NULL, NULL);
label = ip - il_code;
if (dh->indenter) {
tmp = dh->indenter (dh, method, label);
g_string_append (str, tmp);
g_free (tmp);
}
if (dh->label_format)
g_string_append_printf (str, dh->label_format, label);
i = mono_opcode_value (&ip, end);
ip++;
opcode = &mono_opcodes [i];
g_string_append_printf (str, "%-10s", mono_opcode_name (i));
switch (opcode->argument) {
case MonoInlineNone:
break;
case MonoInlineType:
case MonoInlineField:
case MonoInlineMethod:
case MonoInlineTok:
case MonoInlineSig:
token = read32 (ip);
if (dh->tokener) {
tmp = dh->tokener (dh, method, token);
g_string_append (str, tmp);
g_free (tmp);
} else {
g_string_append_printf (str, "0x%08x", token);
}
ip += 4;
break;
case MonoInlineString: {
const char *blob;
char *s;
size_t len2;
char *blob2 = NULL;
if (!image_is_dynamic (method->klass->image) && !method_is_dynamic (method)) {
token = read32 (ip);
blob = mono_metadata_user_string (method->klass->image, mono_metadata_token_index (token));
len2 = mono_metadata_decode_blob_size (blob, &blob);
len2 >>= 1;
#ifdef NO_UNALIGNED_ACCESS
/* The blob might not be 2 byte aligned */
blob2 = g_malloc ((len2 * 2) + 1);
memcpy (blob2, blob, len2 * 2);
#else
blob2 = (char*)blob;
#endif
#if G_BYTE_ORDER != G_LITTLE_ENDIAN
{
guint16 *buf = g_new (guint16, len2 + 1);
int i;
for (i = 0; i < len2; ++i)
buf [i] = GUINT16_FROM_LE (((guint16*)blob2) [i]);
s = g_utf16_to_utf8 (buf, len2, NULL, NULL, NULL);
g_free (buf);
}
#else
s = g_utf16_to_utf8 ((gunichar2*)blob2, len2, NULL, NULL, NULL);
#endif
g_string_append_printf (str, "\"%s\"", s);
g_free (s);
if (blob != blob2)
g_free (blob2);
}
ip += 4;
break;
}
case MonoInlineVar:
g_string_append_printf (str, "%d", read16 (ip));
ip += 2;
break;
case MonoShortInlineVar:
g_string_append_printf (str, "%d", (*ip));
ip ++;
break;
case MonoInlineBrTarget:
sval = read32 (ip);
ip += 4;
if (dh->label_target)
g_string_append_printf (str, dh->label_target, ip + sval - il_code);
else
g_string_append_printf (str, "%d", sval);
break;
case MonoShortInlineBrTarget:
sval = *(const signed char*)ip;
ip ++;
if (dh->label_target)
g_string_append_printf (str, dh->label_target, ip + sval - il_code);
else
g_string_append_printf (str, "%d", sval);
break;
case MonoInlineSwitch: {
const unsigned char *end;
sval = read32 (ip);
ip += 4;
end = ip + sval * 4;
g_string_append_c (str, '(');
for (i = 0; i < sval; ++i) {
if (i > 0)
g_string_append (str, ", ");
label = read32 (ip);
if (dh->label_target)
g_string_append_printf (str, dh->label_target, end + label - il_code);
else
g_string_append_printf (str, "%d", label);
ip += 4;
}
g_string_append_c (str, ')');
break;
}
case MonoInlineR: {
double r;
readr8 (ip, &r);
g_string_append_printf (str, "%g", r);
ip += 8;
break;
}
case MonoShortInlineR: {
float r;
readr4 (ip, &r);
g_string_append_printf (str, "%g", r);
ip += 4;
break;
}
case MonoInlineI:
g_string_append_printf (str, "%d", (gint32)read32 (ip));
ip += 4;
break;
case MonoShortInlineI:
g_string_append_printf (str, "%d", *(const signed char*)ip);
ip ++;
break;
case MonoInlineI8:
ip += 8;
break;
default:
g_assert_not_reached ();
}
/*
* mono_debug_add_vg_method:
*
* Register symbol information for the method with valgrind
*/
static void
mono_debug_add_vg_method (MonoMethod *method, MonoDebugMethodJitInfo *jit)
{
#ifdef VALGRIND_ADD_LINE_INFO
MonoMethodHeader *header;
MonoDebugMethodInfo *minfo;
int i;
char *filename = NULL;
guint32 address, line_number;
const char *full_name;
guint32 *addresses;
guint32 *lines;
if (!RUNNING_ON_VALGRIND)
return;
header = mono_method_get_header (method);
full_name = mono_method_full_name (method, TRUE);
addresses = g_new0 (guint32, header->code_size + 1);
lines = g_new0 (guint32, header->code_size + 1);
/*
* Very simple code to convert the addr->offset mappings that mono has
* into [addr-addr] ->line number mappings.
*/
minfo = mono_debug_lookup_method (method);
if (minfo) {
/* Create offset->line number mapping */
for (i = 0; i < header->code_size; ++i) {
MonoDebugSourceLocation *location;
location = mono_debug_symfile_lookup_location (minfo, i);
if (!location)
continue;
lines [i] = location.row;
if (!filename)
filename = location.source_file;
mono_debug_free_source_location (location);
}
}
/* Create address->offset mapping */
for (i = 0; i < jit->num_line_numbers; ++i) {
MonoDebugLineNumberEntry *lne = jit->line_numbers [i];
g_assert (lne->offset <= header->code_size);
if ((addresses [lne->offset] == 0) || (lne->address < addresses [lne->offset]))
addresses [lne->offset] = lne->address;
}
/* Fill out missing addresses */
address = 0;
for (i = 0; i < header->code_size; ++i) {
if (addresses [i] == 0)
addresses [i] = address;
else
address = addresses [i];
}
address = 0;
line_number = 0;
i = 0;
while (i < header->code_size) {
if (lines [i] == line_number)
i ++;
else {
if (line_number > 0) {
//g_assert (addresses [i] - 1 >= address);
if (addresses [i] - 1 >= address) {
VALGRIND_ADD_LINE_INFO (jit->code_start + address, jit->code_start + addresses [i] - 1, filename, line_number);
//printf ("[%d-%d] -> %d.\n", address, addresses [i] - 1, line_number);
}
}
address = addresses [i];
line_number = lines [i];
}
}
if (line_number > 0) {
VALGRIND_ADD_LINE_INFO (jit->code_start + address, jit->code_start + jit->code_size - 1, filename, line_number);
//printf ("[%d-%d] -> %d.\n", address, jit->code_size - 1, line_number);
}
VALGRIND_ADD_SYMBOL (jit->code_start, jit->code_size, full_name);
g_free (addresses);
g_free (lines);
mono_metadata_free_mh (header);
#endif /* VALGRIND_ADD_LINE_INFO */
}
void CPipeServer::GetMethodHeader()
{
void *method=(void *)ReadQword();
void *result=mono_method_get_header(method);
WriteQword((UINT_PTR)result);
}