/*
 *  Copyright (C) 2002-2007  The DOSBox Team
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */


/*
	The functions in this file are called almost exclusively by	decoder.h,
	they translate an (or a set of) instruction(s) into hostspecific code
	and use the lower-level functions from decoder_basic.h and generating
	functions from risc_?.h
	Some complex instructions as well as most instructions that can modify
	the condition flags are translated by generating a call to a C-function
	(see operators.h). Parameter loading and result writeback is done
	according to the instruction.
*/

static void dyn_dop_ebgb(DualOps op) {
	dyn_get_modrm();
	if (decode.modrm.mod<3) {
		dyn_fill_ea(FC_ADDR);
		gen_protect_addr_reg();
		dyn_read_byte_canuseword(FC_ADDR,FC_OP1);
		gen_mov_byte_to_reg_low_canuseword(FC_OP2,DRCD_REG_BYTE(decode.modrm.reg&3,(decode.modrm.reg>>2)&1));
		dyn_dop_byte_gencall(op);

		if ((op!=DOP_CMP) && (op!=DOP_TEST)) {
			gen_restore_addr_reg();
			dyn_write_byte(FC_ADDR,FC_RETOP);
		}
	} else {
		gen_mov_byte_to_reg_low_canuseword(FC_OP1,DRCD_REG_BYTE(decode.modrm.rm&3,(decode.modrm.rm>>2)&1));
		gen_mov_byte_to_reg_low_canuseword(FC_OP2,DRCD_REG_BYTE(decode.modrm.reg&3,(decode.modrm.reg>>2)&1));
		dyn_dop_byte_gencall(op);
		if ((op!=DOP_CMP) && (op!=DOP_TEST)) gen_mov_byte_from_reg_low(FC_RETOP,DRCD_REG_BYTE(decode.modrm.rm&3,(decode.modrm.rm>>2)&1));
	}
}

static void dyn_dop_ebgb_mov(void) {
	dyn_get_modrm();
	if (decode.modrm.mod<3) {
		dyn_fill_ea(FC_ADDR);
		gen_mov_byte_to_reg_low(FC_TMP_BA1,DRCD_REG_BYTE(decode.modrm.reg&3,(decode.modrm.reg>>2)&1));
		dyn_write_byte(FC_ADDR,FC_TMP_BA1);
	} else {
		gen_mov_byte_to_reg_low(FC_TMP_BA1,DRCD_REG_BYTE(decode.modrm.reg&3,(decode.modrm.reg>>2)&1));
		gen_mov_byte_from_reg_low(FC_TMP_BA1,DRCD_REG_BYTE(decode.modrm.rm&3,(decode.modrm.rm>>2)&1));
	}
}

static void dyn_dop_ebib_mov(void) {
	dyn_get_modrm();
	if (decode.modrm.mod<3) {
		dyn_fill_ea(FC_ADDR);
		gen_mov_byte_to_reg_low_imm(FC_TMP_BA1,decode_fetchb());
		dyn_write_byte(FC_ADDR,FC_TMP_BA1);
	} else {
		gen_mov_byte_to_reg_low_imm(FC_TMP_BA1,decode_fetchb());
		gen_mov_byte_from_reg_low(FC_TMP_BA1,DRCD_REG_BYTE(decode.modrm.rm&3,(decode.modrm.rm>>2)&1));
	}
}

static void dyn_dop_ebgb_xchg(void) {
	dyn_get_modrm();
	if (decode.modrm.mod<3) {
		dyn_fill_ea(FC_ADDR);
		gen_protect_addr_reg();
		dyn_read_byte(FC_ADDR,FC_TMP_BA1);
		gen_mov_byte_to_reg_low(FC_TMP_BA2,DRCD_REG_BYTE(decode.modrm.reg&3,(decode.modrm.reg>>2)&1));

		gen_mov_byte_from_reg_low(FC_TMP_BA1,DRCD_REG_BYTE(decode.modrm.reg&3,(decode.modrm.reg>>2)&1));
		gen_restore_addr_reg();
		dyn_write_byte(FC_ADDR,FC_TMP_BA2);
	} else {
		gen_mov_byte_to_reg_low(FC_TMP_BA1,DRCD_REG_BYTE(decode.modrm.rm&3,(decode.modrm.rm>>2)&1));
		gen_mov_byte_to_reg_low(FC_TMP_BA2,DRCD_REG_BYTE(decode.modrm.reg&3,(decode.modrm.reg>>2)&1));
		gen_mov_byte_from_reg_low(FC_TMP_BA1,DRCD_REG_BYTE(decode.modrm.reg&3,(decode.modrm.reg>>2)&1));
		gen_mov_byte_from_reg_low(FC_TMP_BA2,DRCD_REG_BYTE(decode.modrm.rm&3,(decode.modrm.rm>>2)&1));
	}
}

static void dyn_dop_gbeb(DualOps op) {
	dyn_get_modrm();
	if (decode.modrm.mod<3) {
		dyn_fill_ea(FC_ADDR);
		dyn_read_byte_canuseword(FC_ADDR,FC_OP2);
		gen_mov_byte_to_reg_low_canuseword(FC_OP1,DRCD_REG_BYTE(decode.modrm.reg&3,(decode.modrm.reg>>2)&1));
		dyn_dop_byte_gencall(op);
		if ((op!=DOP_CMP) && (op!=DOP_TEST)) gen_mov_byte_from_reg_low(FC_RETOP,DRCD_REG_BYTE(decode.modrm.reg&3,(decode.modrm.reg>>2)&1));
	} else {
		gen_mov_byte_to_reg_low_canuseword(FC_OP2,DRCD_REG_BYTE(decode.modrm.rm&3,(decode.modrm.rm>>2)&1));
		gen_mov_byte_to_reg_low_canuseword(FC_OP1,DRCD_REG_BYTE(decode.modrm.reg&3,(decode.modrm.reg>>2)&1));
		dyn_dop_byte_gencall(op);
		if ((op!=DOP_CMP) && (op!=DOP_TEST)) gen_mov_byte_from_reg_low(FC_RETOP,DRCD_REG_BYTE(decode.modrm.reg&3,(decode.modrm.reg>>2)&1));
	}
}

static void dyn_dop_gbeb_mov(void) {
	dyn_get_modrm();
	if (decode.modrm.mod<3) {
		dyn_fill_ea(FC_ADDR);
		dyn_read_byte(FC_ADDR,FC_TMP_BA1);
		gen_mov_byte_from_reg_low(FC_TMP_BA1,DRCD_REG_BYTE(decode.modrm.reg&3,(decode.modrm.reg>>2)&1));
	} else {
		gen_mov_byte_to_reg_low(FC_TMP_BA1,DRCD_REG_BYTE(decode.modrm.rm&3,(decode.modrm.rm>>2)&1));
		gen_mov_byte_from_reg_low(FC_TMP_BA1,DRCD_REG_BYTE(decode.modrm.reg&3,(decode.modrm.reg>>2)&1));
	}
}

static void dyn_dop_evgv(DualOps op) {
	dyn_get_modrm();
	if (decode.modrm.mod<3) {
		dyn_fill_ea(FC_ADDR);
		dyn_read_word(FC_ADDR,FC_OP1,decode.big_op);
		gen_protect_addr_reg();
		gen_mov_word_to_reg(FC_OP2,DRCD_REG_WORD(decode.modrm.reg,decode.big_op),decode.big_op);
		dyn_dop_word_gencall(op,decode.big_op);
		if ((op!=DOP_CMP) && (op!=DOP_TEST)) {
			gen_restore_addr_reg();
			dyn_write_word(FC_ADDR,FC_RETOP,decode.big_op);
		}
	} else {
		gen_mov_word_to_reg(FC_OP1,DRCD_REG_WORD(decode.modrm.rm,decode.big_op),decode.big_op);
		gen_mov_word_to_reg(FC_OP2,DRCD_REG_WORD(decode.modrm.reg,decode.big_op),decode.big_op);
		dyn_dop_word_gencall(op,decode.big_op);
		if ((op!=DOP_CMP) && (op!=DOP_TEST)) gen_mov_word_from_reg(FC_RETOP,DRCD_REG_WORD(decode.modrm.rm,decode.big_op),decode.big_op);
	}
}

static void dyn_dop_evgv_mov(void) {
	dyn_get_modrm();
	if (decode.modrm.mod<3) {
		dyn_fill_ea(FC_ADDR);
		gen_mov_word_to_reg(FC_OP1,DRCD_REG_WORD(decode.modrm.reg,decode.big_op),decode.big_op);
		dyn_write_word(FC_ADDR,FC_OP1,decode.big_op);
	} else {
		gen_mov_word_to_reg(FC_OP1,DRCD_REG_WORD(decode.modrm.reg,decode.big_op),decode.big_op);
		gen_mov_word_from_reg(FC_OP1,DRCD_REG_WORD(decode.modrm.rm,decode.big_op),decode.big_op);
	}
}

