target_link_libraries(libmono-static monoruntime-static monoutils-static monogc-static wapi-static ${GLIB2_LIBRARIES} ${LIBS})
set_target_properties(libmono-static PROPERTIES OUTPUT_NAME "mono-static")
+# Since cmake has no support for convenience libraries, we have to link the
+# final libmono.a ourselves, similarly to how libtool does it
+add_custom_target(libmono.a
+ COMMAND rm -rf .libs/tmp libmono.a
+ COMMAND mkdir -p .libs/tmp/{1,2,3,4,5}
+ COMMAND cd .libs/tmp/1 && ar x ../../../../metadata/libmonoruntime-static.a
+ COMMAND cd .libs/tmp/2 && ar x ../../../../utils/libmonoutils-static.a
+ COMMAND cd .libs/tmp/3 && ar x ../../../../io-layer/libwapi-static.a
+ COMMAND cd .libs/tmp/3 && ar x ../../../../mini/libmono-static.a
+ COMMAND cd .libs/tmp/4 && ar x ../../../../../libgc/libmonogc-static.a
+ COMMAND ar r libmono.a `find .libs/tmp/ -name '*.o'`
+)
+
# FIXME: cmake has no support for convenience libraries, so we would end up
# creating a lot of shared libraries linking to each other
#add_library(libmono SHARED ${libmono_la_SOURCES} ${CMAKE_CURRENT_BINARY_DIR}/${arch_built})
add_dependencies(mono libmono-static)
target_link_libraries(mono libmono-static ${GLIB2_LIBRARIES})
+install(
+ TARGETS mono
+ RUNTIME DESTINATION bin)
+
+# FIXME: Can't specify a dependency on libmono.a, and we don't want to build
+# libmono.a until needed
+install(
+ FILES libmono.a DESTINATION lib)
+
# Test file targets
foreach(test ${test_sources})
+
+Mon Jul 13 17:58:50 CEST 2009 Paolo Molaro <lupus@ximian.com>
+
+ * mini-ppc.c: fixed bug introduced by Steven's TLS changes.
+
+2009-07-13 Mark Probst <mark.probst@gmail.com>
+
+ * mini.c: Register function for getting the IP from a signal
+ context with metadata.
+
2009-07-13 Zoltan Varga <vargaz@gmail.com>
- * basic-simd.cs: Add a test for #521662.
+ * method-to-ir.c (mono_method_to_ir): When calling a gshared method,
+ call a generic class init trampoline if needed. Fixes #519336.
+
+ * generics.cs: Add a test.
+
+2009-07-09 Mark Probst <mark.probst@gmail.com>
+
+ * method-to-ir.c: When doing a call which might be remote from
+ shared generic code to other shared code with open type arguments,
+ get the remoting invoke wrapper from the RGCTX and do an indirect
+ call to it.
+
+2009-07-03 Zoltan Varga <vargaz@gmail.com>
+
+ * mini-trampolines.c (get_unbox_trampoline): Add an rgctx trampoline
+ after the unbox trampoline in the full-aot case.
+
+2009-07-02 jonas echterhoff <jonas@unity3d.com>
+
+ * mini.c: Move initialization of jit_mutex before debugger initialization
+
+ to avoid crashes.
+
+
+ * Info.plist: added Info.plist and link flag to enable the mono executable
+ to access other processes. Requires codesigning of the executable to work.
+
+ * mdb-debug-info32-darwin.s: The same as mdb-debug-info32.s, changed to
+
+ compile on OS X.
+
+
+2009-06-30 Zoltan Varga <vargaz@gmail.com>
+
+ * driver.c (mini_regression): Handle loading errors. Fixes #508869.
+
+2009-06-29 Zoltan Varga <vargaz@gmail.com>
+
+ * mini-exceptions.c (get_generic_context_from_stack_frame): Fix the case
+ when the generic instance is an instantiation of a subclass of the
+ methods class. Fixes #517166.
+
+2009-06-26 Zoltan Varga <vargaz@gmail.com>
+
+ * mini-amd64.c (mono_arch_emit_prolog): Fix thread attaching in AOTed
+ code.
+
+ * mini.c (mono_jit_thread_attach): Allow domain to be NULL for calls from
+ AOTed code.
+
+ * CMakeLists.txt: Add minimal support for installation.
+
+2009-06-25 Zoltan Varga <vargaz@gmail.com>
+
+ * aot-compiler.c (emit_and_reloc_code): Factor out the code to
+ determine whenever a method is directly callable to a separate function.
+
+ * mini-<ARCH>.c tramp-<ARCH>.c: Remove needless casts and add new
+ needed ones as a result of the previous change.
+
+ * mini-<ARCH>.c tramp-<ARCH>.c: Use mgreg_t* as the
+ type of register arrays.
+
+ * mini-trampolines.c tramp-<ARCH>.c aot-runtime.c: Use mgreg_t* as the
+ type of register arrays.
+
+2009-06-24 Jerry Maine <crashfourit@gmail.com>
+
+ Contributed under the terms of the MIT/X11 license by
+ Jerry Maine <crashfourit@gail.com>.
+
+ * mini-amd64.c: Added code to convert simd IR to native amd64 sse.
+
+2009-06-24 Zoltan Varga <vargaz@gmail.com>
+
+ * aot-compiler.c (emit_plt): Define debug labels for most plt entries.
2009-06-24 Neale Ferguson <neale@sinenomine.net>
--- /dev/null
+<plist version="1.0">
+<dict>
+ <key>CFBundleDevelopmentRegion</key>
+ <string>English</string>
+ <key>CFBundleIdentifier</key>
+ <string>com.novell.mono</string>
+ <key>CFBundleInfoDictionaryVersion</key>
+ <string>6.0</string>
+ <key>CFBundleName</key>
+ <string>mono</string>
+ <key>CFBundleVersion</key>
+ <string>0.3</string>
+ <key>SecTaskAccess</key>
+ <string>allowed</string>
+</dict>
+</plist>
$(MONO_DTRACE_OBJECT)
mono_LDFLAGS = \
- $(static_flags) -export-dynamic $(monobinldflags)
+ $(static_flags) -export-dynamic $(monobinldflags) $(monobin_platform_ldflags)
if DTRACE_G_REQUIRED
basic-simd.cs
if MONO_DEBUGGER_SUPPORTED
+if PLATFORM_DARWIN
+mono_debugger_arch_sources = mdb-debug-info32-darwin.s
+else
if AMD64
mono_debugger_arch_sources = mdb-debug-info64.s
else
mono_debugger_arch_sources = mdb-debug-info32.s
endif
endif
+endif
mono_debugger_sources = debug-debugger.c debug-debugger.h $(mono_debugger_arch_sources)
else
mono_debugger_sources =
if PLATFORM_WIN32
os_sources = $(windows_sources)
+monobin_platform_ldflags=
endif
if PLATFORM_SIGPOSIX
os_sources = $(posix_sources)
+monobin_platform_ldflags=
endif
if PLATFORM_DARWIN
os_sources = $(darwin_sources) $(posix_sources)
+monobin_platform_ldflags=-sectcreate __TEXT __info_plist $(top_srcdir)/mono/mini/Info.plist
endif
libmono_la_SOURCES = $(common_sources) $(llvm_sources) $(arch_sources) $(os_sources)
}
}
+/*
+ * is_direct_callable:
+ *
+ * Return whenever the method identified by JI is directly callable without
+ * going through the PLT.
+ */
+static gboolean
+is_direct_callable (MonoAotCompile *acfg, MonoMethod *method, MonoJumpInfo *patch_info)
+{
+ if ((patch_info->type == MONO_PATCH_INFO_METHOD) && (patch_info->data.method->klass->image == acfg->image)) {
+ MonoCompile *callee_cfg = g_hash_table_lookup (acfg->method_to_cfg, patch_info->data.method);
+ if (callee_cfg) {
+ gboolean direct_callable = TRUE;
+
+ if (direct_callable && !(!callee_cfg->has_got_slots && (callee_cfg->method->klass->flags & TYPE_ATTRIBUTE_BEFORE_FIELD_INIT)))
+ direct_callable = FALSE;
+ if ((callee_cfg->method->iflags & METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED) && (!method || method->wrapper_type != MONO_WRAPPER_SYNCHRONIZED))
+ // FIXME: Maybe call the wrapper directly ?
+ direct_callable = FALSE;
+
+ if (direct_callable)
+ return TRUE;
+ }
+ }
+
+ return FALSE;
+}
+
/*
* emit_and_reloc_code:
*
* the same assembly and requires no initialization.
*/
direct_call = FALSE;
- if (!got_only && (patch_info->type == MONO_PATCH_INFO_METHOD) && (patch_info->data.method->klass->image == method->klass->image)) {
- MonoCompile *callee_cfg = g_hash_table_lookup (acfg->method_to_cfg, patch_info->data.method);
- if (callee_cfg) {
- gboolean direct_callable = TRUE;
-
- if (direct_callable && !(!callee_cfg->has_got_slots && (callee_cfg->method->klass->flags & TYPE_ATTRIBUTE_BEFORE_FIELD_INIT)))
- direct_callable = FALSE;
- if ((callee_cfg->method->iflags & METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED) && method->wrapper_type != MONO_WRAPPER_SYNCHRONIZED)
- // FIXME: Maybe call the wrapper directly ?
- direct_callable = FALSE;
- if (direct_callable) {
- //printf ("DIRECT: %s %s\n", method ? mono_method_full_name (method, TRUE) : "", mono_method_full_name (callee_cfg->method, TRUE));
- direct_call = TRUE;
- sprintf (direct_call_target, "%sm_%x", acfg->temp_prefix, get_method_index (acfg, callee_cfg->orig_method));
- patch_info->type = MONO_PATCH_INFO_NONE;
- acfg->stats.direct_calls ++;
- }
+ if ((patch_info->type == MONO_PATCH_INFO_METHOD) && (patch_info->data.method->klass->image == acfg->image)) {
+ if (!got_only && is_direct_callable (acfg, method, patch_info)) {
+ MonoCompile *callee_cfg = g_hash_table_lookup (acfg->method_to_cfg, patch_info->data.method);
+ //printf ("DIRECT: %s %s\n", method ? mono_method_full_name (method, TRUE) : "", mono_method_full_name (callee_cfg->method, TRUE));
+ direct_call = TRUE;
+ sprintf (direct_call_target, "%sm_%x", acfg->temp_prefix, get_method_index (acfg, callee_cfg->orig_method));
+ patch_info->type = MONO_PATCH_INFO_NONE;
+ acfg->stats.direct_calls ++;
}
acfg->stats.all_calls ++;
}
}
+/*
+ * sanitize_symbol:
+ *
+ * Modify SYMBOL so it only includes characters permissible in symbols.
+ */
+static void
+sanitize_symbol (char *symbol)
+{
+ int i, len = strlen (symbol);
+
+ for (i = 0; i < len; ++i)
+ if (!isalnum (symbol [i]) && (symbol [i] != '_'))
+ symbol [i] = '_';
+}
+
static char*
get_debug_sym (MonoMethod *method, const char *prefix, GHashTable *cache)
{
emit_label (acfg, label);
if (acfg->aot_opts.write_symbols) {
- MonoJumpInfo *patch_info = g_hash_table_lookup (acfg->plt_offset_to_patch, GUINT_TO_POINTER (i));
+ MonoJumpInfo *ji = g_hash_table_lookup (acfg->plt_offset_to_patch, GUINT_TO_POINTER (i));
+ char *debug_sym = NULL;
- if (patch_info && patch_info->type == MONO_PATCH_INFO_METHOD) {
- char *debug_sym = get_debug_sym (patch_info->data.method, "plt_", cache);
+ if (ji) {
+ switch (ji->type) {
+ case MONO_PATCH_INFO_METHOD:
+ debug_sym = get_debug_sym (ji->data.method, "plt_", cache);
+ break;
+ case MONO_PATCH_INFO_INTERNAL_METHOD:
+ debug_sym = g_strdup_printf ("plt__jit_icall_%s", ji->data.name);
+ break;
+ case MONO_PATCH_INFO_CLASS_INIT:
+ debug_sym = g_strdup_printf ("plt__class_init_%s", mono_type_get_name (&ji->data.klass->byval_arg));
+ sanitize_symbol (debug_sym);
+ break;
+ case MONO_PATCH_INFO_RGCTX_FETCH:
+ debug_sym = g_strdup_printf ("plt__rgctx_fetch_%d", acfg->label_generator ++);
+ break;
+ case MONO_PATCH_INFO_ICALL_ADDR: {
+ char *s = get_debug_sym (ji->data.method, "", cache);
+
+ debug_sym = g_strdup_printf ("plt__icall_native_%s", s);
+ g_free (s);
+ break;
+ }
+ case MONO_PATCH_INFO_JIT_ICALL_ADDR:
+ debug_sym = g_strdup_printf ("plt__jit_icall_native_%s", ji->data.name);
+ break;
+ case MONO_PATCH_INFO_GENERIC_CLASS_INIT:
+ debug_sym = g_strdup_printf ("plt__generic_class_init");
+ break;
+ default:
+ break;
+ }
- emit_local_symbol (acfg, debug_sym, NULL, TRUE);
- emit_label (acfg, debug_sym);
+ if (debug_sym) {
+ emit_local_symbol (acfg, debug_sym, NULL, TRUE);
+ emit_label (acfg, debug_sym);
+ }
}
}
* Return the PLT info offset belonging to the plt entry called by CODE.
*/
guint32
-mono_aot_get_plt_info_offset (gssize *regs, guint8 *code)
+mono_aot_get_plt_info_offset (mgreg_t *regs, guint8 *code)
{
guint8 *plt_entry = mono_aot_get_plt_entry (code);
}
guint32
-mono_aot_get_plt_info_offset (gssize *regs, guint8 *code)
+mono_aot_get_plt_info_offset (mgreg_t *regs, guint8 *code)
{
g_assert_not_reached ();
return 0;
}
- public static int test_0_sse41_vector8s_min () {
- Vector8s v = new Vector8s(2);
- Vector8s v2 = new Vector8s(1);
- v = v.Min(v2);
- if (v.V0 != 1 || v.V1 != 1 || v.V2 != 1 || v.V3 != 1 || v.V4 != 1 || v.V5 != 1 || v.V6 != 1 || v.V7 != 1)
- return 1;
- return 0;
- }
-
public static int Main () {
return TestDriver.RunTests (typeof (SimdTests));
}
/* load the metadata */
for (i = 0; i < mono_image_get_table_rows (image, MONO_TABLE_METHOD); ++i) {
- method = mono_get_method (image, MONO_TOKEN_METHOD_DEF | (i + 1), NULL);
+ method = mono_get_method (image, MONO_TOKEN_METHOD_DEF | (i + 1), NULL);
+ if (!method)
+ continue;
mono_class_init (method->klass);
if (!strncmp (method->name, "test_", 5) && mini_stats_fd) {
if (mini_stats_fd)
fprintf (mini_stats_fd, "[");
for (i = 0; i < mono_image_get_table_rows (image, MONO_TABLE_METHOD); ++i) {
- method = mono_get_method (image, MONO_TOKEN_METHOD_DEF | (i + 1), NULL);
+ method = mono_get_method (image, MONO_TOKEN_METHOD_DEF | (i + 1), NULL);
+ if (!method)
+ continue;
if (strncmp (method->name, "test_", 5) == 0) {
expected = atoi (method->name + 5);
run++;
return idx;
}
+ static int cctor_count = 0;
+
+ public abstract class Beta<TChanged>
+ {
+ static Beta()
+ {
+ cctor_count ++;
+ }
+ }
+
+ public class Gamma<T> : Beta<T>
+ {
+ static Gamma()
+ {
+ }
+ }
+
+ // #519336
+ public static int test_2_generic_class_init_gshared_ctor () {
+ new Gamma<object>();
+ new Gamma<string>();
+
+ return cctor_count;
+ }
+
public static void VirtualInterfaceCallFromGenericMethod <T> (IFoo f) {
f.Bar <T> ();
}
--- /dev/null
+.text
+.globl _MONO_DEBUGGER__debugger_info
+.globl _MONO_DEBUGGER__notification_function
+_MONO_DEBUGGER__notification_function:
+ int3
+ ret
+.section .mdb_debug_info, "aw"
+.globl _MONO_DEBUGGER__debugger_info_ptr
+.globl _MONO_DEBUGGER__using_debugger
+_MONO_DEBUGGER__debugger_info_ptr:
+ .long _MONO_DEBUGGER__debugger_info
+_MONO_DEBUGGER__using_debugger:
+ .quad 0
#endif
}
+static MonoInst*
+emit_get_rgctx_method (MonoCompile *cfg, int context_used, MonoMethod *cmethod, int rgctx_type);
+
static MonoInst*
mono_emit_method_call_full (MonoCompile *cfg, MonoMethod *method, MonoMethodSignature *sig,
MonoInst **args, MonoInst *this, MonoInst *imt_arg)
{
+ gboolean might_be_remote;
gboolean virtual = this != NULL;
gboolean enable_for_aot = TRUE;
+ int context_used;
MonoCallInst *call;
if (method->string_ctor) {
sig = ctor_sig;
}
+ might_be_remote = this && sig->hasthis &&
+ (method->klass->marshalbyref || method->klass == mono_defaults.object_class) &&
+ !(method->flags & METHOD_ATTRIBUTE_VIRTUAL) && !MONO_CHECK_THIS (this);
+
+ context_used = mono_method_check_context_used (method);
+ if (might_be_remote && context_used) {
+ MonoInst *addr;
+
+ g_assert (cfg->generic_sharing_context);
+
+ addr = emit_get_rgctx_method (cfg, context_used, method, MONO_RGCTX_INFO_REMOTING_INVOKE_WITH_CHECK);
+
+ return mono_emit_calli (cfg, sig, args, addr);
+ }
+
call = mono_emit_call_args (cfg, sig, args, FALSE, virtual, FALSE);
- if (this && sig->hasthis &&
- (method->klass->marshalbyref || method->klass == mono_defaults.object_class) &&
- !(method->flags & METHOD_ATTRIBUTE_VIRTUAL) && !MONO_CHECK_THIS (this)) {
+ if (might_be_remote)
call->method = mono_marshal_get_remoting_invoke_with_check (method);
- } else {
+ else
call->method = method;
- }
call->inst.flags |= MONO_INST_HAS_METHOD;
call->inst.inst_left = this;
return emit_rgctx_fetch (cfg, rgctx, entry);
}
+static void
+emit_generic_class_init (MonoCompile *cfg, MonoClass *klass)
+{
+ MonoInst *vtable_arg;
+ MonoCallInst *call;
+ int context_used = 0;
+
+ if (cfg->generic_sharing_context)
+ context_used = mono_class_check_context_used (klass);
+
+ if (context_used) {
+ vtable_arg = emit_get_rgctx_klass (cfg, context_used,
+ klass, MONO_RGCTX_INFO_VTABLE);
+ } else {
+ MonoVTable *vtable = mono_class_vtable (cfg->domain, klass);
+
+ if (!vtable)
+ return;
+ EMIT_NEW_VTABLECONST (cfg, vtable_arg, vtable);
+ }
+
+ call = (MonoCallInst*)mono_emit_abs_call (cfg, MONO_PATCH_INFO_GENERIC_CLASS_INIT, NULL, helper_sig_generic_class_init_trampoline, &vtable_arg);
+#ifdef MONO_ARCH_VTABLE_REG
+ mono_call_inst_add_outarg_reg (cfg, call, vtable_arg->dreg, MONO_ARCH_VTABLE_REG, FALSE);
+ cfg->uses_vtable_reg = TRUE;
+#else
+ NOT_IMPLEMENTED;
+#endif
+}
+
static void
mini_emit_check_array_type (MonoCompile *cfg, MonoInst *obj, MonoClass *array_class)
{
if (*ip != CEE_CALLI && check_call_signature (cfg, fsig, sp))
UNVERIFIED;
+ /*
+ * If the callee is a shared method, then its static cctor
+ * might not get called after the call was patched.
+ */
+ if (cfg->generic_sharing_context && cmethod && cmethod->klass != method->klass && cmethod->klass->generic_class && mono_method_is_generic_sharable_impl (cmethod, TRUE) && mono_class_needs_cctor_run (cmethod->klass, method)) {
+ emit_generic_class_init (cfg, cmethod->klass);
+ }
if (cmethod && ((cmethod->flags & METHOD_ATTRIBUTE_STATIC) || cmethod->klass->valuetype) &&
(cmethod->klass->generic_class || cmethod->klass->generic_container)) {
INLINE_FAILURE;
ins = mono_emit_rgctx_method_call_full (cfg, cmethod, fsig, sp,
callvirt_this_arg, NULL, vtable_arg);
- if (mono_method_is_generic_sharable_impl (cmethod, TRUE) && ((MonoCallInst*)ins)->method->wrapper_type == MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK)
- GENERIC_SHARING_FAILURE (*ip);
}
}
*/
gpointer*
-mono_arch_get_vcall_slot_addr (guint8* code, gpointer *regs)
+mono_arch_get_vcall_slot_addr (guint8* code, mgreg_t *regs)
{
unsigned int *pc = (unsigned int *)code;
guint32 reg, disp;
}
gpointer
-mono_arch_get_this_arg_from_call (MonoGenericSharingContext *gsctx, MonoMethodSignature *sig, gssize *regs, guint8 *code)
+mono_arch_get_this_arg_from_call (MonoGenericSharingContext *gsctx, MonoMethodSignature *sig, mgreg_t *regs, guint8 *code)
{
unsigned int *pc = (unsigned int *)code;
return opts;
}
+/*
+ * This function test for all SSE functions supported.
+ *
+ * Returns a bitmask corresponding to all supported versions.
+ *
+ * TODO detect other versions like SSE4a.
+ */
+guint32
+mono_arch_cpu_enumerate_simd_versions (void)
+{
+ int eax, ebx, ecx, edx;
+ guint32 sse_opts = 0;
+
+ if (cpuid (1, &eax, &ebx, &ecx, &edx)) {
+ if (edx & (1 << 25))
+ sse_opts |= 1 << SIMD_VERSION_SSE1;
+ if (edx & (1 << 26))
+ sse_opts |= 1 << SIMD_VERSION_SSE2;
+ if (ecx & (1 << 0))
+ sse_opts |= 1 << SIMD_VERSION_SSE3;
+ if (ecx & (1 << 9))
+ sse_opts |= 1 << SIMD_VERSION_SSSE3;
+ if (ecx & (1 << 19))
+ sse_opts |= 1 << SIMD_VERSION_SSE41;
+ if (ecx & (1 << 20))
+ sse_opts |= 1 << SIMD_VERSION_SSE42;
+ }
+ return sse_opts;
+}
+
GList *
mono_arch_get_allocatable_int_vars (MonoCompile *cfg)
{
amd64_mov_reg_reg (code, ins->dreg, AMD64_RAX, size);
break;
}
+#ifdef MONO_ARCH_SIMD_INTRINSICS
+ case OP_ADDPS:
+ amd64_sse_addps_reg_reg (code, ins->sreg1, ins->sreg2);
+ break;
+ case OP_DIVPS:
+ amd64_sse_divps_reg_reg (code, ins->sreg1, ins->sreg2);
+ break;
+ case OP_MULPS:
+ amd64_sse_mulps_reg_reg (code, ins->sreg1, ins->sreg2);
+ break;
+ case OP_SUBPS:
+ amd64_sse_subps_reg_reg (code, ins->sreg1, ins->sreg2);
+ break;
+ case OP_MAXPS:
+ amd64_sse_maxps_reg_reg (code, ins->sreg1, ins->sreg2);
+ break;
+ case OP_MINPS:
+ amd64_sse_minps_reg_reg (code, ins->sreg1, ins->sreg2);
+ break;
+ case OP_COMPPS:
+ g_assert (ins->inst_c0 >= 0 && ins->inst_c0 <= 7);
+ amd64_sse_cmpps_reg_reg_imm (code, ins->sreg1, ins->sreg2, ins->inst_c0);
+ break;
+ case OP_ANDPS:
+ amd64_sse_andps_reg_reg (code, ins->sreg1, ins->sreg2);
+ break;
+ case OP_ANDNPS:
+ amd64_sse_andnps_reg_reg (code, ins->sreg1, ins->sreg2);
+ break;
+ case OP_ORPS:
+ amd64_sse_orps_reg_reg (code, ins->sreg1, ins->sreg2);
+ break;
+ case OP_XORPS:
+ amd64_sse_xorps_reg_reg (code, ins->sreg1, ins->sreg2);
+ break;
+ case OP_SQRTPS:
+ amd64_sse_sqrtps_reg_reg (code, ins->dreg, ins->sreg1);
+ break;
+ case OP_RSQRTPS:
+ amd64_sse_rsqrtps_reg_reg (code, ins->dreg, ins->sreg1);
+ break;
+ case OP_RCPPS:
+ amd64_sse_rcpps_reg_reg (code, ins->dreg, ins->sreg1);
+ break;
+ case OP_ADDSUBPS:
+ amd64_sse_addsubps_reg_reg (code, ins->sreg1, ins->sreg2);
+ break;
+ case OP_HADDPS:
+ amd64_sse_haddps_reg_reg (code, ins->sreg1, ins->sreg2);
+ break;
+ case OP_HSUBPS:
+ amd64_sse_hsubps_reg_reg (code, ins->sreg1, ins->sreg2);
+ break;
+ case OP_DUPPS_HIGH:
+ amd64_sse_movshdup_reg_reg (code, ins->dreg, ins->sreg1);
+ break;
+ case OP_DUPPS_LOW:
+ amd64_sse_movsldup_reg_reg (code, ins->dreg, ins->sreg1);
+ break;
+
+ case OP_PSHUFLEW_HIGH:
+ g_assert (ins->inst_c0 >= 0 && ins->inst_c0 <= 0xFF);
+ amd64_sse_pshufhw_reg_reg_imm (code, ins->dreg, ins->sreg1, ins->inst_c0);
+ break;
+ case OP_PSHUFLEW_LOW:
+ g_assert (ins->inst_c0 >= 0 && ins->inst_c0 <= 0xFF);
+ amd64_sse_pshuflw_reg_reg_imm (code, ins->dreg, ins->sreg1, ins->inst_c0);
+ break;
+ case OP_PSHUFLED:
+ g_assert (ins->inst_c0 >= 0 && ins->inst_c0 <= 0xFF);
+ amd64_sse_pshufd_reg_reg_imm (code, ins->dreg, ins->sreg1, ins->inst_c0);
+ break;
+
+ case OP_ADDPD:
+ amd64_sse_addpd_reg_reg (code, ins->sreg1, ins->sreg2);
+ break;
+ case OP_DIVPD:
+ amd64_sse_divpd_reg_reg (code, ins->sreg1, ins->sreg2);
+ break;
+ case OP_MULPD:
+ amd64_sse_mulpd_reg_reg (code, ins->sreg1, ins->sreg2);
+ break;
+ case OP_SUBPD:
+ amd64_sse_subpd_reg_reg (code, ins->sreg1, ins->sreg2);
+ break;
+ case OP_MAXPD:
+ amd64_sse_maxpd_reg_reg (code, ins->sreg1, ins->sreg2);
+ break;
+ case OP_MINPD:
+ amd64_sse_minpd_reg_reg (code, ins->sreg1, ins->sreg2);
+ break;
+ case OP_COMPPD:
+ g_assert (ins->inst_c0 >= 0 && ins->inst_c0 <= 7);
+ amd64_sse_cmppd_reg_reg_imm (code, ins->sreg1, ins->sreg2, ins->inst_c0);
+ break;
+ case OP_ANDPD:
+ amd64_sse_andpd_reg_reg (code, ins->sreg1, ins->sreg2);
+ break;
+ case OP_ANDNPD:
+ amd64_sse_andnpd_reg_reg (code, ins->sreg1, ins->sreg2);
+ break;
+ case OP_ORPD:
+ amd64_sse_orpd_reg_reg (code, ins->sreg1, ins->sreg2);
+ break;
+ case OP_XORPD:
+ amd64_sse_xorpd_reg_reg (code, ins->sreg1, ins->sreg2);
+ break;
+ /* TODO: This op is in the AMD64 manual but has not been implemented.
+ case OP_SQRTPD:
+ amd64_sse_sqrtpd_reg_reg (code, ins->dreg, ins->sreg1);
+ break;
+ */
+ case OP_ADDSUBPD:
+ amd64_sse_addsubpd_reg_reg (code, ins->sreg1, ins->sreg2);
+ break;
+ case OP_HADDPD:
+ amd64_sse_haddpd_reg_reg (code, ins->sreg1, ins->sreg2);
+ break;
+ case OP_HSUBPD:
+ amd64_sse_hsubpd_reg_reg (code, ins->sreg1, ins->sreg2);
+ break;
+ case OP_DUPPD:
+ amd64_sse_movddup_reg_reg (code, ins->dreg, ins->sreg1);
+ break;
+
+ case OP_EXTRACT_MASK:
+ amd64_sse_pmovmskb_reg_reg (code, ins->dreg, ins->sreg1);
+ break;
+
+ case OP_PAND:
+ amd64_sse_pand_reg_reg (code, ins->sreg1, ins->sreg2);
+ break;
+ case OP_POR:
+ amd64_sse_por_reg_reg (code, ins->sreg1, ins->sreg2);
+ break;
+ case OP_PXOR:
+ amd64_sse_pxor_reg_reg (code, ins->sreg1, ins->sreg2);
+ break;
+
+ case OP_PADDB:
+ amd64_sse_paddb_reg_reg (code, ins->sreg1, ins->sreg2);
+ break;
+ case OP_PADDW:
+ amd64_sse_paddw_reg_reg (code, ins->sreg1, ins->sreg2);
+ break;
+ case OP_PADDD:
+ amd64_sse_paddd_reg_reg (code, ins->sreg1, ins->sreg2);
+ break;
+ case OP_PADDQ:
+ amd64_sse_paddq_reg_reg (code, ins->sreg1, ins->sreg2);
+ break;
+#endif
case OP_LIVERANGE_START: {
if (cfg->verbose_level > 1)
printf ("R%d START=0x%x\n", MONO_VARINFO (cfg, ins->inst_c0)->vreg, (int)(code - cfg->native_code));
guint8 *buf, *no_domain_branch;
code = mono_amd64_emit_tls_get (code, AMD64_RAX, appdomain_tls_offset);
- if ((domain >> 32) == 0)
- amd64_mov_reg_imm_size (code, AMD64_ARG_REG1, domain, 4);
- else
- amd64_mov_reg_imm_size (code, AMD64_ARG_REG1, domain, 8);
+ if (cfg->compile_aot) {
+ /* AOT code is only used in the root domain */
+ amd64_mov_reg_imm (code, AMD64_ARG_REG1, 0);
+ } else {
+ if ((domain >> 32) == 0)
+ amd64_mov_reg_imm_size (code, AMD64_ARG_REG1, domain, 4);
+ else
+ amd64_mov_reg_imm_size (code, AMD64_ARG_REG1, domain, 8);
+ }
amd64_alu_reg_reg (code, X86_CMP, AMD64_RAX, AMD64_ARG_REG1);
no_domain_branch = code;
x86_branch8 (code, X86_CC_NE, 0, 0);
#endif
} else {
g_assert (!cfg->compile_aot);
- if ((domain >> 32) == 0)
- amd64_mov_reg_imm_size (code, AMD64_ARG_REG1, domain, 4);
- else
- amd64_mov_reg_imm_size (code, AMD64_ARG_REG1, domain, 8);
+ if (cfg->compile_aot) {
+ /* AOT code is only used in the root domain */
+ amd64_mov_reg_imm (code, AMD64_ARG_REG1, 0);
+ } else {
+ if ((domain >> 32) == 0)
+ amd64_mov_reg_imm_size (code, AMD64_ARG_REG1, domain, 4);
+ else
+ amd64_mov_reg_imm_size (code, AMD64_ARG_REG1, domain, 8);
+ }
code = emit_call (cfg, code, MONO_PATCH_INFO_INTERNAL_METHOD,
(gpointer)"mono_jit_thread_attach", TRUE);
}
if (method->save_lmf) {
if ((lmf_tls_offset != -1) && !optimize_for_xen) {
/*
- * Optimized version which uses the mono_lmf TLS variable instead of indirection
- * through the mono_lmf_addr TLS variable.
+ * Optimized version which uses the mono_lmf TLS variable instead of
+ * indirection through the mono_lmf_addr TLS variable.
*/
/* %rax = previous_lmf */
x86_prefix (code, X86_FS_PREFIX);
}
gpointer
-mono_arch_get_vcall_slot (guint8 *code, gpointer *regs, int *displacement)
+mono_arch_get_vcall_slot (guint8 *code, mgreg_t *regs, int *displacement)
{
guint8 buf [10];
guint32 reg;
g_assert (reg != AMD64_R11);
*displacement = disp;
- return regs [reg];
+ return (gpointer)regs [reg];
}
int
}
gpointer
-mono_arch_get_this_arg_from_call (MonoGenericSharingContext *gsctx, MonoMethodSignature *sig, gssize *regs, guint8 *code)
+mono_arch_get_this_arg_from_call (MonoGenericSharingContext *gsctx, MonoMethodSignature *sig, mgreg_t *regs, guint8 *code)
{
return (gpointer)regs [mono_arch_get_this_arg_reg (sig, gsctx, code)];
}
}
MonoMethod*
-mono_arch_find_imt_method (gpointer *regs, guint8 *code)
+mono_arch_find_imt_method (mgreg_t *regs, guint8 *code)
{
- return regs [MONO_ARCH_IMT_REG];
+ return (MonoMethod*)regs [MONO_ARCH_IMT_REG];
}
MonoObject*
-mono_arch_find_this_argument (gpointer *regs, MonoMethod *method, MonoGenericSharingContext *gsctx)
+mono_arch_find_this_argument (mgreg_t *regs, MonoMethod *method, MonoGenericSharingContext *gsctx)
{
- return mono_arch_get_this_arg_from_call (gsctx, mono_method_signature (method), (gssize*)regs, NULL);
+ return mono_arch_get_this_arg_from_call (gsctx, mono_method_signature (method), regs, NULL);
}
#endif
MonoVTable*
-mono_arch_find_static_call_vtable (gpointer *regs, guint8 *code)
+mono_arch_find_static_call_vtable (mgreg_t *regs, guint8 *code)
{
return (MonoVTable*) regs [MONO_ARCH_RGCTX_REG];
}
}
static gpointer
-decode_vcall_slot_from_ldr (guint32 ldr, gpointer *regs, int *displacement)
+decode_vcall_slot_from_ldr (guint32 ldr, mgreg_t *regs, int *displacement)
{
char *o = NULL;
int reg, offset = 0;
}
gpointer
-mono_arch_get_vcall_slot (guint8 *code_ptr, gpointer *regs, int *displacement)
+mono_arch_get_vcall_slot (guint8 *code_ptr, mgreg_t *regs, int *displacement)
{
guint32* code = (guint32*)code_ptr;
}
gpointer
-mono_arch_get_this_arg_from_call (MonoGenericSharingContext *gsctx, MonoMethodSignature *sig, gssize *regs, guint8 *code)
+mono_arch_get_this_arg_from_call (MonoGenericSharingContext *gsctx, MonoMethodSignature *sig, mgreg_t *regs, guint8 *code)
{
/* FIXME: handle returning a struct */
if (MONO_TYPE_ISSTRUCT (sig->ret))
}
MonoMethod*
-mono_arch_find_imt_method (gpointer *regs, guint8 *code)
+mono_arch_find_imt_method (mgreg_t *regs, guint8 *code)
{
guint32 *code_ptr = (guint32*)code;
code_ptr -= 2;
}
MonoObject*
-mono_arch_find_this_argument (gpointer *regs, MonoMethod *method, MonoGenericSharingContext *gsctx)
+mono_arch_find_this_argument (mgreg_t *regs, MonoMethod *method, MonoGenericSharingContext *gsctx)
{
- return mono_arch_get_this_arg_from_call (gsctx, mono_method_signature (method), (gssize*)regs, NULL);
+ return mono_arch_get_this_arg_from_call (gsctx, mono_method_signature (method), regs, NULL);
}
MonoVTable*
-mono_arch_find_static_call_vtable (gpointer *regs, guint8 *code)
+mono_arch_find_static_call_vtable (mgreg_t *regs, guint8 *code)
{
return (MonoVTable*) regs [MONO_ARCH_RGCTX_REG];
}
class = generic_info;
}
- if (class->generic_class || class->generic_container)
- context.class_inst = mini_class_get_context (class)->class_inst;
-
g_assert (!ji->method->klass->generic_container);
if (ji->method->klass->generic_class)
method_container_class = ji->method->klass->generic_class->container_class;
else
method_container_class = ji->method->klass;
+ /* class might refer to a subclass of ji->method's class */
+ while (class->generic_class && class->generic_class->container_class != method_container_class) {
+ class = class->parent;
+ g_assert (class);
+ }
+
+ if (class->generic_class || class->generic_container)
+ context.class_inst = mini_class_get_context (class)->class_inst;
+
if (class->generic_class)
g_assert (mono_class_has_parent_and_ignore_generics (class->generic_class->container_class, method_container_class));
else
{
MonoGenericContext context;
MonoMethod *method;
-
+
if (!ji->has_generic_jit_info || !mono_jit_info_get_generic_jit_info (ji)->has_this)
return ji->method;
context = get_generic_context_from_stack_frame (ji, generic_info);
}
gpointer
-mono_altstack_restore_prot (gssize *regs, guint8 *code, gpointer *tramp_data, guint8* tramp)
+mono_altstack_restore_prot (mgreg_t *regs, guint8 *code, gpointer *tramp_data, guint8* tramp)
{
void (*func)(void) = (gpointer)tramp_data;
func ();
* Determine the vtable slot used by a virtual call.
*/
gpointer*
-mono_arch_get_vcall_slot_addr (guint8 *code8, gpointer *regs)
+mono_arch_get_vcall_slot_addr (guint8 *code8, mgreg_t *regs)
{
guint32 *code = (guint32*)((unsigned long)code8 & ~3);
}
gpointer
-mono_arch_get_vcall_slot (guint8* code, gpointer *regs, int *displacement)
+mono_arch_get_vcall_slot (guint8* code, mgreg_t *regs, int *displacement)
{
guint8 *bundle2 = code - 48;
guint8 *bundle3 = code - 32;
}
gpointer*
-mono_arch_get_delegate_method_ptr_addr (guint8* code, gpointer *regs)
+mono_arch_get_delegate_method_ptr_addr (guint8* code, mgreg_t *regs)
{
NOT_IMPLEMENTED;
}
MonoMethod*
-mono_arch_find_imt_method (gpointer *regs, guint8 *code)
+mono_arch_find_imt_method (mgreg_t *regs, guint8 *code)
{
return regs [IA64_R9];
}
#endif
gpointer
-mono_arch_get_this_arg_from_call (MonoGenericSharingContext *gsctx, MonoMethodSignature *sig, gssize *regs, guint8 *code)
+mono_arch_get_this_arg_from_call (MonoGenericSharingContext *gsctx, MonoMethodSignature *sig, mgreg_t *regs, guint8 *code)
{
return (gpointer)regs [IA64_R10];
}
MonoObject*
-mono_arch_find_this_argument (gpointer *regs, MonoMethod *method, MonoGenericSharingContext *gsctx)
+mono_arch_find_this_argument (mgreg_t *regs, MonoMethod *method, MonoGenericSharingContext *gsctx)
{
- return mono_arch_get_this_arg_from_call (gsctx, mono_method_signature (method), (gssize*)regs, NULL);
+ return mono_arch_get_this_arg_from_call (gsctx, mono_method_signature (method), regs, NULL);
}
gpointer
gpointer
-mono_arch_get_this_arg_from_call (MonoGenericSharingContext *gsctx, MonoMethodSignature *sig, gssize *regs, guint8 *code)
+mono_arch_get_this_arg_from_call (MonoGenericSharingContext *gsctx, MonoMethodSignature *sig, mgreg_t *regs, guint8 *code)
{
/* FIXME: handle returning a struct */
if (MONO_TYPE_ISSTRUCT (sig->ret))
}
MonoMethod*
-mono_arch_find_imt_method (gpointer *regs, guint8 *code)
+mono_arch_find_imt_method (mgreg_t *regs, guint8 *code)
{
return (MonoMethod*) regs [MONO_ARCH_IMT_REG];
}
MonoObject*
-mono_arch_find_this_argument (gpointer *regs, MonoMethod *method, MonoGenericSharingContext *gsctx)
+mono_arch_find_this_argument (mgreg_t *regs, MonoMethod *method, MonoGenericSharingContext *gsctx)
{
- return mono_arch_get_this_arg_from_call (gsctx, mono_method_signature (method), (gssize*)regs, NULL);
+ return mono_arch_get_this_arg_from_call (gsctx, mono_method_signature (method), regs, NULL);
}
#endif
MonoVTable*
-mono_arch_find_static_call_vtable (gpointer *regs, guint8 *code)
+mono_arch_find_static_call_vtable (mgreg_t *regs, guint8 *code)
{
NOT_IMPLEMENTED;
return (MonoVTable*) regs [MONO_ARCH_RGCTX_REG];
}
gpointer
-mono_arch_get_vcall_slot (guint8 *code_ptr, gpointer *regs, int *displacement)
+mono_arch_get_vcall_slot (guint8 *code_ptr, mgreg_t *regs, int *displacement)
{
char *o = NULL;
int reg, offset = 0;
}
gpointer
-mono_arch_get_this_arg_from_call (MonoGenericSharingContext *gsctx, MonoMethodSignature *sig, gssize *regs, guint8 *code)
+mono_arch_get_this_arg_from_call (MonoGenericSharingContext *gsctx, MonoMethodSignature *sig, mgreg_t *regs, guint8 *code)
{
/* FIXME: handle returning a struct */
if (MONO_TYPE_ISSTRUCT (sig->ret))
conf_size = confstr ( _CS_GNU_LIBPTHREAD_VERSION, confbuf, sizeof(confbuf));
if ((conf_size > 4) && (strncmp (confbuf, "NPTL", 4) == 0))
tls_mode = TLS_MODE_NPTL;
- else
- tls_mode = TLS_MODE_LTHREADS;
#else
ins = (guint32*)pthread_getspecific;
/* uncond branch to the real method */
}
#endif
}
+ if (tls_mode == TLS_MODE_DETECT)
+ tls_mode = TLS_MODE_FAILED;
+ if (tls_mode == TLS_MODE_FAILED)
+ return;
if ((monodomain_key == -1) && (tls_mode == TLS_MODE_NPTL)) {
monodomain_key = mono_domain_get_tls_offset();
}
}
MonoMethod*
-mono_arch_find_imt_method (gpointer *regs, guint8 *code)
+mono_arch_find_imt_method (mgreg_t *regs, guint8 *code)
{
return (MonoMethod*) regs [MONO_ARCH_IMT_REG];
}
MonoObject*
-mono_arch_find_this_argument (gpointer *regs, MonoMethod *method, MonoGenericSharingContext *gsctx)
+mono_arch_find_this_argument (mgreg_t *regs, MonoMethod *method, MonoGenericSharingContext *gsctx)
{
- return mono_arch_get_this_arg_from_call (gsctx, mono_method_signature (method), (gssize*)regs, NULL);
+ return mono_arch_get_this_arg_from_call (gsctx, mono_method_signature (method), regs, NULL);
}
#endif
MonoVTable*
-mono_arch_find_static_call_vtable (gpointer *regs, guint8 *code)
+mono_arch_find_static_call_vtable (mgreg_t *regs, guint8 *code)
{
return (MonoVTable*) regs [MONO_ARCH_RGCTX_REG];
}
gboolean mono_ppc_is_direct_call_sequence (guint32 *code) MONO_INTERNAL;
-void mono_ppc_patch_plt_entry (guint8 *code, gpointer *got, gssize *regs, guint8 *addr) MONO_INTERNAL;
+void mono_ppc_patch_plt_entry (guint8 *code, gpointer *got, mgreg_t *regs, guint8 *addr) MONO_INTERNAL;
#endif /* __MONO_MINI_PPC_H__ */
* Determine the vtable slot used by a virtual call.
*/
gpointer
-mono_arch_get_vcall_slot (guint8 *code8, gpointer *regs, int *displacement)
+mono_arch_get_vcall_slot (guint8 *code8, mgreg_t *regs, int *displacement)
{
guint32 *code = (guint32*)(gpointer)code8;
guint32 ins = code [0];
}
MonoMethod*
-mono_arch_find_imt_method (gpointer *regs, guint8 *code)
+mono_arch_find_imt_method (mgreg_t *regs, guint8 *code)
{
#ifdef SPARCV9
g_assert_not_reached ();
}
MonoObject*
-mono_arch_find_this_argument (gpointer *regs, MonoMethod *method, MonoGenericSharingContext *gsctx)
+mono_arch_find_this_argument (mgreg_t *regs, MonoMethod *method, MonoGenericSharingContext *gsctx)
{
mono_sparc_flushw ();
gboolean mono_sparc_is_virtual_call (guint32 *code);
-gpointer* mono_sparc_get_vcall_slot_addr (guint32 *code, gpointer *regs);
+gpointer* mono_sparc_get_vcall_slot_addr (guint32 *code, mgreg_t *regs);
void mono_sparc_flushw (void);
static CRITICAL_SECTION trampolines_mutex;
static gpointer
-get_unbox_trampoline (MonoGenericSharingContext *gsctx, MonoMethod *m, gpointer addr)
+get_unbox_trampoline (MonoGenericSharingContext *gsctx, MonoMethod *m, gpointer addr, gboolean need_rgctx_tramp)
{
- if (mono_aot_only)
- return mono_aot_get_unbox_trampoline (m);
- else
+ if (mono_aot_only) {
+ if (need_rgctx_tramp)
+ /*
+ * The unbox trampolines call the method directly, so need to add
+ * an rgctx tramp before them.
+ */
+ return mono_create_static_rgctx_trampoline (m, mono_aot_get_unbox_trampoline (m));
+ else
+ return mono_aot_get_unbox_trampoline (m);
+ } else {
return mono_arch_get_unbox_trampoline (gsctx, m, addr);
+ }
}
#ifdef MONO_ARCH_HAVE_STATIC_RGCTX_TRAMPOLINE
#endif
gpointer*
-mono_get_vcall_slot_addr (guint8* code, gpointer *regs)
+mono_get_vcall_slot_addr (guint8* code, mgreg_t *regs)
{
gpointer vt;
int displacement;
#ifdef MONO_ARCH_HAVE_IMT
static gpointer*
-mono_convert_imt_slot_to_vtable_slot (gpointer* slot, gpointer *regs, guint8 *code, MonoMethod *method, MonoMethod **impl_method, gboolean *need_rgctx_tramp)
+mono_convert_imt_slot_to_vtable_slot (gpointer* slot, mgreg_t *regs, guint8 *code, MonoMethod *method, MonoMethod **impl_method, gboolean *need_rgctx_tramp)
{
MonoGenericSharingContext *gsctx = mono_get_generic_context_from_code (code);
MonoObject *this_argument = mono_arch_find_this_argument (regs, method, gsctx);
* This trampoline handles calls from JITted code.
*/
gpointer
-mono_magic_trampoline (gssize *regs, guint8 *code, MonoMethod *m, guint8* tramp)
+mono_magic_trampoline (mgreg_t *regs, guint8 *code, MonoMethod *m, guint8* tramp)
{
gpointer addr;
gpointer *vtable_slot;
if (m == MONO_FAKE_VTABLE_METHOD) {
int displacement;
- MonoVTable *vt = mono_arch_get_vcall_slot (code, (gpointer*)regs, &displacement);
+ MonoVTable *vt = mono_arch_get_vcall_slot (code, regs, &displacement);
if (!vt) {
int i;
MonoJitInfo *ji;
if (addr)
addr = mono_create_ftnptr (mono_domain_get (), addr);
if (addr && !vt->klass->valuetype) {
- vtable_slot = mono_get_vcall_slot_addr (code, (gpointer*)regs);
+ vtable_slot = mono_get_vcall_slot_addr (code, regs);
if (mono_aot_is_got_entry (code, (guint8*)vtable_slot) || mono_domain_owns_vtable_slot (mono_domain_get (), vtable_slot)) {
*vtable_slot = mono_get_addr_from_ftnptr (addr);
}
/* we get the interface method because mono_convert_imt_slot_to_vtable_slot ()
* needs the signature to be able to find the this argument
*/
- m = mono_arch_find_imt_method ((gpointer*)regs, code);
- vtable_slot = mono_get_vcall_slot_addr (code, (gpointer*)regs);
+ m = mono_arch_find_imt_method (regs, code);
+ vtable_slot = mono_get_vcall_slot_addr (code, regs);
g_assert (vtable_slot);
gsctx = mono_get_generic_context_from_code (code);
- this_arg = mono_arch_find_this_argument ((gpointer*)regs, m, gsctx);
+ this_arg = mono_arch_find_this_argument (regs, m, gsctx);
if (this_arg->vtable->klass == mono_defaults.transparent_proxy_class) {
/* Use the slow path for now */
proxy = TRUE;
m = mono_object_get_virtual_method (this_arg, m);
} else {
- vtable_slot = mono_convert_imt_slot_to_vtable_slot (vtable_slot, (gpointer*)regs, code, m, &impl_method, &need_rgctx_tramp);
+ vtable_slot = mono_convert_imt_slot_to_vtable_slot (vtable_slot, regs, code, m, &impl_method, &need_rgctx_tramp);
/* mono_convert_imt_slot_to_vtable_slot () also gives us the method that is supposed
* to be called, so we compile it and go ahead as usual.
*/
g_assert (!m->klass->generic_container);
#ifdef MONO_ARCH_HAVE_IMT
- generic_virtual = mono_arch_find_imt_method ((gpointer*)regs, code);
+ generic_virtual = mono_arch_find_imt_method (regs, code);
#endif
if (generic_virtual) {
g_assert (generic_virtual->is_inflated);
if (m->is_inflated && mono_method_get_context (m)->method_inst) {
#ifdef MONO_ARCH_RGCTX_REG
- MonoMethodRuntimeGenericContext *mrgctx = (MonoMethodRuntimeGenericContext*)mono_arch_find_static_call_vtable ((gpointer*)regs, code);
+ MonoMethodRuntimeGenericContext *mrgctx = (MonoMethodRuntimeGenericContext*)mono_arch_find_static_call_vtable (regs, code);
klass = mrgctx->class_vtable->klass;
method_inst = mrgctx->method_inst;
#endif
} else if ((m->flags & METHOD_ATTRIBUTE_STATIC) || m->klass->valuetype) {
#ifdef MONO_ARCH_RGCTX_REG
- MonoVTable *vtable = mono_arch_find_static_call_vtable ((gpointer*)regs, code);
+ MonoVTable *vtable = mono_arch_find_static_call_vtable (regs, code);
klass = vtable->klass;
#else
#endif
} else {
#ifdef MONO_ARCH_HAVE_IMT
- MonoObject *this_argument = mono_arch_find_this_argument ((gpointer*)regs, m,
+ MonoObject *this_argument = mono_arch_find_this_argument (regs, m,
mono_get_generic_context_from_code (code));
vt = this_argument->vtable;
- vtable_slot = mono_get_vcall_slot_addr (code, (gpointer*)regs);
+ vtable_slot = mono_get_vcall_slot_addr (code, regs);
g_assert (this_argument->vtable->klass->inited);
//mono_class_init (this_argument->vtable->klass);
if (generic_virtual) {
int displacement;
- MonoVTable *vt = mono_arch_get_vcall_slot (code, (gpointer*)regs, &displacement);
+ MonoVTable *vt = mono_arch_get_vcall_slot (code, regs, &displacement);
- vtable_slot = mono_get_vcall_slot_addr (code, (gpointer*)regs);
+ vtable_slot = mono_get_vcall_slot_addr (code, regs);
g_assert (vtable_slot);
if (vt->klass->valuetype)
- addr = get_unbox_trampoline (mono_get_generic_context_from_code (code), m, addr);
+ addr = get_unbox_trampoline (mono_get_generic_context_from_code (code), m, addr, need_rgctx_tramp);
mono_method_add_generic_virtual_invocation (mono_domain_get (),
vt, vtable_slot,
return addr;
}
- vtable_slot = mono_get_vcall_slot_addr (code, (gpointer*)regs);
+ vtable_slot = mono_get_vcall_slot_addr (code, regs);
if (vtable_slot) {
if (m->klass->valuetype)
- addr = get_unbox_trampoline (mono_get_generic_context_from_code (code), m, addr);
+ addr = get_unbox_trampoline (mono_get_generic_context_from_code (code), m, addr, need_rgctx_tramp);
g_assert (*vtable_slot);
if (!proxy && (mono_aot_is_got_entry (code, (guint8*)vtable_slot) || mono_domain_owns_vtable_slot (mono_domain_get (), vtable_slot))) {
#ifdef MONO_ARCH_HAVE_IMT
- vtable_slot = mono_convert_imt_slot_to_vtable_slot (vtable_slot, (gpointer*)regs, code, m, NULL, &need_rgctx_tramp);
+ vtable_slot = mono_convert_imt_slot_to_vtable_slot (vtable_slot, regs, code, m, NULL, &need_rgctx_tramp);
#endif
*vtable_slot = mono_get_addr_from_ftnptr (addr);
}
* This trampoline handles virtual calls when using LLVM.
*/
static gpointer
-mono_llvm_vcall_trampoline (gssize *regs, guint8 *code, MonoMethod *m, guint8 *tramp)
+mono_llvm_vcall_trampoline (mgreg_t *regs, guint8 *code, MonoMethod *m, guint8 *tramp)
{
MonoObject *this;
gpointer addr;
g_assert (addr);
if (m->klass->valuetype)
- addr = get_unbox_trampoline (mono_get_generic_context_from_code (code), m, addr);
+ addr = get_unbox_trampoline (mono_get_generic_context_from_code (code), m, addr, need_rgctx_tramp);
vtable_slot = &(vt->vtable [mono_method_get_vtable_slot (m)]);
g_assert (*vtable_slot);
if (!proxy && (mono_aot_is_got_entry (code, (guint8*)vtable_slot) || mono_domain_owns_vtable_slot (mono_domain_get (), vtable_slot))) {
#ifdef MONO_ARCH_HAVE_IMT
- vtable_slot = mono_convert_imt_slot_to_vtable_slot (vtable_slot, (gpointer*)regs, code, m, NULL, &need_rgctx_tramp);
+ vtable_slot = mono_convert_imt_slot_to_vtable_slot (vtable_slot, regs, code, m, NULL, &need_rgctx_tramp);
#endif
*vtable_slot = mono_get_addr_from_ftnptr (addr);
}
#endif
gpointer
-mono_generic_virtual_remoting_trampoline (gssize *regs, guint8 *code, MonoMethod *m, guint8 *tramp)
+mono_generic_virtual_remoting_trampoline (mgreg_t *regs, guint8 *code, MonoMethod *m, guint8 *tramp)
{
MonoGenericContext context = { NULL, NULL };
MonoMethod *imt_method, *declaring;
g_assert (!m->klass->generic_container);
#ifdef MONO_ARCH_HAVE_IMT
- imt_method = mono_arch_find_imt_method ((gpointer*)regs, code);
+ imt_method = mono_arch_find_imt_method (regs, code);
if (imt_method->is_inflated)
context.method_inst = ((MonoMethodInflated*)imt_method)->context.method_inst;
#endif
*/
#ifdef MONO_ARCH_AOT_SUPPORTED
gpointer
-mono_aot_trampoline (gssize *regs, guint8 *code, guint8 *token_info,
+mono_aot_trampoline (mgreg_t *regs, guint8 *code, guint8 *token_info,
guint8* tramp)
{
MonoImage *image;
addr = mono_create_ftnptr (mono_domain_get (), addr);
- vtable_slot = mono_get_vcall_slot_addr (code, (gpointer*)regs);
+ vtable_slot = mono_get_vcall_slot_addr (code, regs);
g_assert (!vtable_slot);
/* This is a normal call through a PLT entry */
#ifdef MONO_ARCH_HAVE_IMT
if (!method)
method = mono_get_method (image, token, NULL);
- vtable_slot = mono_convert_imt_slot_to_vtable_slot (vtable_slot, (gpointer*)regs, code, method, NULL, &need_rgctx_tramp);
+ vtable_slot = mono_convert_imt_slot_to_vtable_slot (vtable_slot, regs, code, method, NULL, &need_rgctx_tramp);
#endif
*vtable_slot = addr;
}
* This trampoline handles calls made from AOT code through the PLT table.
*/
gpointer
-mono_aot_plt_trampoline (gssize *regs, guint8 *code, guint8 *aot_module,
+mono_aot_plt_trampoline (mgreg_t *regs, guint8 *code, guint8 *aot_module,
guint8* tramp)
{
guint32 plt_info_offset = mono_aot_get_plt_info_offset (regs, code);
* for the type, then patches the caller code so it is not called again.
*/
void
-mono_class_init_trampoline (gssize *regs, guint8 *code, MonoVTable *vtable, guint8 *tramp)
+mono_class_init_trampoline (mgreg_t *regs, guint8 *code, MonoVTable *vtable, guint8 *tramp)
{
guint8 *plt_entry = mono_aot_get_plt_entry (code);
* for the type.
*/
void
-mono_generic_class_init_trampoline (gssize *regs, guint8 *code, MonoVTable *vtable, guint8 *tramp)
+mono_generic_class_init_trampoline (mgreg_t *regs, guint8 *code, MonoVTable *vtable, guint8 *tramp)
{
mono_runtime_class_init (vtable);
}
static gpointer
-mono_rgctx_lazy_fetch_trampoline (gssize *regs, guint8 *code, gpointer data, guint8 *tramp)
+mono_rgctx_lazy_fetch_trampoline (mgreg_t *regs, guint8 *code, gpointer data, guint8 *tramp)
{
#ifdef MONO_ARCH_VTABLE_REG
static gboolean inited = FALSE;
static int num_lookups = 0;
guint32 slot = GPOINTER_TO_UINT (data);
- gpointer arg = (gpointer)(gssize)regs [MONO_ARCH_VTABLE_REG];
+ mgreg_t *r = (mgreg_t*)regs;
+ gpointer arg = (gpointer)(gssize)r [MONO_ARCH_VTABLE_REG];
guint32 index = MONO_RGCTX_SLOT_INDEX (slot);
gboolean mrgctx = MONO_RGCTX_SLOT_IS_MRGCTX (slot);
}
void
-mono_monitor_enter_trampoline (gssize *regs, guint8 *code, MonoObject *obj, guint8 *tramp)
+mono_monitor_enter_trampoline (mgreg_t *regs, guint8 *code, MonoObject *obj, guint8 *tramp)
{
mono_monitor_enter (obj);
}
void
-mono_monitor_exit_trampoline (gssize *regs, guint8 *code, MonoObject *obj, guint8 *tramp)
+mono_monitor_exit_trampoline (mgreg_t *regs, guint8 *code, MonoObject *obj, guint8 *tramp)
{
mono_monitor_exit (obj);
}
* This is called once the first time a delegate is invoked, so it must be fast.
*/
gpointer
-mono_delegate_trampoline (gssize *regs, guint8 *code, gpointer *tramp_data, guint8* tramp)
+mono_delegate_trampoline (mgreg_t *regs, guint8 *code, gpointer *tramp_data, guint8* tramp)
{
MonoDomain *domain = mono_domain_get ();
MonoDelegate *delegate;
}
MonoMethod*
-mono_arch_find_imt_method (gpointer *regs, guint8 *code)
+mono_arch_find_imt_method (mgreg_t *regs, guint8 *code)
{
return (MonoMethod*) regs [MONO_ARCH_IMT_REG];
}
MonoObject*
-mono_arch_find_this_argument (gpointer *regs, MonoMethod *method, MonoGenericSharingContext *gsctx)
+mono_arch_find_this_argument (mgreg_t *regs, MonoMethod *method, MonoGenericSharingContext *gsctx)
{
MonoMethodSignature *sig = mono_method_signature (method);
CallInfo *cinfo = get_call_info (gsctx, NULL, sig, FALSE);
#endif
MonoVTable*
-mono_arch_find_static_call_vtable (gpointer *regs, guint8 *code)
+mono_arch_find_static_call_vtable (mgreg_t *regs, guint8 *code)
{
return (MonoVTable*) regs [MONO_ARCH_RGCTX_REG];
}
}
gpointer
-mono_arch_get_vcall_slot (guint8 *code, gpointer *regs, int *displacement)
+mono_arch_get_vcall_slot (guint8 *code, mgreg_t *regs, int *displacement)
{
guint8 buf [8];
guint8 reg = 0;
return NULL;
*displacement = disp;
- return regs [reg];
+ return (gpointer)regs [reg];
}
gpointer
mono_arch_get_this_arg_from_call (MonoGenericSharingContext *gsctx, MonoMethodSignature *sig,
- gssize *regs, guint8 *code)
+ mgreg_t *regs, guint8 *code)
{
guint32 esp = regs [X86_ESP];
CallInfo *cinfo = NULL;
void
mono_jit_thread_attach (MonoDomain *domain)
{
+ if (!domain)
+ /*
+ * Happens when called from AOTed code which is only used in the root
+ * domain.
+ */
+ domain = mono_get_root_domain ();
+
#ifdef HAVE_KW_THREAD
if (!mono_lmf_addr) {
mono_thread_attach (domain);
if (!default_opt_set)
default_opt = mono_parse_default_optimizations (NULL);
+ InitializeCriticalSection (&jit_mutex);
+
#ifdef MONO_DEBUGGER_SUPPORTED
if (mini_debug_running_inside_mdb ())
mini_debugger_init ();
mono_runtime_set_has_tls_get (FALSE);
#endif
- InitializeCriticalSection (&jit_mutex);
-
if (!global_codeman)
global_codeman = mono_code_manager_new ();
jit_icall_name_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
mono_install_get_class_from_name (mono_aot_get_class_from_name);
mono_install_jit_info_find_in_aot (mono_aot_find_jit_info);
+ mono_install_get_ip_from_sigctx (mono_arch_ip_from_context);
+
if (runtime_version)
domain = mono_init_version (filename, runtime_version);
else
gpointer mono_aot_get_method_from_token (MonoDomain *domain, MonoImage *image, guint32 token) MONO_INTERNAL;
gboolean mono_aot_is_got_entry (guint8 *code, guint8 *addr) MONO_INTERNAL;
guint8* mono_aot_get_plt_entry (guint8 *code) MONO_INTERNAL;
-guint32 mono_aot_get_plt_info_offset (gssize *regs, guint8 *code) MONO_INTERNAL;
+guint32 mono_aot_get_plt_info_offset (mgreg_t *regs, guint8 *code) MONO_INTERNAL;
gboolean mono_aot_get_cached_class_info (MonoClass *klass, MonoCachedClassInfo *res) MONO_INTERNAL;
gboolean mono_aot_get_class_from_name (MonoImage *image, const char *name_space, const char *name, MonoClass **klass) MONO_INTERNAL;
MonoJitInfo* mono_aot_find_jit_info (MonoDomain *domain, MonoImage *image, gpointer addr) MONO_INTERNAL;
gpointer mono_create_llvm_vcall_trampoline (MonoMethod *method) MONO_INTERNAL;
MonoVTable* mono_find_class_init_trampoline_by_addr (gconstpointer addr) MONO_INTERNAL;
guint32 mono_find_rgctx_lazy_fetch_trampoline_by_addr (gconstpointer addr) MONO_INTERNAL;
-gpointer mono_magic_trampoline (gssize *regs, guint8 *code, MonoMethod *m, guint8* tramp) MONO_INTERNAL;
-gpointer mono_generic_virtual_remoting_trampoline (gssize *regs, guint8 *code, MonoMethod *m, guint8 *tramp) MONO_INTERNAL;
-gpointer mono_delegate_trampoline (gssize *regs, guint8 *code, gpointer *tramp_data, guint8* tramp) MONO_INTERNAL;
-gpointer mono_aot_trampoline (gssize *regs, guint8 *code, guint8 *token_info,
+gpointer mono_magic_trampoline (mgreg_t *regs, guint8 *code, MonoMethod *m, guint8* tramp) MONO_INTERNAL;
+gpointer mono_generic_virtual_remoting_trampoline (mgreg_t *regs, guint8 *code, MonoMethod *m, guint8 *tramp) MONO_INTERNAL;
+gpointer mono_delegate_trampoline (mgreg_t *regs, guint8 *code, gpointer *tramp_data, guint8* tramp) MONO_INTERNAL;
+gpointer mono_aot_trampoline (mgreg_t *regs, guint8 *code, guint8 *token_info,
guint8* tramp) MONO_INTERNAL;
-gpointer mono_aot_plt_trampoline (gssize *regs, guint8 *code, guint8 *token_info,
+gpointer mono_aot_plt_trampoline (mgreg_t *regs, guint8 *code, guint8 *token_info,
guint8* tramp) MONO_INTERNAL;
-void mono_class_init_trampoline (gssize *regs, guint8 *code, MonoVTable *vtable, guint8 *tramp) MONO_INTERNAL;
-void mono_generic_class_init_trampoline (gssize *regs, guint8 *code, MonoVTable *vtable, guint8 *tramp) MONO_INTERNAL;
-void mono_monitor_enter_trampoline (gssize *regs, guint8 *code, MonoObject *obj, guint8 *tramp) MONO_INTERNAL;
-void mono_monitor_exit_trampoline (gssize *regs, guint8 *code, MonoObject *obj, guint8 *tramp) MONO_INTERNAL;
+void mono_class_init_trampoline (mgreg_t *regs, guint8 *code, MonoVTable *vtable, guint8 *tramp) MONO_INTERNAL;
+void mono_generic_class_init_trampoline (mgreg_t *regs, guint8 *code, MonoVTable *vtable, guint8 *tramp) MONO_INTERNAL;
+void mono_monitor_enter_trampoline (mgreg_t *regs, guint8 *code, MonoObject *obj, guint8 *tramp) MONO_INTERNAL;
+void mono_monitor_exit_trampoline (mgreg_t *regs, guint8 *code, MonoObject *obj, guint8 *tramp) MONO_INTERNAL;
gconstpointer mono_get_trampoline_func (MonoTrampolineType tramp_type);
gpointer mini_get_vtable_trampoline (void) MONO_INTERNAL;
-gpointer* mono_get_vcall_slot_addr (guint8* code, gpointer *regs) MONO_INTERNAL;
+gpointer* mono_get_vcall_slot_addr (guint8* code, mgreg_t *regs) MONO_INTERNAL;
gboolean mono_running_on_valgrind (void) MONO_INTERNAL;
void* mono_global_codeman_reserve (int size) MONO_INTERNAL;
gboolean mono_arch_is_int_overflow (void *sigctx, void *info) MONO_INTERNAL;
void mono_arch_invalidate_method (MonoJitInfo *ji, void *func, gpointer func_arg) MONO_INTERNAL;
guint32 mono_arch_get_patch_offset (guint8 *code) MONO_INTERNAL;
-gpointer mono_arch_get_vcall_slot (guint8 *code, gpointer *regs, int *displacement) MONO_INTERNAL;
-gpointer*mono_arch_get_delegate_method_ptr_addr (guint8* code, gpointer *regs) MONO_INTERNAL;
+gpointer mono_arch_get_vcall_slot (guint8 *code, mgreg_t *regs, int *displacement) MONO_INTERNAL;
+gpointer*mono_arch_get_delegate_method_ptr_addr (guint8* code, mgreg_t *regs) MONO_INTERNAL;
void mono_arch_create_vars (MonoCompile *cfg) MONO_INTERNAL;
void mono_arch_save_unwind_info (MonoCompile *cfg) MONO_INTERNAL;
void mono_arch_register_lowlevel_calls (void) MONO_INTERNAL;
gpointer mono_arch_get_unbox_trampoline (MonoGenericSharingContext *gsctx, MonoMethod *m, gpointer addr) MONO_INTERNAL;
gpointer mono_arch_get_static_rgctx_trampoline (MonoMethod *m, MonoMethodRuntimeGenericContext *mrgctx, gpointer addr) MONO_INTERNAL;
void mono_arch_patch_callsite (guint8 *method_start, guint8 *code, guint8 *addr) MONO_INTERNAL;
-void mono_arch_patch_plt_entry (guint8 *code, gpointer *got, gssize *regs, guint8 *addr) MONO_INTERNAL;
-void mono_arch_nullify_class_init_trampoline(guint8 *code, gssize *regs) MONO_INTERNAL;
-void mono_arch_nullify_plt_entry (guint8 *code, gssize *regs) MONO_INTERNAL;
+void mono_arch_patch_plt_entry (guint8 *code, gpointer *got, mgreg_t *regs, guint8 *addr) MONO_INTERNAL;
+void mono_arch_nullify_class_init_trampoline(guint8 *code, mgreg_t *regs) MONO_INTERNAL;
+void mono_arch_nullify_plt_entry (guint8 *code, mgreg_t *regs) MONO_INTERNAL;
int mono_arch_get_this_arg_reg (MonoMethodSignature *sig, MonoGenericSharingContext *gsctx, guint8 *code) MONO_INTERNAL;
-gpointer mono_arch_get_this_arg_from_call (MonoGenericSharingContext *gsctx, MonoMethodSignature *sig, gssize *regs, guint8 *code) MONO_INTERNAL;
-MonoObject* mono_arch_find_this_argument (gpointer *regs, MonoMethod *method, MonoGenericSharingContext *gsctx) MONO_INTERNAL;
+gpointer mono_arch_get_this_arg_from_call (MonoGenericSharingContext *gsctx, MonoMethodSignature *sig, mgreg_t *regs, guint8 *code) MONO_INTERNAL;
+MonoObject* mono_arch_find_this_argument (mgreg_t *regs, MonoMethod *method, MonoGenericSharingContext *gsctx) MONO_INTERNAL;
gpointer mono_arch_get_delegate_invoke_impl (MonoMethodSignature *sig, gboolean has_target) MONO_INTERNAL;
gpointer mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain, guint32 *code_len) MONO_INTERNAL;
void mono_arch_emit_imt_argument (MonoCompile *cfg, MonoCallInst *call, MonoInst *imt_arg) MONO_INTERNAL;
-MonoMethod* mono_arch_find_imt_method (gpointer *regs, guint8 *code) MONO_INTERNAL;
-MonoVTable* mono_arch_find_static_call_vtable (gpointer *regs, guint8 *code) MONO_INTERNAL;
+MonoMethod* mono_arch_find_imt_method (mgreg_t *regs, guint8 *code) MONO_INTERNAL;
+MonoVTable* mono_arch_find_static_call_vtable (mgreg_t *regs, guint8 *code) MONO_INTERNAL;
gpointer mono_arch_build_imt_thunk (MonoVTable *vtable, MonoDomain *domain, MonoIMTCheckItem **imt_entries, int count, gpointer fail_tramp) MONO_INTERNAL;
void mono_arch_notify_pending_exc (void) MONO_INTERNAL;
void mono_jit_walk_stack_from_ctx (MonoStackWalk func, MonoContext *ctx, gboolean do_il_offset, gpointer user_data) MONO_INTERNAL;
void mono_setup_altstack (MonoJitTlsData *tls) MONO_INTERNAL;
void mono_free_altstack (MonoJitTlsData *tls) MONO_INTERNAL;
-gpointer mono_altstack_restore_prot (gssize *regs, guint8 *code, gpointer *tramp_data, guint8* tramp) MONO_INTERNAL;
+gpointer mono_altstack_restore_prot (mgreg_t *regs, guint8 *code, gpointer *tramp_data, guint8* tramp) MONO_INTERNAL;
MonoJitInfo * mono_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls, MonoJitInfo *res, MonoJitInfo *prev_ji, MonoContext *ctx, MonoContext *new_ctx, char **trace, MonoLMF **lmf, int *native_offset, gboolean *managed) MONO_INTERNAL;
/*========================= End of Function ========================*/
void
-mono_arch_nullify_class_init_trampoline (guint8 *code, gssize *regs)
+mono_arch_nullify_class_init_trampoline (guint8 *code, mgreg_t *regs)
{
unsigned int *pcode = (unsigned int *)code;
}
void
-mono_arch_nullify_plt_entry (guint8 *code, gssize *regs)
+mono_arch_nullify_plt_entry (guint8 *code, mgreg_t *regs)
{
g_assert_not_reached ();
}
void
-mono_arch_patch_plt_entry (guint8 *code, gpointer *got, gssize *regs, guint8 *addr)
+mono_arch_patch_plt_entry (guint8 *code, gpointer *got, mgreg_t *regs, guint8 *addr)
{
g_assert_not_reached ();
}
}
void
-mono_arch_patch_plt_entry (guint8 *code, gpointer *got, gssize *regs, guint8 *addr)
+mono_arch_patch_plt_entry (guint8 *code, gpointer *got, mgreg_t *regs, guint8 *addr)
{
gint32 disp;
gpointer *plt_jump_table_entry;
}
void
-mono_arch_nullify_class_init_trampoline (guint8 *code, gssize *regs)
+mono_arch_nullify_class_init_trampoline (guint8 *code, mgreg_t *regs)
{
guint8 buf [16];
gboolean can_write = mono_breakpoint_clean_code (NULL, code, 7, buf, sizeof (buf));
gpointer *vtable_slot;
/* call *<OFFSET>(%rip) */
- vtable_slot = mono_get_vcall_slot_addr (code + 3, (gpointer*)regs);
+ vtable_slot = mono_get_vcall_slot_addr (code + 3, regs);
g_assert (vtable_slot);
*vtable_slot = nullified_class_init_trampoline;
}
void
-mono_arch_nullify_plt_entry (guint8 *code, gssize *regs)
+mono_arch_nullify_plt_entry (guint8 *code, mgreg_t *regs)
{
if (mono_aot_only && !nullified_class_init_trampoline)
nullified_class_init_trampoline = mono_aot_get_named_code ("nullified_class_init_trampoline");
}
void
-mono_arch_patch_plt_entry (guint8 *code, gpointer *got, gssize *regs, guint8 *addr)
+mono_arch_patch_plt_entry (guint8 *code, gpointer *got, mgreg_t *regs, guint8 *addr)
{
guint8 *jump_entry;
}
void
-mono_arch_nullify_class_init_trampoline (guint8 *code, gssize *regs)
+mono_arch_nullify_class_init_trampoline (guint8 *code, mgreg_t *regs)
{
mono_arch_patch_callsite (NULL, code, nullified_class_init_trampoline);
}
void
-mono_arch_nullify_plt_entry (guint8 *code, gssize *regs)
+mono_arch_nullify_plt_entry (guint8 *code, mgreg_t *regs)
{
if (mono_aot_only && !nullified_class_init_trampoline)
nullified_class_init_trampoline = mono_aot_get_named_code ("nullified_class_init_trampoline");
}
void
-mono_arch_patch_plt_entry (guint8 *code, gpointer *got, gssize *regs, guint8 *addr)
+mono_arch_patch_plt_entry (guint8 *code, gpointer *got, mgreg_t *regs, guint8 *addr)
{
g_assert_not_reached ();
}
void
-mono_arch_nullify_class_init_trampoline (guint8 *code8, gssize *regs)
+mono_arch_nullify_class_init_trampoline (guint8 *code8, mgreg_t *regs)
{
guint32 *buf = (guint32 *)((unsigned long)code8 & ~3);
guint32 *code = buf;
}
void
-mono_arch_nullify_plt_entry (guint8 *code, gssize *regs)
+mono_arch_nullify_plt_entry (guint8 *code, mgreg_t *regs)
{
g_assert_not_reached ();
}
hppa_ldo (buf, HPPA_STACK_LMF_OFFSET, hppa_r3, hppa_r1);
hppa_stw (buf, hppa_r1, 0, hppa_r28);
- /* Call mono_magic_trampoline (gssize *regs, guint8 *code, MonoMethod *m, guint8* tramp) */
+ /* Call mono_magic_trampoline (mgreg_t *regs, guint8 *code, MonoMethod *m, guint8* tramp) */
hppa_ldo (buf, HPPA_STACK_LMF_OFFSET + G_STRUCT_OFFSET (MonoLMF, regs), hppa_r3, hppa_r26);
hppa_ldw (buf, HPPA_STACK_LMF_OFFSET + G_STRUCT_OFFSET (MonoLMF, method), hppa_r3, hppa_r24);
if (tramp_type == MONO_TRAMPOLINE_JUMP)
}
void
-mono_arch_patch_plt_entry (guint8 *code, gpointer *got, gssize *regs, guint8 *addr)
+mono_arch_patch_plt_entry (guint8 *code, gpointer *got, mgreg_t *regs, guint8 *addr)
{
g_assert_not_reached ();
}
void
-mono_arch_nullify_class_init_trampoline (guint8 *code, gssize *regs)
+mono_arch_nullify_class_init_trampoline (guint8 *code, mgreg_t *regs)
{
guint8 *callsite_begin;
guint64 *callsite = (guint64*)(gpointer)(code - 16);
}
void
-mono_arch_nullify_plt_entry (guint8 *code, gssize *regs)
+mono_arch_nullify_plt_entry (guint8 *code, mgreg_t *regs)
{
g_assert_not_reached ();
}
}
void
-mono_arch_patch_plt_entry (guint8 *code, gpointer *got, gssize *regs, guint8 *addr)
+mono_arch_patch_plt_entry (guint8 *code, gpointer *got, mgreg_t *regs, guint8 *addr)
{
g_assert_not_reached ();
}
gpointer
-mono_arch_get_vcall_slot (guint8 *code_ptr, gpointer *regs, int *displacement)
+mono_arch_get_vcall_slot (guint8 *code_ptr, mgreg_t *regs, int *displacement)
{
char *o = NULL;
char *vtable = NULL;
}
void
-mono_arch_nullify_plt_entry (guint8 *code, gssize *regs)
+mono_arch_nullify_plt_entry (guint8 *code, mgreg_t *regs)
{
g_assert_not_reached ();
}
void
-mono_arch_nullify_class_init_trampoline (guint8 *code, gssize *regs)
+mono_arch_nullify_class_init_trampoline (guint8 *code, mgreg_t *regs)
{
guint32 *code32 = (guint32*)code;
}
void
-mono_arch_patch_plt_entry (guint8 *code, gpointer *got, gssize *regs, guint8 *addr)
+mono_arch_patch_plt_entry (guint8 *code, gpointer *got, mgreg_t *regs, guint8 *addr)
{
guint32 ins1, ins2, offset;
- mgreg_t *r = (mgreg_t*)regs;
/* Patch the jump table entry used by the plt entry */
/* Either got or regs is set */
if (!got)
- got = (gpointer*)r [30];
+ got = (gpointer*)regs [30];
*(guint8**)((guint8*)got + offset) = addr;
}
void
-mono_arch_nullify_class_init_trampoline (guint8 *code, gssize *regs)
+mono_arch_nullify_class_init_trampoline (guint8 *code, mgreg_t *regs)
{
mono_arch_patch_callsite (NULL, code, nullified_class_init_trampoline);
}
void
-mono_arch_nullify_plt_entry (guint8 *code, gssize *regs)
+mono_arch_nullify_plt_entry (guint8 *code, mgreg_t *regs)
{
if (mono_aot_only && !nullified_class_init_trampoline)
nullified_class_init_trampoline = mono_aot_get_named_code ("nullified_class_init_trampoline");
ppc_stptr (buf, ppc_r0, G_STRUCT_OFFSET(MonoLMF, eip), ppc_r11);
/*
- * Now we're ready to call trampoline (gssize *regs, guint8 *code, gpointer value, guint8 *tramp)
+ * Now we're ready to call trampoline (mgreg_t *regs, guint8 *code, gpointer value, guint8 *tramp)
* Note that the last argument is unused.
*/
/* Arg 1: a pointer to the registers */
/*========================= End of Function ========================*/
void
-mono_arch_patch_plt_entry (guint8 *code, gpointer *got, gssize *regs, guint8 *addr)
+mono_arch_patch_plt_entry (guint8 *code, gpointer *got, mgreg_t *regs, guint8 *addr)
{
g_assert_not_reached ();
}
/*------------------------------------------------------------------*/
void
-mono_arch_nullify_class_init_trampoline (guint8 *code, gssize *regs)
+mono_arch_nullify_class_init_trampoline (guint8 *code, mgreg_t *regs)
{
char patch[6] = {0x47, 0x00, 0x00, 0x00, 0x07, 0x00};
/*========================= End of Function ========================*/
void
-mono_arch_nullify_plt_entry (guint8 *code, gssize *regs)
+mono_arch_nullify_plt_entry (guint8 *code, mgreg_t *regs)
{
g_assert_not_reached ();
}
/*------------------------------------------------------------------*/
gpointer
-mono_arch_get_vcall_slot (guint8 *code, gpointer *regs, int *displacement)
+mono_arch_get_vcall_slot (guint8 *code, mgreg_t *regs, int *displacement)
{
int reg;
guchar* base;
/* Set arguments */
- /* Arg 1: gssize *regs. We pass sp instead */
+ /* Arg 1: mgreg_t *regs. We pass sp instead */
s390_lr (buf, s390_r2, STK_BASE);
s390_ahi (buf, s390_r2, CREATE_STACK_SIZE);
/*========================= End of Function ========================*/
void
-mono_arch_patch_plt_entry (guint8 *code, gpointer *got, gssize *regs, guint8 *addr)
+mono_arch_patch_plt_entry (guint8 *code, gpointer *got, mgreg_t *regs, guint8 *addr)
{
g_assert_not_reached ();
}
/*------------------------------------------------------------------*/
void
-mono_arch_nullify_class_init_trampoline (guint8 *code, gssize *regs)
+mono_arch_nullify_class_init_trampoline (guint8 *code, mgreg_t *regs)
{
char patch[2] = {0x07, 0x00};
/*========================= End of Function ========================*/
void
-mono_arch_nullify_plt_entry (guint8 *code, gssize *regs)
+mono_arch_nullify_plt_entry (guint8 *code, mgreg_t *regs)
{
g_assert_not_reached ();
}
/*------------------------------------------------------------------*/
gpointer
-mono_arch_get_vcall_slot (guint8 *code, gpointer *regs, int *displacement)
+mono_arch_get_vcall_slot (guint8 *code, mgreg_t *regs, int *displacement)
{
int reg, lkReg;
guchar* base;
/* Set arguments */
- /* Arg 1: gssize *regs. We pass sp instead */
+ /* Arg 1: mgreg_t *regs. We pass sp instead */
s390_lgr (buf, s390_r2, STK_BASE);
s390_ahi (buf, s390_r2, CREATE_STACK_SIZE);
}
void
-mono_arch_patch_plt_entry (guint8 *code, gpointer *got, gssize *regs, guint8 *addr)
+mono_arch_patch_plt_entry (guint8 *code, gpointer *got, mgreg_t *regs, guint8 *addr)
{
g_assert_not_reached ();
}
void
-mono_arch_nullify_class_init_trampoline (guint8 *code, gssize *regs)
+mono_arch_nullify_class_init_trampoline (guint8 *code, mgreg_t *regs)
{
/* Patch calling code */
sparc_nop (code);
}
void
-mono_arch_nullify_plt_entry (guint8 *code, gssize *regs)
+mono_arch_nullify_plt_entry (guint8 *code, mgreg_t *regs)
{
g_assert_not_reached ();
}
}
void
-mono_arch_patch_plt_entry (guint8 *code, gpointer *got, gssize *regs, guint8 *addr)
+mono_arch_patch_plt_entry (guint8 *code, gpointer *got, mgreg_t *regs, guint8 *addr)
{
/* A PLT entry: jmp <DISP> */
g_assert (code [0] == 0xe9);
}
void
-mono_arch_nullify_class_init_trampoline (guint8 *code, gssize *regs)
+mono_arch_nullify_class_init_trampoline (guint8 *code, mgreg_t *regs)
{
guint8 buf [16];
gboolean can_write = mono_breakpoint_clean_code (NULL, code, 6, buf, sizeof (buf));
/* call *<OFFSET>(<REG>) -> Call made from AOT code */
gpointer *vtable_slot;
- vtable_slot = mono_get_vcall_slot_addr (code + 5, (gpointer*)regs);
+ vtable_slot = mono_get_vcall_slot_addr (code + 5, regs);
g_assert (vtable_slot);
*vtable_slot = nullified_class_init_trampoline;
}
void
-mono_arch_nullify_plt_entry (guint8 *code, gssize *regs)
+mono_arch_nullify_plt_entry (guint8 *code, mgreg_t *regs)
{
if (!mono_running_on_valgrind ()) {
guint32 ops;
*/
void
mono_unwind_frame (guint8 *unwind_info, guint32 unwind_info_len,
- guint8 *start_ip, guint8 *end_ip, guint8 *ip, gssize *regs,
+ guint8 *start_ip, guint8 *end_ip, guint8 *ip, mgreg_t *regs,
int nregs, guint8 **out_cfa)
{
Loc locations [NUM_REGS];
void
mono_unwind_frame (guint8 *unwind_info, guint32 unwind_info_len,
- guint8 *start_ip, guint8 *end_ip, guint8 *ip, gssize *regs,
+ guint8 *start_ip, guint8 *end_ip, guint8 *ip, mgreg_t *regs,
int nregs, guint8 **out_cfa) MONO_INTERNAL;
void mono_unwind_init (void) MONO_INTERNAL;
projects / mono.git / commitdiff