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;
}
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;
}
inline static guint8*
emit_save_parameters (guint8 *p, MonoMethodSignature *sig, size_data *sz)
{
guint i, fr, gr, act_strs, align,
stack_par_pos, size, local_pos;
guint32 simpletype;
/*----------------------------------------------------------*/
/* If a structure on stack is being returned, reserve r2 */
/* to point to an area where it can be passed. */
/*----------------------------------------------------------*/
if (sz->retStruct)
gr = 1;
else
gr = 0;
fr = 0;
act_strs = 0;
stack_par_pos = S390_MINIMAL_STACK_SIZE;
local_pos = sz->stack_size;
if (sig->hasthis) {
s390_lr (p, s390_r2 + gr, s390_r4);
gr++;
}
act_strs = 0;
for (i = 0; i < sig->param_count; ++i) {
DEBUG(printf("par: %d type: %d ref: %d\n",i,sig->params[i]->type,sig->params[i]->byref));
if (sig->params [i]->byref) {
if (gr < GENERAL_REGS) {
s390_lg (p, s390_r2 + gr, 0, ARG_BASE, STKARG);
gr ++;
} else {
s390_lg (p, s390_r0, 0, ARG_BASE, STKARG);
s390_stg(p, s390_r0, 0, STK_BASE, stack_par_pos);
stack_par_pos += sizeof(long);
}
continue;
}
simpletype = sig->params [i]->type;
enum_calc_size:
switch (simpletype) {
case MONO_TYPE_BOOLEAN:
case MONO_TYPE_I1:
case MONO_TYPE_U1:
case MONO_TYPE_I2:
case MONO_TYPE_U2:
case MONO_TYPE_CHAR:
case MONO_TYPE_I4:
case MONO_TYPE_U4:
case MONO_TYPE_I:
case MONO_TYPE_U:
case MONO_TYPE_PTR:
case MONO_TYPE_CLASS:
case MONO_TYPE_OBJECT:
case MONO_TYPE_STRING:
case MONO_TYPE_SZARRAY:
if (gr < GENERAL_REGS) {
s390_lg (p, s390_r2 + gr, 0, ARG_BASE, STKARG);
gr ++;
} else {
s390_lg (p, s390_r0, 0, ARG_BASE, STKARG);
s390_stg(p, s390_r0, 0, STK_BASE, stack_par_pos);
stack_par_pos += sizeof(long);
}
break;
case MONO_TYPE_VALUETYPE:
if (sig->params [i]->data.klass->enumtype) {
simpletype = sig->params [i]->data.klass->enum_basetype->type;
goto enum_calc_size;
}
if (sig->pinvoke)
size = mono_class_native_size (sig->params [i]->data.klass, &align);
else
size = mono_class_value_size (sig->params [i]->data.klass, &align);
DEBUG(printf("parStruct - size %d pinvoke: %d\n",size,sig->pinvoke));
switch (size) {
case 0:
case 1:
case 2:
case 4:
if (gr < GENERAL_REGS) {
s390_lg (p, s390_r2 + gr, 0,ARG_BASE, STKARG);
s390_lgf(p, s390_r2 + gr, 0, s390_r2 + gr, 0);
gr++;
} else {
stack_par_pos += (stack_par_pos % align);
s390_lg (p, s390_r10, 0,ARG_BASE, STKARG);
s390_lgf(p, s390_r10, 0, s390_r10, 0);
s390_st (p, s390_r10, 0, STK_BASE, stack_par_pos);
stack_par_pos += sizeof(long);
}
break;
case 8:
if (gr < GENERAL_REGS) {
s390_lg (p, s390_r2 + gr, 0, ARG_BASE, STKARG);
s390_lg (p, s390_r2 + gr, 0, s390_r2 + gr, 0);
} else {
stack_par_pos += (stack_par_pos % align);
s390_lg (p, s390_r10, 0, ARG_BASE, STKARG);
s390_mvc (p, sizeof(long long), STK_BASE, stack_par_pos, s390_r10, 0);
stack_par_pos += sizeof(long long);
}
break;
default:
if (size <= 256) {
local_pos += (local_pos % align);
s390_lg (p, s390_r13, 0, ARG_BASE, STKARG);
s390_mvc (p, size, STK_BASE, local_pos, s390_r13, 0);
s390_la (p, s390_r13, 0, STK_BASE, local_pos);
local_pos += size;
} else {
local_pos += (local_pos % align);
s390_bras (p, s390_r13, 4);
s390_llong(p, size);
s390_lg (p, s390_r1, 0, s390_r13, 0);
s390_lg (p, s390_r0, 0, ARG_BASE, STKARG);
s390_lgr (p, s390_r14, s390_r12);
s390_la (p, s390_r12, 0, STK_BASE, local_pos);
s390_lgr (p, s390_r13, s390_r1);
s390_mvcl (p, s390_r12, s390_r0);
s390_lgr (p, s390_r12, s390_r14);
s390_la (p, s390_r13, 0, STK_BASE, local_pos);
local_pos += size;
}
if (gr < GENERAL_REGS) {
s390_lgr(p, s390_r2 + gr, s390_r13);
gr++;
} else {
s390_stg(p, s390_r13, 0, STK_BASE, stack_par_pos);
stack_par_pos += sizeof(long);
}
}
break;
case MONO_TYPE_I8:
if (gr < GENERAL_REGS) {
s390_lg (p, s390_r2 + gr, 0, ARG_BASE, STKARG);
gr += 2;
} else {
*(guint32 *) p += 7;
*(guint32 *) p &= ~7;
s390_mvc (p, sizeof(long long), STK_BASE, stack_par_pos, ARG_BASE, STKARG);
stack_par_pos += sizeof(long long) + (stack_par_pos % sizeof(long long));
}
break;
case MONO_TYPE_R4:
if (fr < FLOAT_REGS) {
s390_le (p, s390_r0 + fr, 0, ARG_BASE, STKARG);
fr++;
} else {
s390_mvc (p, sizeof(float), STK_BASE, stack_par_pos, ARG_BASE, STKARG);
stack_par_pos += sizeof(float);
}
break;
case MONO_TYPE_R8:
if (fr < FLOAT_REGS) {
s390_ld (p, s390_r0 + fr, 0, ARG_BASE, STKARG);
fr++;
} else {
*(guint32 *) p += 7;
*(guint32 *) p &= ~7;
s390_mvc (p, sizeof(double), STK_BASE, stack_par_pos, ARG_BASE, STKARG);
stack_par_pos += sizeof(long long) + (stack_par_pos % sizeof(long long));
}
break;
default:
g_error ("Can't trampoline 0x%x", sig->params [i]->type);
}
}
/*----------------------------------------------------------*/
/* If we're returning a structure but not in a register */
/* then point the result area for the called routine */
/*----------------------------------------------------------*/
if (sz->retStruct) {
s390_lg (p, s390_r2, 0, s390_r8, 0);
}
return p;
}
