#include <math.h>
#include <locale.h>
-#include <mono/os/gc_wrapper.h>
+#include <mono/utils/gc_wrapper.h>
#ifdef HAVE_ALLOCA_H
# include <alloca.h>
ves_real_abort (int line, MonoMethod *mh,
const unsigned short *ip, stackval *stack, stackval *sp)
{
- MonoMethodNormal *mm = (MonoMethodNormal *)mh;
fprintf (stderr, "Execution aborted in method: %s::%s\n", mh->klass->name, mh->name);
fprintf (stderr, "Line=%d IP=0x%04x, Aborted execution\n", line,
- ip-(const unsigned short *)mm->header->code);
+ ip-(const unsigned short *)mono_method_get_header (mh)->code);
g_print ("0x%04x %02x\n",
- ip-(const unsigned short *)mm->header->code, *ip);
+ ip-(const unsigned short *)mono_method_get_header (mh)->code, *ip);
if (sp > stack)
printf ("\t[%d] 0x%08x %0.5f\n", sp-stack, sp[-1].data.i, sp[-1].data.f);
}
} while (0);
static gpointer
-interp_create_remoting_trampoline (MonoMethod *method)
+interp_create_remoting_trampoline (MonoMethod *method, MonoRemotingTarget target)
{
- return mono_interp_get_runtime_method (mono_marshal_get_remoting_invoke (method));
+ return mono_interp_get_runtime_method (mono_marshal_get_remoting_invoke_for_target (method, target));
}
-static CRITICAL_SECTION runtime_method_lookup_section;
+static mono_mutex_t runtime_method_lookup_section;
RuntimeMethod*
mono_interp_get_runtime_method (MonoMethod *method)
MonoDomain *domain = mono_domain_get ();
RuntimeMethod *rtm;
- EnterCriticalSection (&runtime_method_lookup_section);
- if ((rtm = g_hash_table_lookup (domain->jit_code_hash, method))) {
- LeaveCriticalSection (&runtime_method_lookup_section);
+ mono_mutex_lock (&runtime_method_lookup_section);
+ if ((rtm = mono_internal_hash_table_lookup (&domain->jit_code_hash, method))) {
+ mono_mutex_unlock (&runtime_method_lookup_section);
return rtm;
}
rtm = mono_mempool_alloc (domain->mp, sizeof (RuntimeMethod));
memset (rtm, 0, sizeof (*rtm));
rtm->method = method;
- rtm->param_count = method->signature->param_count;
- rtm->hasthis = method->signature->hasthis;
+ rtm->param_count = mono_method_signature (method)->param_count;
+ rtm->hasthis = mono_method_signature (method)->hasthis;
rtm->valuetype = method->klass->valuetype;
- g_hash_table_insert (domain->jit_code_hash, method, rtm);
- LeaveCriticalSection (&runtime_method_lookup_section);
+ mono_internal_hash_table_insert (&domain->jit_code_hash, method, rtm);
+ mono_mutex_unlock (&runtime_method_lookup_section);
return rtm;
}
esize = mono_array_element_size (ac);
ea = mono_array_addr_with_size (ao, esize, pos);
- mt = frame->runtime_method->method->signature->params [ac->rank];
+ mt = mono_method_signature (frame->runtime_method->method)->params [ac->rank];
stackval_to_data (mt, &sp [ac->rank], ea, FALSE);
}
esize = mono_array_element_size (ac);
ea = mono_array_addr_with_size (ao, esize, pos);
- mt = frame->runtime_method->method->signature->ret;
+ mt = mono_method_signature (frame->runtime_method->method)->ret;
stackval_from_data (mt, frame->retval, ea, FALSE);
}
}
static void
-interp_walk_stack (MonoStackWalk func, gpointer user_data)
+interp_walk_stack (MonoStackWalk func, gboolean do_il_offset, gpointer user_data)
{
ThreadContext *context = TlsGetValue (thread_context_id);
- MonoInvocation *frame = context->current_frame;
+ MonoInvocation *frame;
int il_offset;
MonoMethodHeader *hd;
+ if (!context) return;
+
+ frame = context->current_frame;
+
while (frame) {
gboolean managed = FALSE;
MonoMethod *method = frame->runtime_method->method;
(method->iflags & (METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL | METHOD_IMPL_ATTRIBUTE_RUNTIME)))
il_offset = -1;
else {
- hd = ((MonoMethodNormal*)method)->header;
+ hd = mono_method_get_header (method);
il_offset = frame->ip - (const unsigned short *)hd->code;
if (!method->wrapper_type)
managed = TRUE;
return g_string_free (str, FALSE);
while (s < sp) {
- g_string_sprintfa (str, "[%lld/0x%0llx] ", s->data.l, s->data.l);
+ g_string_append_printf (str, "[%lld/0x%0llx] ", s->data.l, s->data.l);
++s;
}
return g_string_free (str, FALSE);
case MONO_TYPE_U4:
case MONO_TYPE_CHAR:
case MONO_TYPE_BOOLEAN:
- g_string_sprintfa (str, "[%d] ", s->data.i);
+ g_string_append_printf (str, "[%d] ", s->data.i);
break;
case MONO_TYPE_STRING:
case MONO_TYPE_SZARRAY:
case MONO_TYPE_PTR:
case MONO_TYPE_I:
case MONO_TYPE_U:
- g_string_sprintfa (str, "[%p] ", s->data.p);
+ g_string_append_printf (str, "[%p] ", s->data.p);
break;
case MONO_TYPE_VALUETYPE:
if (type->data.klass->enumtype)
- g_string_sprintfa (str, "[%d] ", s->data.i);
+ g_string_append_printf (str, "[%d] ", s->data.i);
else
- g_string_sprintfa (str, "[vt:%p] ", s->data.p);
+ g_string_append_printf (str, "[vt:%p] ", s->data.p);
break;
case MONO_TYPE_R4:
case MONO_TYPE_R8:
- g_string_sprintfa (str, "[%g] ", s->data.f);
+ g_string_append_printf (str, "[%g] ", s->data.f);
break;
case MONO_TYPE_I8:
case MONO_TYPE_U8:
default:
- g_string_sprintfa (str, "[%lld/0x%0llx] ", s->data.l, s->data.l);
+ g_string_append_printf (str, "[%lld/0x%0llx] ", s->data.l, s->data.l);
break;
}
}
{
GString *str = g_string_new ("");
int i;
- MonoMethodSignature *signature = inv->runtime_method->method->signature;
+ MonoMethodSignature *signature = mono_method_signature (inv->runtime_method->method);
if (signature->param_count == 0)
return g_string_free (str, FALSE);
if (signature->hasthis)
- g_string_sprintfa (str, "%p ", inv->obj);
+ g_string_append_printf (str, "%p ", inv->obj);
for (i = 0; i < signature->param_count; ++i)
dump_stackval (str, inv->stack_args + i, signature->params [i]);
dump_retval (MonoInvocation *inv)
{
GString *str = g_string_new ("");
- MonoType *ret = inv->runtime_method->method->signature->ret;
+ MonoType *ret = mono_method_signature (inv->runtime_method->method)->ret;
if (ret->type != MONO_TYPE_VOID)
dump_stackval (str, inv->retval, ret);
if ((method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) == 0 &&
(method->iflags & METHOD_IMPL_ATTRIBUTE_RUNTIME) == 0) {
- MonoMethodHeader *hd = ((MonoMethodNormal *)method)->header;
+ MonoMethodHeader *hd = mono_method_get_header (method);
if (hd != NULL) {
if (inv->ip) {
args = dump_args (inv);
name = mono_method_full_name (method, TRUE);
if (source)
- g_string_sprintfa (str, "#%d: 0x%05x %-10s in %s (%s) at %s\n", i, codep, opname,
+ g_string_append_printf (str, "#%d: 0x%05x %-10s in %s (%s) at %s\n", i, codep, opname,
name, args, source);
else
- g_string_sprintfa (str, "#%d: 0x%05x %-10s in %s (%s)\n", i, codep, opname,
+ g_string_append_printf (str, "#%d: 0x%05x %-10s in %s (%s)\n", i, codep, opname,
name, args);
g_free (name);
g_free (args);
MonoInvocation frame;
ThreadContext * volatile context = TlsGetValue (thread_context_id);
MonoObject *retval = NULL;
- MonoMethodSignature *sig = method->signature;
+ MonoMethodSignature *sig = mono_method_signature (method);
MonoClass *klass = mono_class_from_mono_type (sig->ret);
int i, type, isobject = 0;
void *ret = NULL;
context->managed_code = 0;
switch (op) {
+ case MINT_ICALL_V_V: {
+ void (*func)() = ptr;
+ func ();
+ break;
+ }
case MINT_ICALL_P_V: {
void (*func)(gpointer) = ptr;
func (sp [-1].data.p);
return sp;
}
-static CRITICAL_SECTION create_method_pointer_mutex;
+static mono_mutex_t create_method_pointer_mutex;
static MonoGHashTable *method_pointer_hash = NULL;
gpointer addr;
MonoJitInfo *ji;
- EnterCriticalSection (&create_method_pointer_mutex);
+ mono_mutex_lock (&create_method_pointer_mutex);
if (!method_pointer_hash) {
MONO_GC_REGISTER_ROOT (method_pointer_hash);
method_pointer_hash = mono_g_hash_table_new (NULL, NULL);
}
addr = mono_g_hash_table_lookup (method_pointer_hash, method);
if (addr) {
- LeaveCriticalSection (&create_method_pointer_mutex);
+ mono_mutex_unlock (&create_method_pointer_mutex);
return addr;
}
* If it is a static P/Invoke method, we can just return the pointer
* to the method implementation.
*/
- if (method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL && method->addr) {
+ if (method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL && ((MonoMethodPInvoke*) method)->addr) {
ji = g_new0 (MonoJitInfo, 1);
ji->method = method;
ji->code_size = 1;
- ji->code_start = method->addr;
+ ji->code_start = addr = ((MonoMethodPInvoke*) method)->addr;
mono_jit_info_table_add (mono_get_root_domain (), ji);
-
- addr = method->addr;
}
else
addr = mono_arch_create_method_pointer (method);
mono_g_hash_table_insert (method_pointer_hash, method, addr);
- LeaveCriticalSection (&create_method_pointer_mutex);
+ mono_mutex_unlock (&create_method_pointer_mutex);
return addr;
}
#else
#define MINT_IN_BREAK { COUNT_OP(*ip); goto *in_labels[*ip]; }
#endif
-#define MINT_IN_DEFAULT mint_default:
+#define MINT_IN_DEFAULT mint_default: if (0) goto mint_default; /* make gcc shut up */
#else
#define MINT_IN_SWITCH(op) switch (op)
#define MINT_IN_CASE(x) case x:
MINT_IN_BREAK;
}
MINT_IN_CASE(MINT_CALLINT)
- ves_pinvoke_method (frame, frame->runtime_method->method->signature, frame->runtime_method->method->addr,
+ ves_pinvoke_method (frame, mono_method_signature (frame->runtime_method->method), ((MonoMethodPInvoke*) frame->runtime_method->method)->addr,
frame->runtime_method->method->string_ctor, context);
if (frame->ex) {
rtm = NULL;
ip += 2;
child_frame.runtime_method = rtm->data_items [token];
- csig = child_frame.runtime_method->method->signature;
+ csig = mono_method_signature (child_frame.runtime_method->method);
newobj_class = child_frame.runtime_method->method->klass;
/*if (profiling_classes) {
guint count = GPOINTER_TO_UINT (g_hash_table_lookup (profiling_classes, newobj_class));
MINT_IN_BREAK;
MINT_IN_CASE(MINT_LDRMFLD) {
+ gpointer tmp;
MonoClassField *field;
char *addr;
ip += 2;
if (o->vtable->klass == mono_defaults.transparent_proxy_class) {
MonoClass *klass = ((MonoTransparentProxy*)o)->remote_class->proxy_class;
- addr = mono_load_remote_field (o, klass, field, NULL);
+
+ addr = mono_load_remote_field (o, klass, field, &tmp);
} else {
addr = (char*)o + field->offset;
}
MINT_IN_CASE(MINT_LDRMFLD_VT) {
MonoClassField *field;
char *addr;
+ gpointer tmp;
o = sp [-1].data.p;
if (!o)
ip += 4;
if (o->vtable->klass == mono_defaults.transparent_proxy_class) {
MonoClass *klass = ((MonoTransparentProxy*)o)->remote_class->proxy_class;
- addr = mono_load_remote_field (o, klass, field, NULL);
+ addr = mono_load_remote_field (o, klass, field, &tmp);
} else {
addr = (char*)o + field->offset;
}
}
goto handle_finally;
MINT_IN_BREAK;
+ MINT_IN_CASE(MINT_ICALL_V_V)
MINT_IN_CASE(MINT_ICALL_P_V)
MINT_IN_CASE(MINT_ICALL_P_P)
MINT_IN_CASE(MINT_ICALL_PP_V)
MINT_IN_CASE(MINT_MONO_RETOBJ)
++ip;
sp--;
- stackval_from_data (frame->runtime_method->method->signature->ret, frame->retval, sp->data.p, frame->runtime_method->method->signature->pinvoke);
+ stackval_from_data (mono_method_signature (frame->runtime_method->method)->ret, frame->retval, sp->data.p,
+ mono_method_signature (frame->runtime_method->method)->pinvoke);
if (sp > frame->stack)
g_warning ("retobj: more values on stack: %d", sp-frame->stack);
goto exit_frame;
clause = &inv->runtime_method->clauses [i];
if (clause->flags <= 1 && MONO_OFFSET_IN_CLAUSE (clause, ip_offset)) {
if (!clause->flags) {
- if (mono_object_isinst ((MonoObject*)frame->ex, mono_class_get (method->klass->image, clause->token_or_filter))) {
+ if (mono_object_isinst ((MonoObject*)frame->ex, clause->data.catch_class)) {
/*
* OK, we found an handler, now we need to execute the finally
* and fault blocks before branching to the handler code.
MonoExceptionClause *clause;
GSList *old_list = finally_ips;
MonoMethod *method = frame->runtime_method->method;
- MonoMethodHeader *header = ((MonoMethodNormal *)method)->header;
+ MonoMethodHeader *header = mono_method_get_header (method);
#if DEBUG_INTERP
if (tracing)
int i;
guint32 ip_offset;
MonoExceptionClause *clause;
- MonoMethodHeader *header = ((MonoMethodNormal *)frame->runtime_method->method)->header;
+ MonoMethodHeader *header = mono_method_get_header (frame->runtime_method->method);
#if DEBUG_INTERP
if (tracing)
static void
add_signal_handler (int signo, void (*handler)(int))
{
-#ifdef PLATFORM_WIN32
+#ifdef HOST_WIN32
signal (signo, handler);
#else
struct sigaction sa;
thread_abort_handler (int signum)
{
ThreadContext *context = TlsGetValue (thread_context_id);
- MonoThread *thread;
MonoException *exc;
if (context == NULL)
g_log_set_always_fatal (G_LOG_LEVEL_ERROR);
g_log_set_fatal_mask (G_LOG_DOMAIN, G_LOG_LEVEL_ERROR);
- g_thread_init (NULL);
+ if (!g_thread_supported ())
+ g_thread_init (NULL);
thread_context_id = TlsAlloc ();
TlsSetValue (thread_context_id, NULL);
- InitializeCriticalSection (&runtime_method_lookup_section);
- InitializeCriticalSection (&create_method_pointer_mutex);
+ mono_mutex_init_recursive (&runtime_method_lookup_section);
+ mono_mutex_init_recursive (&create_method_pointer_mutex);
mono_runtime_install_handlers ();
mono_interp_transform_init ();
mono_install_handler (interp_ex_handler);
mono_install_stack_walk (interp_walk_stack);
- mono_runtime_install_cleanup (quit_function);
+ mono_install_runtime_cleanup (quit_function);
abort_requested = mono_thread_interruption_request_flag ();
domain = mono_init_from_assembly (file, file);
#ifdef __hpux /* generates very big stack frames */
mono_threads_set_default_stacksize(32*1024*1024);
#endif
- mono_init_icall ();
+ mono_icall_init ();
mono_add_internal_call ("System.Diagnostics.StackFrame::get_frame_info", ves_icall_get_frame_info);
mono_add_internal_call ("System.Diagnostics.StackTrace::get_trace", ves_icall_get_trace);
mono_add_internal_call ("Mono.Runtime::mono_runtime_install_handlers", mono_runtime_install_handlers);
mono_add_internal_call ("System.Delegate::CreateDelegate_internal", ves_icall_System_Delegate_CreateDelegate_internal);
+ mono_register_jit_icall (mono_thread_interruption_checkpoint, "mono_thread_interruption_checkpoint", mono_create_icall_signature ("void"), FALSE);
+
mono_runtime_init (domain, NULL, NULL);
+
+ mono_thread_attach (domain);
return domain;
}
if (argc < 2)
usage ();
+ MONO_GC_PRE_INIT ();
+
for (i = 1; i < argc && argv [i][0] == '-'; i++){
if (strcmp (argv [i], "--trace") == 0)
global_tracing = 1;
mono_profiler_load (NULL);
if (strcmp (argv [i], "--config") == 0)
config_file = argv [++i];
- if (strcmp (argv [i], "--workers") == 0) {
- mono_max_worker_threads = atoi (argv [++i]);
- if (mono_max_worker_threads < 1)
- mono_max_worker_threads = 1;
- }
if (strcmp (argv [i], "--help") == 0)
usage ();
#if DEBUG_INTERP
projects / mono.git / blobdiff