%%

#
# inssel-s390x.brg: burg file for special s390 instructions
#
# Author:
#   Neale Ferguson (Neale.Ferguson@SoftwareAG-usa.com)
#   Dietmar Maurer (dietmar@ximian.com)
#   Paolo Molaro (lupus@ximian.com)
#
# (C) 2002 Ximian, Inc.
#

stmt: OP_START_HANDLER {
	MonoInst *spvar = mono_find_spvar_for_region (s, s->cbb->region);
	tree->inst_left = spvar;
	mono_bblock_add_inst (s->cbb, tree);
}

stmt: CEE_ENDFINALLY {
	MonoInst *spvar = mono_find_spvar_for_region (s, s->cbb->region);
	tree->inst_left = spvar;
	mono_bblock_add_inst (s->cbb, tree);
}

stmt: OP_ENDFILTER (reg) {
	MonoInst *spvar = mono_find_spvar_for_region (s, s->cbb->region);
	tree->inst_left = spvar;
	tree->sreg1 = state->left->reg1;
	mono_bblock_add_inst (s->cbb, tree);
}

reg: CEE_ADD_OVF (reg, reg) "0" {
	MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
}

reg: CEE_ADD_OVF_UN (reg, reg) "0" {
	MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
}

reg: CEE_SUB_OVF (reg, reg) "0" {
	MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
}

reg: CEE_SUB_OVF_UN (reg, reg) "0" {
	MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
}

stmt: CEE_STIND_I8 (OP_REGVAR, reg) {
	MONO_EMIT_NEW_UNALU (s, OP_MOVE, state->left->tree->dreg, state->right->reg1);
//	MONO_EMIT_NEW_UNALU (s, OP_MOVE, s390_r2, state->right->reg1);
}

reg: CEE_LDIND_I8 (OP_REGVAR) {
	MONO_EMIT_NEW_UNALU (s, OP_MOVE, state->reg1, state->left->tree->dreg);
}

freg: OP_LCONV_TO_R8 (lreg) {
	tree->dreg = state->reg1;
	tree->sreg1 = state->left->reg1;
	tree->sreg2 = state->left->reg2;
	mono_bblock_add_inst (s->cbb, tree);
}

freg: OP_LCONV_TO_R4 (lreg) {
	tree->dreg = state->reg1;
	tree->sreg1 = state->left->reg1;
	tree->sreg2 = state->left->reg2;
	mono_bblock_add_inst (s->cbb, tree);
}

freg: CEE_CONV_R_UN (reg) {
	tree->dreg = state->reg1;
	tree->sreg1 = state->left->reg1;
	mono_bblock_add_inst (s->cbb, tree);
}

freg: CEE_CONV_R_UN (reg) {
	mono_bblock_add_inst (s->cbb, tree);
}

stmt: OP_MEMCPY (reg, reg) "0" {
	int size = tree->unused;
	if (size > 0) 
		MONO_EMIT_NEW_MOVE (s, state->left->reg1, 0, state->right->reg1, 0, size);
}

reg: OP_LOCALLOC (OP_ICONST) {
	/* microcoded in mini-s390.c */
	tree->sreg1 = mono_regstate_next_int (s->rs);
	tree->dreg  = state->reg1;
	MONO_EMIT_NEW_ICONST (s, tree->sreg1, state->left->tree->inst_c0);
	mono_bblock_add_inst (s->cbb, tree);
}

reg: OP_LOCALLOC (reg) {
	tree->dreg = state->reg1;
	tree->sreg1 = state->left->reg1;
        mono_bblock_add_inst (s->cbb, tree);
}

stmt: OP_SETRET (reg) {
	tree->opcode = OP_MOVE;
	tree->sreg1 = state->left->reg1;
	tree->dreg = s390_r2;
	mono_bblock_add_inst (s->cbb, tree);
}

# stmt: OP_SETRET (lreg) {
#	tree->opcode = OP_MOVE;
#	tree->sreg1 = state->left->reg1;
#	tree->dreg = s390_r2;
#	mono_bblock_add_inst (s->cbb, tree);
# }