static void dyn_dop_eviv_mov(void) {
	dyn_get_modrm();
	if (decode.modrm.mod<3) {
		dyn_fill_ea(FC_ADDR);
		if (decode.big_op) gen_mov_dword_to_reg_imm(FC_OP1,decode_fetchd());
		else gen_mov_word_to_reg_imm(FC_OP1,decode_fetchw());
		dyn_write_word(FC_ADDR,FC_OP1,decode.big_op);
	} else {
		if (decode.big_op) gen_mov_dword_to_reg_imm(FC_OP1,decode_fetchd());
		else gen_mov_word_to_reg_imm(FC_OP1,decode_fetchw());
		gen_mov_word_from_reg(FC_OP1,DRCD_REG_WORD(decode.modrm.rm,decode.big_op),decode.big_op);
	}
}

static void dyn_dop_evgv_xchg(void) {
	dyn_get_modrm();
	if (decode.modrm.mod<3) {
		dyn_fill_ea(FC_ADDR);
		gen_protect_addr_reg();
		dyn_read_word(FC_ADDR,FC_OP1,decode.big_op);
		gen_mov_word_to_reg(FC_OP2,DRCD_REG_WORD(decode.modrm.reg,decode.big_op),decode.big_op);

		gen_protect_reg(FC_OP1);
		gen_restore_addr_reg();
		dyn_write_word(FC_ADDR,FC_OP2,decode.big_op);
		gen_restore_reg(FC_OP1);
		gen_mov_word_from_reg(FC_OP1,DRCD_REG_WORD(decode.modrm.reg,decode.big_op),decode.big_op);
	} else {
		gen_mov_word_to_reg(FC_OP1,DRCD_REG_WORD(decode.modrm.rm,decode.big_op),decode.big_op);
		gen_mov_word_to_reg(FC_OP2,DRCD_REG_WORD(decode.modrm.reg,decode.big_op),decode.big_op);
		gen_mov_word_from_reg(FC_OP1,DRCD_REG_WORD(decode.modrm.reg,decode.big_op),decode.big_op);
		gen_mov_word_from_reg(FC_OP2,DRCD_REG_WORD(decode.modrm.rm,decode.big_op),decode.big_op);
	}
}

static void dyn_xchg_ax(Bit8u reg) {
	gen_mov_word_to_reg(FC_OP1,DRCD_REG_WORD(DRC_REG_EAX,decode.big_op),decode.big_op);
	gen_mov_word_to_reg(FC_OP2,DRCD_REG_WORD(reg,decode.big_op),decode.big_op);
	gen_mov_word_from_reg(FC_OP1,DRCD_REG_WORD(reg,decode.big_op),decode.big_op);
	gen_mov_word_from_reg(FC_OP2,DRCD_REG_WORD(DRC_REG_EAX,decode.big_op),decode.big_op);
}

static void dyn_dop_gvev(DualOps op) {
	dyn_get_modrm();
	if (decode.modrm.mod<3) {
		dyn_fill_ea(FC_ADDR);
		gen_protect_addr_reg();
		dyn_read_word(FC_ADDR,FC_OP2,decode.big_op);
		gen_mov_word_to_reg(FC_OP1,DRCD_REG_WORD(decode.modrm.reg,decode.big_op),decode.big_op);
		dyn_dop_word_gencall(op,decode.big_op);
		if ((op!=DOP_CMP) && (op!=DOP_TEST)) {
			gen_restore_addr_reg();
			gen_mov_word_from_reg(FC_RETOP,DRCD_REG_WORD(decode.modrm.reg,decode.big_op),decode.big_op);
		}
	} else {
		gen_mov_word_to_reg(FC_OP2,DRCD_REG_WORD(decode.modrm.rm,decode.big_op),decode.big_op);
		gen_mov_word_to_reg(FC_OP1,DRCD_REG_WORD(decode.modrm.reg,decode.big_op),decode.big_op);
		dyn_dop_word_gencall(op,decode.big_op);
		if ((op!=DOP_CMP) && (op!=DOP_TEST)) gen_mov_word_from_reg(FC_RETOP,DRCD_REG_WORD(decode.modrm.reg,decode.big_op),decode.big_op);
	}
}

static void dyn_dop_gvev_mov(void) {
	dyn_get_modrm();
	if (decode.modrm.mod<3) {
		dyn_fill_ea(FC_ADDR);
		dyn_read_word(FC_ADDR,FC_OP1,decode.big_op);
		gen_mov_word_from_reg(FC_OP1,DRCD_REG_WORD(decode.modrm.reg,decode.big_op),decode.big_op);
	} else {
		gen_mov_word_to_reg(FC_OP1,DRCD_REG_WORD(decode.modrm.rm,decode.big_op),decode.big_op);
		gen_mov_word_from_reg(FC_OP1,DRCD_REG_WORD(decode.modrm.reg,decode.big_op),decode.big_op);
	}
}

static void dyn_dop_byte_imm(DualOps op,Bit8u reg,Bit8u idx) {
	gen_mov_byte_to_reg_low_canuseword(FC_OP1,DRCD_REG_BYTE(reg,idx));
	gen_mov_byte_to_reg_low_imm_canuseword(FC_OP2,decode_fetchb());
	dyn_dop_byte_gencall(op);
	if ((op!=DOP_CMP) && (op!=DOP_TEST)) gen_mov_byte_from_reg_low(FC_RETOP,DRCD_REG_BYTE(reg,idx));
}

static void dyn_dop_byte_imm_mem(DualOps op,Bit8u reg,Bit8u idx) {
	gen_mov_byte_to_reg_low_canuseword(FC_OP1,DRCD_REG_BYTE(reg,idx));
	Bitu val;
	if (decode_fetchb_imm(val)) {
		gen_mov_byte_to_reg_low_canuseword(FC_OP2,(void*)val);
	} else {
		gen_mov_byte_to_reg_low_imm_canuseword(FC_OP2,(Bit8u)val);
	}
	dyn_dop_byte_gencall(op);
	if ((op!=DOP_CMP) && (op!=DOP_TEST)) gen_mov_byte_from_reg_low(FC_RETOP,DRCD_REG_BYTE(reg,idx));
}

static void dyn_prep_word_imm(Bit8u reg) {
	Bitu val;
	if (decode.big_op) {
		if (decode_fetchd_imm(val)) {
			gen_mov_word_to_reg(FC_OP2,(void*)val,true);
			return;
		}
	} else {
		if (decode_fetchw_imm(val)) {
			gen_mov_word_to_reg(FC_OP2,(void*)val,false);
			return;
		}
	}
	if (decode.big_op) gen_mov_dword_to_reg_imm(FC_OP2,(Bit32u)val);
	else gen_mov_word_to_reg_imm(FC_OP2,(Bit16u)val);
}

static void dyn_dop_word_imm(DualOps op,Bit8u reg) {
	gen_mov_word_to_reg(FC_OP1,DRCD_REG_WORD(reg,decode.big_op),decode.big_op);
	dyn_prep_word_imm(reg);
	dyn_dop_word_gencall(op,decode.big_op);
	if ((op!=DOP_CMP) && (op!=DOP_TEST)) gen_mov_word_from_reg(FC_RETOP,DRCD_REG_WORD(reg,decode.big_op),decode.big_op);
}

static void dyn_dop_word_imm_old(DualOps op,Bit8u reg,Bitu imm) {
	gen_mov_word_to_reg(FC_OP1,DRCD_REG_WORD(reg,decode.big_op),decode.big_op);
	if (decode.big_op) gen_mov_dword_to_reg_imm(FC_OP2,(Bit32u)imm);
	else gen_mov_word_to_reg_imm(FC_OP2,(Bit16u)imm);
	dyn_dop_word_gencall(op,decode.big_op);
	if ((op!=DOP_CMP) && (op!=DOP_TEST)) gen_mov_word_from_reg(FC_RETOP,DRCD_REG_WORD(reg,decode.big_op),decode.big_op);
}

static void dyn_mov_byte_imm(Bit8u reg,Bit8u idx,Bit8u imm) {
	gen_mov_byte_to_reg_low_imm(FC_TMP_BA1,imm);
	gen_mov_byte_from_reg_low(FC_TMP_BA1,DRCD_REG_BYTE(reg,idx));
}

static void dyn_mov_word_imm(Bit8u reg) {
	Bitu val;
	if (decode.big_op) {
		if (decode_fetchd_imm(val)) {
			gen_mov_word_to_reg(FC_OP1,(void*)val,true);
			gen_mov_word_from_reg(FC_OP1,DRCD_REG_WORD(reg,true),true);
			return;
		}
	} else {
		if (decode_fetchw_imm(val)) {
			gen_mov_word_to_reg(FC_OP1,(void*)val,false);
			gen_mov_word_from_reg(FC_OP1,DRCD_REG_WORD(reg,false),false);
			return;
		}
	}
	if (decode.big_op) gen_mov_dword_to_reg_imm(FC_OP1,(Bit32u)val);
	else gen_mov_word_to_reg_imm(FC_OP1,(Bit16u)val);
	gen_mov_word_from_reg(FC_OP1,DRCD_REG_WORD(reg,decode.big_op),decode.big_op);
}


static void dyn_sop_word(SingleOps op,Bit8u reg) {
	gen_mov_word_to_reg(FC_OP1,DRCD_REG_WORD(reg,decode.big_op),decode.big_op);
	dyn_sop_word_gencall(op,decode.big_op);
	gen_mov_word_from_reg(FC_RETOP,DRCD_REG_WORD(reg,decode.big_op),decode.big_op);
}


