gpointer
mono_arch_create_handler_block_trampoline (MonoTrampInfo **info, gboolean aot)
{
guint8 *tramp = mono_get_trampoline_code (MONO_TRAMPOLINE_HANDLER_BLOCK_GUARD);
guint8 *code, *buf;
int tramp_size = 64;
MonoJumpInfo *ji = NULL;
GSList *unwind_ops = NULL;
g_assert (!aot);
code = buf = mono_global_codeman_reserve (tramp_size);
/*
* This trampoline restore the call chain of the handler block
* then jumps into the code that deals with it.
*/
if (mono_get_jit_tls_offset () != -1) {
s390_ear (code, s390_r1, 0);
s390_sllg (code, s390_r1, s390_r1, 0, 32);
s390_ear (code, s390_r1, 1);
S390_SET (code, s390_r14, mono_get_jit_tls_offset());
s390_lg (code, s390_r14, s390_r1, 0, G_STRUCT_OFFSET(MonoJitTlsData, handler_block_return_address));
/*
* Simulate a call
*/
S390_SET (code, s390_r1, tramp);
s390_br (code, s390_r1);
} else {
/*
* Slow path uses a C helper
*/
S390_SET (code, s390_r2, tramp);
S390_SET (code, s390_r1, handler_block_trampoline_helper);
s390_br (code, s390_r1);
}
mono_arch_flush_icache (buf, code - buf);
if (mono_profiler_events & MONO_PROFILE_JIT_COMPILATION)
mono_profiler_code_buffer_new (buf, code - buf, MONO_PROFILER_CODE_BUFFER_HELPER, NULL);
g_assert (code - buf <= tramp_size);
*info = mono_tramp_info_create ("handler_block_trampoline", buf, code - buf, ji, unwind_ops);
return buf;
}
gpointer
mono_arch_get_unbox_trampoline (MonoGenericSharingContext *gsctx, MonoMethod *method, gpointer addr)
{
guint8 *code, *start;
int this_pos = s390_r2;
MonoDomain *domain = mono_domain_get ();
start = addr;
if (MONO_TYPE_ISSTRUCT (mono_method_signature (method)->ret))
this_pos = s390_r3;
start = code = mono_domain_code_reserve (domain, 28);
s390_basr (code, s390_r13, 0);
s390_j (code, 4);
s390_word (code, addr);
s390_l (code, s390_r1, 0, s390_r13, 4);
s390_ahi (code, this_pos, sizeof(MonoObject));
s390_br (code, s390_r1);
g_assert ((code - start) <= 28);
mono_arch_flush_icache (start, code - start);
return start;
}
gpointer
mono_arch_get_unbox_trampoline (MonoMethod *method, gpointer addr)
{
guint8 *code, *start;
int this_pos = s390_r2;
MonoDomain *domain = mono_domain_get ();
char trampName[128];
start = code = mono_domain_code_reserve (domain, 28);
S390_SET (code, s390_r1, addr);
s390_aghi (code, this_pos, MONO_ABI_SIZEOF (MonoObject));
s390_br (code, s390_r1);
g_assert ((code - start) <= 28);
mono_arch_flush_icache (start, code - start);
MONO_PROFILER_RAISE (jit_code_buffer, (start, code - start, MONO_PROFILER_CODE_BUFFER_UNBOX_TRAMPOLINE, method));
snprintf(trampName, sizeof(trampName), "%s_unbox_trampoline", method->name);
mono_tramp_info_register (mono_tramp_info_create (trampName, start, code - start, NULL, NULL), domain);
return start;
}
void
mono_arch_invalidate_method (MonoJitInfo *ji, void *func, gpointer func_arg)
{
/* FIXME: This is not thread safe */
guint8 *code = ji->code_start;
S390_SET (code, s390_r1, func);
S390_SET (code, s390_r2, func_arg);
s390_br (code, s390_r1);
}
static inline guint8 *
emit_epilog (guint8 *p, MonoMethodSignature *sig, size_data *sz)
{
/* function epilog */
s390_lg (p, STK_BASE, 0, STK_BASE, 0);
s390_lg (p, s390_r4, 0, STK_BASE, S390_RET_ADDR_OFFSET);
s390_lmg (p, s390_r6, STK_BASE, STK_BASE, S390_REG_SAVE_OFFSET);
s390_br (p, s390_r4);
return p;
}
gpointer
mono_arch_get_nullified_class_init_trampoline (MonoTrampInfo **info)
{
guint8 *buf, *code;
code = buf = mono_global_codeman_reserve (16);
s390_br (code, s390_r14);
if (info)
*info = mono_tramp_info_create ("nullified_class_init_trampoline",
buf, code - buf, NULL, NULL);
return (buf);
}
gpointer
mono_arch_get_nullified_class_init_trampoline (MonoTrampInfo **info)
{
guint8 *buf, *code;
code = buf = mono_global_codeman_reserve (16);
s390_br (code, s390_r14);
mono_arch_flush_icache (buf, code - buf);
mono_profiler_code_buffer_new (buf, code - buf, MONO_PROFILER_CODE_BUFFER_HELPER, NULL);
*info = mono_tramp_info_create ("nullified_class_init_trampoline",
buf, code - buf, NULL, NULL);
return (buf);
}
gpointer
mono_arch_get_unbox_trampoline (MonoMethod *method, gpointer addr)
{
guint8 *code, *start;
int this_pos = s390_r2;
MonoDomain *domain = mono_domain_get ();
start = code = mono_domain_code_reserve (domain, 28);
S390_SET (code, s390_r1, addr);
s390_aghi (code, this_pos, sizeof(MonoObject));
s390_br (code, s390_r1);
g_assert ((code - start) <= 28);
mono_arch_flush_icache (start, code - start);
return start;
}
gpointer
mono_arch_get_unbox_trampoline (MonoMethod *method, gpointer addr)
{
guint8 *code, *start;
int this_pos = s390_r2;
MonoDomain *domain = mono_domain_get ();
start = code = mono_domain_code_reserve (domain, 28);
S390_SET (code, s390_r1, addr);
s390_aghi (code, this_pos, sizeof(MonoObject));
s390_br (code, s390_r1);
g_assert ((code - start) <= 28);
mono_arch_flush_icache (start, code - start);
mono_profiler_code_buffer_new (start, code - start, MONO_PROFILER_CODE_BUFFER_UNBOX_TRAMPOLINE, method);
return start;
}
gpointer
mono_arch_get_unbox_trampoline (MonoGenericSharingContext *gsctx, MonoMethod *method, gpointer addr)
{
guint8 *code, *start;
int this_pos = s390_r2;
MonoDomain *domain = mono_domain_get ();
start = code = mono_domain_code_reserve (domain, 28);
s390_basr (code, s390_r1, 0);
s390_j (code, 6);
s390_llong(code, addr);
s390_lg (code, s390_r1, 0, s390_r1, 4);
s390_aghi (code, this_pos, sizeof(MonoObject));
s390_br (code, s390_r1);
g_assert ((code - start) <= 28);
mono_arch_flush_icache (start, code - start);
return start;
}
guchar*
mono_arch_create_generic_trampoline (MonoTrampolineType tramp_type, MonoTrampInfo **info, gboolean aot)
{
guint8 *buf, *tramp, *code;
int i, offset, lmfOffset;
g_assert (!aot);
if (info)
*info = NULL;
/* Now we'll create in 'buf' the S/390 trampoline code. This
is the trampoline code common to all methods */
code = buf = mono_global_codeman_reserve(512);
/*-----------------------------------------------------------
STEP 0: First create a non-standard function prologue with a
stack size big enough to save our registers.
-----------------------------------------------------------*/
s390_stmg (buf, s390_r6, s390_r15, STK_BASE, S390_REG_SAVE_OFFSET);
s390_lgr (buf, s390_r11, s390_r15);
s390_aghi (buf, STK_BASE, -CREATE_STACK_SIZE);
s390_stg (buf, s390_r11, 0, STK_BASE, 0);
s390_stg (buf, s390_r1, 0, STK_BASE, METHOD_SAVE_OFFSET);
s390_stmg (buf, s390_r2, s390_r5, STK_BASE, CREATE_GR_OFFSET);
/* Save the FP registers */
offset = CREATE_FP_OFFSET;
for (i = s390_f0; i <= s390_f15; ++i) {
s390_std (buf, i, 0, STK_BASE, offset);
offset += 8;
}
/*----------------------------------------------------------
STEP 1: call 'mono_get_lmf_addr()' to get the address of our
LMF. We'll need to restore it after the call to
's390_magic_trampoline' and before the call to the native
method.
----------------------------------------------------------*/
s390_basr (buf, s390_r13, 0);
s390_j (buf, 6);
s390_llong(buf, mono_get_lmf_addr);
s390_lg (buf, s390_r1, 0, s390_r13, 4);
s390_basr (buf, s390_r14, s390_r1);
/*---------------------------------------------------------------*/
/* we build the MonoLMF structure on the stack - see mini-s390.h */
/* Keep in sync with the code in mono_arch_emit_prolog */
/*---------------------------------------------------------------*/
lmfOffset = CREATE_STACK_SIZE - sizeof(MonoLMF);
s390_lgr (buf, s390_r13, STK_BASE);
s390_aghi (buf, s390_r13, lmfOffset);
/*---------------------------------------------------------------*/
/* Set lmf.lmf_addr = jit_tls->lmf */
/*---------------------------------------------------------------*/
s390_stg (buf, s390_r2, 0, s390_r13,
G_STRUCT_OFFSET(MonoLMF, lmf_addr));
/*---------------------------------------------------------------*/
/* Get current lmf */
/*---------------------------------------------------------------*/
s390_lg (buf, s390_r0, 0, s390_r2, 0);
/*---------------------------------------------------------------*/
/* Set our lmf as the current lmf */
/*---------------------------------------------------------------*/
s390_stg (buf, s390_r13, 0, s390_r2, 0);
/*---------------------------------------------------------------*/
/* Have our lmf.previous_lmf point to the last lmf */
/*---------------------------------------------------------------*/
s390_stg (buf, s390_r0, 0, s390_r13,
G_STRUCT_OFFSET(MonoLMF, previous_lmf));
/*---------------------------------------------------------------*/
/* save method info */
/*---------------------------------------------------------------*/
s390_lg (buf, s390_r1, 0, STK_BASE, METHOD_SAVE_OFFSET);
s390_stg (buf, s390_r1, 0, s390_r13,
G_STRUCT_OFFSET(MonoLMF, method));
/*---------------------------------------------------------------*/
/* save the current SP */
/*---------------------------------------------------------------*/
s390_lg (buf, s390_r1, 0, STK_BASE, 0);
s390_stg (buf, s390_r1, 0, s390_r13, G_STRUCT_OFFSET(MonoLMF, ebp));
/*---------------------------------------------------------------*/
/* save the current IP */
/*---------------------------------------------------------------*/
if (tramp_type == MONO_TRAMPOLINE_JUMP) {
s390_lghi (buf, s390_r1, 0);
} else {
s390_lg (buf, s390_r1, 0, s390_r1, S390_RET_ADDR_OFFSET);
// s390_la (buf, s390_r1, 0, s390_r1, 0);
}
s390_stg (buf, s390_r1, 0, s390_r13, G_STRUCT_OFFSET(MonoLMF, eip));
/*---------------------------------------------------------------*/
/* Save general and floating point registers */
/*---------------------------------------------------------------*/
s390_mvc (buf, 4*sizeof(gulong), s390_r13, G_STRUCT_OFFSET(MonoLMF, gregs[2]),
STK_BASE, CREATE_GR_OFFSET);
s390_mvc (buf, 10*sizeof(gulong), s390_r13, G_STRUCT_OFFSET(MonoLMF, gregs[6]),
s390_r11, S390_REG_SAVE_OFFSET);
/* Simply copy fpregs already saved above */
s390_mvc (buf, 16*sizeof(double), s390_r13, G_STRUCT_OFFSET(MonoLMF, fregs[0]),
STK_BASE, CREATE_FP_OFFSET);
/*---------------------------------------------------------------*/
/* STEP 2: call the C trampoline function */
/*---------------------------------------------------------------*/
/* Set arguments */
/* Arg 1: mgreg_t *regs. We pass sp instead */
s390_la (buf, s390_r2, 0, STK_BASE, CREATE_STACK_SIZE);
/* Arg 2: code (next address to the instruction that called us) */
if (tramp_type == MONO_TRAMPOLINE_JUMP) {
s390_lghi (buf, s390_r3, 0);
} else {
s390_lg (buf, s390_r3, 0, s390_r11, S390_RET_ADDR_OFFSET);
}
/* Arg 3: MonoMethod *method. It was put in r1 by the
method-specific trampoline code, and then saved before the call
to mono_get_lmf_addr()'. */
s390_lg (buf, s390_r4, 0, STK_BASE, METHOD_SAVE_OFFSET);
/* Arg 4: trampoline address. Ignore for now */
/* Calculate call address and call the C trampoline. Return value will be in r2 */
s390_basr (buf, s390_r13, 0);
s390_j (buf, 6);
tramp = (guint8*)mono_get_trampoline_func (tramp_type);
s390_llong (buf, tramp);
s390_lg (buf, s390_r1, 0, s390_r13, 4);
s390_basr (buf, s390_r14, s390_r1);
/* OK, code address is now on r2. Move it to r1, so that we
can restore r2 and use it from r1 later */
s390_lgr (buf, s390_r1, s390_r2);
/*----------------------------------------------------------
STEP 3: Restore the LMF
----------------------------------------------------------*/
restoreLMF(buf, STK_BASE, CREATE_STACK_SIZE);
/*----------------------------------------------------------
STEP 4: call the compiled method
----------------------------------------------------------*/
/* Restore registers */
s390_lmg (buf, s390_r2, s390_r5, STK_BASE, CREATE_GR_OFFSET);
/* Restore the FP registers */
offset = CREATE_FP_OFFSET;
for (i = s390_f0; i <= s390_f15; ++i) {
s390_ld (buf, i, 0, STK_BASE, offset);
offset += 8;
}
/* Restore stack pointer and jump to the code -
R14 contains the return address to our caller */
s390_lgr (buf, STK_BASE, s390_r11);
s390_lmg (buf, s390_r6, s390_r14, STK_BASE, S390_REG_SAVE_OFFSET);
if (tramp_type == MONO_TRAMPOLINE_CLASS_INIT || tramp_type == MONO_TRAMPOLINE_GENERIC_CLASS_INIT)
s390_br (buf, s390_r14);
else
s390_br (buf, s390_r1);
/* Flush instruction cache, since we've generated code */
mono_arch_flush_icache (code, buf - code);
/* Sanity check */
g_assert ((buf - code) <= 512);
return code;
}
gpointer
mono_arch_create_rgctx_lazy_fetch_trampoline (guint32 slot, MonoTrampInfo **info, gboolean aot)
{
#ifdef MONO_ARCH_VTABLE_REG
guint8 *tramp;
guint8 *code, *buf;
guint8 **rgctx_null_jumps;
gint32 displace;
int tramp_size,
depth,
index,
iPatch = 0,
i;
gboolean mrgctx;
MonoJumpInfo *ji = NULL;
GSList *unwind_ops = NULL;
mrgctx = MONO_RGCTX_SLOT_IS_MRGCTX (slot);
index = MONO_RGCTX_SLOT_INDEX (slot);
if (mrgctx)
index += MONO_SIZEOF_METHOD_RUNTIME_GENERIC_CONTEXT / sizeof (gpointer);
for (depth = 0; ; ++depth) {
int size = mono_class_rgctx_get_array_size (depth, mrgctx);
if (index < size - 1)
break;
index -= size - 1;
}
tramp_size = 48 + 16 * depth;
if (mrgctx)
tramp_size += 4;
else
tramp_size += 12;
code = buf = mono_global_codeman_reserve (tramp_size);
unwind_ops = mono_arch_get_cie_program ();
rgctx_null_jumps = g_malloc (sizeof (guint8*) * (depth + 2));
if (mrgctx) {
/* get mrgctx ptr */
s390_lgr (code, s390_r1, s390_r2);
} else {
/* load rgctx ptr from vtable */
s390_lg (code, s390_r1, 0, s390_r2, G_STRUCT_OFFSET(MonoVTable, runtime_generic_context));
/* is the rgctx ptr null? */
s390_ltgr (code, s390_r1, s390_r1);
/* if yes, jump to actual trampoline */
rgctx_null_jumps [iPatch++] = code;
s390_jge (code, 0);
}
for (i = 0; i < depth; ++i) {
/* load ptr to next array */
if (mrgctx && i == 0)
s390_lg (code, s390_r1, 0, s390_r1, MONO_SIZEOF_METHOD_RUNTIME_GENERIC_CONTEXT);
else
s390_lg (code, s390_r1, 0, s390_r1, 0);
s390_ltgr (code, s390_r1, s390_r1);
/* if the ptr is null then jump to actual trampoline */
rgctx_null_jumps [iPatch++] = code;
s390_jge (code, 0);
}
/* fetch slot */
s390_lg (code, s390_r1, 0, s390_r1, (sizeof (gpointer) * (index + 1)));
/* is the slot null? */
s390_ltgr (code, s390_r1, s390_r1);
/* if yes, jump to actual trampoline */
rgctx_null_jumps [iPatch++] = code;
s390_jge (code, 0);
/* otherwise return r1 */
s390_lgr (code, s390_r2, s390_r1);
s390_br (code, s390_r14);
for (i = 0; i < iPatch; i++) {
displace = ((uintptr_t) code - (uintptr_t) rgctx_null_jumps[i]) / 2;
s390_patch_rel ((rgctx_null_jumps [i] + 2), displace);
}
g_free (rgctx_null_jumps);
/* move the rgctx pointer to the VTABLE register */
s390_lgr (code, MONO_ARCH_VTABLE_REG, s390_r2);
tramp = mono_arch_create_specific_trampoline (GUINT_TO_POINTER (slot),
MONO_TRAMPOLINE_RGCTX_LAZY_FETCH, mono_get_root_domain (), NULL);
/* jump to the actual trampoline */
displace = (tramp - code) / 2;
s390_jg (code, displace);
mono_arch_flush_icache (buf, code - buf);
g_assert (code - buf <= tramp_size);
if (info) {
char *name = mono_get_rgctx_fetch_trampoline_name (slot);
*info = mono_tramp_info_create (name, buf, code - buf, ji, unwind_ops);
g_free (name);
}
return(buf);
#else
g_assert_not_reached ();
#endif
return(NULL);
}
gpointer
mono_arch_create_monitor_exit_trampoline (MonoTrampInfo **info, gboolean aot)
{
guint8 *tramp,
*code, *buf;
gint16 *jump_obj_null,
*jump_have_waiters,
*jump_sync_null,
*jump_not_owned,
*jump_cs_failed,
*jump_next,
*jump_sync_thin_hash = NULL;
int tramp_size,
status_offset, nest_offset;
MonoJumpInfo *ji = NULL;
GSList *unwind_ops = NULL;
int obj_reg = s390_r2,
sync_reg = s390_r3,
status_reg = s390_r4;
g_assert (obj_reg == MONO_ARCH_MONITOR_OBJECT_REG);
mono_monitor_threads_sync_members_offset (&status_offset, &nest_offset);
g_assert (MONO_THREADS_SYNC_MEMBER_SIZE (status_offset) == sizeof (guint32));
g_assert (MONO_THREADS_SYNC_MEMBER_SIZE (nest_offset) == sizeof (guint32));
status_offset = MONO_THREADS_SYNC_MEMBER_OFFSET (status_offset);
nest_offset = MONO_THREADS_SYNC_MEMBER_OFFSET (nest_offset);
tramp_size = 160;
code = buf = mono_global_codeman_reserve (tramp_size);
unwind_ops = mono_arch_get_cie_program ();
if (mono_thread_get_tls_offset () != -1) {
/* MonoObject* obj is in obj_reg */
/* is obj null? */
s390_ltgr (code, obj_reg, obj_reg);
/* if yes, jump to actual trampoline */
s390_jz (code, 0); CODEPTR(code, jump_obj_null);
/* load obj->synchronization to RCX */
s390_lg (code, sync_reg, 0, obj_reg, MONO_STRUCT_OFFSET (MonoObject, synchronisation));
if (mono_gc_is_moving ()) {
/*if bit zero is set it's a thin hash*/
s390_tmll (code, sync_reg, 1);
s390_jo (code, 0); CODEPTR(code, jump_sync_thin_hash);
/* Clear bits used by the gc */
s390_nill (code, sync_reg, ~0x3);
}
/* is synchronization null? */
s390_ltgr (code, sync_reg, sync_reg);
/* if yes, jump to actual trampoline */
s390_jz (code, 0); CODEPTR(code, jump_sync_null);
/* next case: synchronization is not null */
/* load MonoInternalThread* into r5 */
s390_ear (code, s390_r5, 0);
s390_sllg(code, s390_r5, s390_r5, 0, 32);
s390_ear (code, s390_r5, 1);
/* load TID into r1 */
s390_lg (code, s390_r1, 0, s390_r5, mono_thread_get_tls_offset ());
s390_lgf (code, s390_r1, 0, s390_r1, MONO_STRUCT_OFFSET (MonoInternalThread, small_id));
/* is synchronization->owner == TID */
s390_lgf (code, status_reg, 0, sync_reg, status_offset);
s390_xr (code, s390_r1, status_reg);
s390_tmlh (code, s390_r1, OWNER_MASK);
/* if not, jump to actual trampoline */
s390_jno (code, 0); CODEPTR(code, jump_not_owned);
/* next case: synchronization->owner == TID */
/* is synchronization->nest == 1 */
s390_lgf (code, s390_r0, 0, sync_reg, nest_offset);
s390_chi (code, s390_r0, 1);
/* if not, jump to next case */
s390_jne (code, 0); CODEPTR(code, jump_next);
/* if yes, is synchronization->entry_count greater than zero */
s390_cfi (code, status_reg, ENTRY_COUNT_WAITERS);
/* if not, jump to actual trampoline */
s390_jnz (code, 0); CODEPTR(code, jump_have_waiters);
/* if yes, try to set synchronization->owner to null and return */
/* old status in s390_r0 */
s390_lgfr (code, s390_r0, status_reg);
/* form new status */
s390_nilf (code, status_reg, ENTRY_COUNT_MASK);
/* compare and exchange */
s390_cs (code, s390_r0, status_reg, sync_reg, status_offset);
/* if not successful, jump to actual trampoline */
s390_jnz (code, 0); CODEPTR(code, jump_cs_failed);
s390_br (code, s390_r14);
/* next case: synchronization->nest is not 1 */
PTRSLOT (code, jump_next);
/* decrease synchronization->nest and return */
s390_lgf (code, s390_r0, 0, sync_reg, nest_offset);
s390_ahi (code, s390_r0, -1);
s390_st (code, s390_r0, 0, sync_reg, nest_offset);
s390_br (code, s390_r14);
PTRSLOT (code, jump_obj_null);
if (jump_sync_thin_hash)
PTRSLOT (code, jump_sync_thin_hash);
PTRSLOT (code, jump_have_waiters);
PTRSLOT (code, jump_not_owned);
PTRSLOT (code, jump_cs_failed);
PTRSLOT (code, jump_sync_null);
}
/* jump to the actual trampoline */
tramp = mono_arch_create_specific_trampoline (NULL, MONO_TRAMPOLINE_MONITOR_EXIT, mono_get_root_domain (), NULL);
S390_SET (code, s390_r1, tramp);
s390_br (code, s390_r1);
mono_arch_flush_icache (code, code - buf);
mono_profiler_code_buffer_new (buf, code - buf, MONO_PROFILER_CODE_BUFFER_MONITOR, NULL);
g_assert (code - buf <= tramp_size);
if (info)
*info = mono_tramp_info_create ("monitor_exit_trampoline", buf, code - buf, ji, unwind_ops);
return buf;
}
gpointer
mono_arch_create_monitor_enter_trampoline (MonoTrampInfo **info, gboolean is_v4, gboolean aot)
{
guint8 *tramp,
*code, *buf;
gint16 *jump_obj_null,
*jump_sync_null,
*jump_cs_failed,
*jump_other_owner,
*jump_tid,
*jump_sync_thin_hash = NULL,
*jump_lock_taken_true = NULL;
int tramp_size,
status_reg = s390_r0,
lock_taken_reg = s390_r1,
obj_reg = s390_r2,
sync_reg = s390_r3,
tid_reg = s390_r4,
status_offset,
nest_offset;
MonoJumpInfo *ji = NULL;
GSList *unwind_ops = NULL;
g_assert (MONO_ARCH_MONITOR_OBJECT_REG == obj_reg);
#ifdef MONO_ARCH_MONITOR_LOCK_TAKEN_REG
g_assert (MONO_ARCH_MONITOR_LOCK_TAKEN_REG == lock_taken_reg);
#else
g_assert (!is_v4);
#endif
mono_monitor_threads_sync_members_offset (&status_offset, &nest_offset);
g_assert (MONO_THREADS_SYNC_MEMBER_SIZE (status_offset) == sizeof (guint32));
g_assert (MONO_THREADS_SYNC_MEMBER_SIZE (nest_offset) == sizeof (guint32));
status_offset = MONO_THREADS_SYNC_MEMBER_OFFSET (status_offset);
nest_offset = MONO_THREADS_SYNC_MEMBER_OFFSET (nest_offset);
tramp_size = 160;
code = buf = mono_global_codeman_reserve (tramp_size);
unwind_ops = mono_arch_get_cie_program ();
if (mono_thread_get_tls_offset () != -1) {
/* MonoObject* obj is in obj_reg */
/* is obj null? */
s390_ltgr (code, obj_reg, obj_reg);
/* if yes, jump to actual trampoline */
s390_jz (code, 0); CODEPTR(code, jump_obj_null);
if (is_v4) {
s390_cli (code, lock_taken_reg, 0, 1);
/* if *lock_taken is 1, jump to actual trampoline */
s390_je (code, 0); CODEPTR(code, jump_lock_taken_true);
}
/* load obj->synchronization to sync_reg */
s390_lg (code, sync_reg, 0, obj_reg, MONO_STRUCT_OFFSET (MonoObject, synchronisation));
if (mono_gc_is_moving ()) {
/*if bit zero is set it's a thin hash*/
s390_tmll (code, sync_reg, 1);
s390_jo (code, 0); CODEPTR(code, jump_sync_thin_hash);
/* Clear bits used by the gc */
s390_nill (code, sync_reg, ~0x3);
}
/* is synchronization null? */
s390_ltgr (code, sync_reg, sync_reg);
/* if yes, jump to actual trampoline */
s390_jz (code, 0); CODEPTR(code, jump_sync_null);
/* load MonoInternalThread* into tid_reg */
s390_ear (code, s390_r5, 0);
s390_sllg(code, s390_r5, s390_r5, 0, 32);
s390_ear (code, s390_r5, 1);
/* load tid */
s390_lg (code, tid_reg, 0, s390_r5, mono_thread_get_tls_offset ());
s390_lgf (code, tid_reg, 0, tid_reg, MONO_STRUCT_OFFSET (MonoInternalThread, small_id));
/* is synchronization->owner free */
s390_lgf (code, status_reg, 0, sync_reg, status_offset);
s390_nilf (code, status_reg, OWNER_MASK);
/* if not, jump to next case */
s390_jnz (code, 0); CODEPTR(code, jump_tid);
/* if yes, try a compare-exchange with the TID */
/* Form new status in tid_reg */
s390_xr (code, tid_reg, status_reg);
/* compare and exchange */
s390_cs (code, status_reg, tid_reg, sync_reg, status_offset);
s390_jnz (code, 0); CODEPTR(code, jump_cs_failed);
/* if successful, return */
if (is_v4)
s390_mvi (code, lock_taken_reg, 0, 1);
s390_br (code, s390_r14);
/* next case: synchronization->owner is not null */
PTRSLOT(code, jump_tid);
/* is synchronization->owner == TID? */
s390_nilf (code, status_reg, OWNER_MASK);
s390_cr (code, status_reg, tid_reg);
/* if not, jump to actual trampoline */
s390_jnz (code, 0); CODEPTR(code, jump_other_owner);
/* if yes, increment nest */
s390_lgf (code, s390_r5, 0, sync_reg, nest_offset);
s390_ahi (code, s390_r5, 1);
s390_st (code, s390_r5, 0, sync_reg, nest_offset);
/* return */
if (is_v4)
s390_mvi (code, lock_taken_reg, 0, 1);
s390_br (code, s390_r14);
PTRSLOT (code, jump_obj_null);
if (jump_sync_thin_hash)
PTRSLOT (code, jump_sync_thin_hash);
PTRSLOT (code, jump_sync_null);
PTRSLOT (code, jump_cs_failed);
PTRSLOT (code, jump_other_owner);
if (is_v4)
PTRSLOT (code, jump_lock_taken_true);
}
/* jump to the actual trampoline */
if (is_v4)
tramp = mono_arch_create_specific_trampoline (NULL, MONO_TRAMPOLINE_MONITOR_ENTER_V4, mono_get_root_domain (), NULL);
else
tramp = mono_arch_create_specific_trampoline (NULL, MONO_TRAMPOLINE_MONITOR_ENTER, mono_get_root_domain (), NULL);
/* jump to the actual trampoline */
S390_SET (code, s390_r1, tramp);
s390_br (code, s390_r1);
mono_arch_flush_icache (code, code - buf);
mono_profiler_code_buffer_new (buf, code - buf, MONO_PROFILER_CODE_BUFFER_MONITOR, NULL);
g_assert (code - buf <= tramp_size);
if (info) {
if (is_v4)
*info = mono_tramp_info_create ("monitor_enter_v4_trampoline", buf, code - buf, ji, unwind_ops);
else
*info = mono_tramp_info_create ("monitor_enter_trampoline", buf, code - buf, ji, unwind_ops);
}
return buf;
}
guchar*
mono_arch_create_generic_trampoline (MonoTrampolineType tramp_type, MonoTrampInfo **info, gboolean aot)
{
char *tramp_name;
guint8 *buf, *tramp, *code;
int i, offset, has_caller;
GSList *unwind_ops = NULL;
MonoJumpInfo *ji = NULL;
g_assert (!aot);
/* Now we'll create in 'buf' the S/390 trampoline code. This
is the trampoline code common to all methods */
code = buf = mono_global_codeman_reserve(512);
if ((tramp_type == MONO_TRAMPOLINE_JUMP) ||
(tramp_type == MONO_TRAMPOLINE_HANDLER_BLOCK_GUARD))
has_caller = 0;
else
has_caller = 1;
/*-----------------------------------------------------------
STEP 0: First create a non-standard function prologue with a
stack size big enough to save our registers.
-----------------------------------------------------------*/
s390_stmg (buf, s390_r6, s390_r15, STK_BASE, S390_REG_SAVE_OFFSET);
s390_lgr (buf, s390_r11, s390_r15);
s390_aghi (buf, STK_BASE, -sizeof(trampStack_t));
s390_stg (buf, s390_r11, 0, STK_BASE, 0);
/*---------------------------------------------------------------*/
/* we build the MonoLMF structure on the stack - see mini-s390.h */
/* Keep in sync with the code in mono_arch_emit_prolog */
/*---------------------------------------------------------------*/
s390_lgr (buf, LMFReg, STK_BASE);
s390_aghi (buf, LMFReg, G_STRUCT_OFFSET(trampStack_t, LMF));
/*---------------------------------------------------------------*/
/* Save general and floating point registers in LMF */
/*---------------------------------------------------------------*/
s390_stmg (buf, s390_r0, s390_r1, LMFReg, G_STRUCT_OFFSET(MonoLMF, gregs[0]));
s390_stmg (buf, s390_r2, s390_r5, LMFReg, G_STRUCT_OFFSET(MonoLMF, gregs[2]));
s390_mvc (buf, 10*sizeof(gulong), LMFReg, G_STRUCT_OFFSET(MonoLMF, gregs[6]),
s390_r11, S390_REG_SAVE_OFFSET);
offset = G_STRUCT_OFFSET(MonoLMF, fregs[0]);
for (i = s390_f0; i <= s390_f15; ++i) {
s390_std (buf, i, 0, LMFReg, offset);
offset += sizeof(gdouble);
}
/*----------------------------------------------------------
STEP 1: call 'mono_get_lmf_addr()' to get the address of our
LMF. We'll need to restore it after the call to
's390_magic_trampoline' and before the call to the native
method.
----------------------------------------------------------*/
S390_SET (buf, s390_r1, mono_get_lmf_addr);
s390_basr (buf, s390_r14, s390_r1);
/*---------------------------------------------------------------*/
/* Set lmf.lmf_addr = jit_tls->lmf */
/*---------------------------------------------------------------*/
s390_stg (buf, s390_r2, 0, LMFReg,
G_STRUCT_OFFSET(MonoLMF, lmf_addr));
/*---------------------------------------------------------------*/
/* Get current lmf */
/*---------------------------------------------------------------*/
s390_lg (buf, s390_r0, 0, s390_r2, 0);
/*---------------------------------------------------------------*/
/* Set our lmf as the current lmf */
/*---------------------------------------------------------------*/
s390_stg (buf, LMFReg, 0, s390_r2, 0);
/*---------------------------------------------------------------*/
/* Have our lmf.previous_lmf point to the last lmf */
/*---------------------------------------------------------------*/
s390_stg (buf, s390_r0, 0, LMFReg,
G_STRUCT_OFFSET(MonoLMF, previous_lmf));
/*---------------------------------------------------------------*/
/* save method info */
/*---------------------------------------------------------------*/
s390_lg (buf, s390_r1, 0, LMFReg, G_STRUCT_OFFSET(MonoLMF, gregs[1]));
s390_stg (buf, s390_r1, 0, LMFReg, G_STRUCT_OFFSET(MonoLMF, method));
/*---------------------------------------------------------------*/
/* save the current SP */
/*---------------------------------------------------------------*/
s390_lg (buf, s390_r1, 0, STK_BASE, 0);
s390_stg (buf, s390_r1, 0, LMFReg, G_STRUCT_OFFSET(MonoLMF, ebp));
/*---------------------------------------------------------------*/
/* save the current IP */
/*---------------------------------------------------------------*/
if (has_caller) {
s390_lg (buf, s390_r1, 0, s390_r1, S390_RET_ADDR_OFFSET);
} else {
s390_lghi (buf, s390_r1, 0);
}
s390_stg (buf, s390_r1, 0, LMFReg, G_STRUCT_OFFSET(MonoLMF, eip));
/*---------------------------------------------------------------*/
/* STEP 2: call the C trampoline function */
/*---------------------------------------------------------------*/
/* Set arguments */
/* Arg 1: mgreg_t *regs */
s390_la (buf, s390_r2, 0, LMFReg, G_STRUCT_OFFSET(MonoLMF, gregs[0]));
/* Arg 2: code (next address to the instruction that called us) */
if (has_caller) {
s390_lg (buf, s390_r3, 0, s390_r11, S390_RET_ADDR_OFFSET);
} else {
s390_lghi (buf, s390_r3, 0);
}
/* Arg 3: Trampoline argument */
if (tramp_type == MONO_TRAMPOLINE_GENERIC_CLASS_INIT)
s390_lg (buf, s390_r4, 0, LMFReg,
G_STRUCT_OFFSET(MonoLMF, gregs[MONO_ARCH_VTABLE_REG]));
else
s390_lg (buf, s390_r4, 0, LMFReg, G_STRUCT_OFFSET(MonoLMF, gregs[1]));
/* Arg 4: trampoline address. */
S390_SET (buf, s390_r5, buf);
/* Calculate call address and call the C trampoline. Return value will be in r2 */
tramp = (guint8*)mono_get_trampoline_func (tramp_type);
S390_SET (buf, s390_r1, tramp);
s390_basr (buf, s390_r14, s390_r1);
/* OK, code address is now on r2. Move it to r1, so that we
can restore r2 and use it from r1 later */
s390_lgr (buf, s390_r1, s390_r2);
/*----------------------------------------------------------
STEP 3: Restore the LMF
----------------------------------------------------------*/
restoreLMF(buf, STK_BASE, sizeof(trampStack_t));
/*----------------------------------------------------------
STEP 4: call the compiled method
----------------------------------------------------------*/
/* Restore parameter registers */
s390_lmg (buf, s390_r2, s390_r5, LMFReg, G_STRUCT_OFFSET(MonoLMF, gregs[2]));
/* Restore the FP registers */
offset = G_STRUCT_OFFSET(MonoLMF, fregs[0]);
for (i = s390_f0; i <= s390_f15; ++i) {
s390_ld (buf, i, 0, LMFReg, offset);
offset += sizeof(gdouble);
}
/* Restore stack pointer and jump to the code -
* R14 contains the return address to our caller
*/
s390_lgr (buf, STK_BASE, s390_r11);
s390_lmg (buf, s390_r6, s390_r14, STK_BASE, S390_REG_SAVE_OFFSET);
if (MONO_TRAMPOLINE_TYPE_MUST_RETURN(tramp_type)) {
s390_lgr (buf, s390_r2, s390_r1);
s390_br (buf, s390_r14);
} else {
s390_br (buf, s390_r1);
}
/* Flush instruction cache, since we've generated code */
mono_arch_flush_icache (code, buf - code);
mono_profiler_code_buffer_new (buf, code - buf, MONO_PROFILER_CODE_BUFFER_GENERICS_TRAMPOLINE, NULL);
g_assert (info);
tramp_name = mono_get_generic_trampoline_name (tramp_type);
*info = mono_tramp_info_create (tramp_name, buf, buf - code, ji, unwind_ops);
g_free (tramp_name);
/* Sanity check */
g_assert ((buf - code) <= 512);
return code;
}
void *
mono_arch_create_method_pointer (MonoMethod *method)
{
MonoMethodSignature *sig;
MonoJitInfo *ji;
guint8 *p, *code_buffer;
guint i, align = 0, simple_type, retSize, reg_save = 0,
stackval_arg_pos, local_pos, float_pos,
local_start, reg_param = 0, stack_param,
this_flag, arg_pos, fpr_param, parSize;
guint32 simpletype;
size_data sz;
int *vtbuf, cpos, vt_cur;
sz.code_size = 1024;
sz.stack_size = 1024;
stack_param = 0;
fpr_param = 0;
arg_pos = 0;
sig = method->signature;
p = code_buffer = g_malloc (sz.code_size);
DEBUG (printf ("\nDelegate [start emiting] %s at 0x%08x\n",
method->name,p));
/*----------------------------------------------------------*/
/* prolog */
/*----------------------------------------------------------*/
s390_stmg(p, s390_r6, STK_BASE, STK_BASE, S390_REG_SAVE_OFFSET);
s390_lg (p, s390_r7, 0, STK_BASE, MINV_POS);
s390_lgr (p, s390_r0, STK_BASE);
s390_aghi(p, STK_BASE, -(sz.stack_size+MINV_POS));
s390_stg (p, s390_r0, 0, STK_BASE, 0);
s390_la (p, s390_r8, 0, STK_BASE, 4);
s390_lgr (p, s390_r10, s390_r8);
s390_lghi(p, s390_r9, sz.stack_size+92);
s390_lghi(p, s390_r11, 0);
s390_mvcl(p, s390_r8, s390_r10);
/*----------------------------------------------------------*/
/* Let's fill MonoInvocation - first zero some fields */
/*----------------------------------------------------------*/
s390_lghi (p, s390_r0, 0);
s390_stg (p, s390_r0, 0, STK_BASE, (MINV_POS + G_STRUCT_OFFSET (MonoInvocation, ex)));
s390_stg (p, s390_r0, 0, STK_BASE, (MINV_POS + G_STRUCT_OFFSET (MonoInvocation, ex_handler)));
s390_stg (p, s390_r0, 0, STK_BASE, (MINV_POS + G_STRUCT_OFFSET (MonoInvocation, parent)));
s390_lghi (p, s390_r0, 1);
s390_stg (p, s390_r0, 0, STK_BASE, (MINV_POS + G_STRUCT_OFFSET (MonoInvocation, invoke_trap)));
/*----------------------------------------------------------*/
/* set method pointer */
/*----------------------------------------------------------*/
s390_bras (p, s390_r13, 4);
s390_llong(p, method);
s390_lg (p, s390_r0, 0, s390_r13, 0);
s390_stg (p, s390_r0, 0, STK_BASE, (MINV_POS + G_STRUCT_OFFSET (MonoInvocation, method)));
local_start = local_pos = MINV_POS +
sizeof (MonoInvocation) + (sig->param_count + 1) * sizeof (stackval);
this_flag = (sig->hasthis ? 1 : 0);
/*----------------------------------------------------------*/
/* if we are returning a structure, checks it's length to */
/* see if there's a "hidden" parameter that points to the */
/* area. If necessary save this hidden parameter for later */
/*----------------------------------------------------------*/
if (MONO_TYPE_ISSTRUCT(sig->ret)) {
if (sig->pinvoke)
retSize = mono_class_native_size (sig->ret->data.klass, &align);
else
retSize = mono_class_value_size (sig->ret->data.klass, &align);
switch(retSize) {
case 0:
case 1:
case 2:
case 4:
case 8:
sz.retStruct = 0;
break;
default:
sz.retStruct = 1;
s390_lgr(p, s390_r8, s390_r2);
reg_save = 1;
}
} else {
reg_save = 0;
}
if (this_flag) {
s390_stg (p, s390_r2 + reg_save, 0, STK_BASE,
(MINV_POS + G_STRUCT_OFFSET (MonoInvocation, obj)));
reg_param++;
} else {
s390_stg (p, s390_r2 + reg_save, 0, STK_BASE, local_pos);
local_pos += sizeof(int);
s390_stg (p, s390_r0, 0, STK_BASE,
(MINV_POS + G_STRUCT_OFFSET (MonoInvocation, obj)));
}
s390_stmg (p, s390_r3 + reg_param, s390_r6, STK_BASE, local_pos);
local_pos += 4 * sizeof(long);
float_pos = local_pos;
s390_std (p, s390_f0, 0, STK_BASE, local_pos);
local_pos += sizeof(double);
s390_std (p, s390_f2, 0, STK_BASE, local_pos);
local_pos += sizeof(double);
/*----------------------------------------------------------*/
/* prepare space for valuetypes */
/*----------------------------------------------------------*/
vt_cur = local_pos;
vtbuf = alloca (sizeof(int)*sig->param_count);
cpos = 0;
for (i = 0; i < sig->param_count; i++) {
MonoType *type = sig->params [i];
vtbuf [i] = -1;
DEBUG(printf("par: %d type: %d ref: %d\n",i,type->type,type->byref));
if (type->type == MONO_TYPE_VALUETYPE) {
MonoClass *klass = type->data.klass;
gint size;
if (klass->enumtype)
continue;
size = mono_class_native_size (klass, &align);
cpos += align - 1;
cpos &= ~(align - 1);
vtbuf [i] = cpos;
cpos += size;
}
}
cpos += 3;
cpos &= ~3;
local_pos += cpos;
/*----------------------------------------------------------*/
/* set MonoInvocation::stack_args */
/*----------------------------------------------------------*/
stackval_arg_pos = MINV_POS + sizeof (MonoInvocation);
s390_la (p, s390_r0, 0, STK_BASE, stackval_arg_pos);
s390_stg (p, s390_r0, 0, STK_BASE, (MINV_POS + G_STRUCT_OFFSET (MonoInvocation, stack_args)));
/*----------------------------------------------------------*/
/* add stackval arguments */
/*----------------------------------------------------------*/
for (i = 0; i < sig->param_count; ++i) {
if (sig->params [i]->byref) {
ADD_ISTACK_PARM(0, 1);
} else {
simple_type = sig->params [i]->type;
enum_savechk:
switch (simple_type) {
case MONO_TYPE_I8:
ADD_ISTACK_PARM(-1, 2);
break;
case MONO_TYPE_R4:
ADD_RSTACK_PARM(1);
break;
case MONO_TYPE_R8:
ADD_RSTACK_PARM(2);
break;
case MONO_TYPE_VALUETYPE:
if (sig->params [i]->data.klass->enumtype) {
simple_type = sig->params [i]->data.klass->enum_basetype->type;
goto enum_savechk;
}
if (sig->pinvoke)
parSize = mono_class_native_size (sig->params [i]->data.klass, &align);
else
parSize = mono_class_value_size (sig->params [i]->data.klass, &align);
switch(parSize) {
case 0:
case 1:
case 2:
case 4:
ADD_PSTACK_PARM(0, 1);
break;
case 8:
ADD_PSTACK_PARM(-1, 2);
break;
default:
ADD_TSTACK_PARM;
}
break;
default:
ADD_ISTACK_PARM(0, 1);
}
}
if (vtbuf [i] >= 0) {
s390_la (p, s390_r3, 0, STK_BASE, vt_cur);
s390_stg (p, s390_r3, 0, STK_BASE, stackval_arg_pos);
s390_la (p, s390_r3, 0, STK_BASE, stackval_arg_pos);
vt_cur += vtbuf [i];
} else {
s390_la (p, s390_r3, 0, STK_BASE, stackval_arg_pos);
}
/*--------------------------------------*/
/* Load the parameter registers for the */
/* call to stackval_from_data */
/*--------------------------------------*/
s390_bras (p, s390_r13, 8);
s390_llong(p, sig->params [i]);
s390_llong(p, sig->pinvoke);
s390_llong(p, stackval_from_data);
s390_lg (p, s390_r2, 0, s390_r13, 0);
s390_lg (p, s390_r5, 0, s390_r13, 4);
s390_lg (p, s390_r1, 0, s390_r13, 8);
s390_basr (p, s390_r14, s390_r1);
stackval_arg_pos += sizeof(stackval);
/* fixme: alignment */
DEBUG (printf ("arg_pos %d --> ", arg_pos));
if (sig->pinvoke)
arg_pos += mono_type_native_stack_size (sig->params [i], &align);
else
arg_pos += mono_type_stack_size (sig->params [i], &align);
DEBUG (printf ("%d\n", stackval_arg_pos));
}
/*----------------------------------------------------------*/
/* Set return area pointer. */
/*----------------------------------------------------------*/
s390_la (p, s390_r10, 0, STK_BASE, stackval_arg_pos);
s390_stg(p, s390_r10, 0, STK_BASE, (MINV_POS + G_STRUCT_OFFSET (MonoInvocation, retval)));
if (sig->ret->type == MONO_TYPE_VALUETYPE && !sig->ret->byref) {
MonoClass *klass = sig->ret->data.klass;
if (!klass->enumtype) {
s390_la (p, s390_r9, 0, s390_r10, sizeof(stackval));
s390_st (p, s390_r9, 0,STK_BASE, stackval_arg_pos);
stackval_arg_pos += sizeof(stackval);
}
}
/*----------------------------------------------------------*/
/* call ves_exec_method */
/*----------------------------------------------------------*/
s390_bras (p, s390_r13, 4);
s390_llong(p, ves_exec_method);
s390_lg (p, s390_r1, 0, s390_r13, 0);
s390_la (p, s390_r2, 0, STK_BASE, MINV_POS);
s390_basr (p, s390_r14, s390_r1);
/*----------------------------------------------------------*/
/* move retval from stackval to proper place (r3/r4/...) */
/*----------------------------------------------------------*/
DEBUG(printf("retType: %d byRef: %d\n",sig->ret->type,sig->ret->byref));
if (sig->ret->byref) {
DEBUG (printf ("ret by ref\n"));
s390_stg(p, s390_r2, 0, s390_r10, 0);
} else {
enum_retvalue:
switch (sig->ret->type) {
case MONO_TYPE_VOID:
break;
case MONO_TYPE_BOOLEAN:
case MONO_TYPE_U1:
s390_lghi(p, s390_r2, 0);
s390_ic (p, s390_r2, 0, s390_r10, 0);
break;
case MONO_TYPE_I2:
case MONO_TYPE_U2:
s390_lh (p, s390_r2, 0,s390_r10, 0);
break;
case MONO_TYPE_I4:
case MONO_TYPE_U4:
case MONO_TYPE_I:
case MONO_TYPE_U:
s390_lgf(p, s390_r2, 0, s390_r10, 0);
break;
case MONO_TYPE_OBJECT:
case MONO_TYPE_STRING:
case MONO_TYPE_CLASS:
case MONO_TYPE_I8:
s390_lg (p, s390_r2, 0, s390_r10, 0);
break;
case MONO_TYPE_R4:
s390_le (p, s390_f0, 0, s390_r10, 0);
break;
case MONO_TYPE_R8:
s390_ld (p, s390_f0, 0, s390_r10, 0);
break;
case MONO_TYPE_VALUETYPE:
if (sig->ret->data.klass->enumtype) {
simpletype = sig->ret->data.klass->enum_basetype->type;
goto enum_retvalue;
}
/*---------------------------------*/
/* Call stackval_to_data to return */
/* the structure */
/*---------------------------------*/
s390_bras (p, s390_r13, 8);
s390_llong(p, sig->ret);
s390_llong(p, sig->pinvoke);
s390_llong(p, stackval_to_data);
s390_lg (p, s390_r2, 0, s390_r13, 0);
s390_lg (p, s390_r3, 0, STK_BASE, (MINV_POS + G_STRUCT_OFFSET (MonoInvocation, retval)));
if (sz.retStruct) {
/*------------------------------------------*/
/* Get stackval_to_data to set result area */
/*------------------------------------------*/
s390_lgr (p, s390_r4, s390_r8);
} else {
/*------------------------------------------*/
/* Give stackval_to_data a temp result area */
/*------------------------------------------*/
s390_la (p, s390_r4, 0, STK_BASE, stackval_arg_pos);
}
s390_lg (p, s390_r5, 0,s390_r13, 4);
s390_lg (p, s390_r1, 0, s390_r13, 8);
s390_basr (p, s390_r14, s390_r1);
switch (retSize) {
case 0:
break;
case 1:
s390_lghi(p, s390_r2, 0);
s390_ic (p, s390_r2, 0, s390_r10, 0);
break;
case 2:
s390_lh (p, s390_r2, 0, s390_r10, 0);
break;
case 4:
s390_lgf(p, s390_r2, 0, s390_r10, 0);
break;
case 8:
s390_lg (p, s390_r2, 0, s390_r10, 0);
break;
default: ;
/*-------------------------------------------------*/
/* stackval_to_data has placed data in result area */
/*-------------------------------------------------*/
}
break;
default:
g_error ("Type 0x%x not handled yet in thunk creation",
sig->ret->type);
break;
}
}
/*----------------------------------------------------------*/
/* epilog */
/*----------------------------------------------------------*/
s390_lg (p, STK_BASE, 0, STK_BASE, 0);
s390_lg (p, s390_r4, 0, STK_BASE, S390_RET_ADDR_OFFSET);
s390_lmg (p, s390_r6, STK_BASE, STK_BASE, S390_REG_SAVE_OFFSET);
s390_br (p, s390_r4);
DEBUG (printf ("emited code size: %d\n", p - code_buffer));
DEBUG (printf ("Delegate [end emiting]\n"));
ji = g_new0 (MonoJitInfo, 1);
ji->method = method;
ji->code_size = p - code_buffer;
ji->code_start = code_buffer;
mono_jit_info_table_add (mono_get_root_domain (), ji);
return ji->code_start;
}