stmt: OP_SETRET (freg) {
	if (mono_method_signature (s->method)->ret->type == MONO_TYPE_R4) {
		tree->opcode = OP_S390_SETF4RET;
		tree->sreg1  = state->left->reg1;
		tree->dreg   = s390_f0;
	} else {
		tree->opcode = OP_FMOVE;
		tree->sreg1  = state->left->reg1;
		tree->dreg   = s390_f0;
	}
	mono_bblock_add_inst (s->cbb, tree);
}

stmt: OP_SETRET (OP_ICONST) {
	tree->opcode = OP_ICONST;
	tree->inst_c0 = state->left->tree->inst_c0;
	tree->dreg = s390_r2;
	mono_bblock_add_inst (s->cbb, tree);
}

stmt: OP_OUTARG (reg) {
	if (tree->inst_imm) {
		MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, STK_BASE, tree->inst_imm, state->left->reg1);
		return;
	}
	tree->opcode = OP_SETREG;
	tree->dreg = tree->unused;
	tree->sreg1 = state->left->reg1;
	mono_bblock_add_inst (s->cbb, tree);
}

stmt: OP_OUTARG (OP_REGVAR) {
	if (tree->inst_imm) {
		MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, STK_BASE, tree->inst_imm, state->left->tree->dreg);
		return;
	}
	tree->opcode = OP_SETREG;
	tree->dreg = tree->unused;
	tree->sreg1 = state->left->tree->dreg;
	mono_bblock_add_inst (s->cbb, tree);
}

stmt: OP_OUTARG (OP_I8CONST) {
	if (tree->inst_imm) {
		MONO_EMIT_NEW_STORE_MEMBASE_IMM (s, OP_STORE_MEMBASE_IMM, 
					         STK_BASE, tree->inst_imm, 
						 state->left->tree->inst_c0);
		return;
	}
	tree->opcode = OP_SETREGIMM;
	tree->dreg = tree->unused;
	tree->inst_c0 = state->left->tree->inst_c0;
	mono_bblock_add_inst (s->cbb, tree);
}

stmt: OP_OUTARG (OP_ICONST) {
	if (tree->inst_imm) {
		MONO_EMIT_NEW_STORE_MEMBASE_IMM (s, OP_STOREI4_MEMBASE_IMM, 
					         STK_BASE, tree->inst_imm, 
						 state->left->tree->inst_c0);
		return;
	}
	tree->opcode = OP_SETREGIMM;
	tree->dreg = tree->unused;
	tree->inst_c0 = state->left->tree->inst_c0;
	mono_bblock_add_inst (s->cbb, tree);
}

stmt: OP_OUTARG (CEE_LDIND_REF (OP_REGVAR)) {
	if (tree->inst_imm) {
		MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, STK_BASE, tree->inst_imm, state->left->left->tree->dreg);
		return;
	}
	tree->opcode = OP_SETREG;
	tree->sreg1 = state->left->left->tree->dreg;
	tree->dreg = tree->unused;
	mono_bblock_add_inst (s->cbb, tree);
}

stmt: OP_OUTARG (CEE_LDIND_I (OP_REGVAR)) {
	tree->opcode = OP_SETREG;
	tree->dreg   = tree->unused;
	tree->sreg1  = state->left->left->tree->dreg;
	mono_bblock_add_inst (s->cbb, tree);
}

stmt: OP_OUTARG (CEE_LDIND_I8 (OP_REGVAR)) {
	tree->opcode = OP_SETREG;
	tree->dreg   = tree->unused;
	tree->sreg1  = state->left->left->tree->dreg;
	mono_bblock_add_inst (s->cbb, tree);
}

stmt: OP_OUTARG (CEE_LDIND_I4 (OP_REGVAR)) {
	tree->opcode = OP_SETREG;
	tree->dreg   = tree->unused;
	tree->sreg1  = state->left->left->tree->dreg;
	mono_bblock_add_inst (s->cbb, tree);
}

stmt: OP_OUTARG (CEE_LDIND_I (base)) {
	MONO_EMIT_LOAD_MEMBASE (s, tree, tree->unused, 
				state->left->left->tree->inst_basereg,
				state->left->left->tree->inst_offset);
	mono_bblock_add_inst (s->cbb, tree);
}

stmt: OP_OUTARG (CEE_LDIND_I4 (base)) {
	MONO_EMIT_LOAD_MEMBASE_OP (s, tree, OP_LOADI4_MEMBASE, 
				tree->unused, state->left->left->tree->inst_basereg,
				state->left->left->tree->inst_offset);
	mono_bblock_add_inst (s->cbb, tree);
}

