target-i386/cc_helper.c - qemu - Git at Google

 /*
  *  x86 condition code helpers
  *
  *  Copyright (c) 2003 Fabrice Bellard
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library 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
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  */

 #include "cpu.h"
 #include "helper.h"

 const uint8_t parity_table[256] = {
     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
 };

 #define SHIFT 0
 #include "cc_helper_template.h"
 #undef SHIFT

 #define SHIFT 1
 #include "cc_helper_template.h"
 #undef SHIFT

 #define SHIFT 2
 #include "cc_helper_template.h"
 #undef SHIFT

 #ifdef TARGET_X86_64

 #define SHIFT 3
 #include "cc_helper_template.h"
 #undef SHIFT

 #endif

 static target_ulong compute_all_adcx(target_ulong dst, target_ulong src1,
                                      target_ulong src2)
 {
     return (src1 & ~CC_C) | (dst * CC_C);
 }

 static target_ulong compute_all_adox(target_ulong dst, target_ulong src1,
                                      target_ulong src2)
 {
     return (src1 & ~CC_O) | (src2 * CC_O);
 }

 static target_ulong compute_all_adcox(target_ulong dst, target_ulong src1,
                                       target_ulong src2)
 {
     return (src1 & ~(CC_C | CC_O)) | (dst * CC_C) | (src2 * CC_O);
 }

 target_ulong helper_cc_compute_all(target_ulong dst, target_ulong src1,
                                    target_ulong src2, int op)
 {
     switch (op) {
     default: /* should never happen */
         return 0;

     case CC_OP_EFLAGS:
         return src1;
     case CC_OP_CLR:
         return CC_Z;

     case CC_OP_MULB:
         return compute_all_mulb(dst, src1);
     case CC_OP_MULW:
         return compute_all_mulw(dst, src1);
     case CC_OP_MULL:
         return compute_all_mull(dst, src1);

     case CC_OP_ADDB:
         return compute_all_addb(dst, src1);
     case CC_OP_ADDW:
         return compute_all_addw(dst, src1);
     case CC_OP_ADDL:
         return compute_all_addl(dst, src1);

     case CC_OP_ADCB:
         return compute_all_adcb(dst, src1, src2);
     case CC_OP_ADCW:
         return compute_all_adcw(dst, src1, src2);
     case CC_OP_ADCL:
         return compute_all_adcl(dst, src1, src2);

     case CC_OP_SUBB:
         return compute_all_subb(dst, src1);
     case CC_OP_SUBW:
         return compute_all_subw(dst, src1);
     case CC_OP_SUBL:
         return compute_all_subl(dst, src1);

     case CC_OP_SBBB:
         return compute_all_sbbb(dst, src1, src2);
     case CC_OP_SBBW:
         return compute_all_sbbw(dst, src1, src2);
     case CC_OP_SBBL:
         return compute_all_sbbl(dst, src1, src2);

     case CC_OP_LOGICB:
         return compute_all_logicb(dst, src1);
     case CC_OP_LOGICW:
         return compute_all_logicw(dst, src1);
     case CC_OP_LOGICL:
         return compute_all_logicl(dst, src1);

     case CC_OP_INCB:
         return compute_all_incb(dst, src1);
     case CC_OP_INCW:
         return compute_all_incw(dst, src1);
     case CC_OP_INCL:
         return compute_all_incl(dst, src1);

     case CC_OP_DECB:
         return compute_all_decb(dst, src1);
     case CC_OP_DECW:
         return compute_all_decw(dst, src1);
     case CC_OP_DECL:
         return compute_all_decl(dst, src1);

     case CC_OP_SHLB:
         return compute_all_shlb(dst, src1);
     case CC_OP_SHLW:
         return compute_all_shlw(dst, src1);
     case CC_OP_SHLL:
         return compute_all_shll(dst, src1);

     case CC_OP_SARB:
         return compute_all_sarb(dst, src1);
     case CC_OP_SARW:
         return compute_all_sarw(dst, src1);
     case CC_OP_SARL:
         return compute_all_sarl(dst, src1);

     case CC_OP_BMILGB:
         return compute_all_bmilgb(dst, src1);
     case CC_OP_BMILGW:
         return compute_all_bmilgw(dst, src1);
     case CC_OP_BMILGL:
         return compute_all_bmilgl(dst, src1);

     case CC_OP_ADCX:
         return compute_all_adcx(dst, src1, src2);
     case CC_OP_ADOX:
         return compute_all_adox(dst, src1, src2);
     case CC_OP_ADCOX:
         return compute_all_adcox(dst, src1, src2);

 #ifdef TARGET_X86_64
     case CC_OP_MULQ:
         return compute_all_mulq(dst, src1);
     case CC_OP_ADDQ:
         return compute_all_addq(dst, src1);
     case CC_OP_ADCQ:
         return compute_all_adcq(dst, src1, src2);
     case CC_OP_SUBQ:
         return compute_all_subq(dst, src1);
     case CC_OP_SBBQ:
         return compute_all_sbbq(dst, src1, src2);
     case CC_OP_LOGICQ:
         return compute_all_logicq(dst, src1);
     case CC_OP_INCQ:
         return compute_all_incq(dst, src1);
     case CC_OP_DECQ:
         return compute_all_decq(dst, src1);
     case CC_OP_SHLQ:
         return compute_all_shlq(dst, src1);
     case CC_OP_SARQ:
         return compute_all_sarq(dst, src1);
     case CC_OP_BMILGQ:
         return compute_all_bmilgq(dst, src1);
 #endif
     }
 }

 uint32_t cpu_cc_compute_all(CPUX86State *env, int op)
 {
     return helper_cc_compute_all(CC_DST, CC_SRC, CC_SRC2, op);
 }

 target_ulong helper_cc_compute_c(target_ulong dst, target_ulong src1,
                                  target_ulong src2, int op)
 {
     switch (op) {
     default: /* should never happen */
     case CC_OP_LOGICB:
     case CC_OP_LOGICW:
     case CC_OP_LOGICL:
     case CC_OP_LOGICQ:
     case CC_OP_CLR:
         return 0;

     case CC_OP_EFLAGS:
     case CC_OP_SARB:
     case CC_OP_SARW:
     case CC_OP_SARL:
     case CC_OP_SARQ:
     case CC_OP_ADOX:
         return src1 & 1;

     case CC_OP_INCB:
     case CC_OP_INCW:
     case CC_OP_INCL:
     case CC_OP_INCQ:
     case CC_OP_DECB:
     case CC_OP_DECW:
     case CC_OP_DECL:
     case CC_OP_DECQ:
         return src1;

     case CC_OP_MULB:
     case CC_OP_MULW:
     case CC_OP_MULL:
     case CC_OP_MULQ:
         return src1 != 0;

     case CC_OP_ADCX:
     case CC_OP_ADCOX:
         return dst;

     case CC_OP_ADDB:
         return compute_c_addb(dst, src1);
     case CC_OP_ADDW:
         return compute_c_addw(dst, src1);
     case CC_OP_ADDL:
         return compute_c_addl(dst, src1);

     case CC_OP_ADCB:
         return compute_c_adcb(dst, src1, src2);
     case CC_OP_ADCW:
         return compute_c_adcw(dst, src1, src2);
     case CC_OP_ADCL:
         return compute_c_adcl(dst, src1, src2);

     case CC_OP_SUBB:
         return compute_c_subb(dst, src1);
     case CC_OP_SUBW:
         return compute_c_subw(dst, src1);
     case CC_OP_SUBL:
         return compute_c_subl(dst, src1);

     case CC_OP_SBBB:
         return compute_c_sbbb(dst, src1, src2);
     case CC_OP_SBBW:
         return compute_c_sbbw(dst, src1, src2);
     case CC_OP_SBBL:
         return compute_c_sbbl(dst, src1, src2);

     case CC_OP_SHLB:
         return compute_c_shlb(dst, src1);
     case CC_OP_SHLW:
         return compute_c_shlw(dst, src1);
     case CC_OP_SHLL:
         return compute_c_shll(dst, src1);

     case CC_OP_BMILGB:
         return compute_c_bmilgb(dst, src1);
     case CC_OP_BMILGW:
         return compute_c_bmilgw(dst, src1);
     case CC_OP_BMILGL:
         return compute_c_bmilgl(dst, src1);

 #ifdef TARGET_X86_64
     case CC_OP_ADDQ:
         return compute_c_addq(dst, src1);
     case CC_OP_ADCQ:
         return compute_c_adcq(dst, src1, src2);
     case CC_OP_SUBQ:
         return compute_c_subq(dst, src1);
     case CC_OP_SBBQ:
         return compute_c_sbbq(dst, src1, src2);
     case CC_OP_SHLQ:
         return compute_c_shlq(dst, src1);
     case CC_OP_BMILGQ:
         return compute_c_bmilgq(dst, src1);
 #endif
     }
 }

 void helper_write_eflags(CPUX86State *env, target_ulong t0,
                          uint32_t update_mask)
 {
     cpu_load_eflags(env, t0, update_mask);
 }

 target_ulong helper_read_eflags(CPUX86State *env)
 {
     uint32_t eflags;

     eflags = cpu_cc_compute_all(env, CC_OP);
     eflags |= (DF & DF_MASK);
     eflags |= env->eflags & ~(VM_MASK | RF_MASK);
     return eflags;
 }

 void helper_clts(CPUX86State *env)
 {
     env->cr[0] &= ~CR0_TS_MASK;
     env->hflags &= ~HF_TS_MASK;
 }

 void helper_reset_rf(CPUX86State *env)
 {
     env->eflags &= ~RF_MASK;
 }

 void helper_cli(CPUX86State *env)
 {
     env->eflags &= ~IF_MASK;
 }

 void helper_sti(CPUX86State *env)
 {
     env->eflags |= IF_MASK;
 }

 void helper_clac(CPUX86State *env)
 {
     env->eflags &= ~AC_MASK;
 }

 void helper_stac(CPUX86State *env)
 {
     env->eflags |= AC_MASK;
 }

 #if 0
 /* vm86plus instructions */
 void helper_cli_vm(CPUX86State *env)
 {
     env->eflags &= ~VIF_MASK;
 }

 void helper_sti_vm(CPUX86State *env)
 {
     env->eflags |= VIF_MASK;
     if (env->eflags & VIP_MASK) {
         raise_exception(env, EXCP0D_GPF);
     }
 }
 #endif

 void helper_set_inhibit_irq(CPUX86State *env)
 {
     env->hflags |= HF_INHIBIT_IRQ_MASK;
 }

 void helper_reset_inhibit_irq(CPUX86State *env)
 {
     env->hflags &= ~HF_INHIBIT_IRQ_MASK;
 }
	/*
	* x86 condition code helpers
	*
	* Copyright (c) 2003 Fabrice Bellard
	*
	* This library is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Lesser General Public
	* License as published by the Free Software Foundation; either
	* version 2 of the License, or (at your option) any later version.
	*
	* This library 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
	* Lesser General Public License for more details.
	*
	* You should have received a copy of the GNU Lesser General Public
	* License along with this library; if not, see <http://www.gnu.org/licenses/>.
	*/

	#include "cpu.h"
	#include "helper.h"

	const uint8_t parity_table[256] = {
	CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
	0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
	0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
	CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
	0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
	CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
	CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
	0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
	0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
	CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
	CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
	0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
	CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
	0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
	0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
	CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
	0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
	CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
	CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
	0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
	CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
	0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
	0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
	CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
	CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
	0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
	0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
	CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
	0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
	CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
	CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
	0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
	};

	#define SHIFT 0
	#include "cc_helper_template.h"
	#undef SHIFT

	#define SHIFT 1
	#include "cc_helper_template.h"
	#undef SHIFT

	#define SHIFT 2
	#include "cc_helper_template.h"
	#undef SHIFT

	#ifdef TARGET_X86_64

	#define SHIFT 3
	#include "cc_helper_template.h"
	#undef SHIFT

	#endif

	static target_ulong compute_all_adcx(target_ulong dst, target_ulong src1,
	target_ulong src2)
	{
	return (src1 & ~CC_C) \| (dst * CC_C);
	}

	static target_ulong compute_all_adox(target_ulong dst, target_ulong src1,
	target_ulong src2)
	{
	return (src1 & ~CC_O) \| (src2 * CC_O);
	}

	static target_ulong compute_all_adcox(target_ulong dst, target_ulong src1,
	target_ulong src2)
	{
	return (src1 & ~(CC_C \| CC_O)) \| (dst * CC_C) \| (src2 * CC_O);
	}

	target_ulong helper_cc_compute_all(target_ulong dst, target_ulong src1,
	target_ulong src2, int op)
	{
	switch (op) {
	default: /* should never happen */
	return 0;

	case CC_OP_EFLAGS:
	return src1;
	case CC_OP_CLR:
	return CC_Z;

	case CC_OP_MULB:
	return compute_all_mulb(dst, src1);
	case CC_OP_MULW:
	return compute_all_mulw(dst, src1);
	case CC_OP_MULL:
	return compute_all_mull(dst, src1);

	case CC_OP_ADDB:
	return compute_all_addb(dst, src1);
	case CC_OP_ADDW:
	return compute_all_addw(dst, src1);
	case CC_OP_ADDL:
	return compute_all_addl(dst, src1);

	case CC_OP_ADCB:
	return compute_all_adcb(dst, src1, src2);
	case CC_OP_ADCW:
	return compute_all_adcw(dst, src1, src2);
	case CC_OP_ADCL:
	return compute_all_adcl(dst, src1, src2);

	case CC_OP_SUBB:
	return compute_all_subb(dst, src1);
	case CC_OP_SUBW:
	return compute_all_subw(dst, src1);
	case CC_OP_SUBL:
	return compute_all_subl(dst, src1);

	case CC_OP_SBBB:
	return compute_all_sbbb(dst, src1, src2);
	case CC_OP_SBBW:
	return compute_all_sbbw(dst, src1, src2);
	case CC_OP_SBBL:
	return compute_all_sbbl(dst, src1, src2);

	case CC_OP_LOGICB:
	return compute_all_logicb(dst, src1);
	case CC_OP_LOGICW:
	return compute_all_logicw(dst, src1);
	case CC_OP_LOGICL:
	return compute_all_logicl(dst, src1);

	case CC_OP_INCB:
	return compute_all_incb(dst, src1);
	case CC_OP_INCW:
	return compute_all_incw(dst, src1);
	case CC_OP_INCL:
	return compute_all_incl(dst, src1);

	case CC_OP_DECB:
	return compute_all_decb(dst, src1);
	case CC_OP_DECW:
	return compute_all_decw(dst, src1);
	case CC_OP_DECL:
	return compute_all_decl(dst, src1);

	case CC_OP_SHLB:
	return compute_all_shlb(dst, src1);
	case CC_OP_SHLW:
	return compute_all_shlw(dst, src1);
	case CC_OP_SHLL:
	return compute_all_shll(dst, src1);

	case CC_OP_SARB:
	return compute_all_sarb(dst, src1);
	case CC_OP_SARW:
	return compute_all_sarw(dst, src1);
	case CC_OP_SARL:
	return compute_all_sarl(dst, src1);

	case CC_OP_BMILGB:
	return compute_all_bmilgb(dst, src1);
	case CC_OP_BMILGW:
	return compute_all_bmilgw(dst, src1);
	case CC_OP_BMILGL:
	return compute_all_bmilgl(dst, src1);

	case CC_OP_ADCX:
	return compute_all_adcx(dst, src1, src2);
	case CC_OP_ADOX:
	return compute_all_adox(dst, src1, src2);
	case CC_OP_ADCOX:
	return compute_all_adcox(dst, src1, src2);

	#ifdef TARGET_X86_64
	case CC_OP_MULQ:
	return compute_all_mulq(dst, src1);
	case CC_OP_ADDQ:
	return compute_all_addq(dst, src1);
	case CC_OP_ADCQ:
	return compute_all_adcq(dst, src1, src2);
	case CC_OP_SUBQ:
	return compute_all_subq(dst, src1);
	case CC_OP_SBBQ:
	return compute_all_sbbq(dst, src1, src2);
	case CC_OP_LOGICQ:
	return compute_all_logicq(dst, src1);
	case CC_OP_INCQ:
	return compute_all_incq(dst, src1);
	case CC_OP_DECQ:
	return compute_all_decq(dst, src1);
	case CC_OP_SHLQ:
	return compute_all_shlq(dst, src1);
	case CC_OP_SARQ:
	return compute_all_sarq(dst, src1);
	case CC_OP_BMILGQ:
	return compute_all_bmilgq(dst, src1);
	#endif
	}
	}

	uint32_t cpu_cc_compute_all(CPUX86State *env, int op)
	{
	return helper_cc_compute_all(CC_DST, CC_SRC, CC_SRC2, op);
	}

	target_ulong helper_cc_compute_c(target_ulong dst, target_ulong src1,
	target_ulong src2, int op)
	{
	switch (op) {
	default: /* should never happen */
	case CC_OP_LOGICB:
	case CC_OP_LOGICW:
	case CC_OP_LOGICL:
	case CC_OP_LOGICQ:
	case CC_OP_CLR:
	return 0;

	case CC_OP_EFLAGS:
	case CC_OP_SARB:
	case CC_OP_SARW:
	case CC_OP_SARL:
	case CC_OP_SARQ:
	case CC_OP_ADOX:
	return src1 & 1;

	case CC_OP_INCB:
	case CC_OP_INCW:
	case CC_OP_INCL:
	case CC_OP_INCQ:
	case CC_OP_DECB:
	case CC_OP_DECW:
	case CC_OP_DECL:
	case CC_OP_DECQ:
	return src1;

	case CC_OP_MULB:
	case CC_OP_MULW:
	case CC_OP_MULL:
	case CC_OP_MULQ:
	return src1 != 0;

	case CC_OP_ADCX:
	case CC_OP_ADCOX:
	return dst;

	case CC_OP_ADDB:
	return compute_c_addb(dst, src1);
	case CC_OP_ADDW:
	return compute_c_addw(dst, src1);
	case CC_OP_ADDL:
	return compute_c_addl(dst, src1);

	case CC_OP_ADCB:
	return compute_c_adcb(dst, src1, src2);
	case CC_OP_ADCW:
	return compute_c_adcw(dst, src1, src2);
	case CC_OP_ADCL:
	return compute_c_adcl(dst, src1, src2);

	case CC_OP_SUBB:
	return compute_c_subb(dst, src1);
	case CC_OP_SUBW:
	return compute_c_subw(dst, src1);
	case CC_OP_SUBL:
	return compute_c_subl(dst, src1);

	case CC_OP_SBBB:
	return compute_c_sbbb(dst, src1, src2);
	case CC_OP_SBBW:
	return compute_c_sbbw(dst, src1, src2);
	case CC_OP_SBBL:
	return compute_c_sbbl(dst, src1, src2);

	case CC_OP_SHLB:
	return compute_c_shlb(dst, src1);
	case CC_OP_SHLW:
	return compute_c_shlw(dst, src1);
	case CC_OP_SHLL:
	return compute_c_shll(dst, src1);

	case CC_OP_BMILGB:
	return compute_c_bmilgb(dst, src1);
	case CC_OP_BMILGW:
	return compute_c_bmilgw(dst, src1);
	case CC_OP_BMILGL:
	return compute_c_bmilgl(dst, src1);

	#ifdef TARGET_X86_64
	case CC_OP_ADDQ:
	return compute_c_addq(dst, src1);
	case CC_OP_ADCQ:
	return compute_c_adcq(dst, src1, src2);
	case CC_OP_SUBQ:
	return compute_c_subq(dst, src1);
	case CC_OP_SBBQ:
	return compute_c_sbbq(dst, src1, src2);
	case CC_OP_SHLQ:
	return compute_c_shlq(dst, src1);
	case CC_OP_BMILGQ:
	return compute_c_bmilgq(dst, src1);
	#endif
	}
	}

	void helper_write_eflags(CPUX86State *env, target_ulong t0,
	uint32_t update_mask)
	{
	cpu_load_eflags(env, t0, update_mask);
	}

	target_ulong helper_read_eflags(CPUX86State *env)
	{
	uint32_t eflags;

	eflags = cpu_cc_compute_all(env, CC_OP);
	eflags \|= (DF & DF_MASK);
	eflags \|= env->eflags & ~(VM_MASK \| RF_MASK);
	return eflags;
	}

	void helper_clts(CPUX86State *env)
	{
	env->cr[0] &= ~CR0_TS_MASK;
	env->hflags &= ~HF_TS_MASK;
	}

	void helper_reset_rf(CPUX86State *env)
	{
	env->eflags &= ~RF_MASK;
	}

	void helper_cli(CPUX86State *env)
	{
	env->eflags &= ~IF_MASK;
	}

	void helper_sti(CPUX86State *env)
	{
	env->eflags \|= IF_MASK;
	}

	void helper_clac(CPUX86State *env)
	{
	env->eflags &= ~AC_MASK;
	}

	void helper_stac(CPUX86State *env)
	{
	env->eflags \|= AC_MASK;
	}

	#if 0
	/* vm86plus instructions */
	void helper_cli_vm(CPUX86State *env)
	{
	env->eflags &= ~VIF_MASK;
	}

	void helper_sti_vm(CPUX86State *env)
	{
	env->eflags \|= VIF_MASK;
	if (env->eflags & VIP_MASK) {
	raise_exception(env, EXCP0D_GPF);
	}
	}
	#endif

	void helper_set_inhibit_irq(CPUX86State *env)
	{
	env->hflags \|= HF_INHIBIT_IRQ_MASK;
	}

	void helper_reset_inhibit_irq(CPUX86State *env)
	{
	env->hflags &= ~HF_INHIBIT_IRQ_MASK;
	}