static void dyn_mov_byte_al_direct(Bitu imm) {
	gen_mov_word_to_reg(FC_ADDR,DRCD_SEG_PHYS(decode.seg_prefix_used ? decode.seg_prefix : DRC_SEG_DS),true);
	gen_add_imm(FC_ADDR,imm);
	dyn_read_byte(FC_ADDR,FC_TMP_BA1);
	gen_mov_byte_from_reg_low(FC_TMP_BA1,DRCD_REG_BYTE(DRC_REG_EAX,0));
}

static void dyn_mov_byte_ax_direct(Bitu imm) {
	gen_mov_word_to_reg(FC_ADDR,DRCD_SEG_PHYS(decode.seg_prefix_used ? decode.seg_prefix : DRC_SEG_DS),true);
	gen_add_imm(FC_ADDR,imm);
	dyn_read_word(FC_ADDR,FC_OP1,decode.big_op);
	gen_mov_word_from_reg(FC_OP1,DRCD_REG_WORD(DRC_REG_EAX,decode.big_op),decode.big_op);
}

static void dyn_mov_byte_direct_al() {
	gen_mov_word_to_reg(FC_ADDR,DRCD_SEG_PHYS(decode.seg_prefix_used ? decode.seg_prefix : DRC_SEG_DS),true);
	if (decode.big_addr) {
		Bitu val;
		if (decode_fetchd_imm(val)) {
			gen_add(FC_ADDR,(void*)val);
		} else {
			gen_add_imm(FC_ADDR,(Bit32u)val);
		}
	} else {
		gen_add_imm(FC_ADDR,decode_fetchw());
	}
	gen_mov_byte_to_reg_low(FC_TMP_BA1,DRCD_REG_BYTE(DRC_REG_EAX,0));
	dyn_write_byte(FC_ADDR,FC_TMP_BA1);
}

static void dyn_mov_byte_direct_ax(Bitu imm) {
	gen_mov_word_to_reg(FC_ADDR,DRCD_SEG_PHYS(decode.seg_prefix_used ? decode.seg_prefix : DRC_SEG_DS),true);
	gen_add_imm(FC_ADDR,imm);
	gen_mov_word_to_reg(FC_OP1,DRCD_REG_WORD(DRC_REG_EAX,decode.big_op),decode.big_op);
	dyn_write_word(FC_ADDR,FC_OP1,decode.big_op);
}


static void dyn_movx_ev_gb(bool sign) {
	dyn_get_modrm();
	if (decode.modrm.mod<3) {
		dyn_fill_ea(FC_ADDR);
		dyn_read_byte(FC_ADDR,FC_TMP_BA1);
		gen_extend_byte(sign,FC_TMP_BA1);
		gen_mov_word_from_reg(FC_TMP_BA1,DRCD_REG_WORD(decode.modrm.reg,decode.big_op),decode.big_op);
	} else {
		gen_mov_byte_to_reg_low(FC_TMP_BA1,DRCD_REG_BYTE(decode.modrm.rm&3,(decode.modrm.rm>>2)&1));
		gen_extend_byte(sign,FC_TMP_BA1);
		gen_mov_word_from_reg(FC_TMP_BA1,DRCD_REG_WORD(decode.modrm.reg,decode.big_op),decode.big_op);
	}
}

static void dyn_movx_ev_gw(bool sign) {
	dyn_get_modrm();
	if (decode.modrm.mod<3) {
		dyn_fill_ea(FC_ADDR);
		dyn_read_word(FC_ADDR,FC_OP1,false);
		gen_extend_word(sign,FC_OP1);
		gen_mov_word_from_reg(FC_OP1,DRCD_REG_WORD(decode.modrm.reg,decode.big_op),decode.big_op);
	} else {
		gen_mov_word_to_reg(FC_OP1,DRCD_REG_WORD(decode.modrm.rm,false),false);
		gen_extend_word(sign,FC_OP1);
		gen_mov_word_from_reg(FC_OP1,DRCD_REG_WORD(decode.modrm.reg,decode.big_op),decode.big_op);
	}
}


static void dyn_mov_ev_seg(void) {
	dyn_get_modrm();
	gen_mov_word_to_reg(FC_OP1,DRCD_SEG_VAL(decode.modrm.reg),false);
	if (decode.modrm.mod<3) {
		dyn_fill_ea(FC_ADDR);
		dyn_write_word(FC_ADDR,FC_OP1,false);
	} else {
		if (decode.big_op) gen_extend_word(false,FC_OP1);
		gen_mov_word_from_reg(FC_OP1,DRCD_REG_WORD(decode.modrm.rm,decode.big_op),decode.big_op);
	}
}


static void dyn_push_seg(Bit8u seg) {
	gen_mov_word_to_reg(FC_OP1,DRCD_SEG_VAL(seg),false);
	if (decode.big_op) {
		gen_extend_word(false,FC_OP1);
		gen_call_function_raw((void*)&dynrec_push_dword);
	} else {
		gen_call_function_raw((void*)&dynrec_push_word);
	}
}

static void dyn_pop_seg(Bit8u seg) {
	gen_call_function_II((void *)&CPU_PopSeg,seg,decode.big_op);
	if (cpu.pmode) dyn_check_exception(FC_RETOP);
}

static void dyn_push_reg(Bit8u reg) {
	gen_mov_word_to_reg(FC_OP1,DRCD_REG_WORD(reg,decode.big_op),decode.big_op);
	if (decode.big_op) gen_call_function_raw((void*)&dynrec_push_dword);
	else gen_call_function_raw((void*)&dynrec_push_word);
}

static void dyn_pop_reg(Bit8u reg) {
	if (decode.big_op) gen_call_function_raw((void*)&dynrec_pop_dword);
	else gen_call_function_raw((void*)&dynrec_pop_word);
	gen_mov_word_from_reg(FC_RETOP,DRCD_REG_WORD(reg,decode.big_op),decode.big_op);
}

static void dyn_push_byte_imm(Bit8s imm) {
	gen_mov_dword_to_reg_imm(FC_OP1,(Bit32u)imm);
	if (decode.big_op) gen_call_function_raw((void*)&dynrec_push_dword);
	else gen_call_function_raw((void*)&dynrec_push_word);
}

static void dyn_push_word_imm(Bitu imm) {
	if (decode.big_op) {
		gen_mov_dword_to_reg_imm(FC_OP1,imm);
		gen_call_function_raw((void*)&dynrec_push_dword);
	} else {
		gen_mov_word_to_reg_imm(FC_OP1,(Bit16u)imm);
		gen_call_function_raw((void*)&dynrec_push_word);
	}
}

static void dyn_pop_ev(void) {
	dyn_get_modrm();
	if (decode.modrm.mod<3) {
/*		dyn_fill_ea(FC_ADDR);
		gen_protect_addr_reg();
		dyn_read_word(FC_ADDR,FC_OP1,decode.big_op);	// dummy read to trigger possible page faults */
		if (decode.big_op) gen_call_function_raw((void*)&dynrec_pop_dword);
		else gen_call_function_raw((void*)&dynrec_pop_word);
		dyn_fill_ea(FC_ADDR);
//		gen_restore_addr_reg();
		dyn_write_word(FC_ADDR,FC_RETOP,decode.big_op);
	} else {
		if (decode.big_op) gen_call_function_raw((void*)&dynrec_pop_dword);
		else gen_call_function_raw((void*)&dynrec_pop_word);
		gen_mov_word_from_reg(FC_RETOP,DRCD_REG_WORD(decode.modrm.rm,decode.big_op),decode.big_op);
	}
}


static void dyn_segprefix(Bit8u seg) {
	if (GCC_UNLIKELY(decode.seg_prefix_used)) IllegalOptionDynrec("dyn_segprefix");
	decode.seg_prefix=seg;
	decode.seg_prefix_used=true;
}

 static void dyn_mov_seg_ev(void) {
	dyn_get_modrm();
	if (GCC_UNLIKELY(decode.modrm.reg==DRC_SEG_CS)) IllegalOptionDynrec("dyn_mov_seg_ev");
	if (decode.modrm.mod<3) {
		dyn_fill_ea(FC_ADDR);
		dyn_read_word(FC_ADDR,FC_RETOP,false);
	} else {
		gen_mov_word_to_reg(FC_RETOP,DRCD_REG_WORD(decode.modrm.rm,false),false);
	}
	gen_call_function_IR((void *)&CPU_SetSegGeneral,decode.modrm.reg,FC_RETOP);
	if (cpu.pmode) dyn_check_exception(FC_RETOP);
}

static void dyn_load_seg_off_ea(Bit8u seg) {
	dyn_get_modrm();
	if (decode.modrm.mod<3) {
		dyn_fill_ea(FC_ADDR);
		gen_protect_addr_reg();
		dyn_read_word(FC_ADDR,FC_OP1,decode.big_op);
		gen_protect_reg(FC_OP1);

		gen_restore_addr_reg();
		gen_add_imm(FC_ADDR,decode.big_op ? 4:2);
		dyn_read_word(FC_ADDR,FC_RETOP,false);

		gen_call_function_IR((void *)&CPU_SetSegGeneral,seg,FC_RETOP);
		if (cpu.pmode) dyn_check_exception(FC_RETOP);

		gen_restore_reg(FC_OP1);
		gen_mov_word_from_reg(FC_OP1,DRCD_REG_WORD(decode.modrm.reg,decode.big_op),decode.big_op);
	} else {
		IllegalOptionDynrec("dyn_load_seg_off_ea");
	}
}



