/*------------------------------------------------------------------*/
#define NOT_IMPLEMENTED(x) \
- g_error ("FIXME: %s is not yet implemented. (trampoline)", x);
+ g_error ("FIXME: %s is not yet implemented.", x);
#define EMIT_COND_BRANCH(ins,cond) \
{ \
/* P r o t o t y p e s */
/*------------------------------------------------------------------*/
-static guint32 *emit_memcpy (guint8 *, int, int, int, int, int);
+static guint32 * emit_memcpy (guint8 *, int, int, int, int, int);
static void indent (int);
+static guint8 * restoreLMF(MonoCompile *, guint8 *);
+static guint8 * backUpStackPtr(MonoCompile *, guint8 *);
static void decodeParm (MonoType *, void *, int);
static void enter_method (MonoMethod *, RegParm *, char *);
static void leave_method (MonoMethod *, ...);
/*========================= End of Function ========================*/
+/*------------------------------------------------------------------*/
+/* */
+/* Name - restoreLMF */
+/* */
+/* Function - Restore the LMF state prior to exiting a method. */
+/* */
+/*------------------------------------------------------------------*/
+
+static inline guint8 *
+restoreLMF(MonoCompile *cfg, guint8 *code)
+{
+ int lmfOffset = 0;
+
+ s390_lr (code, s390_r13, cfg->frame_reg);
+
+ lmfOffset = cfg->stack_usage - sizeof(MonoLMF);
+
+ /*-------------------------------------------------*/
+ /* r13 = my lmf */
+ /*-------------------------------------------------*/
+ s390_ahi (code, s390_r13, lmfOffset);
+
+ /*-------------------------------------------------*/
+ /* r6 = &jit_tls->lmf */
+ /*-------------------------------------------------*/
+ s390_l (code, s390_r6, 0, s390_r13, G_STRUCT_OFFSET(MonoLMF, lmf_addr));
+
+ /*-------------------------------------------------*/
+ /* r0 = lmf.previous_lmf */
+ /*-------------------------------------------------*/
+ s390_l (code, s390_r0, 0, s390_r13, G_STRUCT_OFFSET(MonoLMF, previous_lmf));
+
+ /*-------------------------------------------------*/
+ /* jit_tls->lmf = previous_lmf */
+ /*-------------------------------------------------*/
+ s390_l (code, s390_r13, 0, s390_r6, 0);
+ s390_st (code, s390_r0, 0, s390_r6, 0);
+ return (code);
+}
+
+/*========================= End of Function ========================*/
+
+/*------------------------------------------------------------------*/
+/* */
+/* Name - backStackPtr. */
+/* */
+/* Function - Restore Stack Pointer to previous frame. */
+/* */
+/*------------------------------------------------------------------*/
+
+static inline guint8 *
+backUpStackPtr(MonoCompile *cfg, guint8 *code)
+{
+ int stackSize = cfg->stack_usage;
+
+ if (s390_is_imm16 (cfg->stack_usage)) {
+ s390_ahi (code, STK_BASE, cfg->stack_usage);
+ } else {
+ while (stackSize > 32767) {
+ s390_ahi (code, STK_BASE, 32767);
+ stackSize -= 32767;
+ }
+ s390_ahi (code, STK_BASE, stackSize);
+ }
+ return (code);
+}
+
+/*========================= End of Function ========================*/
+
/*------------------------------------------------------------------*/
/* */
/* Name - indent */
/* */
/*------------------------------------------------------------------*/
-static int methodCount = 0;
-
static void
enter_method (MonoMethod *method, RegParm *rParm, char *sp)
{
size_data sz;
void *curParm;
-methodCount++;
-if (methodCount > 150000) {
-methodCount = 0;
-rewind(stdout);
-}
fname = mono_method_full_name (method, TRUE);
indent (1);
printf ("ENTER: %s(", fname);
g_free (fname);
ip = (*(guint32 *) (sp+S390_RET_ADDR_OFFSET)) & 0x7fffffff;
- printf (") ip: %p sp: %p\n", ip, sp);
+ printf (") ip: %p sp: %p - ", ip, sp);
if (rParm == NULL)
return;
}
case MONO_TYPE_I: {
int *val = va_arg (ap, int*);
- printf ("[INT:%p]", val);
+ printf ("[INT:%d]", val);
printf("]");
break;
}
case MONO_TYPE_U: {
int *val = va_arg (ap, int*);
- printf ("[UINT:%p]", val);
+ printf ("[UINT:%d]", val);
printf("]");
break;
}
printf ("[LONG:%lld]", l);
break;
}
+ case MONO_TYPE_R4: {
+ double f = va_arg (ap, double);
+ printf ("[FLOAT4:%f]\n", (float) f);
+ break;
+ }
case MONO_TYPE_R8: {
double f = va_arg (ap, double);
- printf ("[FP:%g]\n", f);
+ printf ("[FLOAT8:%g]\n", f);
break;
}
case MONO_TYPE_VALUETYPE:
fr = 0;
gr = s390_r2;
+ nParm = 0;
cinfo->struct_ret = 0;
sz->retStruct = 0;
sz->stack_size = S390_MINIMAL_STACK_SIZE;
sz->code_size = 0;
sz->local_size = 0;
- nParm = 0;
/*----------------------------------------------------------*/
/* We determine the size of the return code/stack in case we*/
/* need to reserve a register to be used to address a stack */
sz->stack_size += S390_ALIGN(size, align);
gr++;
break;
+ case MONO_TYPE_TYPEDBYREF:
case MONO_TYPE_VOID:
break;
default:
case 2:
case 4:
add_general(&gr, sz, cinfo->args+nParm, TRUE);
-// cinfo->args[nParm].size = sizeof(int);
cinfo->args[nParm].size = size;
cinfo->args[nParm].regtype = RegTypeStructByVal;
nParm++;
sz->code_size += 4;
fr += 2;
} else {
-// sz->stack_size = S390_ALIGN(sz->stack_size,
-// S390_STACK_ALIGNMENT);
cinfo->args[nParm].offset = sz->stack_size;
cinfo->args[nParm].reg = STK_BASE;
cinfo->args[nParm].regtype = RegTypeBase;
}
}
-
- /* align stack size */
cinfo->stack_usage = S390_ALIGN(sz->stack_size+sz->local_size,
S390_STACK_ALIGNMENT);
return (cinfo);
header = ((MonoMethodNormal *)m->method)->header;
- /*
- * We use the frame register also for any method that has
- * filter clauses. This way, when the handlers are called,
- * the code will reference local variables using the frame reg instead of
- * the stack pointer: if we had to restore the stack pointer, we'd
- * corrupt the method frames that are already on the stack (since
- * filters get called before stack unwinding happens) when the filter
- * code would call any method.
- */
+ /*---------------------------------------------------------*/
+ /* We use the frame register also for any method that has */
+ /* filter clauses. This way, when the handlers are called, */
+ /* the code will reference local variables using the frame */
+ /* reg instead of the stack pointer: if we had to restore */
+ /* the stack pointer, we'd corrupt the method frames that */
+ /* are already on the stack (since filters get called */
+ /* before stack unwinding happens) when the filter code */
+ /* would call any method. */
+ /*---------------------------------------------------------*/
if ((m->flags & MONO_CFG_HAS_ALLOCA) || header->num_clauses)
-// if (m->flags & MONO_CFG_HAS_ALLOCA)
frame_reg = s390_r11;
m->frame_reg = frame_reg;
case RegTypeStructByAddr :
inst->opcode = OP_S390_LOADARG;
inst->inst_basereg = frame_reg;
-// size = sizeof(long);
size = abs(cinfo->args[iParm].vtsize);
offset = S390_ALIGN(offset, size);
inst->inst_offset = offset;
: 0);
inst->inst_offset = cinfo->args[iParm].offset +
size;
-// inst->unused = stackOffset;
inst->unused = 0;
size = sizeof(long);
}
if (inst->opcode == OP_REGVAR)
continue;
- /* inst->unused indicates native sized value types, this is used by the
- * pinvoke wrappers when they call functions returning structure */
+ /*--------------------------------------------------*/
+ /* inst->unused indicates native sized value types, */
+ /* this is used by the pinvoke wrappers when they */
+ /* call functions returning structure */
+ /*--------------------------------------------------*/
if (inst->unused && MONO_TYPE_ISSTRUCT (inst->inst_vtype))
size = mono_class_native_size (inst->inst_vtype->data.klass, &align);
else
//DEBUG (g_print("allocating local %d to %d\n", iVar, inst->inst_offset));
}
-// if (sig->hasthis)
-// curinst = sArg = 1;
-// else
-// curinst = sArg = 0;
-//
-
/*------------------------------------------------------*/
/* Allow space for the trace method stack area if needed*/
/*------------------------------------------------------*/
/*------------------------------------------------------------------*/
MonoCallInst*
-mono_arch_call_opcode (MonoCompile *cfg, MonoBasicBlock* bb, MonoCallInst *call, int is_virtual) {
+mono_arch_call_opcode (MonoCompile *cfg, MonoBasicBlock* bb,
+ MonoCallInst *call, int is_virtual) {
MonoInst *arg, *in;
MonoMethodSignature *sig;
int i, n, lParamArea;
lParamArea = cinfo->stack_usage - S390_MINIMAL_STACK_SIZE;
cfg->param_area = MAX (cfg->param_area, lParamArea);
cfg->flags |= MONO_CFG_HAS_CALLS;
- /*----------------------------------------------------------*/
- /* should set more info in call, such as the stack space */
- /* used by the args that needs to be added back to esp */
- /*----------------------------------------------------------*/
if (cinfo->struct_ret)
call->used_iregs |= 1 << cinfo->struct_ret;
arg->inst_imm = ainfo->offset;
call->used_fregs |= 1 << ainfo->reg;
} else if (ainfo->regtype == RegTypeFP) {
-// arg->opcode = OP_OUTARG_R8;
-// arg->unused = ainfo->reg;
-// call->used_fregs |= 1 << ainfo->reg;
-// if (ainfo->size == 4) {
-// /* we reduce the precision */
-// MonoInst *conv;
-// MONO_INST_NEW (cfg, conv, OP_FCONV_TO_R4);
-// conv->inst_left = arg->inst_left;
-// arg->inst_left = conv;
-// }
arg->unused = ainfo->reg;
call->used_fregs |= 1 << ainfo->reg;
if (ainfo->size == 4) {
/* sreg is a float, dreg is an integer reg. */
if (is_signed) {
s390_cfdbr (code, dreg, 5, sreg);
+ switch (size) {
+ case 1:
+ s390_lhi (code, s390_r0, 0);
+ s390_lhi (code, s390_r13, 0xff);
+ s390_ltr (code, dreg, dreg);
+ s390_jnl (code, 4);
+ s390_lhi (code, s390_r0, 0x80);
+ s390_nr (code, dreg, s390_r13);
+ s390_or (code, dreg, s390_r0);
+ break;
+ }
} else {
s390_basr (code, s390_r13, 0);
s390_j (code, 10);
- s390_double (code, 0x41e0000000000000);
- s390_double (code, 0x41f0000000000000);
+ s390_llong (code, 0x41e0000000000000);
+ s390_llong (code, 0x41f0000000000000);
s390_ldr (code, s390_f15, sreg);
s390_cdb (code, s390_f15, 0, s390_r13, 0);
s390_jl (code, 10);
s390_sdb (code, s390_f15, 0, s390_r13, 8);
s390_cfdbr (code, dreg, 7, s390_f15);
- s390_j (code, 5);
+ s390_j (code, 4);
s390_cfdbr (code, dreg, 5, sreg);
+ switch (size) {
+ case 1:
+ s390_lhi (code, s390_r0, 0xff);
+ s390_nr (code, dreg, s390_r0);
+ break;
+ case 2:
+ s390_lhi (code, s390_r0, -1);
+ s390_srl (code, s390_r0, 0, 16);
+ s390_nr (code, dreg, s390_r0);
+ break;
+ }
}
return code;
}
code = cfg->native_code + offset;
}
+ mono_debug_record_line_number (cfg, ins, offset);
+
switch (ins->opcode) {
case OP_STOREI1_MEMBASE_IMM: {
s390_lhi (code, s390_r14, ins->inst_imm);
if (s390_is_uimm12(ins->inst_offset)) {
s390_sth (code, s390_r14, 0, ins->inst_destbasereg, ins->inst_offset);
} else {
- s390_basr (code, s390_r14, 0);
+ s390_basr (code, s390_r13, 0);
s390_j (code, 4);
s390_word (code, ins->inst_offset);
s390_l (code, s390_r13, 0, s390_r13, 4);
break;
case CEE_CONV_I2: {
s390_lhi (code, s390_r0, 0x80);
+ s390_sll (code, s390_r0, 0, 8);
if (ins->dreg != ins->sreg1) {
s390_lr (code, ins->dreg, ins->sreg1);
}
case OP_COMPARE: {
if ((ins->next) &&
((ins->next->opcode >= CEE_BNE_UN) &&
- (ins->next->opcode <= CEE_BLT_UN)))
+ (ins->next->opcode <= CEE_BLT_UN)) ||
+ ((ins->next->opcode >= OP_COND_EXC_NE_UN) &&
+ (ins->next->opcode <= OP_COND_EXC_LT_UN)) ||
+ ((ins->next->opcode == OP_CLT_UN) ||
+ (ins->next->opcode == OP_CGT_UN)))
s390_clr (code, ins->sreg1, ins->sreg2);
else
s390_cr (code, ins->sreg1, ins->sreg2);
if (s390_is_imm16 (ins->inst_imm)) {
s390_lhi (code, s390_r0, ins->inst_imm);
if ((ins->next) &&
- ((ins->next->opcode >= CEE_BNE_UN) &&
- (ins->next->opcode <= CEE_BLT_UN)))
+ ((ins->next->opcode >= CEE_BNE_UN) &&
+ (ins->next->opcode <= CEE_BLT_UN)) ||
+ ((ins->next->opcode >= OP_COND_EXC_NE_UN) &&
+ (ins->next->opcode <= OP_COND_EXC_LT_UN)) ||
+ ((ins->next->opcode == OP_CLT_UN) ||
+ (ins->next->opcode == OP_CGT_UN)))
s390_clr (code, ins->sreg1, s390_r0);
else
s390_cr (code, ins->sreg1, s390_r0);
s390_j (code, 4);
s390_word (code, ins->inst_imm);
if ((ins->next) &&
- ((ins->next->opcode >= CEE_BNE_UN) &&
- (ins->next->opcode <= CEE_BLT_UN)))
+ ((ins->next->opcode >= CEE_BNE_UN) &&
+ (ins->next->opcode <= CEE_BLT_UN)) ||
+ ((ins->next->opcode >= OP_COND_EXC_NE_UN) &&
+ (ins->next->opcode <= OP_COND_EXC_LT_UN)) ||
+ ((ins->next->opcode == OP_CLT_UN) &&
+ (ins->next->opcode == OP_CGT_UN)))
s390_cl (code, ins->sreg1, 0, s390_r13, 4);
else
s390_c (code, ins->sreg1, 0, s390_r13, 4);
s390_alcr (code, ins->dreg, ins->sreg2);
}
break;
+ case OP_ADDCC_IMM:
case OP_ADD_IMM: {
if ((ins->next) &&
(ins->next->opcode == OP_ADC_IMM)) {
if (ins->dreg != ins->sreg1) {
s390_lr (code, ins->dreg, ins->sreg1);
}
- s390_sr (code, ins->dreg, ins->sreg2);
+ s390_slr (code, ins->dreg, ins->sreg2);
}
break;
case CEE_SUB: {
s390_slbr (code, ins->dreg, ins->sreg2);
}
break;
+ case OP_SUBCC_IMM:
case OP_SUB_IMM: {
if (s390_is_imm16 (-ins->inst_imm)) {
if (ins->dreg != ins->sreg1) {
s390_slbr (code, s390_r0, s390_r1);
s390_sr (code, ins->dreg, ins->sreg2);
EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV, "OverflowException");
- s390_sr (code, ins->dreg, s390_r0);
+ s390_ar (code, ins->dreg, s390_r0);
EMIT_COND_SYSTEM_EXCEPTION (S390_CC_OV, "OverflowException");
}
break;
}
}
break;
- case OP_FCONV_TO_R4: {
+ case OP_S390_SETF4RET: {
s390_ledbr (code, ins->dreg, ins->sreg1);
}
break;
- case CEE_JMP:
- g_assert_not_reached ();
+ case OP_FCONV_TO_R4: {
+ if ((ins->next) &&
+ (ins->next->opcode != OP_STORER4_MEMBASE_REG))
+ s390_ledbr (code, ins->dreg, ins->sreg1);
+ }
+ break;
+ case CEE_JMP: {
+ int fParm;
+ if (cfg->method->save_lmf)
+ code = restoreLMF(cfg, code);
+
+ if (cfg->flags & MONO_CFG_HAS_TAIL) {
+ s390_lm (code, s390_r2, s390_r5, STK_BASE,
+ S390_PARM_SAVE_OFFSET);
+ for (fParm = 0; fParm < 4; fParm++)
+ s390_ld (code, fParm, 0, STK_BASE,
+ S390_FLOAT_SAVE_OFFSET+fParm*sizeof(double));
+ }
+
+ code = backUpStackPtr(cfg, code);
+ s390_l (code, s390_r14, 0, STK_BASE, S390_RET_ADDR_OFFSET);
+ mono_add_patch_info (cfg, code - cfg->native_code,
+ MONO_PATCH_INFO_METHOD_JUMP,
+ ins->inst_p0);
+ s390_jcl (code, S390_CC_UN, 0);
+ }
break;
case OP_CHECK_THIS: {
/* ensure ins->sreg1 is not NULL */
s390_icm (code, s390_r0, 15, ins->sreg1, 0);
}
break;
+ case OP_ARGLIST: {
+ NOT_IMPLEMENTED("OP_ARGLIST");
+ s390_basr (code, s390_r13, 0);
+ s390_j (code, 4);
+ s390_word (code, cfg->sig_cookie);
+ s390_mvc (code, 4, ins->sreg1, 0, s390_r13, 4);
+ }
+ break;
case OP_FCALL: {
call = (MonoCallInst*)ins;
if (ins->flags & MONO_INST_HAS_METHOD)
s390_l (code, s390_r14, s390_r13,
ins->inst_left->inst_basereg, 0);
}
-// s390_l (code, STK_BASE, 0, STK_BASE, 0);
-// s390_lm (code, s390_r6, s390_r14, STK_BASE, S390_REG_SAVE_OFFSET);
s390_br (code, s390_r14);
}
break;
s390_l (code, s390_r14, s390_r13,
ins->inst_left->inst_basereg, 0);
}
-// s390_l (code, s390_r14, 0, ins->inst_left->inst_basereg, ins->inst_left->inst_offset);
s390_br (code, s390_r14);
}
break;
s390_word (code, ins->inst_p0);
s390_l (code, s390_r13, 0, s390_r13, 4);
s390_ldeb (code, ins->dreg, 0, s390_r13, 0);
-// s390_ldebr(code, ins->dreg, ins->dreg);
}
}
break;
s390_l (code, s390_r13, 0, s390_r13, 4);
s390_ldeb (code, ins->dreg, s390_r13, ins->inst_basereg, 0);
}
-// s390_ldebr (code, ins->dreg, ins->dreg);
}
break;
case CEE_CONV_R_UN: {
break;
case CEE_CKFINITE: {
short *o;
- s390_lhi (code, s390_r13, 0xfc0);
+ s390_lhi (code, s390_r13, 0x7f);
s390_tcdb (code, ins->sreg1, 0, s390_r13, 0);
s390_jz (code, 0); CODEPTR(code, o);
- mono_add_patch_info (cfg, code - cfg->native_code + 2,
+ mono_add_patch_info (cfg, code - cfg->native_code,
MONO_PATCH_INFO_EXC, "ArithmeticException");
s390_brasl (code, s390_r14,0);
PTRSLOT(code, o);
}
break;
case OP_S390_MOVE: {
- if (ins->unused <= 256) {
- s390_mvc (code, ins->unused, ins->dreg,
- ins->inst_offset, ins->sreg1, ins->inst_imm);
- } else {
- s390_lr (code, s390_r0, ins->dreg);
- if (s390_is_imm16 (ins->inst_offset)) {
- s390_ahi (code, s390_r0, ins->inst_offset);
- } else {
- s390_basr (code, s390_r13, 0);
- s390_j (code, 4);
- s390_word (code, ins->inst_offset);
- s390_a (code, s390_r0, 0, s390_r13, 4);
- }
- s390_lr (code, s390_r1, ins->sreg2);
- if (s390_is_imm16 (ins->inst_imm)) {
- s390_ahi (code, s390_r1, ins->inst_imm);
+ if (ins->unused > 0) {
+ if (ins->unused <= 256) {
+ s390_mvc (code, ins->unused, ins->dreg,
+ ins->inst_offset, ins->sreg1, ins->inst_imm);
} else {
- s390_basr (code, s390_r13, 0);
- s390_j (code, 4);
- s390_word (code, ins->inst_imm);
- s390_a (code, s390_r1, 0, s390_r13, 4);
+ s390_lr (code, s390_r0, ins->dreg);
+ if (s390_is_imm16 (ins->inst_offset)) {
+ s390_ahi (code, s390_r0, ins->inst_offset);
+ } else {
+ s390_basr (code, s390_r13, 0);
+ s390_j (code, 4);
+ s390_word (code, ins->inst_offset);
+ s390_a (code, s390_r0, 0, s390_r13, 4);
+ }
+ s390_lr (code, s390_r12, ins->sreg1);
+ if (s390_is_imm16 (ins->inst_imm)) {
+ s390_ahi (code, s390_r12, ins->inst_imm);
+ } else {
+ s390_basr (code, s390_r13, 0);
+ s390_j (code, 4);
+ s390_word (code, ins->inst_imm);
+ s390_a (code, s390_r12, 0, s390_r13, 4);
+ }
+ s390_lr (code, s390_r1, ins->sreg1);
+ s390_lr (code, s390_r13, s390_r1);
+ s390_mvcle(code, s390_r0, s390_r12, 0, 0);
+ s390_jo (code, -2);
}
- s390_lr (code, s390_r12, ins->sreg1);
- s390_lr (code, s390_r13, s390_r1);
- s390_mvcle(code, s390_r0, s390_r12, 0, 0);
- s390_jo (code, -2);
}
}
break;
ip += 2; /* Skip over op-code */
break;
}
- case MONO_PATCH_INFO_METHOD_JUMP:
- g_assert_not_reached ();
+ case MONO_PATCH_INFO_METHOD_JUMP: {
+ GSList *list;
+
+ /*------------------------------------------------------*/
+ /* get the trampoline to the method from the domain */
+ /*------------------------------------------------------*/
+ target = mono_create_jump_trampoline (domain,
+ patch_info->data.method,
+ TRUE);
+ target = S390_RELATIVE(target, ip);
+ if (!domain->jump_target_hash)
+ domain->jump_target_hash = g_hash_table_new (NULL, NULL);
+ list = g_hash_table_lookup (domain->jump_target_hash,
+ patch_info->data.method);
+ list = g_slist_prepend (list, ip);
+ g_hash_table_insert (domain->jump_target_hash,
+ patch_info->data.method, list);
+ ip +=2;
break;
+ }
case MONO_PATCH_INFO_METHOD:
if (patch_info->data.method == method) {
target = S390_RELATIVE(code, ip);
cfg->code_size = 256;
cfg->native_code = code = g_malloc (cfg->code_size);
- s390_stm (code, s390_r6, s390_r14, STK_BASE, S390_REG_SAVE_OFFSET);
+ if (cfg->flags & MONO_CFG_HAS_TAIL) {
+ s390_stm (code, s390_r2, s390_r14, STK_BASE, S390_PARM_SAVE_OFFSET);
+ for (pos = 0; pos < 4; pos++)
+ s390_std (code, pos, 0, STK_BASE,
+ S390_FLOAT_SAVE_OFFSET+pos*sizeof(double));
+ } else {
+ s390_stm (code, s390_r6, s390_r14, STK_BASE, S390_REG_SAVE_OFFSET);
+ }
if (cfg->flags & MONO_CFG_HAS_ALLOCA) {
cfg->used_int_regs |= 1 << 11;
}
alloc_size = cfg->stack_offset;
-// if (tracing)
-// alloc_size += S390_TRACE_STACK_SIZE;
-// pos = 0;
- /* reserve room to save return value */
-// if (tracing)
-// pos += 8;
-
-// alloc_size += pos;
-
-// if (method->save_lmf)
-// alloc_size += sizeof(MonoLMF);
-
-// alloc_size = S390_ALIGN(alloc_size, S390_STACK_ALIGNMENT);
cfg->stack_usage = alloc_size;
s390_lr (code, s390_r11, STK_BASE);
}
s390_st (code, s390_r11, 0, STK_BASE, 0);
-// if (cfg->flags & MONO_CFG_HAS_ALLOCA)
if (cfg->frame_reg != STK_BASE)
s390_lr (code, s390_r11, STK_BASE);
if (inst->dreg != ainfo->reg) {
if (ainfo->size == 4) {
s390_ledbr (code, inst->dreg, ainfo->reg);
-// s390_ler (code, inst->dreg, ainfo->reg);
} else {
s390_ldr (code, inst->dreg, ainfo->reg);
}
if (ainfo->reg == STK_BASE) {
s390_lr (code, s390_r13, ainfo->reg);
s390_ahi (code, s390_r13, alloc_size);
+ s390_l (code, s390_r13, 0, s390_r13,
+ ainfo->offparm + S390_MINIMAL_STACK_SIZE);
code = emit_memcpy (code, abs(ainfo->vtsize),
inst->inst_basereg,
- inst->inst_offset, s390_r13,
- ainfo->offparm +
- S390_MINIMAL_STACK_SIZE);
+ inst->inst_offset, s390_r13, 0);
} else {
code = emit_memcpy (code, abs(ainfo->vtsize),
inst->inst_basereg,
/* save the current IP */
/*---------------------------------------------------------------*/
s390_lr (code, s390_r1, cfg->frame_reg);
-// s390_ahi (code, s390_r1, alloc_size);
s390_st (code, s390_r1, 0, s390_r13, G_STRUCT_OFFSET(MonoLMF, ebp));
s390_l (code, s390_r1, 0, s390_r1, S390_RET_ADDR_OFFSET);
s390_la (code, s390_r1, 0, s390_r1, 0);
MonoMethod *method = cfg->method;
MonoMethodSignature *sig = method->signature;
MonoInst *inst;
- int i, lmfOffset, tracing = 0;
+ int i, tracing = 0;
guint8 *code;
code = cfg->native_code + cfg->code_len;
tracing = 1;
}
- if (method->save_lmf) {
- s390_lr (code, s390_r13, cfg->frame_reg);
-
- lmfOffset = cfg->stack_usage - sizeof(MonoLMF);
-
- /*-------------------------------------------------*/
- /* r13 = my lmf */
- /*-------------------------------------------------*/
- s390_ahi (code, s390_r13, lmfOffset);
-
- /*-------------------------------------------------*/
- /* r6 = &jit_tls->lmf */
- /*-------------------------------------------------*/
- s390_l (code, s390_r6, 0, s390_r13, G_STRUCT_OFFSET(MonoLMF, lmf_addr));
-
- /*-------------------------------------------------*/
- /* r0 = lmf.previous_lmf */
- /*-------------------------------------------------*/
- s390_l (code, s390_r0, 0, s390_r13, G_STRUCT_OFFSET(MonoLMF, previous_lmf));
-
- /*-------------------------------------------------*/
- /* jit_tls->lmf = previous_lmf */
- /*-------------------------------------------------*/
- s390_l (code, s390_r13, 0, s390_r6, 0);
- s390_st (code, s390_r0, 0, s390_r6, 0);
- }
-
-// if (cfg->frame_reg != STK_BASE)
-// s390_lr (code, STK_BASE, cfg->frame_reg);
+ if (method->save_lmf)
+ code = restoreLMF(cfg, code);
- if (cfg->flags & MONO_CFG_HAS_ALLOCA) {
+ if (cfg->flags & MONO_CFG_HAS_ALLOCA)
s390_l (code, STK_BASE, 0, STK_BASE, 0);
- } else {
- if (s390_is_imm16 (cfg->stack_usage)) {
- s390_ahi (code, STK_BASE, cfg->stack_usage);
- } else {
- int stackSize = cfg->stack_usage;
- while (stackSize > 32767) {
- s390_ahi (code, STK_BASE, -32767);
- stackSize -= 32767;
- }
- s390_ahi (code, STK_BASE, -stackSize);
- }
- }
+ else
+ code = backUpStackPtr(cfg, code);
+
s390_lm (code, s390_r6, s390_r14, STK_BASE, S390_REG_SAVE_OFFSET);
s390_br (code, s390_r14);
done = 1;
break;
case OP_S390_MOVE:
- printf ("[%x(%d,%s),%x(%s)]",
+ printf ("[0x%x(%d,%s),0x%x(%s)]",
tree->inst_offset, tree->unused,
tree->dreg, tree->inst_imm,
tree->sreg1);
done = 1;
break;
+ case OP_S390_SETF4RET:
+ printf ("[f%d,f%d]",
+ mono_arch_regname (tree->dreg),
+ mono_arch_regname (tree->sreg1));
default:
done = 0;
}
}
/*========================= End of Function ========================*/
+
+MonoInst* mono_arch_get_domain_intrinsic (MonoCompile* cfg)
+{
+ return NULL;
+}
+
+MonoInst* mono_arch_get_thread_intrinsic (MonoCompile* cfg)
+{
+ return NULL;
+}
projects / mono.git / blobdiff