#include <mono/metadata/appdomain.h>
#include <mono/metadata/marshal.h>
#include <mono/metadata/tabledefs.h>
-#include <mono/metadata/mono-debug-debugger.h>
#include "mini.h"
#include "mini-sparc.h"
mono_arch_get_unbox_trampoline (MonoMethod *m, gpointer addr)
{
guint8 *code, *start;
- int this_pos = 4, reg;
+ int reg;
- if (!mono_method_signature (m)->ret->byref && MONO_TYPE_ISSTRUCT (mono_method_signature (m)->ret))
- this_pos = 8;
-
start = code = mono_global_codeman_reserve (36);
/* This executes in the context of the caller, hence o0 */
}
void
-mono_arch_patch_callsite (guint8 *code, guint8 *addr)
+mono_arch_patch_callsite (guint8 *method_start, guint8 *code, guint8 *addr)
{
- if (sparc_inst_op (*code) == 0x1) {
+ if (sparc_inst_op (*(guint32*)code) == 0x1) {
sparc_call_simple (code, (guint8*)addr - (guint8*)code);
}
}
void
-mono_arch_nullify_class_init_trampoline (guint8 *code, gssize *regs)
+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, mgreg_t *regs)
{
/* Patch calling code */
sparc_nop (code);
}
+void
+mono_arch_nullify_plt_entry (guint8 *code, mgreg_t *regs)
+{
+ g_assert_not_reached ();
+}
+
#define ALIGN_TO(val,align) (((val) + ((align) - 1)) & ~((align) - 1))
guchar*
-mono_arch_create_trampoline_code (MonoTrampolineType tramp_type)
+mono_arch_create_generic_trampoline (MonoTrampolineType tramp_type, MonoTrampInfo **info, gboolean aot)
{
guint8 *buf, *code, *tramp_addr;
guint32 lmf_offset, regs_offset, method_reg, i;
gboolean has_caller;
+ g_assert (!aot);
+ if (info)
+ *info = NULL;
+
if (tramp_type == MONO_TRAMPOLINE_JUMP)
has_caller = FALSE;
else
method_reg = sparc_g1;
#endif
+ regs_offset = MONO_SPARC_STACK_BIAS + 1000;
+
+ /* Save r1 needed by the IMT code */
+ sparc_sti_imm (code, sparc_g1, sparc_sp, regs_offset + (sparc_g1 * sizeof (gpointer)));
+
+ /*
+ * sparc_g5 contains the return address, the trampoline argument is stored in the
+ * instruction stream after the call.
+ */
+ sparc_ld_imm (code, sparc_g5, 8, method_reg);
+
#ifdef SPARCV9
/* Save fp regs since they are not preserved by calls */
for (i = 0; i < 16; i ++)
code = mono_sparc_emit_save_lmf (code, lmf_offset);
- regs_offset = MONO_SPARC_STACK_BIAS + 1000;
-
if (has_caller) {
/* Load all registers of the caller into a table inside this frame */
/* first the out registers */
for (i = 0; i < 8; ++i)
- sparc_sti_imm (code, sparc_i0 + i, sparc_sp, regs_offset + (i * sizeof (gpointer)));
+ sparc_sti_imm (code, sparc_i0 + i, sparc_sp, regs_offset + ((sparc_o0 + i) * sizeof (gpointer)));
/* then the in+local registers */
for (i = 0; i < 16; i ++) {
sparc_ldi_imm (code, sparc_fp, MONO_SPARC_STACK_BIAS + (i * sizeof (gpointer)), sparc_o7);
- sparc_sti_imm (code, sparc_o7, sparc_sp, regs_offset + ((i + 8) * sizeof (gpointer)));
+ sparc_sti_imm (code, sparc_o7, sparc_sp, regs_offset + ((sparc_l0 + i) * sizeof (gpointer)));
}
}
- if (tramp_type == MONO_TRAMPOLINE_CLASS_INIT)
- tramp_addr = &mono_class_init_trampoline;
- else
- tramp_addr = &mono_magic_trampoline;
- sparc_ldi_imm (code, sparc_sp, MONO_SPARC_STACK_BIAS + 200, sparc_o0);
+ tramp_addr = mono_get_trampoline_func (tramp_type);
+ sparc_ldi_imm (code, sparc_sp, MONO_SPARC_STACK_BIAS + 200, sparc_o2);
/* pass address of register table as third argument */
- sparc_add_imm (code, FALSE, sparc_sp, regs_offset, sparc_o2);
+ sparc_add_imm (code, FALSE, sparc_sp, regs_offset, sparc_o0);
sparc_set (code, tramp_addr, sparc_o7);
/* set %o1 to caller address */
if (has_caller)
sparc_mov_reg_reg (code, sparc_i7, sparc_o1);
else
sparc_set (code, 0, sparc_o1);
+ sparc_set (code, 0, sparc_o3);
sparc_jmpl (code, sparc_o7, sparc_g0, sparc_o7);
sparc_nop (code);
/* Save result */
sparc_sti_imm (code, sparc_o0, sparc_sp, MONO_SPARC_STACK_BIAS + 304);
+ /* Check for thread interruption */
+ sparc_set (code, (guint8*)mono_thread_force_interruption_checkpoint, sparc_o7);
+ sparc_jmpl (code, sparc_o7, sparc_g0, sparc_o7);
+ sparc_nop (code);
+
/* Restore lmf */
code = mono_sparc_emit_restore_lmf (code, lmf_offset);
return buf;
}
-#define TRAMPOLINE_SIZE (((SPARC_SET_MAX_SIZE >> 2) * 2) + 2)
+#define TRAMPOLINE_SIZE (SPARC_SET_MAX_SIZE + 3)
-static MonoJitInfo*
-create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain)
+gpointer
+mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain, guint32 *code_len)
{
- MonoJitInfo *ji;
guint32 *code, *buf, *tramp;
tramp = mono_get_trampoline_code (tramp_type);
- mono_domain_lock (domain);
- code = buf = mono_code_manager_reserve (domain->code_mp, TRAMPOLINE_SIZE * 4);
- mono_domain_unlock (domain);
+ code = buf = mono_domain_code_reserve (domain, TRAMPOLINE_SIZE * 4);
/* We have to use g5 here because there is no other free register */
sparc_set (code, tramp, sparc_g5);
+ sparc_jmpl (code, sparc_g5, sparc_g0, sparc_g5);
+ sparc_nop (code);
#ifdef SPARCV9
- sparc_set (code, arg1, sparc_g4);
+ g_assert_not_reached ();
#else
- sparc_set (code, arg1, sparc_g1);
+ *code = (guint32)arg1;
+ code ++;
#endif
- sparc_jmpl (code, sparc_g5, sparc_g0, sparc_g0);
- sparc_nop (code);
g_assert ((code - buf) <= TRAMPOLINE_SIZE);
- ji = g_new0 (MonoJitInfo, 1);
- ji->code_start = buf;
- ji->code_size = (code - buf) * 4;
-
- mono_jit_stats.method_trampolines++;
+ if (code_len)
+ *code_len = (code - buf) * 4;
- mono_arch_flush_icache (ji->code_start, ji->code_size);
+ mono_arch_flush_icache ((guint8*)buf, (code - buf) * 4);
- return ji;
+ return buf;
}
-MonoJitInfo*
-mono_arch_create_jump_trampoline (MonoMethod *method)
-{
- MonoJitInfo *ji = create_specific_trampoline (method, MONO_TRAMPOLINE_JUMP, mono_domain_get ());
-
- ji->method = method;
- return ji;
-}
-
-/**
- * mono_arch_create_jit_trampoline:
- * @method: pointer to the method info
- *
- * Creates a trampoline function for virtual methods. If the created
- * code is called it first starts JIT compilation of method,
- * and then calls the newly created method. I also replaces the
- * corresponding vtable entry (see sparc_magic_trampoline).
- *
- * Returns: a pointer to the newly created code
- */
-gpointer
-mono_arch_create_jit_trampoline (MonoMethod *method)
-{
- MonoJitInfo *ji;
- gpointer code_start;
-
- ji = create_specific_trampoline (method, MONO_TRAMPOLINE_GENERIC, mono_domain_get ());
- code_start = ji->code_start;
- g_free (ji);
-
- return code_start;
-}
-
-/**
- * mono_arch_create_class_init_trampoline:
- * @vtable: the type to initialize
- *
- * Creates a trampoline function to run a type initializer.
- * If the trampoline is called, it calls mono_runtime_class_init with the
- * given vtable, then patches the caller code so it does not get called any
- * more.
- *
- * Returns: a pointer to the newly created code
- */
gpointer
-mono_arch_create_class_init_trampoline (MonoVTable *vtable)
+mono_arch_create_rgctx_lazy_fetch_trampoline (guint32 slot, MonoTrampInfo **info, gboolean aot)
{
- MonoJitInfo *ji;
- gpointer code;
-
- ji = create_specific_trampoline (vtable, MONO_TRAMPOLINE_CLASS_INIT, vtable->domain);
- code = ji->code_start;
- g_free (ji);
-
- return code;
-}
-
-/*
- * This method is only called when running in the Mono Debugger.
- */
-gpointer
-mono_debugger_create_notification_function (gpointer *notification_address)
-{
- guint8 *ptr, *buf;
-
- ptr = buf = mono_global_codeman_reserve (16);
- if (notification_address)
- *notification_address = buf;
-
+ /* FIXME: implement! */
g_assert_not_reached ();
-
- return ptr;
+ return NULL;
}