static void dyn_imul_gvev(Bitu immsize) {
	dyn_get_modrm();
	if (decode.modrm.mod<3) {
		dyn_fill_ea(FC_ADDR);
		dyn_read_word(FC_ADDR,FC_OP1,decode.big_op);
	} else {
		gen_mov_word_to_reg(FC_OP1,DRCD_REG_WORD(decode.modrm.rm,decode.big_op),decode.big_op);
	}

	switch (immsize) {
		case 0:
			gen_mov_word_to_reg(FC_OP2,DRCD_REG_WORD(decode.modrm.reg,decode.big_op),decode.big_op);
			break;
		case 1:
			if (decode.big_op) gen_mov_dword_to_reg_imm(FC_OP2,(Bit8s)decode_fetchb());
			else  gen_mov_word_to_reg_imm(FC_OP2,(Bit8s)decode_fetchb());
			break;
		case 2:
			if (decode.big_op) gen_mov_dword_to_reg_imm(FC_OP2,(Bit16s)decode_fetchw());
			else gen_mov_word_to_reg_imm(FC_OP2,(Bit16s)decode_fetchw());
			break;
		case 4:
			if (decode.big_op) gen_mov_dword_to_reg_imm(FC_OP2,(Bit32s)decode_fetchd());
			else gen_mov_word_to_reg_imm(FC_OP2,(Bit16u)((Bit32s)decode_fetchd()));
			break;
	}

	if (decode.big_op) gen_call_function_raw((void*)dynrec_dimul_dword);
	else gen_call_function_raw((void*)dynrec_dimul_word);

	gen_mov_word_from_reg(FC_RETOP,DRCD_REG_WORD(decode.modrm.reg,decode.big_op),decode.big_op);
}

static void dyn_dshift_ev_gv(bool left,bool immediate) {
	dyn_get_modrm();
	if (decode.modrm.mod<3) {
		dyn_fill_ea(FC_ADDR);
		gen_protect_addr_reg();
		dyn_read_word(FC_ADDR,FC_OP1,decode.big_op);
	} else {
		gen_mov_word_to_reg(FC_OP1,DRCD_REG_WORD(decode.modrm.rm,decode.big_op),decode.big_op);
	}
	gen_mov_word_to_reg(FC_OP2,DRCD_REG_WORD(decode.modrm.reg,decode.big_op),decode.big_op);
	if (immediate) gen_mov_byte_to_reg_low_imm(FC_RETOP,decode_fetchb());
	else gen_mov_byte_to_reg_low(FC_RETOP,DRCD_REG_BYTE(DRC_REG_ECX,0));
	if (decode.big_op) dyn_dpshift_dword_gencall(left);
	else dyn_dpshift_word_gencall(left);

	if (decode.modrm.mod<3) {
		gen_restore_addr_reg();
		dyn_write_word(FC_ADDR,FC_RETOP,decode.big_op);
	} else {
		gen_mov_word_from_reg(FC_RETOP,DRCD_REG_WORD(decode.modrm.rm,decode.big_op),decode.big_op);
	}
}


static void dyn_grp1_eb_ib(void) {
	dyn_get_modrm();
	DualOps op=grp1_table[decode.modrm.reg];
	if (decode.modrm.mod<3) {
		dyn_fill_ea(FC_ADDR);
		gen_protect_addr_reg();
		dyn_read_byte_canuseword(FC_ADDR,FC_OP1);
		gen_mov_byte_to_reg_low_imm_canuseword(FC_OP2,decode_fetchb());
		dyn_dop_byte_gencall(op);

		if ((op!=DOP_CMP) && (op!=DOP_TEST)) {
			gen_restore_addr_reg();
			dyn_write_byte(FC_ADDR,FC_RETOP);
		}
	} else {
		dyn_dop_byte_imm_mem(op,decode.modrm.rm&3,(decode.modrm.rm>>2)&1);
	}
}

static void dyn_grp1_ev_iv(bool withbyte) {
	dyn_get_modrm();
	DualOps op=grp1_table[decode.modrm.reg];
	if (decode.modrm.mod<3) {
		dyn_fill_ea(FC_ADDR);
		gen_protect_addr_reg();
		dyn_read_word(FC_ADDR,FC_OP1,decode.big_op);

		if (!withbyte) {
			dyn_prep_word_imm(FC_OP2);
		} else {
			Bits imm=(Bit8s)decode_fetchb(); 
			if (decode.big_op) gen_mov_dword_to_reg_imm(FC_OP2,(Bit32u)imm);
			else gen_mov_word_to_reg_imm(FC_OP2,(Bit16u)imm);
		}

		dyn_dop_word_gencall(op,decode.big_op);

		if ((op!=DOP_CMP) && (op!=DOP_TEST)) {
			gen_restore_addr_reg();
			dyn_write_word(FC_ADDR,FC_RETOP,decode.big_op);
		}
	} else {
		if (!withbyte) {
			dyn_dop_word_imm(op,decode.modrm.rm);
		} else {
			Bits imm=withbyte ? (Bit8s)decode_fetchb() : (decode.big_op ? decode_fetchd(): decode_fetchw()); 
			dyn_dop_word_imm_old(op,decode.modrm.rm,imm);
		}
	}
}


static void dyn_grp2_eb(grp2_types type) {
	dyn_get_modrm();
	if (decode.modrm.mod<3) {
		dyn_fill_ea(FC_ADDR);
		gen_protect_addr_reg();
		dyn_read_byte_canuseword(FC_ADDR,FC_OP1);
	} else {
		gen_mov_byte_to_reg_low_canuseword(FC_OP1,DRCD_REG_BYTE(decode.modrm.rm&3,(decode.modrm.rm>>2)&1));
	}
	switch (type) {
	case grp2_1:
		gen_mov_byte_to_reg_low_imm_canuseword(FC_OP2,1);
		dyn_shift_byte_gencall((ShiftOps)decode.modrm.reg);
		break;
	case grp2_imm: {
		Bit8u imm=decode_fetchb();
		if (imm) {
			gen_mov_byte_to_reg_low_imm_canuseword(FC_OP2,imm&0x1f);
			dyn_shift_byte_gencall((ShiftOps)decode.modrm.reg);
		} else return;
		}
		break;
	case grp2_cl:
		gen_mov_byte_to_reg_low_canuseword(FC_OP2,DRCD_REG_BYTE(DRC_REG_ECX,0));
		gen_and_imm(FC_OP2,0x1f);
		dyn_shift_byte_gencall((ShiftOps)decode.modrm.reg);
		break;
	}
	if (decode.modrm.mod<3) {
		gen_restore_addr_reg();
		dyn_write_byte(FC_ADDR,FC_RETOP);
	} else {
		gen_mov_byte_from_reg_low(FC_RETOP,DRCD_REG_BYTE(decode.modrm.rm&3,(decode.modrm.rm>>2)&1));
	}
}

static void dyn_grp2_ev(grp2_types type) {
	dyn_get_modrm();
	if (decode.modrm.mod<3) {
		dyn_fill_ea(FC_ADDR);
		gen_protect_addr_reg();
		dyn_read_word(FC_ADDR,FC_OP1,decode.big_op);
	} else {
		gen_mov_word_to_reg(FC_OP1,DRCD_REG_WORD(decode.modrm.rm,decode.big_op),decode.big_op);
	}
	switch (type) {
	case grp2_1:
		gen_mov_byte_to_reg_low_imm_canuseword(FC_OP2,1);
		dyn_shift_word_gencall((ShiftOps)decode.modrm.reg,decode.big_op);
		break;
	case grp2_imm: {
		Bitu val;
		if (decode_fetchb_imm(val)) {
			gen_mov_byte_to_reg_low_canuseword(FC_OP2,(void*)val);
			gen_and_imm(FC_OP2,0x1f);
			dyn_shift_word_gencall((ShiftOps)decode.modrm.reg,decode.big_op);
			break;
		}
		Bit8u imm=(Bit8u)val;
		if (imm) {
			gen_mov_byte_to_reg_low_imm_canuseword(FC_OP2,imm&0x1f);
			dyn_shift_word_gencall((ShiftOps)decode.modrm.reg,decode.big_op);
		} else return;
		}
		break;
	case grp2_cl:
		gen_mov_byte_to_reg_low_canuseword(FC_OP2,DRCD_REG_BYTE(DRC_REG_ECX,0));
		gen_and_imm(FC_OP2,0x1f);
		dyn_shift_word_gencall((ShiftOps)decode.modrm.reg,decode.big_op);
		break;
	}
	if (decode.modrm.mod<3) {
		gen_restore_addr_reg();
		dyn_write_word(FC_ADDR,FC_RETOP,decode.big_op);
	} else {
		gen_mov_word_from_reg(FC_RETOP,DRCD_REG_WORD(decode.modrm.rm,decode.big_op),decode.big_op);
	}
}