stmt: OP_OUTARG (OP_LDADDR (OP_S390_LOADARG)) {
	if (tree->inst_imm) {
		MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, STK_BASE, 
					     tree->inst_imm, 
					     state->left->left->tree->dreg);
		return;
	}
	MONO_EMIT_BIALU_IMM (s, tree, OP_ADD_IMM, tree->unused,
			     state->left->left->tree->sreg1,
			     state->left->left->tree->inst_offset);
}

stmt: OP_OUTARG (freg) {
	if (tree->inst_imm) {
		/*----------------------------------------------*/
		/* The length stored in unused tells us whether */
		/* we need to store a float or a double		*/
		/*----------------------------------------------*/
		if ((tree->unused & 0xff00) == 0x0400) {
			MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER4_MEMBASE_REG, 
						     STK_BASE, tree->inst_imm, 
						     state->left->reg1);
		} else {
			MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER8_MEMBASE_REG, 
						     STK_BASE, tree->inst_imm, 
						     state->left->reg1);
		}
		return;
	}
	tree->opcode = OP_SETFREG;
	tree->sreg1 = state->left->reg1;
	tree->dreg = tree->unused;
	mono_bblock_add_inst (s->cbb, tree);
}

stmt: OP_OUTARG_R4 (freg) {
	if (tree->inst_imm) {
		MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER4_MEMBASE_REG, STK_BASE, tree->inst_imm, state->left->reg1);
		return;
	}
	tree->opcode = OP_SETFREG;
	tree->sreg1 = state->left->reg1;
	tree->dreg = tree->unused;
	mono_bblock_add_inst (s->cbb, tree);
}

stmt: OP_OUTARG_R8 (freg) {
	if (tree->inst_imm) {
		MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER8_MEMBASE_REG, STK_BASE, tree->inst_imm, state->left->reg1);
		return;
	}
	tree->opcode = OP_SETFREG;
	tree->sreg1 = state->left->reg1;
	tree->dreg = tree->unused;
	mono_bblock_add_inst (s->cbb, tree);
}

stmt: OP_OUTARG_VT (CEE_LDOBJ (base)) {
	MonoInst *vt  = state->left->left->tree;
	int start_reg = tree->sreg1;
	int size      = tree->unused;
	int soffset   = vt->inst_offset;
	int tmpr;
	
//printf("OP_OUTARG_VT(CEE_LDOBJ(base))\n");
	if (size < 0) { 
		size = -size;
		if (start_reg != STK_BASE) {
			MONO_EMIT_NEW_MOVE(s, STK_BASE, tree->sreg2,
					   vt->inst_basereg, soffset, size);
			MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, start_reg, 
						 STK_BASE, tree->sreg2);
		} else { 
			MONO_EMIT_NEW_MOVE(s, STK_BASE, tree->sreg2+sizeof(gpointer),
					   vt->inst_basereg, soffset, size);
			tmpr = mono_regstate_next_int (s->rs);
			MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, tmpr, STK_BASE, 
						 tree->sreg2+sizeof(gpointer));
			MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, 
						     STK_BASE, tree->sreg2, tmpr);
		}
	} else {
		if (start_reg != STK_BASE) {
			MONO_OUTPUT_VTR (s, size, start_reg, vt->inst_basereg, soffset);
		} else {
			MONO_OUTPUT_VTS (s, size, STK_BASE, tree->inst_imm,
					 vt->inst_basereg, soffset);
		}	
	}
}

