/*
* mini.c: The new Mono code generator.
*
- * Author:
+ * Authors:
* Paolo Molaro (lupus@ximian.com)
* Dietmar Maurer (dietmar@ximian.com)
*
- * (C) 2002 Ximian, Inc.
+ * Copyright 2002-2003 Ximian, Inc.
+ * Coprygith 2003-2010 Novell, Inc.
*/
+#define MONO_LLVM_IN_MINI 1
#include <config.h>
#include <signal.h>
#ifdef HAVE_ALLOCA_H
#include <mono/metadata/verify-internals.h>
#include <mono/metadata/mempool-internals.h>
#include <mono/metadata/attach.h>
+#include <mono/metadata/runtime.h>
#include <mono/utils/mono-math.h>
#include <mono/utils/mono-compiler.h>
#include <mono/utils/mono-counters.h>
-#include <mono/utils/mono-logger.h>
+#include <mono/utils/mono-logger-internal.h>
#include <mono/utils/mono-mmap.h>
#include <mono/utils/dtrace.h>
#include "mini.h"
+#include "mini-llvm.h"
#include "tasklets.h"
#include <string.h>
#include <ctype.h>
MonoMethodSignature *helper_sig_class_init_trampoline = NULL;
MonoMethodSignature *helper_sig_domain_get = NULL;
MonoMethodSignature *helper_sig_generic_class_init_trampoline = NULL;
+MonoMethodSignature *helper_sig_generic_class_init_trampoline_llvm = NULL;
MonoMethodSignature *helper_sig_rgctx_lazy_fetch_trampoline = NULL;
MonoMethodSignature *helper_sig_monitor_enter_exit_trampoline = NULL;
MonoMethodSignature *helper_sig_monitor_enter_exit_trampoline_llvm = NULL;
/*
* This flag controls whenever the runtime uses LLVM compiled code.
* Enabling this causes different/slower code paths to be used, which is why it
- * defaults to FALSE if ENABLE_LLVM is not defined, i.e. the runtime is only capable of
- * running AOT code compiled by LLVM.
+ * defaults to FALSE.
* Changes when this flag is set include:
* - a per method vtable trampoline is used to handle virtual calls, instead of only
* one trampoline.
* - fast generic virtual calls are not supported.
*/
-#ifdef ENABLE_LLVM
+#if defined(ENABLE_LLVM) && !defined(MONO_LLVM_LOADED)
gboolean mono_use_llvm = TRUE;
#else
gboolean mono_use_llvm = FALSE;
return FALSE;
}
+typedef struct {
+ MonoExceptionClause *clause;
+ MonoBasicBlock *basic_block;
+ int start_offset;
+} TryBlockHole;
+
typedef struct {
void *ip;
MonoMethod *method;
{
return mono_jump_info_token_new2 (mp, image, token, NULL);
}
+
+/*
+ * mono_tramp_info_create:
+ *
+ * Create a MonoTrampInfo structure from the arguments. This function assumes ownership
+ * of NAME, JI, and UNWIND_OPS.
+ */
+MonoTrampInfo*
+mono_tramp_info_create (const char *name, guint8 *code, guint32 code_size, MonoJumpInfo *ji, GSList *unwind_ops)
+{
+ MonoTrampInfo *info = g_new0 (MonoTrampInfo, 1);
+
+ info->name = (char*)name;
+ info->code = code;
+ info->code_size = code_size;
+ info->ji = ji;
+ info->unwind_ops = unwind_ops;
+
+ return info;
+}
+
+void
+mono_tramp_info_free (MonoTrampInfo *info)
+{
+ g_free (info->name);
+
+ // FIXME: ji + unwind_ops
+}
#define MONO_INIT_VARINFO(vi,id) do { \
(vi)->range.first_use.pos.bid = 0xffff; \
static int
mono_find_block_region_notry (MonoCompile *cfg, int offset)
{
- MonoMethod *method = cfg->method;
- MonoMethodHeader *header = mono_method_get_header (method);
+ MonoMethodHeader *header = cfg->header;
MonoExceptionClause *clause;
int i;
mono_get_block_region_notry (MonoCompile *cfg, int region)
{
if ((region & (0xf << 4)) == MONO_REGION_TRY) {
- MonoMethodHeader *header = mono_method_get_header (cfg->method);
+ MonoMethodHeader *header = cfg->header;
/*
* This can happen if a try clause is nested inside a finally clause.
return FALSE;
}
-static MonoJitICallInfo **emul_opcode_map = NULL;
-
-MonoJitICallInfo *
-mono_find_jit_opcode_emulation (int opcode)
-{
- g_assert (opcode >= 0 && opcode <= OP_LAST);
- if (emul_opcode_map)
- return emul_opcode_map [opcode];
- else
- return NULL;
-}
-
gboolean
mini_assembly_can_skip_verification (MonoDomain *domain, MonoMethod *method)
{
helper_sig_domain_get = mono_create_icall_signature ("ptr");
helper_sig_class_init_trampoline = mono_create_icall_signature ("void");
helper_sig_generic_class_init_trampoline = mono_create_icall_signature ("void");
+ helper_sig_generic_class_init_trampoline_llvm = mono_create_icall_signature ("void ptr");
helper_sig_rgctx_lazy_fetch_trampoline = mono_create_icall_signature ("ptr ptr");
helper_sig_monitor_enter_exit_trampoline = mono_create_icall_signature ("void");
helper_sig_monitor_enter_exit_trampoline_llvm = mono_create_icall_signature ("void object");
#else
case MONO_TYPE_I8:
#endif
-#ifdef HAVE_SGEN_GC
- slot_info = &scalar_stack_slots [MONO_TYPE_I];
- break;
-#else
+ if (cfg->disable_ref_noref_stack_slot_share) {
+ slot_info = &scalar_stack_slots [MONO_TYPE_I];
+ break;
+ }
/* Fall through */
-#endif
case MONO_TYPE_CLASS:
case MONO_TYPE_OBJECT:
#else
case MONO_TYPE_I8:
#endif
-#ifdef HAVE_SGEN_GC
- slot_info = &scalar_stack_slots [MONO_TYPE_I];
- break;
-#else
+ if (cfg->disable_ref_noref_stack_slot_share) {
+ slot_info = &scalar_stack_slots [MONO_TYPE_I];
+ break;
+ }
/* Fall through */
-#endif
case MONO_TYPE_CLASS:
case MONO_TYPE_OBJECT:
return mono_allocate_stack_slots_full (m, TRUE, stack_size, stack_align);
}
+#define EMUL_HIT_SHIFT 3
+#define EMUL_HIT_MASK ((1 << EMUL_HIT_SHIFT) - 1)
+/* small hit bitmap cache */
+static mono_byte emul_opcode_hit_cache [(OP_LAST>>EMUL_HIT_SHIFT) + 1] = {0};
+static short emul_opcode_num = 0;
+static short emul_opcode_alloced = 0;
+static short *emul_opcode_opcodes = NULL;
+static MonoJitICallInfo **emul_opcode_map = NULL;
+
+MonoJitICallInfo *
+mono_find_jit_opcode_emulation (int opcode)
+{
+ g_assert (opcode >= 0 && opcode <= OP_LAST);
+ if (emul_opcode_hit_cache [opcode >> (EMUL_HIT_SHIFT + 3)] & (1 << (opcode & EMUL_HIT_MASK))) {
+ int i;
+ for (i = 0; i < emul_opcode_num; ++i) {
+ if (emul_opcode_opcodes [i] == opcode)
+ return emul_opcode_map [i];
+ }
+ }
+ return NULL;
+}
+
void
mono_register_opcode_emulation (int opcode, const char *name, const char *sigstr, gpointer func, gboolean no_throw)
{
MonoJitICallInfo *info;
MonoMethodSignature *sig = mono_create_icall_signature (sigstr);
- if (!emul_opcode_map)
- emul_opcode_map = g_new0 (MonoJitICallInfo*, OP_LAST + 1);
-
g_assert (!sig->hasthis);
g_assert (sig->param_count < 3);
info = mono_register_jit_icall (func, name, sig, no_throw);
- emul_opcode_map [opcode] = info;
+ if (emul_opcode_num >= emul_opcode_alloced) {
+ int incr = emul_opcode_alloced? emul_opcode_alloced/2: 16;
+ emul_opcode_alloced += incr;
+ emul_opcode_map = g_realloc (emul_opcode_map, sizeof (emul_opcode_map [0]) * emul_opcode_alloced);
+ emul_opcode_opcodes = g_realloc (emul_opcode_opcodes, sizeof (emul_opcode_opcodes [0]) * emul_opcode_alloced);
+ }
+ emul_opcode_map [emul_opcode_num] = info;
+ emul_opcode_opcodes [emul_opcode_num] = opcode;
+ emul_opcode_num++;
+ emul_opcode_hit_cache [opcode >> (EMUL_HIT_SHIFT + 3)] |= (1 << (opcode & EMUL_HIT_MASK));
}
static void
void
mono_destroy_compile (MonoCompile *cfg)
{
+ GSList *l;
+
+ if (cfg->header)
+ mono_metadata_free_mh (cfg->header);
//mono_mempool_stats (cfg->mempool);
mono_free_loop_info (cfg);
if (cfg->rs)
g_hash_table_destroy (cfg->spvars);
if (cfg->exvars)
g_hash_table_destroy (cfg->exvars);
- mono_mempool_destroy (cfg->mempool);
+ for (l = cfg->headers_to_free; l; l = l->next)
+ mono_metadata_free_mh (l->data);
g_list_free (cfg->ldstr_list);
g_hash_table_destroy (cfg->token_info_hash);
if (cfg->abs_patches)
g_hash_table_destroy (cfg->abs_patches);
+ mono_mempool_destroy (cfg->mempool);
g_free (cfg->varinfo);
g_free (cfg->vars);
}
static void
-mono_thread_start_cb (gsize tid, gpointer stack_start, gpointer func)
+mono_thread_start_cb (intptr_t tid, gpointer stack_start, gpointer func)
{
MonoInternalThread *thread;
void *jit_tls = setup_jit_tls_data (stack_start, mono_thread_abort);
}
static void
-mono_thread_attach_cb (gsize tid, gpointer stack_start)
+mono_thread_attach_cb (intptr_t tid, gpointer stack_start)
{
MonoInternalThread *thread;
void *jit_tls = setup_jit_tls_data (stack_start, mono_thread_abort_dummy);
mono_create_tls_get (MonoCompile *cfg, int offset)
{
#ifdef MONO_ARCH_HAVE_TLS_GET
- MonoInst* ins;
-
- if (offset == -1)
- return NULL;
-
- MONO_INST_NEW (cfg, ins, OP_TLS_GET);
- ins->dreg = mono_alloc_preg (cfg);
- ins->inst_offset = offset;
- return ins;
-#else
- return NULL;
+ if (MONO_ARCH_HAVE_TLS_GET) {
+ MonoInst* ins;
+
+ if (offset == -1)
+ return NULL;
+
+ MONO_INST_NEW (cfg, ins, OP_TLS_GET);
+ ins->dreg = mono_alloc_preg (cfg);
+ ins->inst_offset = offset;
+ return ins;
+ }
#endif
+ return NULL;
}
MonoInst*
case MONO_PATCH_INFO_SFLDA: {
MonoVTable *vtable = mono_class_vtable (domain, patch_info->data.field->parent);
+ if (mono_class_field_is_special_static (patch_info->data.field)) {
+ gpointer addr = NULL;
+
+ mono_domain_lock (domain);
+ if (domain->special_static_fields)
+ addr = g_hash_table_lookup (domain->special_static_fields, patch_info->data.field);
+ mono_domain_unlock (domain);
+ g_assert (addr);
+ return addr;
+ }
+
g_assert (vtable);
if (!vtable->initialized && !(vtable->klass->flags & TYPE_ATTRIBUTE_BEFORE_FIELD_INIT) && (method && mono_class_needs_cctor_run (vtable->klass, method)))
/* Done by the generated code */
MonoMethodHeader *header;
int i;
- header = mono_method_get_header (cfg->method);
+ header = cfg->header;
sig = mono_method_signature (cfg->method);
bb->native_offset = cfg->code_len;
//if ((bb == cfg->bb_entry) || !(bb->region == -1 && !bb->dfn))
mono_arch_output_basic_block (cfg, bb);
+ bb->native_length = cfg->code_len - bb->native_offset;
if (bb == cfg->bb_exit) {
cfg->epilog_begin = cfg->code_len;
static MonoJitInfo*
create_jit_info (MonoCompile *cfg, MonoMethod *method_to_compile)
{
+ GSList *tmp;
MonoMethodHeader *header;
MonoJitInfo *jinfo;
int num_clauses;
int generic_info_size;
+ int holes_size = 0, num_holes = 0;
- header = mono_method_get_header (method_to_compile);
+ g_assert (method_to_compile == cfg->method);
+ header = cfg->header;
if (cfg->generic_sharing_context)
generic_info_size = sizeof (MonoGenericJitInfo);
else
generic_info_size = 0;
+ if (cfg->try_block_holes) {
+ for (tmp = cfg->try_block_holes; tmp; tmp = tmp->next) {
+ TryBlockHole *hole = tmp->data;
+ MonoExceptionClause *ec = hole->clause;
+ int hole_end = hole->basic_block->native_offset + hole->basic_block->native_length;
+ MonoBasicBlock *clause_last_bb = cfg->cil_offset_to_bb [ec->try_offset + ec->try_len];
+ g_assert (clause_last_bb);
+
+ /* Holes at the end of a try region can be represented by simply reducing the size of the block itself.*/
+ if (clause_last_bb->native_offset != hole_end)
+ ++num_holes;
+ }
+ if (num_holes)
+ holes_size = sizeof (MonoTryBlockHoleTableJitInfo) + num_holes * sizeof (MonoTryBlockHoleJitInfo);
+ if (G_UNLIKELY (cfg->verbose_level >= 4))
+ printf ("Number of try block holes %d\n", num_holes);
+ }
+
if (COMPILE_LLVM (cfg))
num_clauses = cfg->llvm_ex_info_len;
else
if (cfg->method->dynamic) {
jinfo = g_malloc0 (MONO_SIZEOF_JIT_INFO + (num_clauses * sizeof (MonoJitExceptionInfo)) +
- generic_info_size);
+ generic_info_size + holes_size);
} else {
jinfo = mono_domain_alloc0 (cfg->domain, MONO_SIZEOF_JIT_INFO +
(num_clauses * sizeof (MonoJitExceptionInfo)) +
- generic_info_size);
+ generic_info_size + holes_size);
}
jinfo->method = cfg->method_to_register;
mini_method_get_context (method_to_compile)->method_inst ||
method_to_compile->klass->valuetype) {
inst = cfg->rgctx_var;
- g_assert (inst->opcode == OP_REGOFFSET);
+ if (!COMPILE_LLVM (cfg))
+ g_assert (inst->opcode == OP_REGOFFSET);
} else {
inst = cfg->args [0];
}
- if (inst->opcode == OP_REGVAR) {
+ if (COMPILE_LLVM (cfg)) {
+ g_assert (cfg->llvm_this_reg != -1);
+ gi->this_in_reg = 0;
+ gi->this_reg = cfg->llvm_this_reg;
+ gi->this_offset = cfg->llvm_this_offset;
+ } else if (inst->opcode == OP_REGVAR) {
gi->this_in_reg = 1;
gi->this_reg = inst->dreg;
} else {
}
}
+ if (num_holes) {
+ MonoTryBlockHoleTableJitInfo *table;
+ int i;
+
+ jinfo->has_try_block_holes = 1;
+ table = mono_jit_info_get_try_block_hole_table_info (jinfo);
+ table->num_holes = (guint16)num_holes;
+ i = 0;
+ for (tmp = cfg->try_block_holes; tmp; tmp = tmp->next) {
+ guint32 start_bb_offset;
+ MonoTryBlockHoleJitInfo *hole;
+ TryBlockHole *hole_data = tmp->data;
+ MonoExceptionClause *ec = hole_data->clause;
+ int hole_end = hole_data->basic_block->native_offset + hole_data->basic_block->native_length;
+ MonoBasicBlock *clause_last_bb = cfg->cil_offset_to_bb [ec->try_offset + ec->try_len];
+ g_assert (clause_last_bb);
+
+ /* Holes at the end of a try region can be represented by simply reducing the size of the block itself.*/
+ if (clause_last_bb->native_offset == hole_end)
+ continue;
+
+ start_bb_offset = hole_data->start_offset - hole_data->basic_block->native_offset;
+ hole = &table->holes [i++];
+ hole->clause = hole_data->clause - &header->clauses [0];
+ hole->offset = (guint32)hole_data->start_offset;
+ hole->length = (guint16)(hole_data->basic_block->native_length - start_bb_offset);
+
+ if (G_UNLIKELY (cfg->verbose_level >= 4))
+ printf ("\tTry block hole at eh clause %d offset %x length %x\n", hole->clause, hole->offset, hole->length);
+ }
+ g_assert (i == num_holes);
+ }
+
if (COMPILE_LLVM (cfg)) {
if (num_clauses)
memcpy (&jinfo->clauses [0], &cfg->llvm_ex_info [0], num_clauses * sizeof (MonoJitExceptionInfo));
tblock = cfg->cil_offset_to_bb [ec->handler_offset];
g_assert (tblock);
ei->handler_start = cfg->native_code + tblock->native_offset;
+
+ for (tmp = cfg->try_block_holes; tmp; tmp = tmp->next) {
+ TryBlockHole *hole = tmp->data;
+ gpointer hole_end = cfg->native_code + (hole->basic_block->native_offset + hole->basic_block->native_length);
+ if (hole->clause == ec && hole_end == ei->try_end) {
+ if (G_UNLIKELY (cfg->verbose_level >= 4))
+ printf ("\tShortening try block %d from %x to %x\n", i, (int)((guint8*)ei->try_end - cfg->native_code), hole->start_offset);
+
+ ei->try_end = cfg->native_code + hole->start_offset;
+ break;
+ }
+ }
+
+ if (ec->flags == MONO_EXCEPTION_CLAUSE_FINALLY) {
+ int end_offset;
+ if (ec->handler_offset + ec->handler_len < header->code_size) {
+ tblock = cfg->cil_offset_to_bb [ec->handler_offset + ec->handler_len];
+ g_assert (tblock);
+ end_offset = tblock->native_offset;
+ } else {
+ end_offset = cfg->epilog_begin;
+ }
+ ei->data.handler_end = cfg->native_code + end_offset;
+ }
+ }
+ }
+
+ if (G_UNLIKELY (cfg->verbose_level >= 4)) {
+ int i;
+ for (i = 0; i < jinfo->num_clauses; i++) {
+ MonoJitExceptionInfo *ei = &jinfo->clauses [i];
+ int start = (guint8*)ei->try_start - cfg->native_code;
+ int end = (guint8*)ei->try_end - cfg->native_code;
+ int handler = (guint8*)ei->handler_start - cfg->native_code;
+
+ printf ("JitInfo EH clause %d flags %x try %x-%x handler %x\n", i, ei->flags, start, end, handler);
}
}
return jinfo;
}
+#endif
+
+/*
+ * mini_get_shared_method:
+ *
+ * Return the method which is actually compiled/registered when doing generic sharing.
+ */
+MonoMethod*
+mini_get_shared_method (MonoMethod *method)
+{
+ MonoGenericContext shared_context;
+ MonoMethod *declaring_method, *res;
+ int i;
+ gboolean partial = FALSE;
+
+ if (method->is_generic || method->klass->generic_container)
+ declaring_method = method;
+ else
+ declaring_method = mono_method_get_declaring_generic_method (method);
+
+ if (declaring_method->is_generic)
+ shared_context = mono_method_get_generic_container (declaring_method)->context;
+ else
+ shared_context = declaring_method->klass->generic_container->context;
+
+ /* Handle partial sharing */
+ if (method != declaring_method && method->is_inflated && !mono_method_is_generic_sharable_impl_full (method, FALSE, FALSE)) {
+ MonoGenericContext *context = mono_method_get_context (method);
+ MonoGenericInst *inst;
+ MonoType **type_argv;
+
+ /*
+ * Create the shared context by replacing the ref type arguments with
+ * type parameters, and keeping the rest.
+ */
+ partial = TRUE;
+ inst = context->class_inst;
+ if (inst) {
+ type_argv = g_new0 (MonoType*, inst->type_argc);
+ for (i = 0; i < inst->type_argc; ++i) {
+ if (MONO_TYPE_IS_REFERENCE (inst->type_argv [i]) || inst->type_argv [i]->type == MONO_TYPE_VAR || inst->type_argv [i]->type == MONO_TYPE_MVAR)
+ type_argv [i] = shared_context.class_inst->type_argv [i];
+ else
+ type_argv [i] = inst->type_argv [i];
+ }
+ shared_context.class_inst = mono_metadata_get_generic_inst (inst->type_argc, type_argv);
+ g_free (type_argv);
+ }
+
+ inst = context->method_inst;
+ if (inst) {
+ type_argv = g_new0 (MonoType*, inst->type_argc);
+ for (i = 0; i < inst->type_argc; ++i) {
+ if (MONO_TYPE_IS_REFERENCE (inst->type_argv [i]) || inst->type_argv [i]->type == MONO_TYPE_VAR || inst->type_argv [i]->type == MONO_TYPE_MVAR)
+ type_argv [i] = shared_context.method_inst->type_argv [i];
+ else
+ type_argv [i] = inst->type_argv [i];
+ }
+
+ shared_context.method_inst = mono_metadata_get_generic_inst (inst->type_argc, type_argv);
+ g_free (type_argv);
+ }
+ }
+
+ res = mono_class_inflate_generic_method (declaring_method, &shared_context);
+ if (!partial) {
+ /* The result should be an inflated method whose parent is not inflated */
+ g_assert (!res->klass->is_inflated);
+ }
+ return res;
+}
+
+#ifndef DISABLE_JIT
/*
* mini_method_compile:
* @method: the method to compile
mini_method_compile (MonoMethod *method, guint32 opts, MonoDomain *domain, gboolean run_cctors, gboolean compile_aot, int parts)
{
MonoMethodHeader *header;
+ MonoMethodSignature *sig;
+ MonoError err;
guint8 *ip;
MonoCompile *cfg;
int dfn, i, code_size_ratio;
MONO_PROBE_METHOD_COMPILE_BEGIN (method);
if (compile_aot)
- /* We are passed the original generic method definition */
+ /*
+ * We might get passed the original generic method definition or
+ * instances with type parameters.
+ * FIXME: Remove the method->klass->generic_class limitation.
+ */
try_generic_shared = mono_class_generic_sharing_enabled (method->klass) &&
- (opts & MONO_OPT_GSHARED) && (method->is_generic || method->klass->generic_container);
+ (opts & MONO_OPT_GSHARED) && ((method->is_generic || method->klass->generic_container) || (!method->klass->generic_class && mono_method_is_generic_sharable_impl (method, TRUE)));
else
try_generic_shared = mono_class_generic_sharing_enabled (method->klass) &&
(opts & MONO_OPT_GSHARED) && mono_method_is_generic_sharable_impl (method, FALSE);
mono_stats.generics_unsharable_methods++;
}
- try_llvm = TRUE;
-
-#ifndef ENABLE_LLVM
- try_llvm = FALSE;
-#endif
+ try_llvm = mono_use_llvm;
restart_compile:
if (try_generic_shared) {
- MonoMethod *declaring_method;
- MonoGenericContext *shared_context;
-
- if (compile_aot) {
- declaring_method = method;
- } else {
- declaring_method = mono_method_get_declaring_generic_method (method);
- if (method->klass->generic_class)
- g_assert (method->klass->generic_class->container_class == declaring_method->klass);
- else
- g_assert (method->klass == declaring_method->klass);
- }
-
- if (declaring_method->is_generic)
- shared_context = &(mono_method_get_generic_container (declaring_method)->context);
- else
- shared_context = &declaring_method->klass->generic_container->context;
-
- method_to_compile = mono_class_inflate_generic_method (declaring_method, shared_context);
+ method_to_compile = mini_get_shared_method (method);
g_assert (method_to_compile);
} else {
method_to_compile = method;
cfg = g_new0 (MonoCompile, 1);
cfg->method = method_to_compile;
+ cfg->header = mono_method_get_header (cfg->method);
cfg->mempool = mono_mempool_new ();
cfg->opt = opts;
cfg->prof_options = mono_profiler_get_events ();
}
if (cfg->generic_sharing_context) {
- MonoGenericContext object_context = mono_method_construct_object_context (method_to_compile);
-
- method_to_register = mono_class_inflate_generic_method (method_to_compile, &object_context);
+ method_to_register = method_to_compile;
} else {
g_assert (method == method_to_compile);
method_to_register = method;
}
cfg->method_to_register = method_to_register;
- if (cfg->compile_llvm) {
- /* No way to obtain the location info for 'this' */
- if (try_generic_shared) {
- cfg->exception_message = g_strdup ("gshared");
- cfg->disable_llvm = TRUE;
- }
-
- if (cfg->method->save_lmf) {
- cfg->exception_message = g_strdup ("lmf");
- cfg->disable_llvm = TRUE;
- }
-
- /* FIXME: */
- if (cfg->method->dynamic) {
- cfg->exception_message = g_strdup ("dynamic.");
- cfg->disable_llvm = TRUE;
- }
+ mono_error_init (&err);
+ sig = mono_method_signature_checked (cfg->method, &err);
+ if (!sig) {
+ cfg->exception_type = MONO_EXCEPTION_TYPE_LOAD;
+ cfg->exception_message = g_strdup (mono_error_get_message (&err));
+ mono_error_cleanup (&err);
+ if (MONO_PROBE_METHOD_COMPILE_END_ENABLED ())
+ MONO_PROBE_METHOD_COMPILE_END (method, FALSE);
+ return cfg;
}
- header = mono_method_get_header (method_to_compile);
+ header = cfg->header;
if (!header) {
MonoLoaderError *error;
return cfg;
}
- if (FALSE && header->clauses) {
- /*
- * Cannot be enabled until LLVM supports implicit exceptions, or we use
- * explicit checks, or we disable this for methods which might throw implicit
- * exceptions inside clauses.
- */
- cfg->exception_message = g_strdup ("clauses");
- cfg->disable_llvm = TRUE;
- }
-
#ifdef ENABLE_LLVM
{
static gboolean inited;
mono_counters_register ("Methods JITted using mono JIT", MONO_COUNTER_JIT | MONO_COUNTER_INT, &methods_without_llvm);
inited = TRUE;
}
-
+
/*
* Check for methods which cannot be compiled by LLVM early, to avoid
* the extra compilation pass.
*/
- if (COMPILE_LLVM (cfg) && cfg->disable_llvm) {
- if (cfg->verbose_level >= 1) {
- //nm = mono_method_full_name (cfg->method, TRUE);
- printf ("LLVM failed for '%s': %s\n", method->name, cfg->exception_message);
- //g_free (nm);
+ if (COMPILE_LLVM (cfg)) {
+ mono_llvm_check_method_supported (cfg);
+ if (cfg->disable_llvm) {
+ if (cfg->verbose_level >= 1) {
+ //nm = mono_method_full_name (cfg->method, TRUE);
+ printf ("LLVM failed for '%s': %s\n", method->name, cfg->exception_message);
+ //g_free (nm);
+ }
+ InterlockedIncrement (&methods_without_llvm);
+ mono_destroy_compile (cfg);
+ try_llvm = FALSE;
+ goto restart_compile;
}
- InterlockedIncrement (&methods_without_llvm);
- mono_destroy_compile (cfg);
- try_llvm = FALSE;
- goto restart_compile;
}
}
#endif
cfg->compute_precise_live_ranges = TRUE;
}
- mini_gc_init_gc_map (cfg);
+ mini_gc_init_cfg (cfg);
if (COMPILE_LLVM (cfg)) {
cfg->opt |= MONO_OPT_ABCREM;
if (getenv ("MONO_VERBOSE_METHOD")) {
char *name = getenv ("MONO_VERBOSE_METHOD");
- if (strchr (name, '.') || strchr (name, ':')) {
+ if ((strchr (name, '.') > name) || strchr (name, ':')) {
MonoMethodDesc *desc;
desc = mono_method_desc_new (name, TRUE);
if (COMPILE_LLVM (cfg))
g_print ("converting llvm method %s\n", mono_method_full_name (method, TRUE));
else if (cfg->generic_sharing_context)
- g_print ("converting shared method %s\n", mono_method_full_name (method, TRUE));
+ g_print ("converting shared method %s\n", mono_method_full_name (method_to_compile, TRUE));
else
g_print ("converting method %s\n", mono_method_full_name (method, TRUE));
}
mono_decompose_array_access_opts (cfg);
if (cfg->got_var) {
+#ifndef MONO_ARCH_GOT_REG
GList *regs;
+#endif
+ int got_reg;
g_assert (cfg->got_var_allocated);
* branches problem. Testcase: mcs crash in
* System.MonoCustomAttrs:GetCustomAttributes.
*/
+#ifdef MONO_ARCH_GOT_REG
+ got_reg = MONO_ARCH_GOT_REG;
+#else
regs = mono_arch_get_global_int_regs (cfg);
g_assert (regs);
+ got_reg = GPOINTER_TO_INT (regs->data);
+ g_list_free (regs);
+#endif
cfg->got_var->opcode = OP_REGVAR;
- cfg->got_var->dreg = GPOINTER_TO_INT (regs->data);
+ cfg->got_var->dreg = got_reg;
cfg->used_int_regs |= 1LL << cfg->got_var->dreg;
-
- g_list_free (regs);
}
/*
}
if ((cfg->opt & MONO_OPT_LINEARS) && !cfg->globalra) {
- GList *vars, *regs;
+ GList *vars, *regs, *l;
/* fixme: maybe we can avoid to compute livenesss here if already computed ? */
cfg->comp_done &= ~MONO_COMP_LIVENESS;
if ((vars = mono_arch_get_allocatable_int_vars (cfg))) {
regs = mono_arch_get_global_int_regs (cfg);
- if (cfg->got_var)
- regs = g_list_delete_link (regs, regs);
+ /* Remove the reg reserved for holding the GOT address */
+ if (cfg->got_var) {
+ for (l = regs; l; l = l->next) {
+ if (GPOINTER_TO_UINT (l->data) == cfg->got_var->dreg) {
+ regs = g_list_delete_link (regs, l);
+ break;
+ }
+ }
+ }
mono_linear_scan (cfg, vars, regs, &cfg->used_int_regs);
}
}
g_free (mono_jit_stats.biggest_method);
mono_jit_stats.biggest_method = g_strdup_printf ("%s::%s)", method->klass->name, method->name);
}
- code_size_ratio = (code_size_ratio * 100) / mono_method_get_header (method)->code_size;
+ code_size_ratio = (code_size_ratio * 100) / header->code_size;
if (code_size_ratio > mono_jit_stats.max_code_size_ratio && mono_jit_stats.enabled) {
mono_jit_stats.max_code_size_ratio = code_size_ratio;
g_free (mono_jit_stats.max_ratio_method);
#endif /* DISABLE_JIT */
-static MonoJitInfo*
-lookup_generic_method (MonoDomain *domain, MonoMethod *method)
+MonoJitInfo*
+mono_domain_lookup_shared_generic (MonoDomain *domain, MonoMethod *method)
{
- MonoMethod *open_method;
+ static gboolean inited = FALSE;
+ static int lookups = 0;
+ static int failed_lookups = 0;
+ MonoJitInfo *ji;
- if (!mono_method_is_generic_sharable_impl (method, FALSE))
- return NULL;
+ ji = mono_internal_hash_table_lookup (&domain->jit_code_hash, mini_get_shared_method (method));
+ if (ji && !ji->has_generic_jit_info)
+ ji = NULL;
+
+ if (!inited) {
+ mono_counters_register ("Shared generic lookups", MONO_COUNTER_INT|MONO_COUNTER_GENERICS, &lookups);
+ mono_counters_register ("Failed shared generic lookups", MONO_COUNTER_INT|MONO_COUNTER_GENERICS, &failed_lookups);
+ inited = TRUE;
+ }
- open_method = mono_method_get_declaring_generic_method (method);
+ ++lookups;
+ if (!ji)
+ ++failed_lookups;
- return mono_domain_lookup_shared_generic (domain, open_method);
+ return ji;
}
/*
if (ji)
return ji;
- return lookup_generic_method (domain, method);
+ if (!mono_method_is_generic_sharable_impl (method, FALSE))
+ return NULL;
+ return mono_domain_lookup_shared_generic (domain, method);
}
static MonoJitInfo*
return info;
}
+#if ENABLE_JIT_MAP
+static FILE* perf_map_file = NULL;
+
+void
+mono_enable_jit_map (void)
+{
+ if (!perf_map_file) {
+ char name [64];
+ g_snprintf (name, sizeof (name), "/tmp/perf-%d.map", getpid ());
+ unlink (name);
+ perf_map_file = fopen (name, "w");
+ }
+}
+
+void
+mono_emit_jit_tramp (void *start, int size, const char *desc)
+{
+ if (perf_map_file)
+ fprintf (perf_map_file, "%llx %x %s\n", (long long unsigned int)(gsize)start, size, desc);
+}
+
+void
+mono_emit_jit_map (MonoJitInfo *jinfo)
+{
+ if (perf_map_file) {
+ char *name = mono_method_full_name (jinfo->method, TRUE);
+ mono_emit_jit_tramp (jinfo->code_start, jinfo->code_size, name);
+ g_free (name);
+ }
+}
+#endif
+
static gpointer
mono_jit_compile_method_inner (MonoMethod *method, MonoDomain *target_domain, int opt, MonoException **jit_ex)
{
mono_destroy_compile (cfg);
+#ifndef DISABLE_JIT
if (domain_jit_info (target_domain)->jump_target_hash) {
MonoJumpInfo patch_info;
GSList *list, *tmp;
g_slist_free (list);
}
+ mono_emit_jit_map (jinfo);
+#endif
mono_domain_unlock (target_domain);
mono_loader_unlock ();
vtable = mono_class_vtable (target_domain, method->klass);
if (!vtable) {
- MonoException *exc;
- exc = mono_class_get_exception_for_failure (method->klass);
- g_assert (exc);
- mono_raise_exception (exc);
+ ex = mono_class_get_exception_for_failure (method->klass);
+ g_assert (ex);
+ *jit_ex = ex;
+ return NULL;
}
if (prof_options & MONO_PROFILE_JIT_COMPILATION) {
- if (method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE)
- /* The profiler doesn't know about wrappers, so pass the original icall method */
- mono_profiler_method_end_jit (mono_marshal_method_from_wrapper (method), jinfo, MONO_PROFILE_OK);
- else
+ if (method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE) {
+ if (mono_marshal_method_from_wrapper (method)) {
+ /* Native func wrappers have no method */
+ /* The profiler doesn't know about wrappers, so pass the original icall method */
+ mono_profiler_method_end_jit (mono_marshal_method_from_wrapper (method), jinfo, MONO_PROFILE_OK);
+ }
+ } else {
mono_profiler_method_end_jit (method, jinfo, MONO_PROFILE_OK);
+ }
}
- mono_runtime_class_init (vtable);
+ ex = mono_runtime_class_init_full (vtable, FALSE);
+ if (ex) {
+ *jit_ex = ex;
+ return NULL;
+ }
return code;
}
* We need this here because mono_marshal_get_runtime_invoke can place
* the helper method in System.Object and not the target class.
*/
- mono_runtime_class_init (info->vtable);
+ if (exc) {
+ *exc = (MonoObject*)mono_runtime_class_init_full (info->vtable, FALSE);
+ if (*exc)
+ return NULL;
+ } else {
+ mono_runtime_class_init (info->vtable);
+ }
+
+ /* The wrappers expect this to be initialized to NULL */
+ if (exc)
+ *exc = NULL;
#ifdef MONO_ARCH_DYN_CALL_SUPPORTED
if (info->dyn_call_info) {
mono_arch_handle_exception (ctx, exc, FALSE);
}
+#if defined(MONO_ARCH_USE_SIGACTION) || defined(HOST_WIN32)
+#define HAVE_SIG_INFO
+#endif
+
void
SIG_HANDLER_SIGNATURE (mono_sigsegv_signal_handler)
{
-#ifndef MONO_ARCH_SIGSEGV_ON_ALTSTACK
- MonoException *exc = NULL;
-#endif
MonoJitInfo *ji;
MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
GET_CONTEXT;
-#ifdef MONO_ARCH_SOFT_DEBUG_SUPPORTED
+#if defined(MONO_ARCH_SOFT_DEBUG_SUPPORTED) && defined(HAVE_SIG_INFO)
if (mono_arch_is_single_step_event (info, ctx)) {
mono_debugger_agent_single_step_event (ctx);
return;
}
#endif
-#ifndef HOST_WIN32
+#if !defined(HOST_WIN32) && defined(HAVE_SIG_INFO)
if (mono_aot_is_pagefault (info->si_addr)) {
mono_aot_handle_pagefault (info->si_addr);
return;
mono_handle_native_sigsegv (SIGSEGV, ctx);
}
- mono_arch_handle_exception (ctx, exc, FALSE);
+ mono_arch_handle_exception (ctx, NULL, FALSE);
#endif
}
return mono_get_addr_from_ftnptr (addr);
}
-#ifdef MONO_ARCH_HAVE_IMT
-static G_GNUC_UNUSED gpointer
-mini_get_imt_trampoline (void)
-{
- static gpointer tramp = NULL;
- if (!tramp)
- tramp = mono_create_specific_trampoline (MONO_FAKE_IMT_METHOD, MONO_TRAMPOLINE_JIT, mono_get_root_domain (), NULL);
- return tramp;
-}
-#endif
+static gpointer *vtable_trampolines;
+static int vtable_trampolines_size;
gpointer
mini_get_vtable_trampoline (int slot_index)
{
- static gpointer tramp = NULL;
+ int index = slot_index + MONO_IMT_SIZE;
- if (!tramp)
- tramp = mono_create_specific_trampoline (MONO_FAKE_VTABLE_METHOD, MONO_TRAMPOLINE_JIT, mono_get_root_domain (), NULL);
- return tramp;
+ g_assert (slot_index >= - MONO_IMT_SIZE);
+ if (!vtable_trampolines || slot_index + MONO_IMT_SIZE >= vtable_trampolines_size) {
+ mono_jit_lock ();
+ if (!vtable_trampolines || index >= vtable_trampolines_size) {
+ int new_size;
+ gpointer new_table;
+
+ new_size = vtable_trampolines_size ? vtable_trampolines_size * 2 : 128;
+ while (new_size <= index)
+ new_size *= 2;
+ new_table = g_new0 (gpointer, new_size);
+
+ if (vtable_trampolines)
+ memcpy (new_table, vtable_trampolines, vtable_trampolines_size * sizeof (gpointer));
+ mono_memory_barrier ();
+ vtable_trampolines = new_table;
+ vtable_trampolines_size = new_size;
+ }
+ mono_jit_unlock ();
+ }
+
+ if (!vtable_trampolines [index])
+ vtable_trampolines [index] = mono_create_specific_trampoline (GUINT_TO_POINTER (slot_index), MONO_TRAMPOLINE_VCALL, mono_get_root_domain (), NULL);
+ return vtable_trampolines [index];
+}
+
+static gpointer
+mini_get_imt_trampoline (int slot_index)
+{
+ return mini_get_vtable_trampoline (slot_index - MONO_IMT_SIZE);
}
static void
#endif
#ifdef MONO_ARCH_HAVE_TLS_GET
- mono_runtime_set_has_tls_get (TRUE);
+ mono_runtime_set_has_tls_get (MONO_ARCH_HAVE_TLS_GET);
#else
mono_runtime_set_has_tls_get (FALSE);
#endif
#ifdef MONO_ARCH_HAVE_IMT
if (mono_use_imt) {
- if (!mono_use_llvm) {
- /* LLVM needs a per-method vtable trampoline */
- callbacks.get_vtable_trampoline = mini_get_vtable_trampoline;
- }
+ callbacks.get_vtable_trampoline = mini_get_vtable_trampoline;
+ callbacks.get_imt_trampoline = mini_get_imt_trampoline;
}
#endif
}
#ifdef ENABLE_LLVM
- mono_llvm_init ();
+ if (!mono_llvm_load (NULL)) {
+ mono_use_llvm = FALSE;
+ fprintf (stderr, "Mono Warning: llvm support could not be loaded.\n");
+ }
+ if (mono_use_llvm)
+ mono_llvm_init ();
#endif
mono_trampolines_init ();
if (!g_thread_supported ())
g_thread_init (NULL);
- mono_gc_base_init ();
-
mono_jit_tls_id = TlsAlloc ();
setup_jit_tls_data ((gpointer)-1, mono_thread_abort);
#ifdef JIT_TRAMPOLINES_WORK
mono_install_compile_method (mono_jit_compile_method);
mono_install_free_method (mono_jit_free_method);
-#ifdef MONO_ARCH_LLVM_SUPPORTED
- if (mono_use_llvm)
- /* The runtime currently only uses this for filling out vtables */
- mono_install_trampoline (mono_create_llvm_vcall_trampoline);
- else
- mono_install_trampoline (mono_create_jit_trampoline);
-#else
mono_install_trampoline (mono_create_jit_trampoline);
-#endif
mono_install_jump_trampoline (mono_create_jump_trampoline);
mono_install_remoting_trampoline (mono_jit_create_remoting_trampoline);
mono_install_delegate_trampoline (mono_create_delegate_trampoline);
mono_install_imt_thunk_builder (mono_aot_get_imt_thunk);
else
mono_install_imt_thunk_builder (mono_arch_build_imt_thunk);
- if (!mono_use_llvm) {
- /*
- * The imt code in mono_magic_trampoline () can't handle LLVM code. By disabling
- * this, we force iface calls to go through the llvm vcall trampoline.
- */
- mono_install_imt_trampoline (mini_get_imt_trampoline ());
- }
}
#endif
register_icall (mono_get_throw_exception (), "mono_arch_throw_exception", "void object", TRUE);
register_icall (mono_get_rethrow_exception (), "mono_arch_rethrow_exception", "void object", TRUE);
-#ifdef MONO_ARCH_HAVE_THROW_EXCEPTION_BY_NAME
- register_icall (mono_get_throw_exception_by_name (), "mono_arch_throw_exception_by_name", "void ptr", TRUE);
-#endif
#if MONO_ARCH_HAVE_THROW_CORLIB_EXCEPTION
register_icall (mono_get_throw_corlib_exception (), "mono_arch_throw_corlib_exception",
"void ptr", TRUE);
register_icall (mono_isfinite, "mono_isfinite", "uint32 double", FALSE);
#endif
+#ifdef COMPRESSED_INTERFACE_BITMAP
+ register_icall (mono_class_interface_match, "mono_class_interface_match", "uint32 ptr int32", TRUE);
+#endif
+
#if SIZEOF_REGISTER == 4
mono_register_opcode_emulation (OP_FCONV_TO_U, "__emul_fconv_to_u", "uint32 double", mono_fconv_u4, TRUE);
#endif
register_icall (mono_array_new_2, "mono_array_new_2", "object ptr int int", FALSE);
register_icall (mono_array_new_3, "mono_array_new_3", "object ptr int int int", FALSE);
register_icall (mono_get_native_calli_wrapper, "mono_get_native_calli_wrapper", "ptr ptr ptr ptr", FALSE);
+ register_icall (mono_resume_unwind, "mono_resume_unwind", "void", TRUE);
+
+#ifdef HAVE_WRITE_BARRIERS
+ register_icall (mono_gc_wbarrier_value_copy_bitmap, "mono_gc_wbarrier_value_copy_bitmap", "void ptr ptr int int", FALSE);
+#endif
+
#endif
mono_generic_sharing_init ();
g_print ("JIT info table lookups: %ld\n", mono_stats.jit_info_table_lookup_count);
g_print ("Hazardous pointers: %ld\n", mono_stats.hazardous_pointer_count);
-#ifdef HAVE_SGEN_GC
g_print ("Minor GC collections: %ld\n", mono_stats.minor_gc_count);
-#endif
g_print ("Major GC collections: %ld\n", mono_stats.major_gc_count);
-#ifdef HAVE_SGEN_GC
g_print ("Minor GC time in msecs: %lf\n", (double)mono_stats.minor_gc_time_usecs / 1000.0);
-#endif
g_print ("Major GC time in msecs: %lf\n", (double)mono_stats.major_gc_time_usecs / 1000.0);
if (mono_security_get_mode () == MONO_SECURITY_MODE_CAS) {
g_print ("\nDecl security check : %ld\n", mono_jit_stats.cas_declsec_check);
cominterop_release_all_rcws ();
#endif
+ mono_runtime_shutdown ();
+
#ifndef MONO_CROSS_COMPILE
/*
* mono_runtime_cleanup() and mono_domain_finalize () need to
mono_debugger_cleanup ();
#ifdef ENABLE_LLVM
- mono_llvm_cleanup ();
+ if (mono_use_llvm)
+ mono_llvm_cleanup ();
#endif
mono_trampolines_cleanup ();
mono_code_manager_destroy (global_codeman);
g_hash_table_destroy (jit_icall_name_hash);
g_free (emul_opcode_map);
+ g_free (emul_opcode_opcodes);
mono_arch_cleanup ();
return mono_arch_instrument_epilog_full (cfg, func, p, enable_arguments, FALSE);
}
+void
+mono_cfg_add_try_hole (MonoCompile *cfg, MonoExceptionClause *clause, guint8 *start, MonoBasicBlock *bb)
+{
+ TryBlockHole *hole = mono_mempool_alloc (cfg->mempool, sizeof (TryBlockHole));
+ hole->clause = clause;
+ hole->start_offset = start - cfg->native_code;
+ hole->basic_block = bb;
+
+ cfg->try_block_holes = g_slist_append_mempool (cfg->mempool, cfg->try_block_holes, hole);
+}
+
#endif
projects / mono.git / blobdiff