static void dyn_grp3_eb(void) {
	dyn_get_modrm();
	if (decode.modrm.mod<3) {
		dyn_fill_ea(FC_ADDR);
		if ((decode.modrm.reg==2) || (decode.modrm.reg==3)) gen_protect_addr_reg();
		dyn_read_byte_canuseword(FC_ADDR,FC_OP1);
	} else {
		gen_mov_byte_to_reg_low_canuseword(FC_OP1,DRCD_REG_BYTE(decode.modrm.rm&3,(decode.modrm.rm>>2)&1));
	}
	switch (decode.modrm.reg) {
	case 0x0:	// test eb,ib
		gen_mov_byte_to_reg_low_imm_canuseword(FC_OP2,decode_fetchb());
		dyn_dop_byte_gencall(DOP_TEST);
		return;
	case 0x2:	// NOT Eb
		dyn_sop_byte_gencall(SOP_NOT);
		break;
	case 0x3:	// NEG Eb
		dyn_sop_byte_gencall(SOP_NEG);
		break;
	case 0x4:	// mul Eb
		gen_call_function_raw((void*)&dynrec_mul_byte);
		return;
	case 0x5:	// imul Eb
		gen_call_function_raw((void*)&dynrec_imul_byte);
		return;
	case 0x6:	// div Eb
		gen_call_function_raw((void*)&dynrec_div_byte);
		dyn_check_exception(FC_RETOP);
		return;
	case 0x7:	// idiv Eb
		gen_call_function_raw((void*)&dynrec_idiv_byte);
		dyn_check_exception(FC_RETOP);
		return;
	}
	// Save the result if memory op
	if (decode.modrm.mod<3) {
		gen_restore_addr_reg();
		dyn_write_byte(FC_ADDR,FC_RETOP);
	} else {
		gen_mov_byte_from_reg_low(FC_RETOP,DRCD_REG_BYTE(decode.modrm.rm&3,(decode.modrm.rm>>2)&1));
	}
}

static void dyn_grp3_ev(void) {
	dyn_get_modrm();
	if (decode.modrm.mod<3) {
		dyn_fill_ea(FC_ADDR);
		if ((decode.modrm.reg==2) || (decode.modrm.reg==3)) gen_protect_addr_reg();
		dyn_read_word(FC_ADDR,FC_OP1,decode.big_op);
	} else {
		gen_mov_word_to_reg(FC_OP1,DRCD_REG_WORD(decode.modrm.rm,decode.big_op),decode.big_op);
	}
	switch (decode.modrm.reg) {
	case 0x0:	// test ev,iv
		if (decode.big_op) gen_mov_dword_to_reg_imm(FC_OP2,decode_fetchd());
		else gen_mov_word_to_reg_imm(FC_OP2,decode_fetchw());
		dyn_dop_word_gencall(DOP_TEST,decode.big_op);
		return;
	case 0x2:	// NOT Ev
		dyn_sop_word_gencall(SOP_NOT,decode.big_op);
		break;
	case 0x3:	// NEG Eb
		dyn_sop_word_gencall(SOP_NEG,decode.big_op);
		break;
	case 0x4:	// mul Eb
		if (decode.big_op) gen_call_function_raw((void*)&dynrec_mul_dword);
		else gen_call_function_raw((void*)&dynrec_mul_word);
		return;
	case 0x5:	// imul Eb
		if (decode.big_op) gen_call_function_raw((void*)&dynrec_imul_dword);
		else gen_call_function_raw((void*)&dynrec_imul_word);
		return;
	case 0x6:	// div Eb
		if (decode.big_op) gen_call_function_raw((void*)&dynrec_div_dword);
		else gen_call_function_raw((void*)&dynrec_div_word);
		dyn_check_exception(FC_RETOP);
		return;
	case 0x7:	// idiv Eb
		if (decode.big_op) gen_call_function_raw((void*)&dynrec_idiv_dword);
		else gen_call_function_raw((void*)&dynrec_idiv_word);
		dyn_check_exception(FC_RETOP);
		return;
	}
	// Save the result if memory op
	if (decode.modrm.mod<3) {
		gen_restore_addr_reg();
		dyn_write_word(FC_ADDR,FC_RETOP,decode.big_op);
	} else {
		gen_mov_word_from_reg(FC_RETOP,DRCD_REG_WORD(decode.modrm.rm,decode.big_op),decode.big_op);
	}
}


static bool dyn_grp4_eb(void) {
	dyn_get_modrm();
	switch (decode.modrm.reg) {
	case 0x0://INC Eb
	case 0x1://DEC Eb
		if (decode.modrm.mod<3) {
			dyn_fill_ea(FC_ADDR);
			gen_protect_addr_reg();
			dyn_read_byte_canuseword(FC_ADDR,FC_OP1);
			dyn_sop_byte_gencall(decode.modrm.reg==0 ? SOP_INC : SOP_DEC);
			gen_restore_addr_reg();
			dyn_write_byte(FC_ADDR,FC_RETOP);
		} else {
			gen_mov_byte_to_reg_low_canuseword(FC_OP1,DRCD_REG_BYTE(decode.modrm.rm&3,(decode.modrm.rm>>2)&1));
			dyn_sop_byte_gencall(decode.modrm.reg==0 ? SOP_INC : SOP_DEC);
			gen_mov_byte_from_reg_low(FC_RETOP,DRCD_REG_BYTE(decode.modrm.rm&3,(decode.modrm.rm>>2)&1));
		}
		break;
	case 0x7:		//CALBACK Iw
		gen_mov_direct_dword(&core_dynrec.callback,decode_fetchw());
		dyn_set_eip_end();
		dyn_reduce_cycles();
		dyn_return(BR_CallBack);
		dyn_closeblock();
		return true;
	default:
		IllegalOptionDynrec("dyn_grp4_eb");
		break;
	}
	return false;
}

static bool dyn_grp4_ev(void) {
	dyn_get_modrm();
	if (decode.modrm.mod<3) {
		dyn_fill_ea(FC_ADDR);
		if ((decode.modrm.reg<2) || (decode.modrm.reg==3) || (decode.modrm.reg==5))  gen_protect_addr_reg();
		dyn_read_word(FC_ADDR,FC_OP1,decode.big_op);
	} else {
		gen_mov_word_to_reg(FC_OP1,DRCD_REG_WORD(decode.modrm.rm,decode.big_op),decode.big_op);
	}
	switch (decode.modrm.reg) {
	case 0x0://INC Ev
	case 0x1://DEC Ev
		dyn_sop_word_gencall(decode.modrm.reg==0 ? SOP_INC : SOP_DEC,decode.big_op);
		if (decode.modrm.mod<3) {
			gen_restore_addr_reg();
			dyn_write_word(FC_ADDR,FC_RETOP,decode.big_op);
		} else {
			gen_mov_word_from_reg(FC_RETOP,DRCD_REG_WORD(decode.modrm.rm,decode.big_op),decode.big_op);
		}
		break;
	case 0x2:	// CALL Ev
		gen_mov_regs(FC_ADDR,FC_OP1);
		gen_protect_addr_reg();
		gen_mov_word_to_reg(FC_OP1,decode.big_op?(void*)(&reg_eip):(void*)(&reg_ip),decode.big_op);
		gen_add_imm(FC_OP1,(Bit32u)(decode.code-decode.code_start));
		if (decode.big_op) gen_call_function_raw((void*)&dynrec_push_dword);
		else gen_call_function_raw((void*)&dynrec_push_word);

		gen_restore_addr_reg();
		gen_mov_word_from_reg(FC_ADDR,decode.big_op?(void*)(&reg_eip):(void*)(&reg_ip),decode.big_op);
		return true;
	case 0x4:	// JMP Ev
		gen_mov_word_from_reg(FC_OP1,decode.big_op?(void*)(&reg_eip):(void*)(&reg_ip),decode.big_op);
		return true;
	case 0x3:	// CALL Ep
	case 0x5:	// JMP Ep
		if (!decode.big_op) gen_extend_word(false,FC_OP1);
		if (decode.modrm.mod<3) gen_restore_addr_reg();
		gen_protect_reg(FC_OP1);
		gen_add_imm(FC_ADDR,decode.big_op?4:2);
		dyn_read_word(FC_ADDR,FC_OP2,decode.big_op);
		gen_extend_word(false,FC_OP2);

		dyn_set_eip_last_end(FC_RETOP);
		gen_restore_reg(FC_OP1,FC_ADDR);
		gen_call_function_IRRR(decode.modrm.reg == 3 ? (void*)(&CPU_CALL) : (void*)(&CPU_JMP),
			decode.big_op,FC_OP2,FC_ADDR,FC_RETOP);
		return true;
	case 0x6:		// PUSH Ev
		if (decode.big_op) gen_call_function_raw((void*)&dynrec_push_dword);
		else gen_call_function_raw((void*)&dynrec_push_word);
		break;
	default:
		IllegalOptionDynrec("dyn_grp4_ev");
	}
	return false;
}