stmt: OP_OUTARG_VT (CEE_LDOBJ (OP_S390_ARGPTR)) {
	MonoInst *vt  = state->left->left->tree;
	int start_reg = tree->sreg1;
	int size      = tree->unused;
	int soffset   = vt->inst_offset;
	int tmpr;

//printf("OP_OUTARG_VT(CEE_LDOBJ(OP_S390_ARGPTR))\n");
	if (size < 0) { 
		size = -size;
		if (start_reg != STK_BASE) {
			MONO_EMIT_NEW_MOVE (s, STK_BASE, tree->inst_imm,
					    vt->inst_basereg, soffset, size);
			MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, start_reg, 
						 STK_BASE, tree->sreg2);
		} else {
			MONO_EMIT_NEW_MOVE (s, STK_BASE, 
					    tree->inst_imm+sizeof(gpointer),
					    vt->inst_basereg, soffset, size);
			tmpr = mono_regstate_next_int (s->rs);
			MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, tmpr, STK_BASE,
						 tree->inst_imm+sizeof(gpointer));
			MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, 
						     STK_BASE, tree->inst_imm,
						     tmpr);
		}
	} else {
		if (start_reg != STK_BASE) {
			MONO_OUTPUT_VTR (s, size, start_reg, vt->inst_basereg, soffset);
		} else {
			MONO_OUTPUT_VTS (s, size, STK_BASE, 
					 tree->inst_imm,
				  	 vt->inst_basereg, soffset);
		}	
	}
}

stmt: OP_OUTARG_VT (CEE_LDOBJ (OP_REGOFFSET)) "0" {
	MonoInst *vt  = state->left->left->tree;
	int start_reg = tree->sreg1;
	int size      = tree->unused;
	int soffset   = vt->inst_offset;
	int tmpr;

//printf("OP_OUTARG_VT(CEE_LDOBJ(OP_REGOFFSET))\n");
	if (size < 0) { 
		size = -size;
		if (start_reg != STK_BASE) {
			MONO_EMIT_NEW_MOVE (s, STK_BASE, tree->sreg2, 
					    vt->inst_basereg, soffset, size);
			MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, start_reg, 
						 STK_BASE, tree->sreg2);
		} else {
			MONO_EMIT_NEW_MOVE (s, STK_BASE, 
					    tree->sreg2+sizeof(gpointer),
					    vt->inst_basereg, soffset, size);
			tmpr = mono_regstate_next_int (s->rs);
			MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, tmpr, STK_BASE,
						 tree->sreg2+sizeof(gpointer));
			MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, 
						     STK_BASE, tree->sreg2,
						     tmpr);
		}
	} else {
		if (start_reg != STK_BASE) {
			MONO_OUTPUT_VTR(s, size, start_reg, vt->inst_basereg, soffset);
		} else {
			MONO_OUTPUT_VTS(s, size, STK_BASE, tree->inst_imm,
				 	  vt->inst_basereg, soffset);
		}	
	}
}

stmt: OP_OUTARG_VT (CEE_LDOBJ (OP_S390_LOADARG)) {
	MonoInst *vt  = state->left->left->tree;
	int start_reg = tree->sreg1;
	int size      = -tree->unused;
	int soffset   = vt->inst_offset;
	int tmpr;

//printf("OP_OUTARG_VT(CEE_LDOBJ(OP_S390_LOADARG))\n");
	if (start_reg != STK_BASE) {
		MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, start_reg, STK_BASE, soffset);
		MONO_EMIT_NEW_MOVE (s, STK_BASE, tree->sreg2, start_reg, 0, size);
		MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, start_reg, 
					 STK_BASE, tree->sreg2);
	} else {
		MONO_EMIT_NEW_MOVE (s, STK_BASE, 
				    tree->inst_imm+sizeof(gpointer),
				    vt->inst_basereg, soffset, size);
		tmpr = mono_regstate_next_int (s->rs);
		MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, tmpr, STK_BASE,
					 tree->inst_imm+sizeof(gpointer));
		MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, 
					     STK_BASE, tree->inst_imm,
					     tmpr);
	}
}

stmt: OP_OUTARG_VT (OP_ICONST) {
	int start_reg = tree->sreg1;
	int size      = tree->unused;
	int nregs     = size / 4;

//printf("OP_OUTARG_VT(OP_ICONST)\n");
	if (start_reg != STK_BASE) {
		if (nregs) {
			tree->opcode  = OP_SETREGIMM;
			tree->dreg    = start_reg;
			tree->inst_c0 = state->left->tree->inst_c0;
			mono_bblock_add_inst (s->cbb, tree);
		}
	} else {
		MONO_OUTPUT_VTS (s, size, STK_BASE, tree->inst_c0, 
				 s->frame_reg, tree->inst_offset);
	}
}

