#include <mono/utils/mono-threads-coop.h>
#include "mini.h"
+#include "lldb.h"
+
+#ifdef ENABLE_INTERPRETER
+#include "interp/interp.h"
+#endif
/*
* Address of the trampoline code. This is used by the debugger to check
g_assert (imt_slot < MONO_IMT_SIZE);
- mono_error_init (error);
+ error_init (error);
/* This has to be variance aware since imt_method can be from an interface that vt->klass doesn't directly implement */
interface_offset = mono_class_interface_offset_with_variance (vt->klass, imt_method->klass, &variance_used);
if (interface_offset < 0)
gpointer *orig_vtable_slot, *vtable_slot_to_patch = NULL;
MonoJitInfo *ji = NULL;
- mono_error_init (error);
+ error_init (error);
virtual_ = vt && (gpointer)vtable_slot > (gpointer)vt;
imt_call = vt && (gpointer)vtable_slot < (gpointer)vt;
if (mono_class_is_ginst (m->klass))
context.class_inst = mono_class_get_generic_class (m->klass)->context.class_inst;
else
- g_assert (!m->klass->generic_container);
+ g_assert (!mono_class_is_gtd (m->klass));
generic_virtual = mono_arch_find_imt_method (regs, code);
g_assert (generic_virtual);
if (mono_class_is_ginst (klass))
context.class_inst = mono_class_get_generic_class (klass)->context.class_inst;
- else if (klass->generic_container)
- context.class_inst = klass->generic_container->context.class_inst;
+ else if (mono_class_is_gtd (klass))
+ context.class_inst = mono_class_get_generic_container (klass)->context.class_inst;
context.method_inst = method_inst;
actual_method = mono_class_inflate_generic_method_checked (declaring, &context, error);
gpointer *vtable_slot;
MonoMethod *m;
MonoError error;
- gpointer addr, res;
+ gpointer addr, res = NULL;
trampoline_calls ++;
if (mono_class_is_ginst (m->klass))
context.class_inst = mono_class_get_generic_class (m->klass)->context.class_inst;
else
- g_assert (!m->klass->generic_container);
+ g_assert (!mono_class_is_gtd (m->klass));
imt_method = mono_arch_find_imt_method (regs, code);
if (imt_method->is_inflated)
* delegate->method).
*/
#ifndef DISABLE_REMOTING
- if (delegate->target && delegate->target->vtable->klass == mono_defaults.transparent_proxy_class) {
+ if (delegate->target && mono_object_is_transparent_proxy (delegate->target)) {
is_remote = TRUE;
#ifndef DISABLE_COM
if (((MonoTransparentProxy *)delegate->target)->remote_class->proxy_class != mono_class_get_com_object_class () &&
if (!is_remote) {
sig = tramp_info->sig;
if (!(sig && method == tramp_info->method)) {
- mono_error_init (&err);
+ error_init (&err);
sig = mono_method_signature_checked (method, &err);
if (!sig) {
mono_error_set_pending_exception (&err);
if (method) {
sig = tramp_info->sig;
if (!(sig && method == tramp_info->method)) {
- mono_error_init (&err);
+ error_init (&err);
sig = mono_method_signature_checked (method, &err);
if (!sig) {
mono_error_set_pending_exception (&err);
* If the call doesn't return a valuetype, then the vcall uses the same calling
* convention as a normal call.
*/
- if (((method->klass->flags & TYPE_ATTRIBUTE_SEALED) || !(method->flags & METHOD_ATTRIBUTE_VIRTUAL)) && !MONO_TYPE_ISSTRUCT (sig->ret)) {
+ if ((mono_class_is_sealed (method->klass) || !(method->flags & METHOD_ATTRIBUTE_VIRTUAL)) && !MONO_TYPE_ISSTRUCT (sig->ret)) {
callvirt = FALSE;
enable_caching = FALSE;
}
if (delegate->target &&
method->flags & METHOD_ATTRIBUTE_VIRTUAL &&
method->flags & METHOD_ATTRIBUTE_ABSTRACT &&
- method->klass->flags & TYPE_ATTRIBUTE_ABSTRACT) {
+ mono_class_is_abstract (method->klass)) {
method = mono_object_get_virtual_method (delegate->target, method);
enable_caching = FALSE;
}
MonoContext ctx;
MonoException *exc;
- MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_native_tls_get_value (mono_jit_tls_id);
+ MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_tls_get_jit_tls ();
gpointer resume_ip = jit_tls->handler_block_return_address;
memcpy (&ctx, &jit_tls->handler_block_context, sizeof (MonoContext));
if (!resume_ip) /*this should not happen, but we should avoid crashing */
exc = mono_get_exception_execution_engine ("Invalid internal state, resuming abort after handler block but no resume ip found");
else
- exc = mono_thread_resume_interruption ();
+ exc = mono_thread_resume_interruption (TRUE);
if (exc) {
mono_handle_exception (&ctx, (MonoObject *)exc);
gpointer
mono_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain, guint32 *code_len)
{
+ gpointer code;
+ guint32 len;
+
if (mono_aot_only)
- return mono_aot_create_specific_trampoline (mono_defaults.corlib, arg1, tramp_type, domain, code_len);
+ code = mono_aot_create_specific_trampoline (mono_defaults.corlib, arg1, tramp_type, domain, &len);
else
- return mono_arch_create_specific_trampoline (arg1, tramp_type, domain, code_len);
+ code = mono_arch_create_specific_trampoline (arg1, tramp_type, domain, &len);
+ mono_lldb_save_specific_trampoline_info (arg1, tramp_type, domain, code, len);
+ if (code_len)
+ *code_len = len;
+ return code;
}
gpointer
gpointer code;
guint32 code_size = 0;
- mono_error_init (error);
+ error_init (error);
+
+#ifdef ENABLE_INTERPRETER
+ if (mono_use_interpreter) {
+ gpointer ret = mono_interp_create_trampoline (domain, method, error);
+ if (!mono_error_ok (error))
+ return NULL;
+ return ret;
+ }
+#endif
code = mono_jit_find_compiled_method_with_jit_info (domain, method, &ji);
/*
{
gpointer tramp;
- mono_error_init (error);
+ error_init (error);
if (mono_aot_only) {
if (mono_llvm_only && method->iflags & METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED)
tramp_info->impl_nothis = mono_arch_get_delegate_invoke_impl (mono_method_signature (invoke), FALSE);
tramp_info->method = method;
if (method) {
- mono_error_init (&error);
+ error_init (&error);
tramp_info->sig = mono_method_signature_checked (method, &error);
tramp_info->need_rgctx_tramp = mono_method_needs_static_rgctx_invoke (method, FALSE);
}
gpointer
mono_create_delegate_trampoline (MonoDomain *domain, MonoClass *klass)
{
- if (mono_llvm_only)
+ if (mono_llvm_only || mono_use_interpreter)
return no_delegate_trampoline;
return mono_create_delegate_trampoline_info (domain, klass, NULL)->invoke_impl;