static bool dyn_grp6(void) {
	dyn_get_modrm();
	switch (decode.modrm.reg) {
		case 0x00:	// SLDT
		case 0x01:	// STR
			if (decode.modrm.reg==0) gen_call_function_raw((void*)CPU_SLDT);
			else gen_call_function_raw((void*)CPU_STR);
			if (decode.modrm.mod<3) {
				dyn_fill_ea(FC_ADDR);
				dyn_write_word(FC_ADDR,FC_RETOP,false);
			} else {
				gen_mov_word_from_reg(FC_RETOP,DRCD_REG_WORD(decode.modrm.rm,false),false);
			}
			break;
		case 0x02:	// LLDT
		case 0x03:	// LTR
		case 0x04:	// VERR
		case 0x05:	// VERW
			if (decode.modrm.mod<3) {
				dyn_fill_ea(FC_ADDR);
				dyn_read_word(FC_ADDR,FC_RETOP,false);
			} else {
				gen_mov_word_to_reg(FC_RETOP,DRCD_REG_WORD(decode.modrm.rm,false),false);
			}
			gen_extend_word(false,FC_RETOP);
			switch (decode.modrm.reg) {
				case 0x02:	// LLDT
//					if (cpu.cpl) return CPU_PrepareException(EXCEPTION_GP,0);
					if (cpu.cpl) E_Exit("lldt cpl>0");
					gen_call_function_R((void*)CPU_LLDT,FC_RETOP);
					dyn_check_exception(FC_RETOP);
					break;
				case 0x03:	// LTR
//					if (cpu.cpl) return CPU_PrepareException(EXCEPTION_GP,0);
					if (cpu.cpl) E_Exit("ltr cpl>0");
					gen_call_function_R((void*)CPU_LTR,FC_RETOP);
					dyn_check_exception(FC_RETOP);
					break;
				case 0x04:	// VERR
					gen_call_function_R((void*)CPU_VERR,FC_RETOP);
					break;
				case 0x05:	// VERW
					gen_call_function_R((void*)CPU_VERW,FC_RETOP);
					break;
			}
			break;
		default: IllegalOptionDynrec("dyn_grp6");
	}
	return false;
}

static bool dyn_grp7(void) {
	dyn_get_modrm();
	if (decode.modrm.mod<3) {
		switch (decode.modrm.reg) {
			case 0x00:	// SGDT
				gen_call_function_raw((void*)CPU_SGDT_limit);
				dyn_fill_ea(FC_ADDR);
				gen_protect_addr_reg();
				dyn_write_word(FC_ADDR,FC_RETOP,false);
				gen_call_function_raw((void*)CPU_SGDT_base);
				gen_restore_addr_reg();
				gen_add_imm(FC_ADDR,2);
				dyn_write_word(FC_ADDR,FC_RETOP,true);
				break;
			case 0x01:	// SIDT
				gen_call_function_raw((void*)CPU_SIDT_limit);
				dyn_fill_ea(FC_ADDR);
				gen_protect_addr_reg();
				dyn_write_word(FC_ADDR,FC_RETOP,false);
				gen_call_function_raw((void*)CPU_SIDT_base);
				gen_restore_addr_reg();
				gen_add_imm(FC_ADDR,2);
				dyn_write_word(FC_ADDR,FC_RETOP,true);
				break;
			case 0x02:	// LGDT
			case 0x03:	// LIDT
//				if (cpu.pmode && cpu.cpl) EXCEPTION(EXCEPTION_GP);
				if (cpu.pmode && cpu.cpl) IllegalOptionDynrec("lgdt nonpriviledged");
				dyn_fill_ea(FC_ADDR);
				gen_protect_addr_reg();
				dyn_read_word(FC_ADDR,FC_OP1,false);
				gen_extend_word(false,FC_OP1);
				gen_protect_reg(FC_OP1);

				gen_restore_addr_reg();
				gen_add_imm(FC_ADDR,2);
				dyn_read_word(FC_ADDR,FC_OP2,true);
				if (!decode.big_op) gen_and_imm(FC_OP2,0xffffff);

				gen_restore_reg(FC_OP1);
				if (decode.modrm.reg==2) gen_call_function_RR((void*)CPU_LGDT,FC_OP1,FC_OP2);
				else gen_call_function_RR((void*)CPU_LIDT,FC_OP1,FC_OP2);
				break;
			case 0x04:	// SMSW
				gen_call_function_raw((void*)CPU_SMSW);
				dyn_fill_ea(FC_ADDR);
				dyn_write_word(FC_ADDR,FC_RETOP,false);
				break;
			case 0x06:	// LMSW
				dyn_fill_ea(FC_ADDR);
				dyn_read_word(FC_ADDR,FC_RETOP,false);
				gen_call_function_R((void*)CPU_LMSW,FC_RETOP);
				dyn_check_exception(FC_RETOP);
				dyn_set_eip_end();
				dyn_reduce_cycles();
				dyn_return(BR_Normal);
				dyn_closeblock();
				return true;
			default: IllegalOptionDynrec("dyn_grp7_1");
		}
	} else {
		switch (decode.modrm.reg) {
			case 0x04:	// SMSW
				gen_call_function_raw((void*)CPU_SMSW);
				gen_mov_word_from_reg(FC_RETOP,DRCD_REG_WORD(decode.modrm.rm,false),false);
				break;
			case 0x06:	// LMSW
				gen_mov_word_to_reg(FC_RETOP,DRCD_REG_WORD(decode.modrm.rm,false),false);
				gen_call_function_R((void*)CPU_LMSW,FC_RETOP);
				dyn_check_exception(FC_RETOP);
				dyn_set_eip_end();
				dyn_reduce_cycles();
				dyn_return(BR_Normal);
				dyn_closeblock();
				return true;
			default: IllegalOptionDynrec("dyn_grp7_2");
		}
	}
	return false;
}


/*
static void dyn_larlsl(bool is_lar) {
	dyn_get_modrm();
	if (decode.modrm.mod<3) {
		dyn_fill_ea(FC_ADDR);
		dyn_read_word(FC_ADDR,FC_RETOP,false);
	} else {
		gen_mov_word_to_reg(FC_RETOP,DRCD_REG_WORD(decode.modrm.rm,false),false);
	}
	gen_extend_word(false,FC_RETOP);
	if (is_lar) gen_call_function((void*)CPU_LAR,"%R%A",FC_RETOP,(DRC_PTR_SIZE_IM)&core_dynrec.readdata);
	else gen_call_function((void*)CPU_LSL,"%R%A",FC_RETOP,(DRC_PTR_SIZE_IM)&core_dynrec.readdata);
	DRC_PTR_SIZE_IM brnz=gen_create_branch_on_nonzero(FC_RETOP,true);
	gen_mov_word_to_reg(FC_OP2,&core_dynrec.readdata,true);
	gen_mov_word_from_reg(FC_OP2,DRCD_REG_WORD(decode.modrm.reg,decode.big_op),decode.big_op);
	gen_fill_branch(brnz);
}
*/


static void dyn_mov_from_crx(void) {
	dyn_get_modrm();
	gen_call_function_IA((void*)CPU_READ_CRX,decode.modrm.reg,(DRC_PTR_SIZE_IM)&core_dynrec.readdata);
	dyn_check_exception(FC_RETOP);
	gen_mov_word_to_reg(FC_OP2,&core_dynrec.readdata,true);
	gen_mov_word_from_reg(FC_OP2,DRCD_REG_WORD(decode.modrm.rm,true),true);
}

static void dyn_mov_to_crx(void) {
	dyn_get_modrm();
	gen_mov_word_to_reg(FC_RETOP,DRCD_REG_WORD(decode.modrm.rm,true),true);
	gen_call_function_IR((void*)CPU_WRITE_CRX,decode.modrm.reg,FC_RETOP);
	dyn_check_exception(FC_RETOP);
	dyn_set_eip_end();
	dyn_reduce_cycles();
	dyn_return(BR_Normal);
	dyn_closeblock();
}


static void dyn_cbw(void) {
	if (decode.big_op) {
		gen_mov_word_to_reg(FC_OP1,DRCD_REG_WORD(DRC_REG_EAX,false),false);
		gen_call_function_raw((void *)&dynrec_cwde);
		gen_mov_word_from_reg(FC_RETOP,DRCD_REG_WORD(DRC_REG_EAX,true),true);
	} else {
		gen_mov_byte_to_reg_low_canuseword(FC_OP1,DRCD_REG_BYTE(DRC_REG_EAX,0));
		gen_call_function_raw((void *)&dynrec_cbw);
		gen_mov_word_from_reg(FC_RETOP,DRCD_REG_WORD(DRC_REG_EAX,false),false);
	}
}

static void dyn_cwd(void) {
	gen_mov_word_to_reg(FC_OP1,DRCD_REG_WORD(DRC_REG_EAX,decode.big_op),decode.big_op);
	if (decode.big_op) {
		gen_call_function_raw((void *)&dynrec_cdq);
		gen_mov_word_from_reg(FC_RETOP,DRCD_REG_WORD(DRC_REG_EDX,true),true);
	} else {
		gen_call_function_raw((void *)&dynrec_cwd);
		gen_mov_word_from_reg(FC_RETOP,DRCD_REG_WORD(DRC_REG_EDX,false),false);
	}
}

static void dyn_sahf(void) {
	gen_mov_word_to_reg(FC_OP1,DRCD_REG_WORD(DRC_REG_EAX,false),false);
	gen_call_function_raw((void *)&dynrec_sahf);
	InvalidateFlags();
}


static void dyn_exit_link(Bits eip_change) {
	gen_add_direct_word(&reg_eip,(decode.code-decode.code_start)+eip_change,decode.big_op);
	dyn_reduce_cycles();
	gen_jmp_ptr(&decode.block->link[0].to,offsetof(CacheBlockDynRec,cache.start));
	dyn_closeblock();
}