stmt: OP_OUTARG_VT (reg) {
	int start_reg = tree->sreg1;
	int size      = tree->unused;
	int soffset   = tree->sreg2;
	int tmpr;

//printf("OP_OUTARG_VT(reg)\n");
	if (size < 0) { 
		size = -size;
		if (start_reg != STK_BASE) {
			MONO_EMIT_NEW_MOVE (s, STK_BASE, soffset,
					    state->left->tree->sreg1,
					    tree->inst_imm, size);
			MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, start_reg, 
						 STK_BASE, soffset);
		} else {
			MONO_EMIT_NEW_MOVE (s, STK_BASE, 
					    soffset+sizeof(gpointer),
					    state->left->tree->sreg1,
					    tree->inst_imm, size);
			tmpr = mono_regstate_next_int (s->rs);
			MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, tmpr, STK_BASE,
						 soffset+sizeof(gpointer));
			MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, 
						     STK_BASE, tree->inst_imm,
						     tmpr);
		}
	} else {
		if (start_reg != STK_BASE) {
			MONO_OUTPUT_VTR (s, size, start_reg, STK_BASE,
					 state->left->tree->inst_offset);
		} else {
			MONO_OUTPUT_VTS (s, size, STK_BASE, soffset, tmpr,
					 state->left->tree->inst_offset);
			tmpr = mono_regstate_next_int (s->rs);
			MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, tmpr, STK_BASE, 
						s->stack_offset);
		}
	}
}

stmt: CEE_STIND_R8 (OP_REGVAR, freg) {
	/* nothing to do: the value is already on the FP stack */
}

stmt: CEE_BNE_UN (fpcflags) {
	tree->opcode = OP_FBNE_UN;
	mono_bblock_add_inst (s->cbb, tree);
}

stmt: CEE_BEQ (fpcflags) {
	tree->opcode = OP_FBEQ;
	mono_bblock_add_inst (s->cbb, tree);
}

stmt: CEE_BLT (fpcflags) {
	tree->opcode = OP_FBLT;
	mono_bblock_add_inst (s->cbb, tree);
}

stmt: CEE_BLT_UN (fpcflags) {
	tree->opcode = OP_FBLT_UN;
	mono_bblock_add_inst (s->cbb, tree);
}

stmt: CEE_BGT (fpcflags) {
	tree->opcode = OP_FBGT;
	mono_bblock_add_inst (s->cbb, tree);
}

stmt: CEE_BGT_UN (fpcflags) {
	tree->opcode = OP_FBGT_UN;
	mono_bblock_add_inst (s->cbb, tree);
}

stmt: CEE_BGE  (fpcflags) {
	tree->opcode = OP_FBGE;
	mono_bblock_add_inst (s->cbb, tree);
}

stmt: CEE_BGE_UN (fpcflags) {
	tree->opcode = OP_FBGE_UN;
	mono_bblock_add_inst (s->cbb, tree);
}

stmt: CEE_BLE  (fpcflags) {
	tree->opcode = OP_FBLE;
	mono_bblock_add_inst (s->cbb, tree);
}

stmt: CEE_BLE_UN (fpcflags) {
	tree->opcode = OP_FBLE_UN;
	mono_bblock_add_inst (s->cbb, tree);
}

stmt: CEE_POP (freg) "0" {
	/* nothing to do */
}     

freg: OP_LCONV_TO_R8 (lreg) {
	/* nothing to do - emulated */
}

freg: OP_LCONV_TO_R4 (lreg) {
	/* nothing to do - emulated */
}

freg: OP_LCONV_TO_R_UN (lreg) {
	/* nothing to do - emulated */
}

freg: OP_FREM (freg, freg) {
	/* nothing to do - emulated */
}

reg: OP_CEQ (OP_COMPARE (freg, freg)) {	
	MONO_EMIT_BIALU (s, tree, OP_FCEQ, state->reg1, state->left->left->reg1,
			 state->left->right->reg1);
}

reg: OP_CLT (OP_COMPARE (freg, freg)) {	
	MONO_EMIT_BIALU (s, tree, OP_FCLT, state->reg1, state->left->left->reg1,
			 state->left->right->reg1);
}

reg: OP_CLT_UN (OP_COMPARE (freg, freg)) {	
	MONO_EMIT_BIALU (s, tree, OP_FCLT_UN, state->reg1, state->left->left->reg1,
			 state->left->right->reg1);
}

