+2010-09-12 Klaus Treichel <ktreichel@web.de>
+
+ * config/jit-opcodes.ops: Remove the *eq_inv and *ne_inv float
+ compare a branch opcodes because they behave exactly the same as
+ the corresponding opcodes without the _INV suffix.
+ Add macros to map the removed opcodes to their counterparts without
+ the _INV suffix.
+
+ * jit/jit-insn.c (jit_insn_to_not_bool): Replace the mappings
+ to *EQ_INV and *NE_INV by mappings to *EQ and *NE.
+ Remove the mappings for *EQ_INV and *NE_INV.
+ (jit_insn_branch_if): likwise
+ (jit_insn_branch_if_not): likewise
+
+ * jit/jit-interp.c (_jit_run_function): Remove handling of
+ the *EQ_INV and *NE_INV opcodes.
+
+ * jt/jit-rules-interp.c (_jit_gen_insn): Remove the *EQ_INV
+ and *NE_INV cases.
+
+ * jit/jit-rules-x86-64.ins.c: Remove handling of the *EQ_INV and *NE_INV
+ opcodes.
+
2010-08-10 Klaus Treichel <ktreichel@web.de>
* config/jit-opcodes.ops: Fix arg1 for the address_of opcode.
op_def("br_fle", <=) { op_type(branch), op_values(empty, float32, float32) }
op_def("br_fgt", >) { op_type(branch), op_values(empty, float32, float32) }
op_def("br_fge", >=) { op_type(branch), op_values(empty, float32, float32) }
- op_def("br_feq_inv") { op_type(branch), op_values(empty, float32, float32) }
- op_def("br_fne_inv") { op_type(branch), op_values(empty, float32, float32) }
op_def("br_flt_inv") { op_type(branch), op_values(empty, float32, float32) }
op_def("br_fle_inv") { op_type(branch), op_values(empty, float32, float32) }
op_def("br_fgt_inv") { op_type(branch), op_values(empty, float32, float32) }
op_def("br_dle", <=) { op_type(branch), op_values(empty, float64, float64) }
op_def("br_dgt", >) { op_type(branch), op_values(empty, float64, float64) }
op_def("br_dge", >=) { op_type(branch), op_values(empty, float64, float64) }
- op_def("br_deq_inv") { op_type(branch), op_values(empty, float64, float64) }
- op_def("br_dne_inv") { op_type(branch), op_values(empty, float64, float64) }
op_def("br_dlt_inv") { op_type(branch), op_values(empty, float64, float64) }
op_def("br_dle_inv") { op_type(branch), op_values(empty, float64, float64) }
op_def("br_dgt_inv") { op_type(branch), op_values(empty, float64, float64) }
op_def("br_nfle", <=) { op_type(branch), op_values(empty, nfloat, nfloat) }
op_def("br_nfgt", >) { op_type(branch), op_values(empty, nfloat, nfloat) }
op_def("br_nfge", >=) { op_type(branch), op_values(empty, nfloat, nfloat) }
- op_def("br_nfeq_inv") { op_type(branch), op_values(empty, nfloat, nfloat) }
- op_def("br_nfne_inv") { op_type(branch), op_values(empty, nfloat, nfloat) }
op_def("br_nflt_inv") { op_type(branch), op_values(empty, nfloat, nfloat) }
op_def("br_nfle_inv") { op_type(branch), op_values(empty, nfloat, nfloat) }
op_def("br_nfgt_inv") { op_type(branch), op_values(empty, nfloat, nfloat) }
op_def("fle", <=) { op_values(int, float32, float32) }
op_def("fgt", >) { op_values(int, float32, float32) }
op_def("fge", >=) { op_values(int, float32, float32) }
- op_def("feq_inv") { op_values(int, float32, float32) }
- op_def("fne_inv") { op_values(int, float32, float32) }
op_def("flt_inv") { op_values(int, float32, float32) }
op_def("fle_inv") { op_values(int, float32, float32) }
op_def("fgt_inv") { op_values(int, float32, float32) }
op_def("dle", <=) { op_values(int, float64, float64) }
op_def("dgt", >) { op_values(int, float64, float64) }
op_def("dge", >=) { op_values(int, float64, float64) }
- op_def("deq_inv") { op_values(int, float64, float64) }
- op_def("dne_inv") { op_values(int, float64, float64) }
op_def("dlt_inv") { op_values(int, float64, float64) }
op_def("dle_inv") { op_values(int, float64, float64) }
op_def("dgt_inv") { op_values(int, float64, float64) }
op_def("nfle", <=) { op_values(int, nfloat, nfloat) }
op_def("nfgt", >) { op_values(int, nfloat, nfloat) }
op_def("nfge", >=) { op_values(int, nfloat, nfloat) }
- op_def("nfeq_inv") { op_values(int, nfloat, nfloat) }
- op_def("nfne_inv") { op_values(int, nfloat, nfloat) }
op_def("nflt_inv") { op_values(int, nfloat, nfloat) }
op_def("nfle_inv") { op_values(int, nfloat, nfloat) }
op_def("nfgt_inv") { op_values(int, nfloat, nfloat) }
#endif
JIT_EXPORT_DATA jit_opcode_info_t const jit_opcodes[JIT_OP_NUM_OPCODES];
+/*
+ * Some obsolete opcodes that have been removed because they are duplicates
+ * of other opcodes.
+ */
+#define JIT_OP_FEQ_INV JIT_OP_FEQ
+#define JIT_OP_FNE_INV JIT_OP_FNE
+#define JIT_OP_DEQ_INV JIT_OP_DEQ
+#define JIT_OP_DNE_INV JIT_OP_DNE
+#define JIT_OP_NFEQ_INV JIT_OP_NFEQ
+#define JIT_OP_NFNE_INV JIT_OP_NFNE
+#define JIT_OP_BR_FEQ_INV JIT_OP_BR_FEQ
+#define JIT_OP_BR_FNE_INV JIT_OP_BR_NFE
+#define JIT_OP_BR_DEQ_INV JIT_OP_BR_DEQ
+#define JIT_OP_BR_DNE_INV JIT_OP_BR_DNE
+#define JIT_OP_BR_NFEQ_INV JIT_OP_BR_NFEQ
+#define JIT_OP_BR_NFNE_INV JIT_OP_BR_NFNE
+
#ifdef __cplusplus
};
#endif
case JIT_OP_LGT_UN: opcode = JIT_OP_LLE_UN; break;
case JIT_OP_LGE: opcode = JIT_OP_LLT; break;
case JIT_OP_LGE_UN: opcode = JIT_OP_LLT_UN; break;
- case JIT_OP_FEQ: opcode = JIT_OP_FNE_INV; break;
- case JIT_OP_FNE: opcode = JIT_OP_FEQ_INV; break;
+ case JIT_OP_FEQ: opcode = JIT_OP_FNE; break;
+ case JIT_OP_FNE: opcode = JIT_OP_FEQ; break;
case JIT_OP_FLT: opcode = JIT_OP_FGE_INV; break;
case JIT_OP_FLE: opcode = JIT_OP_FGT_INV; break;
case JIT_OP_FGT: opcode = JIT_OP_FLE_INV; break;
case JIT_OP_FGE: opcode = JIT_OP_FLT_INV; break;
- case JIT_OP_FEQ_INV: opcode = JIT_OP_FNE; break;
- case JIT_OP_FNE_INV: opcode = JIT_OP_FEQ; break;
case JIT_OP_FLT_INV: opcode = JIT_OP_FGE; break;
case JIT_OP_FLE_INV: opcode = JIT_OP_FGT; break;
case JIT_OP_FGT_INV: opcode = JIT_OP_FLE; break;
case JIT_OP_FGE_INV: opcode = JIT_OP_FLT; break;
- case JIT_OP_DEQ: opcode = JIT_OP_DNE_INV; break;
- case JIT_OP_DNE: opcode = JIT_OP_DEQ_INV; break;
+ case JIT_OP_DEQ: opcode = JIT_OP_DNE; break;
+ case JIT_OP_DNE: opcode = JIT_OP_DEQ; break;
case JIT_OP_DLT: opcode = JIT_OP_DGE_INV; break;
case JIT_OP_DLE: opcode = JIT_OP_DGT_INV; break;
case JIT_OP_DGT: opcode = JIT_OP_DLE_INV; break;
case JIT_OP_DGE: opcode = JIT_OP_DLT_INV; break;
- case JIT_OP_DEQ_INV: opcode = JIT_OP_DNE; break;
- case JIT_OP_DNE_INV: opcode = JIT_OP_DEQ; break;
case JIT_OP_DLT_INV: opcode = JIT_OP_DGE; break;
case JIT_OP_DLE_INV: opcode = JIT_OP_DGT; break;
case JIT_OP_DGT_INV: opcode = JIT_OP_DLE; break;
case JIT_OP_DGE_INV: opcode = JIT_OP_DLT; break;
- case JIT_OP_NFEQ: opcode = JIT_OP_NFNE_INV; break;
- case JIT_OP_NFNE: opcode = JIT_OP_NFEQ_INV; break;
+ case JIT_OP_NFEQ: opcode = JIT_OP_NFNE; break;
+ case JIT_OP_NFNE: opcode = JIT_OP_NFEQ; break;
case JIT_OP_NFLT: opcode = JIT_OP_NFGE_INV; break;
case JIT_OP_NFLE: opcode = JIT_OP_NFGT_INV; break;
case JIT_OP_NFGT: opcode = JIT_OP_NFLE_INV; break;
case JIT_OP_NFGE: opcode = JIT_OP_NFLT_INV; break;
- case JIT_OP_NFEQ_INV: opcode = JIT_OP_NFNE; break;
- case JIT_OP_NFNE_INV: opcode = JIT_OP_NFEQ; break;
case JIT_OP_NFLT_INV: opcode = JIT_OP_NFGE; break;
case JIT_OP_NFLE_INV: opcode = JIT_OP_NFGT; break;
case JIT_OP_NFGT_INV: opcode = JIT_OP_NFLE; break;
case JIT_OP_FLE: opcode = JIT_OP_BR_FLE; break;
case JIT_OP_FGT: opcode = JIT_OP_BR_FGT; break;
case JIT_OP_FGE: opcode = JIT_OP_BR_FGE; break;
- case JIT_OP_FEQ_INV: opcode = JIT_OP_BR_FEQ_INV; break;
- case JIT_OP_FNE_INV: opcode = JIT_OP_BR_FNE_INV; break;
case JIT_OP_FLT_INV: opcode = JIT_OP_BR_FLT_INV; break;
case JIT_OP_FLE_INV: opcode = JIT_OP_BR_FLE_INV; break;
case JIT_OP_FGT_INV: opcode = JIT_OP_BR_FGT_INV; break;
case JIT_OP_DLE: opcode = JIT_OP_BR_DLE; break;
case JIT_OP_DGT: opcode = JIT_OP_BR_DGT; break;
case JIT_OP_DGE: opcode = JIT_OP_BR_DGE; break;
- case JIT_OP_DEQ_INV: opcode = JIT_OP_BR_DEQ_INV; break;
- case JIT_OP_DNE_INV: opcode = JIT_OP_BR_DNE_INV; break;
case JIT_OP_DLT_INV: opcode = JIT_OP_BR_DLT_INV; break;
case JIT_OP_DLE_INV: opcode = JIT_OP_BR_DLE_INV; break;
case JIT_OP_DGT_INV: opcode = JIT_OP_BR_DGT_INV; break;
case JIT_OP_NFLE: opcode = JIT_OP_BR_NFLE; break;
case JIT_OP_NFGT: opcode = JIT_OP_BR_NFGT; break;
case JIT_OP_NFGE: opcode = JIT_OP_BR_NFGE; break;
- case JIT_OP_NFEQ_INV: opcode = JIT_OP_BR_NFEQ_INV; break;
- case JIT_OP_NFNE_INV: opcode = JIT_OP_BR_NFNE_INV; break;
case JIT_OP_NFLT_INV: opcode = JIT_OP_BR_NFLT_INV; break;
case JIT_OP_NFLE_INV: opcode = JIT_OP_BR_NFLE_INV; break;
case JIT_OP_NFGT_INV: opcode = JIT_OP_BR_NFGT_INV; break;
case JIT_OP_LGT_UN: opcode = JIT_OP_BR_LLE_UN; break;
case JIT_OP_LGE: opcode = JIT_OP_BR_LLT; break;
case JIT_OP_LGE_UN: opcode = JIT_OP_BR_LLT_UN; break;
- case JIT_OP_FEQ: opcode = JIT_OP_BR_FNE_INV; break;
- case JIT_OP_FNE: opcode = JIT_OP_BR_FEQ_INV; break;
+ case JIT_OP_FEQ: opcode = JIT_OP_BR_FNE; break;
+ case JIT_OP_FNE: opcode = JIT_OP_BR_FEQ; break;
case JIT_OP_FLT: opcode = JIT_OP_BR_FGE_INV; break;
case JIT_OP_FLE: opcode = JIT_OP_BR_FGT_INV; break;
case JIT_OP_FGT: opcode = JIT_OP_BR_FLE_INV; break;
case JIT_OP_FGE: opcode = JIT_OP_BR_FLT_INV; break;
- case JIT_OP_FEQ_INV: opcode = JIT_OP_BR_FNE; break;
- case JIT_OP_FNE_INV: opcode = JIT_OP_BR_FEQ; break;
case JIT_OP_FLT_INV: opcode = JIT_OP_BR_FGE; break;
case JIT_OP_FLE_INV: opcode = JIT_OP_BR_FGT; break;
case JIT_OP_FGT_INV: opcode = JIT_OP_BR_FLE; break;
case JIT_OP_FGE_INV: opcode = JIT_OP_BR_FLT; break;
- case JIT_OP_DEQ: opcode = JIT_OP_BR_DNE_INV; break;
- case JIT_OP_DNE: opcode = JIT_OP_BR_DEQ_INV; break;
+ case JIT_OP_DEQ: opcode = JIT_OP_BR_DNE; break;
+ case JIT_OP_DNE: opcode = JIT_OP_BR_DEQ; break;
case JIT_OP_DLT: opcode = JIT_OP_BR_DGE_INV; break;
case JIT_OP_DLE: opcode = JIT_OP_BR_DGT_INV; break;
case JIT_OP_DGT: opcode = JIT_OP_BR_DLE_INV; break;
case JIT_OP_DGE: opcode = JIT_OP_BR_DLT_INV; break;
- case JIT_OP_DEQ_INV: opcode = JIT_OP_BR_DNE; break;
- case JIT_OP_DNE_INV: opcode = JIT_OP_BR_DEQ; break;
case JIT_OP_DLT_INV: opcode = JIT_OP_BR_DGE; break;
case JIT_OP_DLE_INV: opcode = JIT_OP_BR_DGT; break;
case JIT_OP_DGT_INV: opcode = JIT_OP_BR_DLE; break;
case JIT_OP_DGE_INV: opcode = JIT_OP_BR_DLT; break;
- case JIT_OP_NFEQ: opcode = JIT_OP_BR_NFNE_INV; break;
- case JIT_OP_NFNE: opcode = JIT_OP_BR_NFEQ_INV; break;
+ case JIT_OP_NFEQ: opcode = JIT_OP_BR_NFNE; break;
+ case JIT_OP_NFNE: opcode = JIT_OP_BR_NFEQ; break;
case JIT_OP_NFLT: opcode = JIT_OP_BR_NFGE_INV; break;
case JIT_OP_NFLE: opcode = JIT_OP_BR_NFGT_INV; break;
case JIT_OP_NFGT: opcode = JIT_OP_BR_NFLE_INV; break;
case JIT_OP_NFGE: opcode = JIT_OP_BR_NFLT_INV; break;
- case JIT_OP_NFEQ_INV: opcode = JIT_OP_BR_NFNE; break;
- case JIT_OP_NFNE_INV: opcode = JIT_OP_BR_NFEQ; break;
case JIT_OP_NFLT_INV: opcode = JIT_OP_BR_NFGE; break;
case JIT_OP_NFLE_INV: opcode = JIT_OP_BR_NFGT; break;
case JIT_OP_NFGT_INV: opcode = JIT_OP_BR_NFLE; break;
}
else if(type == jit_type_float32)
{
- opcode = JIT_OP_BR_FEQ_INV;
+ opcode = JIT_OP_BR_FEQ;
value2 = jit_value_create_float32_constant
(func, jit_type_float32, (jit_float32)0.0);
if(!value2)
}
else if(type == jit_type_float64)
{
- opcode = JIT_OP_BR_DEQ_INV;
+ opcode = JIT_OP_BR_DEQ;
value2 = jit_value_create_float64_constant
(func, jit_type_float64, (jit_float64)0.0);
if(!value2)
else
{
type = jit_type_nfloat;
- opcode = JIT_OP_BR_NFEQ_INV;
+ opcode = JIT_OP_BR_NFEQ;
value2 = jit_value_create_nfloat_constant
(func, jit_type_nfloat, (jit_nfloat)0.0);
if(!value2)
* @end deftypefun
@*/
jit_value_t jit_insn_convert(jit_function_t func, jit_value_t value,
- jit_type_t type, int overflow_check)
+ jit_type_t type, int overflow_check)
{
jit_type_t vtype;
const jit_convert_info_t *opcode_map;
jit_constant_t const_value;
const_value = jit_value_get_constant(value);
if(jit_constant_convert(&const_value, &const_value,
- type, overflow_check))
+ type, overflow_check))
{
return jit_value_create_constant(func, &const_value);
}
}
VMBREAK;
- VMCASE(JIT_OP_BR_FEQ_INV):
- {
- /* Branch if 32-bit floats are equal; invert nan test */
- if(!jit_float32_ne(VM_R1_FLOAT32, VM_R2_FLOAT32))
- {
- pc = VM_BR_TARGET;
- }
- else
- {
- VM_MODIFY_PC(2);
- }
- }
- VMBREAK;
-
- VMCASE(JIT_OP_BR_FNE_INV):
- {
- /* Branch if 32-bit floats are not equal; invert nan test */
- if(!jit_float32_eq(VM_R1_FLOAT32, VM_R2_FLOAT32))
- {
- pc = VM_BR_TARGET;
- }
- else
- {
- VM_MODIFY_PC(2);
- }
- }
- VMBREAK;
-
VMCASE(JIT_OP_BR_FLT_INV):
{
/* Branch if 32-bit floats are less than; invert nan test */
}
VMBREAK;
- VMCASE(JIT_OP_BR_DEQ_INV):
- {
- /* Branch if 64-bit floats are equal; invert nan test */
- if(!jit_float64_ne(VM_R1_FLOAT64, VM_R2_FLOAT64))
- {
- pc = VM_BR_TARGET;
- }
- else
- {
- VM_MODIFY_PC(2);
- }
- }
- VMBREAK;
-
- VMCASE(JIT_OP_BR_DNE_INV):
- {
- /* Branch if 64-bit floats are not equal; invert nan test */
- if(!jit_float64_eq(VM_R1_FLOAT64, VM_R2_FLOAT64))
- {
- pc = VM_BR_TARGET;
- }
- else
- {
- VM_MODIFY_PC(2);
- }
- }
- VMBREAK;
-
VMCASE(JIT_OP_BR_DLT_INV):
{
/* Branch if 64-bit floats are less than; invert nan test */
}
VMBREAK;
- VMCASE(JIT_OP_BR_NFEQ_INV):
- {
- /* Branch if native floats are equal; invert nan test */
- if(!jit_nfloat_ne(VM_R1_NFLOAT, VM_R2_NFLOAT))
- {
- pc = VM_BR_TARGET;
- }
- else
- {
- VM_MODIFY_PC(2);
- }
- }
- VMBREAK;
-
- VMCASE(JIT_OP_BR_NFNE_INV):
- {
- /* Branch if native floats are not equal; invert nan test */
- if(!jit_nfloat_eq(VM_R1_NFLOAT, VM_R2_NFLOAT))
- {
- pc = VM_BR_TARGET;
- }
- else
- {
- VM_MODIFY_PC(2);
- }
- }
- VMBREAK;
-
VMCASE(JIT_OP_BR_NFLT_INV):
{
/* Branch if native floats are less than; invert nan test */
}
VMBREAK;
- VMCASE(JIT_OP_FEQ_INV):
- {
- /* Compare 32-bit floats for equal; invert nan test */
- VM_R0_INT = !jit_float32_ne(VM_R1_FLOAT32, VM_R2_FLOAT32);
- VM_MODIFY_PC(1);
- }
- VMBREAK;
-
- VMCASE(JIT_OP_FNE_INV):
- {
- /* Compare 32-bit floats for not equal; invert nan test */
- VM_R0_INT = !jit_float32_eq(VM_R1_FLOAT32, VM_R2_FLOAT32);
- VM_MODIFY_PC(1);
- }
- VMBREAK;
-
VMCASE(JIT_OP_FLT_INV):
{
/* Compare 32-bit floats for less than; invert nan test */
}
VMBREAK;
- VMCASE(JIT_OP_DEQ_INV):
- {
- /* Compare 64-bit floats for equal; invert nan test */
- VM_R0_INT = !jit_float64_ne(VM_R1_FLOAT64, VM_R2_FLOAT64);
- VM_MODIFY_PC(1);
- }
- VMBREAK;
-
- VMCASE(JIT_OP_DNE_INV):
- {
- /* Compare 64-bit floats for equal; invert nan test */
- VM_R0_INT = !jit_float64_eq(VM_R1_FLOAT64, VM_R2_FLOAT64);
- VM_MODIFY_PC(1);
- }
- VMBREAK;
-
VMCASE(JIT_OP_DLT_INV):
{
/* Compare 64-bit floats for equal; invert nan test */
}
VMBREAK;
- VMCASE(JIT_OP_NFEQ_INV):
- {
- /* Compare native floats for equal; invert nan test */
- VM_R0_INT = !jit_nfloat_ne(VM_R1_NFLOAT, VM_R2_NFLOAT);
- VM_MODIFY_PC(1);
- }
- VMBREAK;
-
- VMCASE(JIT_OP_NFNE_INV):
- {
- /* Compare native floats for not equal; invert nan test */
- VM_R0_INT = !jit_nfloat_eq(VM_R1_NFLOAT, VM_R2_NFLOAT);
- VM_MODIFY_PC(1);
- }
- VMBREAK;
-
VMCASE(JIT_OP_NFLT_INV):
{
/* Compare native floats for less than; invert nan test */
case JIT_OP_BR_FLE:
case JIT_OP_BR_FGT:
case JIT_OP_BR_FGE:
- case JIT_OP_BR_FEQ_INV:
- case JIT_OP_BR_FNE_INV:
case JIT_OP_BR_FLT_INV:
case JIT_OP_BR_FLE_INV:
case JIT_OP_BR_FGT_INV:
case JIT_OP_BR_DLE:
case JIT_OP_BR_DGT:
case JIT_OP_BR_DGE:
- case JIT_OP_BR_DEQ_INV:
- case JIT_OP_BR_DNE_INV:
case JIT_OP_BR_DLT_INV:
case JIT_OP_BR_DLE_INV:
case JIT_OP_BR_DGT_INV:
case JIT_OP_BR_NFLE:
case JIT_OP_BR_NFGT:
case JIT_OP_BR_NFGE:
- case JIT_OP_BR_NFEQ_INV:
- case JIT_OP_BR_NFNE_INV:
case JIT_OP_BR_NFLT_INV:
case JIT_OP_BR_NFLE_INV:
case JIT_OP_BR_NFGT_INV:
inst = output_branch(func, inst, 0x73 /* ge_un */, insn);
}
-JIT_OP_BR_FEQ, JIT_OP_BR_FEQ_INV: branch, commutative
+JIT_OP_BR_FEQ: branch, commutative
[xreg, imm] -> {
inst = xmm_cmp_brcc_reg_imm(gen, func, inst, X86_CC_Z, $1, (void *)$2, 0, 0, insn);
}
inst = xmm_cmp_brcc_reg_reg(func, inst, X86_CC_Z, $1, $2, 0, 0, insn);
}
-JIT_OP_BR_FNE, JIT_OP_BR_FNE_INV: branch, commutative
+JIT_OP_BR_FNE: branch, commutative
[xreg, imm] -> {
inst = xmm_cmp_brcc_reg_imm(gen, func, inst, X86_CC_NZ, $1, (void *)$2, 0, 1, insn);
}
inst = xmm_cmp_brcc_reg_reg(func, inst, X86_CC_NC, $1, $2, 0, 1, insn);
}
-JIT_OP_BR_DEQ, JIT_OP_BR_DEQ_INV: branch, commutative
+JIT_OP_BR_DEQ: branch, commutative
[xreg, imm] -> {
inst = xmm_cmp_brcc_reg_imm(gen, func, inst, X86_CC_Z, $1, (void *)$2, 1, 0, insn);
}
inst = xmm_cmp_brcc_reg_reg(func, inst, X86_CC_Z, $1, $2, 1, 0, insn);
}
-JIT_OP_BR_DNE, JIT_OP_BR_DNE_INV: branch, commutative
+JIT_OP_BR_DNE: branch, commutative
[xreg, imm] -> {
inst = xmm_cmp_brcc_reg_imm(gen, func, inst, X86_CC_NZ, $1, (void *)$2, 1, 1, insn);
}
inst = setcc_reg(inst, $1, X86_CC_GE, 0);
}
-JIT_OP_FEQ, JIT_OP_FEQ_INV: commutative
+JIT_OP_FEQ: commutative
[=+reg, xreg, imm, scratch reg, space("23")] -> {
inst = xmm_cmp_setcc_reg_imm(gen, inst, $1, X86_CC_Z, $2, (void *)$3, $4, 0, 0);
}
inst = xmm_cmp_setcc_reg_reg(inst, $1, X86_CC_Z, $2, $3, $4, 0, 0);
}
-JIT_OP_FNE, JIT_OP_FNE_INV: commutative
+JIT_OP_FNE: commutative
[=+reg, xreg, imm, scratch reg, space("23")] -> {
inst = xmm_cmp_setcc_reg_imm(gen, inst, $1, X86_CC_NZ, $2, (void *)$3, $4, 0, 1);
}
inst = xmm_cmp_setcc_reg_reg(inst, $1, X86_CC_NC, $2, $3, $4, 0, 1);
}
-JIT_OP_DEQ, JIT_OP_DEQ_INV: commutative
+JIT_OP_DEQ: commutative
[=+reg, xreg, imm, scratch reg, space("24")] -> {
inst = xmm_cmp_setcc_reg_imm(gen, inst, $1, X86_CC_Z, $2, (void *)$3, $4, 1, 0);
}
inst = xmm_cmp_setcc_reg_reg(inst, $1, X86_CC_Z, $2, $3, $4, 1, 0);
}
-JIT_OP_DNE, JIT_OP_DNE_INV: commutative
+JIT_OP_DNE: commutative
[=+reg, xreg, imm, scratch reg, space("24")] -> {
inst = xmm_cmp_setcc_reg_imm(gen, inst, $1, X86_CC_NZ, $2, (void *)$3, $4, 1, 1);
}
projects / francis / libjit.git / commitdiff