static void dyn_branched_exit(BranchTypes btype,Bit32s eip_add) {
	Bitu eip_base=decode.code-decode.code_start;
	dyn_reduce_cycles();

	dyn_branchflag_to_reg(btype);
	DRC_PTR_SIZE_IM data=gen_create_branch_on_nonzero(FC_RETOP,true);

 	// Branch not taken
	gen_add_direct_word(&reg_eip,eip_base,decode.big_op);
 	gen_jmp_ptr(&decode.block->link[0].to,offsetof(CacheBlockDynRec,cache.start));
 	gen_fill_branch(data);

 	// Branch taken
	gen_add_direct_word(&reg_eip,eip_base+eip_add,decode.big_op);
 	gen_jmp_ptr(&decode.block->link[1].to,offsetof(CacheBlockDynRec,cache.start));
 	dyn_closeblock();
}

/*
static void dyn_set_byte_on_condition(BranchTypes btype) {
	dyn_get_modrm();
	dyn_branchflag_to_reg(btype);
	gen_and_imm(FC_RETOP,1);
	if (decode.modrm.mod<3) {
		dyn_fill_ea(FC_ADDR);
		dyn_write_byte(FC_ADDR,FC_RETOP);
	} else {
		gen_mov_byte_from_reg_low(FC_RETOP,DRCD_REG_BYTE(decode.modrm.rm&3,(decode.modrm.rm>>2)&1));
	}
}
*/

static void dyn_loop(LoopTypes type) {
	dyn_reduce_cycles();
	Bits eip_add=(Bit8s)decode_fetchb();
	Bitu eip_base=decode.code-decode.code_start;
	DRC_PTR_SIZE_IM branch1=0;
	DRC_PTR_SIZE_IM branch2=0;
	switch (type) {
	case LOOP_E:
		dyn_branchflag_to_reg(BR_NZ);
		branch1=gen_create_branch_on_nonzero(FC_RETOP,true);
		break;
	case LOOP_NE:
		dyn_branchflag_to_reg(BR_Z);
		branch1=gen_create_branch_on_nonzero(FC_RETOP,true);
		break;
	}
	switch (type) {
	case LOOP_E:
	case LOOP_NE:
	case LOOP_NONE:
		gen_mov_word_to_reg(FC_OP1,DRCD_REG_WORD(DRC_REG_ECX,decode.big_addr),decode.big_addr);
		gen_add_imm(FC_OP1,(Bit32u)(-1));
		gen_mov_word_from_reg(FC_OP1,DRCD_REG_WORD(DRC_REG_ECX,decode.big_addr),decode.big_addr);
		branch2=gen_create_branch_on_zero(FC_OP1,decode.big_addr);
		break;
	case LOOP_JCXZ:
		gen_mov_word_to_reg(FC_OP1,DRCD_REG_WORD(DRC_REG_ECX,decode.big_addr),decode.big_addr);
		branch2=gen_create_branch_on_nonzero(FC_OP1,decode.big_addr);
		break;
	}
	gen_add_direct_word(&reg_eip,eip_base+eip_add,true);
	gen_jmp_ptr(&decode.block->link[0].to,offsetof(CacheBlockDynRec,cache.start));
	if (branch1) {
		gen_fill_branch(branch1);
		gen_mov_word_to_reg(FC_OP1,DRCD_REG_WORD(DRC_REG_ECX,decode.big_addr),decode.big_addr);
		gen_add_imm(FC_OP1,(Bit32u)(-1));
		gen_mov_word_from_reg(FC_OP1,DRCD_REG_WORD(DRC_REG_ECX,decode.big_addr),decode.big_addr);
	}
	// Branch taken
	gen_fill_branch(branch2);
	gen_add_direct_word(&reg_eip,eip_base,decode.big_op);
	gen_jmp_ptr(&decode.block->link[1].to,offsetof(CacheBlockDynRec,cache.start));
	dyn_closeblock();
}


static void dyn_ret_near(Bitu bytes) {
	dyn_reduce_cycles();

	if (decode.big_op) gen_call_function_raw((void*)&dynrec_pop_dword);
	else {
		gen_call_function_raw((void*)&dynrec_pop_word);
		gen_extend_word(false,FC_RETOP);
	}
	gen_mov_word_from_reg(FC_RETOP,decode.big_op?(void*)(&reg_eip):(void*)(&reg_ip),true);

	if (bytes) gen_add_direct_word(&reg_esp,bytes,true);
	dyn_return(BR_Normal);
	dyn_closeblock();
}

static void dyn_call_near_imm(void) {
	Bits imm;
	if (decode.big_op) imm=(Bit32s)decode_fetchd();
	else imm=(Bit16s)decode_fetchw();
	dyn_set_eip_end(FC_OP1);
	if (decode.big_op) gen_call_function_raw((void*)&dynrec_push_dword);
	else gen_call_function_raw((void*)&dynrec_push_word);

	dyn_set_eip_end(FC_OP1,imm);
	gen_mov_word_from_reg(FC_OP1,decode.big_op?(void*)(&reg_eip):(void*)(&reg_ip),decode.big_op);

	dyn_reduce_cycles();
	gen_jmp_ptr(&decode.block->link[0].to,offsetof(CacheBlockDynRec,cache.start));
	dyn_closeblock();
}

static void dyn_ret_far(Bitu bytes) {
	dyn_reduce_cycles();
	dyn_set_eip_last_end(FC_RETOP);
	gen_call_function_IIR((void*)&CPU_RET,decode.big_op,bytes,FC_RETOP);
	dyn_return(BR_Normal);
	dyn_closeblock();
}

static void dyn_call_far_imm(void) {
	Bitu sel,off;
	off=decode.big_op ? decode_fetchd() : decode_fetchw();
	sel=decode_fetchw();
	dyn_reduce_cycles();
	dyn_set_eip_last_end(FC_RETOP);
	gen_call_function_IIIR((void*)&CPU_CALL,decode.big_op,sel,off,FC_RETOP);
	dyn_return(BR_Normal);
	dyn_closeblock();
}

static void dyn_jmp_far_imm(void) {
	Bitu sel,off;
	off=decode.big_op ? decode_fetchd() : decode_fetchw();
	sel=decode_fetchw();
	dyn_reduce_cycles();
	dyn_set_eip_last_end(FC_RETOP);
	gen_call_function_IIIR((void*)&CPU_JMP,decode.big_op,sel,off,FC_RETOP);
	dyn_return(BR_Normal);
	dyn_closeblock();
}

static void dyn_iret(void) {
	dyn_reduce_cycles();
	dyn_set_eip_last_end(FC_RETOP);
	gen_call_function_IR((void*)&CPU_IRET,decode.big_op,FC_RETOP);
	dyn_return(BR_Iret);
	dyn_closeblock();
}

static void dyn_interrupt(Bit8u num) {
	dyn_reduce_cycles();
	dyn_set_eip_last_end(FC_RETOP);
	gen_call_function_IIR((void*)&CPU_Interrupt,num,CPU_INT_SOFTWARE,FC_RETOP);
	dyn_return(BR_Normal);
	dyn_closeblock();
}