reg: OP_CGT (OP_COMPARE (freg, freg)) {	
	MONO_EMIT_BIALU (s, tree, OP_FCGT, state->reg1, state->left->left->reg1,
			 state->left->right->reg1);
}

reg: OP_CGT_UN (OP_COMPARE (freg, freg)) {	
	MONO_EMIT_BIALU (s, tree, OP_FCGT_UN, state->reg1, state->left->left->reg1,
			 state->left->right->reg1);
}

base: OP_S390_STKARG "0" {
	int tmpr;

	tmpr = mono_regstate_next_int (s->rs);
	MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, tmpr, s->frame_reg, 
				(s->stack_offset+state->tree->unused));
	tree->inst_offset  = state->tree->inst_offset;
	tree->inst_basereg = tmpr;
}

base: OP_LDADDR (OP_S390_LOADARG) "0" {
	int tmpr;

	tmpr = mono_regstate_next_int (s->rs);
	MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, tmpr, s->frame_reg, 
				 state->left->tree->inst_offset);
	tree->inst_offset  = 0;
	tree->inst_basereg = tmpr;
}

base: OP_LDADDR (OP_S390_ARGPTR) "0" {
	int tmpr;

	tmpr = mono_regstate_next_int (s->rs);
	MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, tmpr, s->frame_reg, 
				 state->left->tree->inst_offset);
	tree->inst_offset  = 0;
	tree->inst_basereg = tmpr;
}

base: OP_LDADDR (OP_S390_STKARG) "0" {
	int tmpr;

	tmpr = mono_regstate_next_int (s->rs);
	MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, tmpr, s->frame_reg, 
				 (s->stack_offset + state->left->tree->unused));
	MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, tmpr, tmpr, 
				 state->left->tree->inst_offset);
	tree->inst_offset  = 0;
	tree->inst_basereg = tmpr;
}

reg: OP_LDADDR (OP_S390_LOADARG) "2" {
	MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, state->reg1, s->frame_reg, 
				 state->left->tree->inst_offset);
	tree->inst_offset  = 0;
	tree->inst_basereg = state->reg1;
}

reg: OP_LDADDR (OP_S390_ARGPTR) "2" {
	MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, state->reg1, s->frame_reg, 
				 state->left->tree->inst_offset);
	tree->inst_offset  = 0;
	tree->inst_basereg = state->reg1;
}

reg: OP_LDADDR (OP_S390_STKARG) "2" {
	MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, state->reg1, s->frame_reg, 
				 (s->stack_offset + state->left->tree->unused));
	MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, state->reg1, state->reg1, 
				 state->left->tree->inst_offset);
	tree->inst_offset  = 0;
	tree->inst_basereg = state->reg1;
}

reg: CEE_LDOBJ (OP_S390_LOADARG) "1" {
	MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, state->reg1, s->frame_reg, 
				 state->left->tree->inst_offset);
}

reg: CEE_LDOBJ (OP_S390_ARGPTR) "1" {
	MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, state->reg1, s->frame_reg, 
			     state->left->tree->inst_offset);
}

reg: CEE_LDOBJ (OP_S390_STKARG) "1" {
	MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, state->reg1, s->frame_reg,
				 (s->stack_offset + state->left->tree->unused));
	MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, state->reg1, state->reg1,
				 state->left->tree->inst_offset);
	tree->inst_offset  = 0;
	tree->dreg 	   = state->reg1;
}

base: CEE_LDOBJ (OP_S390_ARGPTR) "0" {
	int tmpr;

	tmpr = mono_regstate_next_int (s->rs);
	MONO_EMIT_NEW_LOAD_MEMBASE (s, tmpr, s->frame_reg, 
				    state->left->tree->inst_offset);
	tree->inst_offset  = 0;
	tree->dreg 	   = tmpr;
}

base: CEE_LDOBJ (OP_S390_STKARG) "0" {
	int tmpr;

	tmpr = mono_regstate_next_int (s->rs);
	MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, tmpr, s->frame_reg,
				 (s->stack_offset + state->left->tree->unused));
	MONO_EMIT_NEW_LOAD_MEMBASE (s, tmpr, tmpr, state->left->tree->inst_offset);
	tree->inst_offset  = 0;
	tree->inst_basereg = tmpr;
}

%%