static void dyn_string(StringOps op) {
	if (decode.rep) gen_mov_word_to_reg(FC_OP1,DRCD_REG_WORD(DRC_REG_ECX,decode.big_addr),decode.big_addr);
	else gen_mov_dword_to_reg_imm(FC_OP1,1);
	gen_mov_word_to_reg(FC_OP2,&cpu.direction,true);
	Bit8u di_base_addr=decode.seg_prefix_used ? decode.seg_prefix : DRC_SEG_DS;
	switch (op) {
		case STR_MOVSB:
			if (decode.big_addr) gen_call_function_mm((void*)&dynrec_movsb_dword,(Bitu)DRCD_SEG_PHYS(di_base_addr),(Bitu)DRCD_SEG_PHYS(DRC_SEG_ES));
			else gen_call_function_mm((void*)&dynrec_movsb_word,(Bitu)DRCD_SEG_PHYS(di_base_addr),(Bitu)DRCD_SEG_PHYS(DRC_SEG_ES));
			break;
		case STR_MOVSW:
			if (decode.big_addr) gen_call_function_mm((void*)&dynrec_movsw_dword,(Bitu)DRCD_SEG_PHYS(di_base_addr),(Bitu)DRCD_SEG_PHYS(DRC_SEG_ES));
			else gen_call_function_mm((void*)&dynrec_movsw_word,(Bitu)DRCD_SEG_PHYS(di_base_addr),(Bitu)DRCD_SEG_PHYS(DRC_SEG_ES));
			break;
		case STR_MOVSD:
			if (decode.big_addr) gen_call_function_mm((void*)&dynrec_movsd_dword,(Bitu)DRCD_SEG_PHYS(di_base_addr),(Bitu)DRCD_SEG_PHYS(DRC_SEG_ES));
			else gen_call_function_mm((void*)&dynrec_movsd_word,(Bitu)DRCD_SEG_PHYS(di_base_addr),(Bitu)DRCD_SEG_PHYS(DRC_SEG_ES));
			break;

		case STR_LODSB:
			if (decode.big_addr) gen_call_function_m((void*)&dynrec_lodsb_dword,(Bitu)DRCD_SEG_PHYS(di_base_addr));
			else gen_call_function_m((void*)&dynrec_lodsb_word,(Bitu)DRCD_SEG_PHYS(di_base_addr));
			break;
		case STR_LODSW:
			if (decode.big_addr) gen_call_function_m((void*)&dynrec_lodsw_dword,(Bitu)DRCD_SEG_PHYS(di_base_addr));
			else gen_call_function_m((void*)&dynrec_lodsw_word,(Bitu)DRCD_SEG_PHYS(di_base_addr));
			break;
		case STR_LODSD:
			if (decode.big_addr) gen_call_function_m((void*)&dynrec_lodsd_dword,(Bitu)DRCD_SEG_PHYS(di_base_addr));
			else gen_call_function_m((void*)&dynrec_lodsd_word,(Bitu)DRCD_SEG_PHYS(di_base_addr));
			break;

		case STR_STOSB:
			if (decode.big_addr) gen_call_function_m((void*)&dynrec_stosb_dword,(Bitu)DRCD_SEG_PHYS(DRC_SEG_ES));
			else gen_call_function_m((void*)&dynrec_stosb_word,(Bitu)DRCD_SEG_PHYS(DRC_SEG_ES));
			break;
		case STR_STOSW:
			if (decode.big_addr) gen_call_function_m((void*)&dynrec_stosw_dword,(Bitu)DRCD_SEG_PHYS(DRC_SEG_ES));
			else gen_call_function_m((void*)&dynrec_stosw_word,(Bitu)DRCD_SEG_PHYS(DRC_SEG_ES));
			break;
		case STR_STOSD:
			if (decode.big_addr) gen_call_function_m((void*)&dynrec_stosd_dword,(Bitu)DRCD_SEG_PHYS(DRC_SEG_ES));
			else gen_call_function_m((void*)&dynrec_stosd_word,(Bitu)DRCD_SEG_PHYS(DRC_SEG_ES));
			break;
		default: IllegalOptionDynrec("dyn_string");
	}
	if (decode.rep) gen_mov_word_from_reg(FC_RETOP,DRCD_REG_WORD(DRC_REG_ECX,decode.big_addr),decode.big_addr);

	if (op<STR_SCASB) {
		// those string operations are allowed for premature termination
		// when not enough cycles left
		if (!decode.big_addr) gen_extend_word(false,FC_RETOP);
		save_info_dynrec[used_save_info_dynrec].branch_pos=gen_create_branch_long_nonzero(FC_RETOP,true);
		save_info_dynrec[used_save_info_dynrec].eip_change=decode.op_start-decode.code_start;
		save_info_dynrec[used_save_info_dynrec].type=string_break;
		used_save_info_dynrec++;
	}
}


static void dyn_read_port_byte_direct(Bit8u port) {
	dyn_add_iocheck_var(port,1);
	gen_call_function_I((void*)&IO_ReadB,port);
	gen_mov_byte_from_reg_low(FC_RETOP,DRCD_REG_BYTE(DRC_REG_EAX,0));
}

static void dyn_read_port_word_direct(Bit8u port) {
	dyn_add_iocheck_var(port,decode.big_op?4:2);
	gen_call_function_I(decode.big_op?((void*)&IO_ReadD):((void*)&IO_ReadW),port);
	gen_mov_word_from_reg(FC_RETOP,DRCD_REG_BYTE(DRC_REG_EAX,decode.big_op),decode.big_op);
}

static void dyn_write_port_byte_direct(Bit8u port) {
	dyn_add_iocheck_var(port,1);
	gen_mov_byte_to_reg_low(FC_RETOP,DRCD_REG_BYTE(DRC_REG_EAX,0));
	gen_extend_byte(false,FC_RETOP);
	gen_call_function_IR((void*)&IO_WriteB,port,FC_RETOP);
}

static void dyn_write_port_word_direct(Bit8u port) {
	dyn_add_iocheck_var(port,decode.big_op?4:2);
	gen_mov_word_to_reg(FC_RETOP,DRCD_REG_WORD(DRC_REG_EAX,decode.big_op),decode.big_op);
	if (!decode.big_op) gen_extend_word(false,FC_RETOP);
	gen_call_function_IR(decode.big_op?((void*)&IO_WriteD):((void*)&IO_WriteW),port,FC_RETOP);
}


static void dyn_read_port_byte(void) {
	gen_mov_word_to_reg(FC_ADDR,DRCD_REG_WORD(DRC_REG_EDX,false),false);
	gen_extend_word(false,FC_ADDR);
	if (cpu.pmode) gen_protect_addr_reg();
	dyn_add_iocheck(FC_ADDR,1);
	if (cpu.pmode) gen_restore_addr_reg();
	gen_call_function_R((void*)&IO_ReadB,FC_ADDR);
	gen_mov_byte_from_reg_low(FC_RETOP,DRCD_REG_BYTE(DRC_REG_EAX,0));
}

static void dyn_read_port_word(void) {
	gen_mov_word_to_reg(FC_ADDR,DRCD_REG_WORD(DRC_REG_EDX,false),false);
	gen_extend_word(false,FC_ADDR);
	if (cpu.pmode) gen_protect_addr_reg();
	dyn_add_iocheck(FC_ADDR,decode.big_op?4:2);
	if (cpu.pmode) gen_restore_addr_reg();
	gen_call_function_R(decode.big_op?((void*)&IO_ReadD):((void*)&IO_ReadW),FC_ADDR);
	gen_mov_word_from_reg(FC_RETOP,DRCD_REG_BYTE(DRC_REG_EAX,decode.big_op),decode.big_op);
}

static void dyn_write_port_byte(void) {
	gen_mov_word_to_reg(FC_ADDR,DRCD_REG_WORD(DRC_REG_EDX,false),false);
	gen_extend_word(false,FC_ADDR);
	if (cpu.pmode) gen_protect_addr_reg();
	dyn_add_iocheck(FC_ADDR,1);
	gen_mov_byte_to_reg_low(FC_RETOP,DRCD_REG_BYTE(DRC_REG_EAX,0));
	gen_extend_byte(false,FC_RETOP);
	if (cpu.pmode) gen_restore_addr_reg();
	gen_call_function_RR((void*)&IO_WriteB,FC_ADDR,FC_RETOP);
}

static void dyn_write_port_word(void) {
	gen_mov_word_to_reg(FC_ADDR,DRCD_REG_WORD(DRC_REG_EDX,false),false);
	gen_extend_word(false,FC_ADDR);
	if (cpu.pmode) gen_protect_addr_reg();
	dyn_add_iocheck(FC_ADDR,decode.big_op?4:2);
	gen_mov_word_to_reg(FC_RETOP,DRCD_REG_WORD(DRC_REG_EAX,decode.big_op),decode.big_op);
	if (!decode.big_op) gen_extend_word(false,FC_RETOP);
	if (cpu.pmode) gen_restore_addr_reg();
	gen_call_function_RR(decode.big_op?((void*)&IO_WriteD):((void*)&IO_WriteW),FC_ADDR,FC_RETOP);
}


static void dyn_enter(void) {
	Bitu bytes=decode_fetchw();
	Bitu level=decode_fetchb();
	gen_call_function_III((void *)&CPU_ENTER,decode.big_op,bytes,level);
}

static void dynrec_leave_word(void) {
	reg_esp&=cpu.stack.notmask;
	reg_esp|=(reg_ebp&cpu.stack.mask);
	reg_bp=(Bit16u)CPU_Pop16();
}

static void dynrec_leave_dword(void) {
	reg_esp&=cpu.stack.notmask;
	reg_esp|=(reg_ebp&cpu.stack.mask);
	reg_ebp=CPU_Pop32();
}

static void dyn_leave(void) {
	if (decode.big_op) gen_call_function_raw((void *)dynrec_leave_dword);
	else gen_call_function_raw((void *)dynrec_leave_word);
}


static void dynrec_pusha_word(void) {
	Bit16u old_sp=reg_sp;
	CPU_Push16(reg_ax);CPU_Push16(reg_cx);CPU_Push16(reg_dx);CPU_Push16(reg_bx);
	CPU_Push16(old_sp);CPU_Push16(reg_bp);CPU_Push16(reg_si);CPU_Push16(reg_di);
}

static void dynrec_pusha_dword(void) {
	Bitu tmpesp = reg_esp;
	CPU_Push32(reg_eax);CPU_Push32(reg_ecx);CPU_Push32(reg_edx);CPU_Push32(reg_ebx);
	CPU_Push32(tmpesp);CPU_Push32(reg_ebp);CPU_Push32(reg_esi);CPU_Push32(reg_edi);
}

static void dynrec_popa_word(void) {
	reg_di=(Bit16u)CPU_Pop16();reg_si=(Bit16u)CPU_Pop16();
	reg_bp=(Bit16u)CPU_Pop16();CPU_Pop16();		//Don't save SP
	reg_bx=(Bit16u)CPU_Pop16();reg_dx=(Bit16u)CPU_Pop16();
	reg_cx=(Bit16u)CPU_Pop16();reg_ax=(Bit16u)CPU_Pop16();
}

static void dynrec_popa_dword(void) {
	reg_edi=CPU_Pop32();reg_esi=CPU_Pop32();reg_ebp=CPU_Pop32();CPU_Pop32();	//Don't save ESP
	reg_ebx=CPU_Pop32();reg_edx=CPU_Pop32();reg_ecx=CPU_Pop32();reg_eax=CPU_Pop32();
}