Separate "cold" parts of comparison instructions

diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
index 49f9003d31e6a542a76ae9a9dcb69d80a448b5e4..7e2497c3a89d66b68556cba4c68d310aa8c2858f 100644 (file)
--- a/Zend/zend_execute.c
+++ b/Zend/zend_execute.c
@@ -4518,6 +4518,14 @@ static zend_never_inline int ZEND_FASTCALL zend_quick_check_constant(
                        ZEND_VM_CONTINUE(); \
                } \
        } while (0)
+#define ZEND_VM_SMART_BRANCH_TRUE_JMPZ() do { \
+               ZEND_VM_SET_NEXT_OPCODE(opline + 2); \
+               ZEND_VM_CONTINUE(); \
+       } while (0)
+#define ZEND_VM_SMART_BRANCH_TRUE_JMPNZ() do { \
+               ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline + 1, (opline+1)->op2)); \
+               ZEND_VM_CONTINUE(); \
+       } while (0)
 #define ZEND_VM_SMART_BRANCH_FALSE() do { \
                if (EXPECTED((opline+1)->opcode == ZEND_JMPNZ)) { \
                        ZEND_VM_SET_NEXT_OPCODE(opline + 2); \
@@ -4527,6 +4535,14 @@ static zend_never_inline int ZEND_FASTCALL zend_quick_check_constant(
                        ZEND_VM_CONTINUE(); \
                } \
        } while (0)
+#define ZEND_VM_SMART_BRANCH_FALSE_JMPZ() do { \
+               ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline + 1, (opline+1)->op2)); \
+               ZEND_VM_CONTINUE(); \
+       } while (0)
+#define ZEND_VM_SMART_BRANCH_FALSE_JMPNZ() do { \
+               ZEND_VM_SET_NEXT_OPCODE(opline + 2); \
+               ZEND_VM_CONTINUE(); \
+       } while (0)
 #else
 # define ZEND_VM_REPEATABLE_OPCODE
 # define ZEND_VM_REPEAT_OPCODE(_opcode)

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index d3b14d70330e480b35aeb2f2d19d88b26c4eeaa1..98f6cd6966c22e52dff8a1d55ab85a5f4bc25560 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -475,6 +475,38 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(17, ZEND_IS_NOT_IDENTICAL, CONST|TMP|VAR|CV, CON
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+ZEND_VM_HELPER(zend_is_equal_helper, ANY, ANY, zval *op_1, zval *op_2)
+{
+       USE_OPLINE
+
+       SAVE_OPLINE();
+       if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
+               op_1 = ZVAL_UNDEFINED_OP1();
+       }
+       if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
+               op_2 = ZVAL_UNDEFINED_OP2();
+       }
+       compare_function(EX_VAR(opline->result.var), op_1, op_2);
+       if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
+               zval_ptr_dtor_nogc(op_1);
+       }
+       if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
+               zval_ptr_dtor_nogc(op_2);
+       }
+       if (UNEXPECTED(EG(exception))) {
+               HANDLE_EXCEPTION();
+       }
+       if (Z_LVAL_P(EX_VAR(opline->result.var)) == 0) {
+               ZEND_VM_SMART_BRANCH_TRUE();
+               ZVAL_TRUE(EX_VAR(opline->result.var));
+               ZEND_VM_NEXT_OPCODE();
+       } else {
+               ZEND_VM_SMART_BRANCH_FALSE();
+               ZVAL_FALSE(EX_VAR(opline->result.var));
+               ZEND_VM_NEXT_OPCODE();
+       }
+}
+
 ZEND_VM_COLD_CONSTCONST_HANDLER(18, ZEND_IS_EQUAL, CONST|TMPVAR|CV, CONST|TMPVAR|CV, SPEC(COMMUTATIVE))
 {
        USE_OPLINE
@@ -484,12 +516,20 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(18, ZEND_IS_EQUAL, CONST|TMPVAR|CV, CONST|TMPVAR
 
        op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
        op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
-       if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
+       if (ZEND_VM_SPEC && OP1_TYPE == IS_CONST && OP2_TYPE == IS_CONST) {
+               /* pass */
+       } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
                        if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
-                               ZEND_VM_C_GOTO(is_equal_true);
+ZEND_VM_C_LABEL(is_equal_true):
+                               ZEND_VM_SMART_BRANCH_TRUE();
+                               ZVAL_TRUE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        } else {
-                               ZEND_VM_C_GOTO(is_equal_false);
+ZEND_VM_C_LABEL(is_equal_false):
+                               ZEND_VM_SMART_BRANCH_FALSE();
+                               ZVAL_FALSE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -527,26 +567,35 @@ ZEND_VM_C_LABEL(is_equal_double):
                        }
                }
        }
+       ZEND_VM_DISPATCH_TO_HELPER(zend_is_equal_helper, op_1, op1, op_2, op2);
+}
+
+ZEND_VM_HELPER(zend_is_not_equal_helper, ANY, ANY, zval *op_1, zval *op_2)
+{
+       USE_OPLINE
+
        SAVE_OPLINE();
-       if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
-               op1 = ZVAL_UNDEFINED_OP1();
+       if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
+               op_1 = ZVAL_UNDEFINED_OP1();
        }
-       if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
-               op2 = ZVAL_UNDEFINED_OP2();
+       if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
+               op_2 = ZVAL_UNDEFINED_OP2();
+       }
+       compare_function(EX_VAR(opline->result.var), op_1, op_2);
+       if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
+               zval_ptr_dtor_nogc(op_1);
+       }
+       if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
+               zval_ptr_dtor_nogc(op_2);
        }
-       compare_function(EX_VAR(opline->result.var), op1, op2);
-       FREE_OP1();
-       FREE_OP2();
        if (UNEXPECTED(EG(exception))) {
                HANDLE_EXCEPTION();
        }
-       if (Z_LVAL_P(EX_VAR(opline->result.var)) == 0) {
-ZEND_VM_C_LABEL(is_equal_true):
+       if (Z_LVAL_P(EX_VAR(opline->result.var)) != 0) {
                ZEND_VM_SMART_BRANCH_TRUE();
                ZVAL_TRUE(EX_VAR(opline->result.var));
                ZEND_VM_NEXT_OPCODE();
        } else {
-ZEND_VM_C_LABEL(is_equal_false):
                ZEND_VM_SMART_BRANCH_FALSE();
                ZVAL_FALSE(EX_VAR(opline->result.var));
                ZEND_VM_NEXT_OPCODE();
@@ -562,12 +611,20 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(19, ZEND_IS_NOT_EQUAL, CONST|TMPVAR|CV, CONST|TM
 
        op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
        op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
-       if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
+       if (ZEND_VM_SPEC && OP1_TYPE == IS_CONST && OP2_TYPE == IS_CONST) {
+               /* pass */
+       } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
                        if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
-                               ZEND_VM_C_GOTO(is_not_equal_true);
+ZEND_VM_C_LABEL(is_not_equal_true):
+                               ZEND_VM_SMART_BRANCH_TRUE();
+                               ZVAL_TRUE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        } else {
-                               ZEND_VM_C_GOTO(is_not_equal_false);
+ZEND_VM_C_LABEL(is_not_equal_false):
+                               ZEND_VM_SMART_BRANCH_FALSE();
+                               ZVAL_FALSE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -605,33 +662,42 @@ ZEND_VM_C_LABEL(is_not_equal_double):
                        }
                }
        }
+       ZEND_VM_DISPATCH_TO_HELPER(zend_is_not_equal_helper, op_1, op1, op_2, op2);
+}
+
+ZEND_VM_HELPER(zend_is_smaller_helper, ANY, ANY, zval *op_1, zval *op_2)
+{
+       USE_OPLINE
+
        SAVE_OPLINE();
-       if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
-               op1 = ZVAL_UNDEFINED_OP1();
+       if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
+               op_1 = ZVAL_UNDEFINED_OP1();
        }
-       if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
-               op2 = ZVAL_UNDEFINED_OP2();
+       if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
+               op_2 = ZVAL_UNDEFINED_OP2();
+       }
+       compare_function(EX_VAR(opline->result.var), op_1, op_2);
+       if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
+               zval_ptr_dtor_nogc(op_1);
+       }
+       if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
+               zval_ptr_dtor_nogc(op_2);
        }
-       compare_function(EX_VAR(opline->result.var), op1, op2);
-       FREE_OP1();
-       FREE_OP2();
        if (UNEXPECTED(EG(exception))) {
                HANDLE_EXCEPTION();
        }
-       if (Z_LVAL_P(EX_VAR(opline->result.var)) != 0) {
-ZEND_VM_C_LABEL(is_not_equal_true):
+       if (Z_LVAL_P(EX_VAR(opline->result.var)) < 0) {
                ZEND_VM_SMART_BRANCH_TRUE();
                ZVAL_TRUE(EX_VAR(opline->result.var));
                ZEND_VM_NEXT_OPCODE();
        } else {
-ZEND_VM_C_LABEL(is_not_equal_false):
                ZEND_VM_SMART_BRANCH_FALSE();
                ZVAL_FALSE(EX_VAR(opline->result.var));
                ZEND_VM_NEXT_OPCODE();
        }
 }
 
-ZEND_VM_COLD_CONSTCONST_HANDLER(20, ZEND_IS_SMALLER, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
+ZEND_VM_COLD_CONSTCONST_HANDLER(20, ZEND_IS_SMALLER, CONST|TMPVARCV, CONST|TMPVARCV)
 {
        USE_OPLINE
        zend_free_op free_op1, free_op2;
@@ -640,12 +706,20 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(20, ZEND_IS_SMALLER, CONST|TMPVAR|CV, CONST|TMPV
 
        op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
        op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
-       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
+       if (ZEND_VM_SPEC && OP1_TYPE == IS_CONST && OP2_TYPE == IS_CONST) {
+               /* pass */
+       } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                        if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
-                               ZEND_VM_C_GOTO(is_smaller_true);
+ZEND_VM_C_LABEL(is_smaller_true):
+                               ZEND_VM_SMART_BRANCH_TRUE();
+                               ZVAL_TRUE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        } else {
-                               ZEND_VM_C_GOTO(is_smaller_false);
+ZEND_VM_C_LABEL(is_smaller_false):
+                               ZEND_VM_SMART_BRANCH_FALSE();
+                               ZVAL_FALSE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -668,33 +742,42 @@ ZEND_VM_C_LABEL(is_smaller_double):
                        ZEND_VM_C_GOTO(is_smaller_double);
                }
        }
+       ZEND_VM_DISPATCH_TO_HELPER(zend_is_smaller_helper, op_1, op1, op_2, op2);
+}
+
+ZEND_VM_HELPER(zend_is_smaller_or_equal_helper, ANY, ANY, zval *op_1, zval *op_2)
+{
+       USE_OPLINE
+
        SAVE_OPLINE();
-       if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
-               op1 = ZVAL_UNDEFINED_OP1();
+       if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
+               op_1 = ZVAL_UNDEFINED_OP1();
        }
-       if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
-               op2 = ZVAL_UNDEFINED_OP2();
+       if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
+               op_2 = ZVAL_UNDEFINED_OP2();
+       }
+       compare_function(EX_VAR(opline->result.var), op_1, op_2);
+       if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
+               zval_ptr_dtor_nogc(op_1);
+       }
+       if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
+               zval_ptr_dtor_nogc(op_2);
        }
-       compare_function(EX_VAR(opline->result.var), op1, op2);
-       FREE_OP1();
-       FREE_OP2();
        if (UNEXPECTED(EG(exception))) {
                HANDLE_EXCEPTION();
        }
-       if (Z_LVAL_P(EX_VAR(opline->result.var)) < 0) {
-ZEND_VM_C_LABEL(is_smaller_true):
+       if (Z_LVAL_P(EX_VAR(opline->result.var)) <= 0) {
                ZEND_VM_SMART_BRANCH_TRUE();
                ZVAL_TRUE(EX_VAR(opline->result.var));
                ZEND_VM_NEXT_OPCODE();
        } else {
-ZEND_VM_C_LABEL(is_smaller_false):
                ZEND_VM_SMART_BRANCH_FALSE();
                ZVAL_FALSE(EX_VAR(opline->result.var));
                ZEND_VM_NEXT_OPCODE();
        }
 }
 
-ZEND_VM_COLD_CONSTCONST_HANDLER(21, ZEND_IS_SMALLER_OR_EQUAL, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
+ZEND_VM_COLD_CONSTCONST_HANDLER(21, ZEND_IS_SMALLER_OR_EQUAL, CONST|TMPVARCV, CONST|TMPVARCV)
 {
        USE_OPLINE
        zend_free_op free_op1, free_op2;
@@ -703,12 +786,20 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(21, ZEND_IS_SMALLER_OR_EQUAL, CONST|TMPVAR|CV, C
 
        op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
        op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
-       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
+       if (ZEND_VM_SPEC && OP1_TYPE == IS_CONST && OP2_TYPE == IS_CONST) {
+               /* pass */
+       } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                        if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
-                               ZEND_VM_C_GOTO(is_smaller_or_equal_true);
+ZEND_VM_C_LABEL(is_smaller_or_equal_true):
+                               ZEND_VM_SMART_BRANCH_TRUE();
+                               ZVAL_TRUE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        } else {
-                               ZEND_VM_C_GOTO(is_smaller_or_equal_false);
+ZEND_VM_C_LABEL(is_smaller_or_equal_false):
+                               ZEND_VM_SMART_BRANCH_FALSE();
+                               ZVAL_FALSE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -731,30 +822,7 @@ ZEND_VM_C_LABEL(is_smaller_or_equal_double):
                        ZEND_VM_C_GOTO(is_smaller_or_equal_double);
                }
        }
-       SAVE_OPLINE();
-       if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
-               op1 = ZVAL_UNDEFINED_OP1();
-       }
-       if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
-               op2 = ZVAL_UNDEFINED_OP2();
-       }
-       compare_function(EX_VAR(opline->result.var), op1, op2);
-       FREE_OP1();
-       FREE_OP2();
-       if (UNEXPECTED(EG(exception))) {
-               HANDLE_EXCEPTION();
-       }
-       if (Z_LVAL_P(EX_VAR(opline->result.var)) <= 0) {
-ZEND_VM_C_LABEL(is_smaller_or_equal_true):
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-ZEND_VM_C_LABEL(is_smaller_or_equal_false):
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
+       ZEND_VM_DISPATCH_TO_HELPER(zend_is_smaller_or_equal_helper, op_1, op1, op_2, op2);
 }
 
 ZEND_VM_COLD_CONSTCONST_HANDLER(170, ZEND_SPACESHIP, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
@@ -5201,6 +5269,35 @@ ZEND_VM_COLD_CONST_HANDLER(52, ZEND_BOOL, CONST|TMPVAR|CV, ANY)
        ZEND_VM_NEXT_OPCODE();
 }
 
+ZEND_VM_HELPER(zend_case_helper, ANY, ANY, zval *op_1, zval *op_2)
+{
+       USE_OPLINE
+
+       SAVE_OPLINE();
+       if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
+               op_1 = ZVAL_UNDEFINED_OP1();
+       }
+       if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
+               op_2 = ZVAL_UNDEFINED_OP2();
+       }
+       compare_function(EX_VAR(opline->result.var), op_1, op_2);
+       if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
+               zval_ptr_dtor_nogc(op_2);
+       }
+       if (UNEXPECTED(EG(exception))) {
+               HANDLE_EXCEPTION();
+       }
+       if (Z_LVAL_P(EX_VAR(opline->result.var)) == 0) {
+               ZEND_VM_SMART_BRANCH_TRUE();
+               ZVAL_TRUE(EX_VAR(opline->result.var));
+               ZEND_VM_NEXT_OPCODE();
+       } else {
+               ZEND_VM_SMART_BRANCH_FALSE();
+               ZVAL_FALSE(EX_VAR(opline->result.var));
+               ZEND_VM_NEXT_OPCODE();
+       }
+}
+
 ZEND_VM_HANDLER(48, ZEND_CASE, TMPVAR, CONST|TMPVAR|CV)
 {
        USE_OPLINE
@@ -5213,9 +5310,15 @@ ZEND_VM_HANDLER(48, ZEND_CASE, TMPVAR, CONST|TMPVAR|CV)
        if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
                        if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
-                               ZEND_VM_C_GOTO(case_true);
+ZEND_VM_C_LABEL(case_true):
+                               ZEND_VM_SMART_BRANCH_TRUE();
+                               ZVAL_TRUE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        } else {
-                               ZEND_VM_C_GOTO(case_false);
+ZEND_VM_C_LABEL(case_false):
+                               ZEND_VM_SMART_BRANCH_FALSE();
+                               ZVAL_FALSE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -5248,29 +5351,7 @@ ZEND_VM_C_LABEL(case_double):
                        }
                }
        }
-       SAVE_OPLINE();
-       if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
-               op1 = ZVAL_UNDEFINED_OP1();
-       }
-       if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
-               op2 = ZVAL_UNDEFINED_OP2();
-       }
-       compare_function(EX_VAR(opline->result.var), op1, op2);
-       FREE_OP2();
-       if (UNEXPECTED(EG(exception))) {
-               HANDLE_EXCEPTION();
-       }
-       if (Z_LVAL_P(EX_VAR(opline->result.var)) == 0) {
-ZEND_VM_C_LABEL(case_true):
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-ZEND_VM_C_LABEL(case_false):
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
+       ZEND_VM_DISPATCH_TO_HELPER(zend_case_helper, op_1, op1, op_2, op2);
 }
 
 ZEND_VM_HANDLER(68, ZEND_NEW, UNUSED|CLASS_FETCH|CONST|VAR, UNUSED|CACHE_SLOT, NUM)

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index e4d5c062b31b858e1831e418b8acabfc05ea8b0b..22c9114dbf26b5e1e5f862ea97bf3fb5f6d343be 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -576,6 +576,134 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_shift_right_helper_SPEC(zval *
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_equal_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+       USE_OPLINE
+
+       SAVE_OPLINE();
+       if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
+               op_1 = ZVAL_UNDEFINED_OP1();
+       }
+       if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
+               op_2 = ZVAL_UNDEFINED_OP2();
+       }
+       compare_function(EX_VAR(opline->result.var), op_1, op_2);
+       if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
+               zval_ptr_dtor_nogc(op_1);
+       }
+       if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
+               zval_ptr_dtor_nogc(op_2);
+       }
+       if (UNEXPECTED(EG(exception))) {
+               HANDLE_EXCEPTION();
+       }
+       if (Z_LVAL_P(EX_VAR(opline->result.var)) == 0) {
+               ZEND_VM_SMART_BRANCH_TRUE();
+               ZVAL_TRUE(EX_VAR(opline->result.var));
+               ZEND_VM_NEXT_OPCODE();
+       } else {
+               ZEND_VM_SMART_BRANCH_FALSE();
+               ZVAL_FALSE(EX_VAR(opline->result.var));
+               ZEND_VM_NEXT_OPCODE();
+       }
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_not_equal_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+       USE_OPLINE
+
+       SAVE_OPLINE();
+       if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
+               op_1 = ZVAL_UNDEFINED_OP1();
+       }
+       if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
+               op_2 = ZVAL_UNDEFINED_OP2();
+       }
+       compare_function(EX_VAR(opline->result.var), op_1, op_2);
+       if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
+               zval_ptr_dtor_nogc(op_1);
+       }
+       if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
+               zval_ptr_dtor_nogc(op_2);
+       }
+       if (UNEXPECTED(EG(exception))) {
+               HANDLE_EXCEPTION();
+       }
+       if (Z_LVAL_P(EX_VAR(opline->result.var)) != 0) {
+               ZEND_VM_SMART_BRANCH_TRUE();
+               ZVAL_TRUE(EX_VAR(opline->result.var));
+               ZEND_VM_NEXT_OPCODE();
+       } else {
+               ZEND_VM_SMART_BRANCH_FALSE();
+               ZVAL_FALSE(EX_VAR(opline->result.var));
+               ZEND_VM_NEXT_OPCODE();
+       }
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_smaller_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+       USE_OPLINE
+
+       SAVE_OPLINE();
+       if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
+               op_1 = ZVAL_UNDEFINED_OP1();
+       }
+       if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
+               op_2 = ZVAL_UNDEFINED_OP2();
+       }
+       compare_function(EX_VAR(opline->result.var), op_1, op_2);
+       if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
+               zval_ptr_dtor_nogc(op_1);
+       }
+       if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
+               zval_ptr_dtor_nogc(op_2);
+       }
+       if (UNEXPECTED(EG(exception))) {
+               HANDLE_EXCEPTION();
+       }
+       if (Z_LVAL_P(EX_VAR(opline->result.var)) < 0) {
+               ZEND_VM_SMART_BRANCH_TRUE();
+               ZVAL_TRUE(EX_VAR(opline->result.var));
+               ZEND_VM_NEXT_OPCODE();
+       } else {
+               ZEND_VM_SMART_BRANCH_FALSE();
+               ZVAL_FALSE(EX_VAR(opline->result.var));
+               ZEND_VM_NEXT_OPCODE();
+       }
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_smaller_or_equal_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+       USE_OPLINE
+
+       SAVE_OPLINE();
+       if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
+               op_1 = ZVAL_UNDEFINED_OP1();
+       }
+       if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
+               op_2 = ZVAL_UNDEFINED_OP2();
+       }
+       compare_function(EX_VAR(opline->result.var), op_1, op_2);
+       if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
+               zval_ptr_dtor_nogc(op_1);
+       }
+       if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
+               zval_ptr_dtor_nogc(op_2);
+       }
+       if (UNEXPECTED(EG(exception))) {
+               HANDLE_EXCEPTION();
+       }
+       if (Z_LVAL_P(EX_VAR(opline->result.var)) <= 0) {
+               ZEND_VM_SMART_BRANCH_TRUE();
+               ZVAL_TRUE(EX_VAR(opline->result.var));
+               ZEND_VM_NEXT_OPCODE();
+       } else {
+               ZEND_VM_SMART_BRANCH_FALSE();
+               ZVAL_FALSE(EX_VAR(opline->result.var));
+               ZEND_VM_NEXT_OPCODE();
+       }
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_or_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
@@ -1989,6 +2117,35 @@ send_array:
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_case_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+       USE_OPLINE
+
+       SAVE_OPLINE();
+       if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
+               op_1 = ZVAL_UNDEFINED_OP1();
+       }
+       if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
+               op_2 = ZVAL_UNDEFINED_OP2();
+       }
+       compare_function(EX_VAR(opline->result.var), op_1, op_2);
+       if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
+               zval_ptr_dtor_nogc(op_2);
+       }
+       if (UNEXPECTED(EG(exception))) {
+               HANDLE_EXCEPTION();
+       }
+       if (Z_LVAL_P(EX_VAR(opline->result.var)) == 0) {
+               ZEND_VM_SMART_BRANCH_TRUE();
+               ZVAL_TRUE(EX_VAR(opline->result.var));
+               ZEND_VM_NEXT_OPCODE();
+       } else {
+               ZEND_VM_SMART_BRANCH_FALSE();
+               ZVAL_FALSE(EX_VAR(opline->result.var));
+               ZEND_VM_NEXT_OPCODE();
+       }
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -4725,12 +4882,20 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CON
 
        op1 = RT_CONSTANT(opline, opline->op1);
        op2 = RT_CONSTANT(opline, opline->op2);
-       if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
+       if (ZEND_VM_SPEC && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
+               /* pass */
+       } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
                        if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
-                               goto is_equal_true;
+is_equal_true:
+                               ZEND_VM_SMART_BRANCH_TRUE();
+                               ZVAL_TRUE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        } else {
-                               goto is_equal_false;
+is_equal_false:
+                               ZEND_VM_SMART_BRANCH_FALSE();
+                               ZVAL_FALSE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -4768,30 +4933,7 @@ is_equal_double:
                        }
                }
        }
-       SAVE_OPLINE();
-       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
-               op1 = ZVAL_UNDEFINED_OP1();
-       }
-       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
-               op2 = ZVAL_UNDEFINED_OP2();
-       }
-       compare_function(EX_VAR(opline->result.var), op1, op2);
-
-
-       if (UNEXPECTED(EG(exception))) {
-               HANDLE_EXCEPTION();
-       }
-       if (Z_LVAL_P(EX_VAR(opline->result.var)) == 0) {
-is_equal_true:
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-is_equal_false:
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
+       ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -4803,12 +4945,20 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC
 
        op1 = RT_CONSTANT(opline, opline->op1);
        op2 = RT_CONSTANT(opline, opline->op2);
-       if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
+       if (ZEND_VM_SPEC && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
+               /* pass */
+       } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
                        if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
-                               goto is_not_equal_true;
+is_not_equal_true:
+                               ZEND_VM_SMART_BRANCH_TRUE();
+                               ZVAL_TRUE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        } else {
-                               goto is_not_equal_false;
+is_not_equal_false:
+                               ZEND_VM_SMART_BRANCH_FALSE();
+                               ZVAL_FALSE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -4846,30 +4996,7 @@ is_not_equal_double:
                        }
                }
        }
-       SAVE_OPLINE();
-       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
-               op1 = ZVAL_UNDEFINED_OP1();
-       }
-       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
-               op2 = ZVAL_UNDEFINED_OP2();
-       }
-       compare_function(EX_VAR(opline->result.var), op1, op2);
-
-
-       if (UNEXPECTED(EG(exception))) {
-               HANDLE_EXCEPTION();
-       }
-       if (Z_LVAL_P(EX_VAR(opline->result.var)) != 0) {
-is_not_equal_true:
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-is_not_equal_false:
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
+       ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -4881,12 +5008,20 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_C
 
        op1 = RT_CONSTANT(opline, opline->op1);
        op2 = RT_CONSTANT(opline, opline->op2);
-       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
+       if (ZEND_VM_SPEC && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
+               /* pass */
+       } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                        if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
-                               goto is_smaller_true;
+is_smaller_true:
+                               ZEND_VM_SMART_BRANCH_TRUE();
+                               ZVAL_TRUE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        } else {
-                               goto is_smaller_false;
+is_smaller_false:
+                               ZEND_VM_SMART_BRANCH_FALSE();
+                               ZVAL_FALSE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -4909,30 +5044,7 @@ is_smaller_double:
                        goto is_smaller_double;
                }
        }
-       SAVE_OPLINE();
-       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
-               op1 = ZVAL_UNDEFINED_OP1();
-       }
-       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
-               op2 = ZVAL_UNDEFINED_OP2();
-       }
-       compare_function(EX_VAR(opline->result.var), op1, op2);
-
-
-       if (UNEXPECTED(EG(exception))) {
-               HANDLE_EXCEPTION();
-       }
-       if (Z_LVAL_P(EX_VAR(opline->result.var)) < 0) {
-is_smaller_true:
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-is_smaller_false:
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
+       ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -4944,12 +5056,20 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQU
 
        op1 = RT_CONSTANT(opline, opline->op1);
        op2 = RT_CONSTANT(opline, opline->op2);
-       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
+       if (ZEND_VM_SPEC && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
+               /* pass */
+       } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                        if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
-                               goto is_smaller_or_equal_true;
+is_smaller_or_equal_true:
+                               ZEND_VM_SMART_BRANCH_TRUE();
+                               ZVAL_TRUE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        } else {
-                               goto is_smaller_or_equal_false;
+is_smaller_or_equal_false:
+                               ZEND_VM_SMART_BRANCH_FALSE();
+                               ZVAL_FALSE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -4972,30 +5092,7 @@ is_smaller_or_equal_double:
                        goto is_smaller_or_equal_double;
                }
        }
-       SAVE_OPLINE();
-       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
-               op1 = ZVAL_UNDEFINED_OP1();
-       }
-       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
-               op2 = ZVAL_UNDEFINED_OP2();
-       }
-       compare_function(EX_VAR(opline->result.var), op1, op2);
-
-
-       if (UNEXPECTED(EG(exception))) {
-               HANDLE_EXCEPTION();
-       }
-       if (Z_LVAL_P(EX_VAR(opline->result.var)) <= 0) {
-is_smaller_or_equal_true:
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-is_smaller_or_equal_false:
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
+       ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -6652,6 +6749,102 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_CONST_TMPVARCV_HANDLER
        ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       zval *op1, *op2;
+       double d1, d2;
+
+       op1 = RT_CONSTANT(opline, opline->op1);
+       op2 = EX_VAR(opline->op2.var);
+       if (ZEND_VM_SPEC && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
+               /* pass */
+       } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
+               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+                       if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
+is_smaller_true:
+                               ZEND_VM_SMART_BRANCH_TRUE();
+                               ZVAL_TRUE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
+                       } else {
+is_smaller_false:
+                               ZEND_VM_SMART_BRANCH_FALSE();
+                               ZVAL_FALSE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
+                       }
+               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
+                       d1 = (double)Z_LVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+                       goto is_smaller_double;
+               }
+       } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
+               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
+                       d1 = Z_DVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+is_smaller_double:
+                       if (d1 < d2) {
+                               goto is_smaller_true;
+                       } else {
+                               goto is_smaller_false;
+                       }
+               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       goto is_smaller_double;
+               }
+       }
+       ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       zval *op1, *op2;
+       double d1, d2;
+
+       op1 = RT_CONSTANT(opline, opline->op1);
+       op2 = EX_VAR(opline->op2.var);
+       if (ZEND_VM_SPEC && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
+               /* pass */
+       } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
+               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+                       if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
+is_smaller_or_equal_true:
+                               ZEND_VM_SMART_BRANCH_TRUE();
+                               ZVAL_TRUE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
+                       } else {
+is_smaller_or_equal_false:
+                               ZEND_VM_SMART_BRANCH_FALSE();
+                               ZVAL_FALSE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
+                       }
+               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
+                       d1 = (double)Z_LVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+                       goto is_smaller_or_equal_double;
+               }
+       } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
+               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
+                       d1 = Z_DVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+is_smaller_or_equal_double:
+                       if (d1 <= d2) {
+                               goto is_smaller_or_equal_true;
+                       } else {
+                               goto is_smaller_or_equal_false;
+                       }
+               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       goto is_smaller_or_equal_double;
+               }
+       }
+       ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -7011,132 +7204,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_TMPVAR_HANDL
        }
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op2;
-       zval *op1, *op2;
-       double d1, d2;
-
-       op1 = RT_CONSTANT(opline, opline->op1);
-       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
-       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
-               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
-                       if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
-                               goto is_smaller_true;
-                       } else {
-                               goto is_smaller_false;
-                       }
-               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
-                       d1 = (double)Z_LVAL_P(op1);
-                       d2 = Z_DVAL_P(op2);
-                       goto is_smaller_double;
-               }
-       } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
-               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
-                       d1 = Z_DVAL_P(op1);
-                       d2 = Z_DVAL_P(op2);
-is_smaller_double:
-                       if (d1 < d2) {
-                               goto is_smaller_true;
-                       } else {
-                               goto is_smaller_false;
-                       }
-               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
-                       d1 = Z_DVAL_P(op1);
-                       d2 = (double)Z_LVAL_P(op2);
-                       goto is_smaller_double;
-               }
-       }
-       SAVE_OPLINE();
-       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
-               op1 = ZVAL_UNDEFINED_OP1();
-       }
-       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
-               op2 = ZVAL_UNDEFINED_OP2();
-       }
-       compare_function(EX_VAR(opline->result.var), op1, op2);
-
-       zval_ptr_dtor_nogc(free_op2);
-       if (UNEXPECTED(EG(exception))) {
-               HANDLE_EXCEPTION();
-       }
-       if (Z_LVAL_P(EX_VAR(opline->result.var)) < 0) {
-is_smaller_true:
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-is_smaller_false:
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
-}
-
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op2;
-       zval *op1, *op2;
-       double d1, d2;
-
-       op1 = RT_CONSTANT(opline, opline->op1);
-       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
-       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
-               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
-                       if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
-                               goto is_smaller_or_equal_true;
-                       } else {
-                               goto is_smaller_or_equal_false;
-                       }
-               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
-                       d1 = (double)Z_LVAL_P(op1);
-                       d2 = Z_DVAL_P(op2);
-                       goto is_smaller_or_equal_double;
-               }
-       } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
-               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
-                       d1 = Z_DVAL_P(op1);
-                       d2 = Z_DVAL_P(op2);
-is_smaller_or_equal_double:
-                       if (d1 <= d2) {
-                               goto is_smaller_or_equal_true;
-                       } else {
-                               goto is_smaller_or_equal_false;
-                       }
-               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
-                       d1 = Z_DVAL_P(op1);
-                       d2 = (double)Z_LVAL_P(op2);
-                       goto is_smaller_or_equal_double;
-               }
-       }
-       SAVE_OPLINE();
-       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
-               op1 = ZVAL_UNDEFINED_OP1();
-       }
-       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
-               op2 = ZVAL_UNDEFINED_OP2();
-       }
-       compare_function(EX_VAR(opline->result.var), op1, op2);
-
-       zval_ptr_dtor_nogc(free_op2);
-       if (UNEXPECTED(EG(exception))) {
-               HANDLE_EXCEPTION();
-       }
-       if (Z_LVAL_P(EX_VAR(opline->result.var)) <= 0) {
-is_smaller_or_equal_true:
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-is_smaller_or_equal_false:
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
-}
-
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -9531,132 +9598,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_CV_HANDLER(Z
        }
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-
-       zval *op1, *op2;
-       double d1, d2;
-
-       op1 = RT_CONSTANT(opline, opline->op1);
-       op2 = EX_VAR(opline->op2.var);
-       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
-               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
-                       if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
-                               goto is_smaller_true;
-                       } else {
-                               goto is_smaller_false;
-                       }
-               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
-                       d1 = (double)Z_LVAL_P(op1);
-                       d2 = Z_DVAL_P(op2);
-                       goto is_smaller_double;
-               }
-       } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
-               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
-                       d1 = Z_DVAL_P(op1);
-                       d2 = Z_DVAL_P(op2);
-is_smaller_double:
-                       if (d1 < d2) {
-                               goto is_smaller_true;
-                       } else {
-                               goto is_smaller_false;
-                       }
-               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
-                       d1 = Z_DVAL_P(op1);
-                       d2 = (double)Z_LVAL_P(op2);
-                       goto is_smaller_double;
-               }
-       }
-       SAVE_OPLINE();
-       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
-               op1 = ZVAL_UNDEFINED_OP1();
-       }
-       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
-               op2 = ZVAL_UNDEFINED_OP2();
-       }
-       compare_function(EX_VAR(opline->result.var), op1, op2);
-
-
-       if (UNEXPECTED(EG(exception))) {
-               HANDLE_EXCEPTION();
-       }
-       if (Z_LVAL_P(EX_VAR(opline->result.var)) < 0) {
-is_smaller_true:
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-is_smaller_false:
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
-}
-
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-
-       zval *op1, *op2;
-       double d1, d2;
-
-       op1 = RT_CONSTANT(opline, opline->op1);
-       op2 = EX_VAR(opline->op2.var);
-       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
-               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
-                       if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
-                               goto is_smaller_or_equal_true;
-                       } else {
-                               goto is_smaller_or_equal_false;
-                       }
-               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
-                       d1 = (double)Z_LVAL_P(op1);
-                       d2 = Z_DVAL_P(op2);
-                       goto is_smaller_or_equal_double;
-               }
-       } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
-               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
-                       d1 = Z_DVAL_P(op1);
-                       d2 = Z_DVAL_P(op2);
-is_smaller_or_equal_double:
-                       if (d1 <= d2) {
-                               goto is_smaller_or_equal_true;
-                       } else {
-                               goto is_smaller_or_equal_false;
-                       }
-               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
-                       d1 = Z_DVAL_P(op1);
-                       d2 = (double)Z_LVAL_P(op2);
-                       goto is_smaller_or_equal_double;
-               }
-       }
-       SAVE_OPLINE();
-       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
-               op1 = ZVAL_UNDEFINED_OP1();
-       }
-       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
-               op2 = ZVAL_UNDEFINED_OP2();
-       }
-       compare_function(EX_VAR(opline->result.var), op1, op2);
-
-
-       if (UNEXPECTED(EG(exception))) {
-               HANDLE_EXCEPTION();
-       }
-       if (Z_LVAL_P(EX_VAR(opline->result.var)) <= 0) {
-is_smaller_or_equal_true:
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-is_smaller_or_equal_false:
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
-}
-
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -11320,6 +11261,102 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_TMPVARCV_CONST_HANDLER
        ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       zval *op1, *op2;
+       double d1, d2;
+
+       op1 = EX_VAR(opline->op1.var);
+       op2 = RT_CONSTANT(opline, opline->op2);
+       if (ZEND_VM_SPEC && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
+               /* pass */
+       } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
+               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+                       if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
+is_smaller_true:
+                               ZEND_VM_SMART_BRANCH_TRUE();
+                               ZVAL_TRUE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
+                       } else {
+is_smaller_false:
+                               ZEND_VM_SMART_BRANCH_FALSE();
+                               ZVAL_FALSE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
+                       }
+               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
+                       d1 = (double)Z_LVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+                       goto is_smaller_double;
+               }
+       } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
+               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
+                       d1 = Z_DVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+is_smaller_double:
+                       if (d1 < d2) {
+                               goto is_smaller_true;
+                       } else {
+                               goto is_smaller_false;
+                       }
+               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       goto is_smaller_double;
+               }
+       }
+       ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       zval *op1, *op2;
+       double d1, d2;
+
+       op1 = EX_VAR(opline->op1.var);
+       op2 = RT_CONSTANT(opline, opline->op2);
+       if (ZEND_VM_SPEC && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
+               /* pass */
+       } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
+               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+                       if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
+is_smaller_or_equal_true:
+                               ZEND_VM_SMART_BRANCH_TRUE();
+                               ZVAL_TRUE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
+                       } else {
+is_smaller_or_equal_false:
+                               ZEND_VM_SMART_BRANCH_FALSE();
+                               ZVAL_FALSE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
+                       }
+               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
+                       d1 = (double)Z_LVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+                       goto is_smaller_or_equal_double;
+               }
+       } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
+               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
+                       d1 = Z_DVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+is_smaller_or_equal_double:
+                       if (d1 <= d2) {
+                               goto is_smaller_or_equal_true;
+                       } else {
+                               goto is_smaller_or_equal_false;
+                       }
+               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       goto is_smaller_or_equal_double;
+               }
+       }
+       ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -12077,6 +12114,102 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HAND
        ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       zval *op1, *op2;
+       double d1, d2;
+
+       op1 = EX_VAR(opline->op1.var);
+       op2 = EX_VAR(opline->op2.var);
+       if (ZEND_VM_SPEC && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
+               /* pass */
+       } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
+               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+                       if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
+is_smaller_true:
+                               ZEND_VM_SMART_BRANCH_TRUE();
+                               ZVAL_TRUE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
+                       } else {
+is_smaller_false:
+                               ZEND_VM_SMART_BRANCH_FALSE();
+                               ZVAL_FALSE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
+                       }
+               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
+                       d1 = (double)Z_LVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+                       goto is_smaller_double;
+               }
+       } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
+               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
+                       d1 = Z_DVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+is_smaller_double:
+                       if (d1 < d2) {
+                               goto is_smaller_true;
+                       } else {
+                               goto is_smaller_false;
+                       }
+               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       goto is_smaller_double;
+               }
+       }
+       ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       zval *op1, *op2;
+       double d1, d2;
+
+       op1 = EX_VAR(opline->op1.var);
+       op2 = EX_VAR(opline->op2.var);
+       if (ZEND_VM_SPEC && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
+               /* pass */
+       } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
+               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+                       if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
+is_smaller_or_equal_true:
+                               ZEND_VM_SMART_BRANCH_TRUE();
+                               ZVAL_TRUE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
+                       } else {
+is_smaller_or_equal_false:
+                               ZEND_VM_SMART_BRANCH_FALSE();
+                               ZVAL_FALSE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
+                       }
+               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
+                       d1 = (double)Z_LVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+                       goto is_smaller_or_equal_double;
+               }
+       } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
+               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
+                       d1 = Z_DVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+is_smaller_or_equal_double:
+                       if (d1 <= d2) {
+                               goto is_smaller_or_equal_true;
+                       } else {
+                               goto is_smaller_or_equal_false;
+                       }
+               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       goto is_smaller_or_equal_double;
+               }
+       }
+       ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -13289,12 +13422,20 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_HAN
 
        op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        op2 = RT_CONSTANT(opline, opline->op2);
-       if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
+       if (ZEND_VM_SPEC && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) {
+               /* pass */
+       } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
                        if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
-                               goto is_equal_true;
+is_equal_true:
+                               ZEND_VM_SMART_BRANCH_TRUE();
+                               ZVAL_TRUE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        } else {
-                               goto is_equal_false;
+is_equal_false:
+                               ZEND_VM_SMART_BRANCH_FALSE();
+                               ZVAL_FALSE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -13332,30 +13473,7 @@ is_equal_double:
                        }
                }
        }
-       SAVE_OPLINE();
-       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
-               op1 = ZVAL_UNDEFINED_OP1();
-       }
-       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
-               op2 = ZVAL_UNDEFINED_OP2();
-       }
-       compare_function(EX_VAR(opline->result.var), op1, op2);
-       zval_ptr_dtor_nogc(free_op1);
-
-       if (UNEXPECTED(EG(exception))) {
-               HANDLE_EXCEPTION();
-       }
-       if (Z_LVAL_P(EX_VAR(opline->result.var)) == 0) {
-is_equal_true:
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-is_equal_false:
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
+       ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -13367,12 +13485,20 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST
 
        op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        op2 = RT_CONSTANT(opline, opline->op2);
-       if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
+       if (ZEND_VM_SPEC && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) {
+               /* pass */
+       } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
                        if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
-                               goto is_not_equal_true;
+is_not_equal_true:
+                               ZEND_VM_SMART_BRANCH_TRUE();
+                               ZVAL_TRUE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        } else {
-                               goto is_not_equal_false;
+is_not_equal_false:
+                               ZEND_VM_SMART_BRANCH_FALSE();
+                               ZVAL_FALSE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -13410,156 +13536,7 @@ is_not_equal_double:
                        }
                }
        }
-       SAVE_OPLINE();
-       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
-               op1 = ZVAL_UNDEFINED_OP1();
-       }
-       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
-               op2 = ZVAL_UNDEFINED_OP2();
-       }
-       compare_function(EX_VAR(opline->result.var), op1, op2);
-       zval_ptr_dtor_nogc(free_op1);
-
-       if (UNEXPECTED(EG(exception))) {
-               HANDLE_EXCEPTION();
-       }
-       if (Z_LVAL_P(EX_VAR(opline->result.var)) != 0) {
-is_not_equal_true:
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-is_not_equal_false:
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
-}
-
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op1;
-       zval *op1, *op2;
-       double d1, d2;
-
-       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
-       op2 = RT_CONSTANT(opline, opline->op2);
-       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
-               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
-                       if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
-                               goto is_smaller_true;
-                       } else {
-                               goto is_smaller_false;
-                       }
-               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
-                       d1 = (double)Z_LVAL_P(op1);
-                       d2 = Z_DVAL_P(op2);
-                       goto is_smaller_double;
-               }
-       } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
-               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
-                       d1 = Z_DVAL_P(op1);
-                       d2 = Z_DVAL_P(op2);
-is_smaller_double:
-                       if (d1 < d2) {
-                               goto is_smaller_true;
-                       } else {
-                               goto is_smaller_false;
-                       }
-               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
-                       d1 = Z_DVAL_P(op1);
-                       d2 = (double)Z_LVAL_P(op2);
-                       goto is_smaller_double;
-               }
-       }
-       SAVE_OPLINE();
-       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
-               op1 = ZVAL_UNDEFINED_OP1();
-       }
-       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
-               op2 = ZVAL_UNDEFINED_OP2();
-       }
-       compare_function(EX_VAR(opline->result.var), op1, op2);
-       zval_ptr_dtor_nogc(free_op1);
-
-       if (UNEXPECTED(EG(exception))) {
-               HANDLE_EXCEPTION();
-       }
-       if (Z_LVAL_P(EX_VAR(opline->result.var)) < 0) {
-is_smaller_true:
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-is_smaller_false:
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
-}
-
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op1;
-       zval *op1, *op2;
-       double d1, d2;
-
-       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
-       op2 = RT_CONSTANT(opline, opline->op2);
-       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
-               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
-                       if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
-                               goto is_smaller_or_equal_true;
-                       } else {
-                               goto is_smaller_or_equal_false;
-                       }
-               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
-                       d1 = (double)Z_LVAL_P(op1);
-                       d2 = Z_DVAL_P(op2);
-                       goto is_smaller_or_equal_double;
-               }
-       } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
-               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
-                       d1 = Z_DVAL_P(op1);
-                       d2 = Z_DVAL_P(op2);
-is_smaller_or_equal_double:
-                       if (d1 <= d2) {
-                               goto is_smaller_or_equal_true;
-                       } else {
-                               goto is_smaller_or_equal_false;
-                       }
-               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
-                       d1 = Z_DVAL_P(op1);
-                       d2 = (double)Z_LVAL_P(op2);
-                       goto is_smaller_or_equal_double;
-               }
-       }
-       SAVE_OPLINE();
-       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
-               op1 = ZVAL_UNDEFINED_OP1();
-       }
-       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
-               op2 = ZVAL_UNDEFINED_OP2();
-       }
-       compare_function(EX_VAR(opline->result.var), op1, op2);
-       zval_ptr_dtor_nogc(free_op1);
-
-       if (UNEXPECTED(EG(exception))) {
-               HANDLE_EXCEPTION();
-       }
-       if (Z_LVAL_P(EX_VAR(opline->result.var)) <= 0) {
-is_smaller_or_equal_true:
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-is_smaller_or_equal_false:
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
+       ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -14140,9 +14117,15 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_CONST_HANDLER
        if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
                        if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
-                               goto case_true;
+case_true:
+                               ZEND_VM_SMART_BRANCH_TRUE();
+                               ZVAL_TRUE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        } else {
-                               goto case_false;
+case_false:
+                               ZEND_VM_SMART_BRANCH_FALSE();
+                               ZVAL_FALSE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -14175,29 +14158,7 @@ case_double:
                        }
                }
        }
-       SAVE_OPLINE();
-       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
-               op1 = ZVAL_UNDEFINED_OP1();
-       }
-       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
-               op2 = ZVAL_UNDEFINED_OP2();
-       }
-       compare_function(EX_VAR(opline->result.var), op1, op2);
-
-       if (UNEXPECTED(EG(exception))) {
-               HANDLE_EXCEPTION();
-       }
-       if (Z_LVAL_P(EX_VAR(opline->result.var)) == 0) {
-case_true:
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-case_false:
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
+       ZEND_VM_TAIL_CALL(zend_case_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -14624,12 +14585,20 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HA
 
        op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
-       if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
+       if (ZEND_VM_SPEC && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
+               /* pass */
+       } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
                        if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
-                               goto is_equal_true;
+is_equal_true:
+                               ZEND_VM_SMART_BRANCH_TRUE();
+                               ZVAL_TRUE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        } else {
-                               goto is_equal_false;
+is_equal_false:
+                               ZEND_VM_SMART_BRANCH_FALSE();
+                               ZVAL_FALSE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -14667,30 +14636,7 @@ is_equal_double:
                        }
                }
        }
-       SAVE_OPLINE();
-       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
-               op1 = ZVAL_UNDEFINED_OP1();
-       }
-       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
-               op2 = ZVAL_UNDEFINED_OP2();
-       }
-       compare_function(EX_VAR(opline->result.var), op1, op2);
-       zval_ptr_dtor_nogc(free_op1);
-       zval_ptr_dtor_nogc(free_op2);
-       if (UNEXPECTED(EG(exception))) {
-               HANDLE_EXCEPTION();
-       }
-       if (Z_LVAL_P(EX_VAR(opline->result.var)) == 0) {
-is_equal_true:
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-is_equal_false:
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
+       ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -14702,12 +14648,20 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVA
 
        op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
        op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
-       if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
+       if (ZEND_VM_SPEC && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
+               /* pass */
+       } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
                        if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
-                               goto is_not_equal_true;
+is_not_equal_true:
+                               ZEND_VM_SMART_BRANCH_TRUE();
+                               ZVAL_TRUE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        } else {
-                               goto is_not_equal_false;
+is_not_equal_false:
+                               ZEND_VM_SMART_BRANCH_FALSE();
+                               ZVAL_FALSE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -14745,156 +14699,7 @@ is_not_equal_double:
                        }
                }
        }
-       SAVE_OPLINE();
-       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
-               op1 = ZVAL_UNDEFINED_OP1();
-       }
-       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
-               op2 = ZVAL_UNDEFINED_OP2();
-       }
-       compare_function(EX_VAR(opline->result.var), op1, op2);
-       zval_ptr_dtor_nogc(free_op1);
-       zval_ptr_dtor_nogc(free_op2);
-       if (UNEXPECTED(EG(exception))) {
-               HANDLE_EXCEPTION();
-       }
-       if (Z_LVAL_P(EX_VAR(opline->result.var)) != 0) {
-is_not_equal_true:
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-is_not_equal_false:
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
-}
-
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op1, free_op2;
-       zval *op1, *op2;
-       double d1, d2;
-
-       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
-       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
-       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
-               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
-                       if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
-                               goto is_smaller_true;
-                       } else {
-                               goto is_smaller_false;
-                       }
-               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
-                       d1 = (double)Z_LVAL_P(op1);
-                       d2 = Z_DVAL_P(op2);
-                       goto is_smaller_double;
-               }
-       } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
-               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
-                       d1 = Z_DVAL_P(op1);
-                       d2 = Z_DVAL_P(op2);
-is_smaller_double:
-                       if (d1 < d2) {
-                               goto is_smaller_true;
-                       } else {
-                               goto is_smaller_false;
-                       }
-               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
-                       d1 = Z_DVAL_P(op1);
-                       d2 = (double)Z_LVAL_P(op2);
-                       goto is_smaller_double;
-               }
-       }
-       SAVE_OPLINE();
-       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
-               op1 = ZVAL_UNDEFINED_OP1();
-       }
-       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
-               op2 = ZVAL_UNDEFINED_OP2();
-       }
-       compare_function(EX_VAR(opline->result.var), op1, op2);
-       zval_ptr_dtor_nogc(free_op1);
-       zval_ptr_dtor_nogc(free_op2);
-       if (UNEXPECTED(EG(exception))) {
-               HANDLE_EXCEPTION();
-       }
-       if (Z_LVAL_P(EX_VAR(opline->result.var)) < 0) {
-is_smaller_true:
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-is_smaller_false:
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
-}
-
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op1, free_op2;
-       zval *op1, *op2;
-       double d1, d2;
-
-       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
-       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
-       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
-               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
-                       if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
-                               goto is_smaller_or_equal_true;
-                       } else {
-                               goto is_smaller_or_equal_false;
-                       }
-               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
-                       d1 = (double)Z_LVAL_P(op1);
-                       d2 = Z_DVAL_P(op2);
-                       goto is_smaller_or_equal_double;
-               }
-       } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
-               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
-                       d1 = Z_DVAL_P(op1);
-                       d2 = Z_DVAL_P(op2);
-is_smaller_or_equal_double:
-                       if (d1 <= d2) {
-                               goto is_smaller_or_equal_true;
-                       } else {
-                               goto is_smaller_or_equal_false;
-                       }
-               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
-                       d1 = Z_DVAL_P(op1);
-                       d2 = (double)Z_LVAL_P(op2);
-                       goto is_smaller_or_equal_double;
-               }
-       }
-       SAVE_OPLINE();
-       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
-               op1 = ZVAL_UNDEFINED_OP1();
-       }
-       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
-               op2 = ZVAL_UNDEFINED_OP2();
-       }
-       compare_function(EX_VAR(opline->result.var), op1, op2);
-       zval_ptr_dtor_nogc(free_op1);
-       zval_ptr_dtor_nogc(free_op2);
-       if (UNEXPECTED(EG(exception))) {
-               HANDLE_EXCEPTION();
-       }
-       if (Z_LVAL_P(EX_VAR(opline->result.var)) <= 0) {
-is_smaller_or_equal_true:
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-is_smaller_or_equal_false:
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
+       ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -15475,9 +15280,15 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLE
        if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
                        if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
-                               goto case_true;
+case_true:
+                               ZEND_VM_SMART_BRANCH_TRUE();
+                               ZVAL_TRUE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        } else {
-                               goto case_false;
+case_false:
+                               ZEND_VM_SMART_BRANCH_FALSE();
+                               ZVAL_FALSE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -15510,29 +15321,7 @@ case_double:
                        }
                }
        }
-       SAVE_OPLINE();
-       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
-               op1 = ZVAL_UNDEFINED_OP1();
-       }
-       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
-               op2 = ZVAL_UNDEFINED_OP2();
-       }
-       compare_function(EX_VAR(opline->result.var), op1, op2);
-       zval_ptr_dtor_nogc(free_op2);
-       if (UNEXPECTED(EG(exception))) {
-               HANDLE_EXCEPTION();
-       }
-       if (Z_LVAL_P(EX_VAR(opline->result.var)) == 0) {
-case_true:
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-case_false:
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
+       ZEND_VM_TAIL_CALL(zend_case_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -16116,132 +15905,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_TMPVAR_CV_HANDLER(
        }
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op1;
-       zval *op1, *op2;
-       double d1, d2;
-
-       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
-       op2 = EX_VAR(opline->op2.var);
-       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
-               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
-                       if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
-                               goto is_smaller_true;
-                       } else {
-                               goto is_smaller_false;
-                       }
-               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
-                       d1 = (double)Z_LVAL_P(op1);
-                       d2 = Z_DVAL_P(op2);
-                       goto is_smaller_double;
-               }
-       } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
-               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
-                       d1 = Z_DVAL_P(op1);
-                       d2 = Z_DVAL_P(op2);
-is_smaller_double:
-                       if (d1 < d2) {
-                               goto is_smaller_true;
-                       } else {
-                               goto is_smaller_false;
-                       }
-               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
-                       d1 = Z_DVAL_P(op1);
-                       d2 = (double)Z_LVAL_P(op2);
-                       goto is_smaller_double;
-               }
-       }
-       SAVE_OPLINE();
-       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
-               op1 = ZVAL_UNDEFINED_OP1();
-       }
-       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
-               op2 = ZVAL_UNDEFINED_OP2();
-       }
-       compare_function(EX_VAR(opline->result.var), op1, op2);
-       zval_ptr_dtor_nogc(free_op1);
-
-       if (UNEXPECTED(EG(exception))) {
-               HANDLE_EXCEPTION();
-       }
-       if (Z_LVAL_P(EX_VAR(opline->result.var)) < 0) {
-is_smaller_true:
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-is_smaller_false:
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
-}
-
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op1;
-       zval *op1, *op2;
-       double d1, d2;
-
-       op1 = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
-       op2 = EX_VAR(opline->op2.var);
-       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
-               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
-                       if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
-                               goto is_smaller_or_equal_true;
-                       } else {
-                               goto is_smaller_or_equal_false;
-                       }
-               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
-                       d1 = (double)Z_LVAL_P(op1);
-                       d2 = Z_DVAL_P(op2);
-                       goto is_smaller_or_equal_double;
-               }
-       } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
-               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
-                       d1 = Z_DVAL_P(op1);
-                       d2 = Z_DVAL_P(op2);
-is_smaller_or_equal_double:
-                       if (d1 <= d2) {
-                               goto is_smaller_or_equal_true;
-                       } else {
-                               goto is_smaller_or_equal_false;
-                       }
-               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
-                       d1 = Z_DVAL_P(op1);
-                       d2 = (double)Z_LVAL_P(op2);
-                       goto is_smaller_or_equal_double;
-               }
-       }
-       SAVE_OPLINE();
-       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
-               op1 = ZVAL_UNDEFINED_OP1();
-       }
-       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
-               op2 = ZVAL_UNDEFINED_OP2();
-       }
-       compare_function(EX_VAR(opline->result.var), op1, op2);
-       zval_ptr_dtor_nogc(free_op1);
-
-       if (UNEXPECTED(EG(exception))) {
-               HANDLE_EXCEPTION();
-       }
-       if (Z_LVAL_P(EX_VAR(opline->result.var)) <= 0) {
-is_smaller_or_equal_true:
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-is_smaller_or_equal_false:
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
-}
-
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -16805,9 +16468,15 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_CV_HANDLER(ZE
        if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
                        if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
-                               goto case_true;
+case_true:
+                               ZEND_VM_SMART_BRANCH_TRUE();
+                               ZVAL_TRUE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        } else {
-                               goto case_false;
+case_false:
+                               ZEND_VM_SMART_BRANCH_FALSE();
+                               ZVAL_FALSE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -16840,29 +16509,7 @@ case_double:
                        }
                }
        }
-       SAVE_OPLINE();
-       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
-               op1 = ZVAL_UNDEFINED_OP1();
-       }
-       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
-               op2 = ZVAL_UNDEFINED_OP2();
-       }
-       compare_function(EX_VAR(opline->result.var), op1, op2);
-
-       if (UNEXPECTED(EG(exception))) {
-               HANDLE_EXCEPTION();
-       }
-       if (Z_LVAL_P(EX_VAR(opline->result.var)) == 0) {
-case_true:
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-case_false:
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
+       ZEND_VM_TAIL_CALL(zend_case_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -37553,12 +37200,20 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER
 
        op1 = EX_VAR(opline->op1.var);
        op2 = RT_CONSTANT(opline, opline->op2);
-       if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
+       if (ZEND_VM_SPEC && IS_CV == IS_CONST && IS_CONST == IS_CONST) {
+               /* pass */
+       } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
                        if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
-                               goto is_equal_true;
+is_equal_true:
+                               ZEND_VM_SMART_BRANCH_TRUE();
+                               ZVAL_TRUE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        } else {
-                               goto is_equal_false;
+is_equal_false:
+                               ZEND_VM_SMART_BRANCH_FALSE();
+                               ZVAL_FALSE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -37596,30 +37251,7 @@ is_equal_double:
                        }
                }
        }
-       SAVE_OPLINE();
-       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
-               op1 = ZVAL_UNDEFINED_OP1();
-       }
-       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
-               op2 = ZVAL_UNDEFINED_OP2();
-       }
-       compare_function(EX_VAR(opline->result.var), op1, op2);
-
-
-       if (UNEXPECTED(EG(exception))) {
-               HANDLE_EXCEPTION();
-       }
-       if (Z_LVAL_P(EX_VAR(opline->result.var)) == 0) {
-is_equal_true:
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-is_equal_false:
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
+       ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -37631,12 +37263,20 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HAN
 
        op1 = EX_VAR(opline->op1.var);
        op2 = RT_CONSTANT(opline, opline->op2);
-       if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
+       if (ZEND_VM_SPEC && IS_CV == IS_CONST && IS_CONST == IS_CONST) {
+               /* pass */
+       } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
                        if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
-                               goto is_not_equal_true;
+is_not_equal_true:
+                               ZEND_VM_SMART_BRANCH_TRUE();
+                               ZVAL_TRUE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        } else {
-                               goto is_not_equal_false;
+is_not_equal_false:
+                               ZEND_VM_SMART_BRANCH_FALSE();
+                               ZVAL_FALSE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -37674,156 +37314,7 @@ is_not_equal_double:
                        }
                }
        }
-       SAVE_OPLINE();
-       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
-               op1 = ZVAL_UNDEFINED_OP1();
-       }
-       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
-               op2 = ZVAL_UNDEFINED_OP2();
-       }
-       compare_function(EX_VAR(opline->result.var), op1, op2);
-
-
-       if (UNEXPECTED(EG(exception))) {
-               HANDLE_EXCEPTION();
-       }
-       if (Z_LVAL_P(EX_VAR(opline->result.var)) != 0) {
-is_not_equal_true:
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-is_not_equal_false:
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
-}
-
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-
-       zval *op1, *op2;
-       double d1, d2;
-
-       op1 = EX_VAR(opline->op1.var);
-       op2 = RT_CONSTANT(opline, opline->op2);
-       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
-               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
-                       if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
-                               goto is_smaller_true;
-                       } else {
-                               goto is_smaller_false;
-                       }
-               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
-                       d1 = (double)Z_LVAL_P(op1);
-                       d2 = Z_DVAL_P(op2);
-                       goto is_smaller_double;
-               }
-       } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
-               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
-                       d1 = Z_DVAL_P(op1);
-                       d2 = Z_DVAL_P(op2);
-is_smaller_double:
-                       if (d1 < d2) {
-                               goto is_smaller_true;
-                       } else {
-                               goto is_smaller_false;
-                       }
-               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
-                       d1 = Z_DVAL_P(op1);
-                       d2 = (double)Z_LVAL_P(op2);
-                       goto is_smaller_double;
-               }
-       }
-       SAVE_OPLINE();
-       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
-               op1 = ZVAL_UNDEFINED_OP1();
-       }
-       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
-               op2 = ZVAL_UNDEFINED_OP2();
-       }
-       compare_function(EX_VAR(opline->result.var), op1, op2);
-
-
-       if (UNEXPECTED(EG(exception))) {
-               HANDLE_EXCEPTION();
-       }
-       if (Z_LVAL_P(EX_VAR(opline->result.var)) < 0) {
-is_smaller_true:
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-is_smaller_false:
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
-}
-
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-
-       zval *op1, *op2;
-       double d1, d2;
-
-       op1 = EX_VAR(opline->op1.var);
-       op2 = RT_CONSTANT(opline, opline->op2);
-       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
-               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
-                       if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
-                               goto is_smaller_or_equal_true;
-                       } else {
-                               goto is_smaller_or_equal_false;
-                       }
-               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
-                       d1 = (double)Z_LVAL_P(op1);
-                       d2 = Z_DVAL_P(op2);
-                       goto is_smaller_or_equal_double;
-               }
-       } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
-               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
-                       d1 = Z_DVAL_P(op1);
-                       d2 = Z_DVAL_P(op2);
-is_smaller_or_equal_double:
-                       if (d1 <= d2) {
-                               goto is_smaller_or_equal_true;
-                       } else {
-                               goto is_smaller_or_equal_false;
-                       }
-               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
-                       d1 = Z_DVAL_P(op1);
-                       d2 = (double)Z_LVAL_P(op2);
-                       goto is_smaller_or_equal_double;
-               }
-       }
-       SAVE_OPLINE();
-       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
-               op1 = ZVAL_UNDEFINED_OP1();
-       }
-       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
-               op2 = ZVAL_UNDEFINED_OP2();
-       }
-       compare_function(EX_VAR(opline->result.var), op1, op2);
-
-
-       if (UNEXPECTED(EG(exception))) {
-               HANDLE_EXCEPTION();
-       }
-       if (Z_LVAL_P(EX_VAR(opline->result.var)) <= 0) {
-is_smaller_or_equal_true:
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-is_smaller_or_equal_false:
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
+       ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -40942,12 +40433,20 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMPVAR_HANDLE
 
        op1 = EX_VAR(opline->op1.var);
        op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
-       if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
+       if (ZEND_VM_SPEC && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
+               /* pass */
+       } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
                        if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
-                               goto is_equal_true;
+is_equal_true:
+                               ZEND_VM_SMART_BRANCH_TRUE();
+                               ZVAL_TRUE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        } else {
-                               goto is_equal_false;
+is_equal_false:
+                               ZEND_VM_SMART_BRANCH_FALSE();
+                               ZVAL_FALSE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -40985,30 +40484,7 @@ is_equal_double:
                        }
                }
        }
-       SAVE_OPLINE();
-       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
-               op1 = ZVAL_UNDEFINED_OP1();
-       }
-       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
-               op2 = ZVAL_UNDEFINED_OP2();
-       }
-       compare_function(EX_VAR(opline->result.var), op1, op2);
-
-       zval_ptr_dtor_nogc(free_op2);
-       if (UNEXPECTED(EG(exception))) {
-               HANDLE_EXCEPTION();
-       }
-       if (Z_LVAL_P(EX_VAR(opline->result.var)) == 0) {
-is_equal_true:
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-is_equal_false:
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
+       ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -41020,12 +40496,20 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HA
 
        op1 = EX_VAR(opline->op1.var);
        op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
-       if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
+       if (ZEND_VM_SPEC && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
+               /* pass */
+       } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
                        if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
-                               goto is_not_equal_true;
+is_not_equal_true:
+                               ZEND_VM_SMART_BRANCH_TRUE();
+                               ZVAL_TRUE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        } else {
-                               goto is_not_equal_false;
+is_not_equal_false:
+                               ZEND_VM_SMART_BRANCH_FALSE();
+                               ZVAL_FALSE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -41063,156 +40547,7 @@ is_not_equal_double:
                        }
                }
        }
-       SAVE_OPLINE();
-       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
-               op1 = ZVAL_UNDEFINED_OP1();
-       }
-       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
-               op2 = ZVAL_UNDEFINED_OP2();
-       }
-       compare_function(EX_VAR(opline->result.var), op1, op2);
-
-       zval_ptr_dtor_nogc(free_op2);
-       if (UNEXPECTED(EG(exception))) {
-               HANDLE_EXCEPTION();
-       }
-       if (Z_LVAL_P(EX_VAR(opline->result.var)) != 0) {
-is_not_equal_true:
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-is_not_equal_false:
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
-}
-
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op2;
-       zval *op1, *op2;
-       double d1, d2;
-
-       op1 = EX_VAR(opline->op1.var);
-       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
-       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
-               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
-                       if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
-                               goto is_smaller_true;
-                       } else {
-                               goto is_smaller_false;
-                       }
-               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
-                       d1 = (double)Z_LVAL_P(op1);
-                       d2 = Z_DVAL_P(op2);
-                       goto is_smaller_double;
-               }
-       } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
-               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
-                       d1 = Z_DVAL_P(op1);
-                       d2 = Z_DVAL_P(op2);
-is_smaller_double:
-                       if (d1 < d2) {
-                               goto is_smaller_true;
-                       } else {
-                               goto is_smaller_false;
-                       }
-               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
-                       d1 = Z_DVAL_P(op1);
-                       d2 = (double)Z_LVAL_P(op2);
-                       goto is_smaller_double;
-               }
-       }
-       SAVE_OPLINE();
-       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
-               op1 = ZVAL_UNDEFINED_OP1();
-       }
-       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
-               op2 = ZVAL_UNDEFINED_OP2();
-       }
-       compare_function(EX_VAR(opline->result.var), op1, op2);
-
-       zval_ptr_dtor_nogc(free_op2);
-       if (UNEXPECTED(EG(exception))) {
-               HANDLE_EXCEPTION();
-       }
-       if (Z_LVAL_P(EX_VAR(opline->result.var)) < 0) {
-is_smaller_true:
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-is_smaller_false:
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
-}
-
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op2;
-       zval *op1, *op2;
-       double d1, d2;
-
-       op1 = EX_VAR(opline->op1.var);
-       op2 = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
-       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
-               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
-                       if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
-                               goto is_smaller_or_equal_true;
-                       } else {
-                               goto is_smaller_or_equal_false;
-                       }
-               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
-                       d1 = (double)Z_LVAL_P(op1);
-                       d2 = Z_DVAL_P(op2);
-                       goto is_smaller_or_equal_double;
-               }
-       } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
-               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
-                       d1 = Z_DVAL_P(op1);
-                       d2 = Z_DVAL_P(op2);
-is_smaller_or_equal_double:
-                       if (d1 <= d2) {
-                               goto is_smaller_or_equal_true;
-                       } else {
-                               goto is_smaller_or_equal_false;
-                       }
-               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
-                       d1 = Z_DVAL_P(op1);
-                       d2 = (double)Z_LVAL_P(op2);
-                       goto is_smaller_or_equal_double;
-               }
-       }
-       SAVE_OPLINE();
-       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
-               op1 = ZVAL_UNDEFINED_OP1();
-       }
-       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
-               op2 = ZVAL_UNDEFINED_OP2();
-       }
-       compare_function(EX_VAR(opline->result.var), op1, op2);
-
-       zval_ptr_dtor_nogc(free_op2);
-       if (UNEXPECTED(EG(exception))) {
-               HANDLE_EXCEPTION();
-       }
-       if (Z_LVAL_P(EX_VAR(opline->result.var)) <= 0) {
-is_smaller_or_equal_true:
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-is_smaller_or_equal_false:
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
+       ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -45903,12 +45238,20 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER(ZE
 
        op1 = EX_VAR(opline->op1.var);
        op2 = EX_VAR(opline->op2.var);
-       if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
+       if (ZEND_VM_SPEC && IS_CV == IS_CONST && IS_CV == IS_CONST) {
+               /* pass */
+       } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
                        if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
-                               goto is_equal_true;
+is_equal_true:
+                               ZEND_VM_SMART_BRANCH_TRUE();
+                               ZVAL_TRUE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        } else {
-                               goto is_equal_false;
+is_equal_false:
+                               ZEND_VM_SMART_BRANCH_FALSE();
+                               ZVAL_FALSE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -45946,30 +45289,7 @@ is_equal_double:
                        }
                }
        }
-       SAVE_OPLINE();
-       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
-               op1 = ZVAL_UNDEFINED_OP1();
-       }
-       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
-               op2 = ZVAL_UNDEFINED_OP2();
-       }
-       compare_function(EX_VAR(opline->result.var), op1, op2);
-
-
-       if (UNEXPECTED(EG(exception))) {
-               HANDLE_EXCEPTION();
-       }
-       if (Z_LVAL_P(EX_VAR(opline->result.var)) == 0) {
-is_equal_true:
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-is_equal_false:
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
+       ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -45981,12 +45301,20 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLE
 
        op1 = EX_VAR(opline->op1.var);
        op2 = EX_VAR(opline->op2.var);
-       if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
+       if (ZEND_VM_SPEC && IS_CV == IS_CONST && IS_CV == IS_CONST) {
+               /* pass */
+       } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
                        if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
-                               goto is_not_equal_true;
+is_not_equal_true:
+                               ZEND_VM_SMART_BRANCH_TRUE();
+                               ZVAL_TRUE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        } else {
-                               goto is_not_equal_false;
+is_not_equal_false:
+                               ZEND_VM_SMART_BRANCH_FALSE();
+                               ZVAL_FALSE(EX_VAR(opline->result.var));
+                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -46024,156 +45352,7 @@ is_not_equal_double:
                        }
                }
        }
-       SAVE_OPLINE();
-       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
-               op1 = ZVAL_UNDEFINED_OP1();
-       }
-       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
-               op2 = ZVAL_UNDEFINED_OP2();
-       }
-       compare_function(EX_VAR(opline->result.var), op1, op2);
-
-
-       if (UNEXPECTED(EG(exception))) {
-               HANDLE_EXCEPTION();
-       }
-       if (Z_LVAL_P(EX_VAR(opline->result.var)) != 0) {
-is_not_equal_true:
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-is_not_equal_false:
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
-}
-
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-
-       zval *op1, *op2;
-       double d1, d2;
-
-       op1 = EX_VAR(opline->op1.var);
-       op2 = EX_VAR(opline->op2.var);
-       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
-               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
-                       if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
-                               goto is_smaller_true;
-                       } else {
-                               goto is_smaller_false;
-                       }
-               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
-                       d1 = (double)Z_LVAL_P(op1);
-                       d2 = Z_DVAL_P(op2);
-                       goto is_smaller_double;
-               }
-       } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
-               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
-                       d1 = Z_DVAL_P(op1);
-                       d2 = Z_DVAL_P(op2);
-is_smaller_double:
-                       if (d1 < d2) {
-                               goto is_smaller_true;
-                       } else {
-                               goto is_smaller_false;
-                       }
-               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
-                       d1 = Z_DVAL_P(op1);
-                       d2 = (double)Z_LVAL_P(op2);
-                       goto is_smaller_double;
-               }
-       }
-       SAVE_OPLINE();
-       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
-               op1 = ZVAL_UNDEFINED_OP1();
-       }
-       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
-               op2 = ZVAL_UNDEFINED_OP2();
-       }
-       compare_function(EX_VAR(opline->result.var), op1, op2);
-
-
-       if (UNEXPECTED(EG(exception))) {
-               HANDLE_EXCEPTION();
-       }
-       if (Z_LVAL_P(EX_VAR(opline->result.var)) < 0) {
-is_smaller_true:
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-is_smaller_false:
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
-}
-
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-
-       zval *op1, *op2;
-       double d1, d2;
-
-       op1 = EX_VAR(opline->op1.var);
-       op2 = EX_VAR(opline->op2.var);
-       if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
-               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
-                       if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
-                               goto is_smaller_or_equal_true;
-                       } else {
-                               goto is_smaller_or_equal_false;
-                       }
-               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
-                       d1 = (double)Z_LVAL_P(op1);
-                       d2 = Z_DVAL_P(op2);
-                       goto is_smaller_or_equal_double;
-               }
-       } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
-               if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
-                       d1 = Z_DVAL_P(op1);
-                       d2 = Z_DVAL_P(op2);
-is_smaller_or_equal_double:
-                       if (d1 <= d2) {
-                               goto is_smaller_or_equal_true;
-                       } else {
-                               goto is_smaller_or_equal_false;
-                       }
-               } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
-                       d1 = Z_DVAL_P(op1);
-                       d2 = (double)Z_LVAL_P(op2);
-                       goto is_smaller_or_equal_double;
-               }
-       }
-       SAVE_OPLINE();
-       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
-               op1 = ZVAL_UNDEFINED_OP1();
-       }
-       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op2) == IS_UNDEF)) {
-               op2 = ZVAL_UNDEFINED_OP2();
-       }
-       compare_function(EX_VAR(opline->result.var), op1, op2);
-
-
-       if (UNEXPECTED(EG(exception))) {
-               HANDLE_EXCEPTION();
-       }
-       if (Z_LVAL_P(EX_VAR(opline->result.var)) <= 0) {
-is_smaller_or_equal_true:
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-is_smaller_or_equal_false:
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
+       ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -49416,55 +48595,55 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_CV_LABEL,
                        (void*)&&ZEND_IS_SMALLER_SPEC_CONST_CONST_LABEL,
-                       (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVAR_LABEL,
-                       (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVAR_LABEL,
+                       (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_LABEL,
+                       (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_IS_SMALLER_SPEC_CONST_CV_LABEL,
-                       (void*)&&ZEND_IS_SMALLER_SPEC_TMPVAR_CONST_LABEL,
-                       (void*)&&ZEND_IS_SMALLER_SPEC_TMPVAR_TMPVAR_LABEL,
-                       (void*)&&ZEND_IS_SMALLER_SPEC_TMPVAR_TMPVAR_LABEL,
+                       (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_LABEL,
+                       (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_LABEL,
+                       (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
+                       (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_IS_SMALLER_SPEC_TMPVAR_CV_LABEL,
-                       (void*)&&ZEND_IS_SMALLER_SPEC_TMPVAR_CONST_LABEL,
-                       (void*)&&ZEND_IS_SMALLER_SPEC_TMPVAR_TMPVAR_LABEL,
-                       (void*)&&ZEND_IS_SMALLER_SPEC_TMPVAR_TMPVAR_LABEL,
+                       (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
+                       (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_LABEL,
+                       (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
+                       (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_IS_SMALLER_SPEC_TMPVAR_CV_LABEL,
+                       (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_IS_SMALLER_SPEC_CV_CONST_LABEL,
-                       (void*)&&ZEND_IS_SMALLER_SPEC_CV_TMPVAR_LABEL,
-                       (void*)&&ZEND_IS_SMALLER_SPEC_CV_TMPVAR_LABEL,
+                       (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_LABEL,
+                       (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
+                       (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_IS_SMALLER_SPEC_CV_CV_LABEL,
+                       (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
                        (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_LABEL,
-                       (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVAR_LABEL,
-                       (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVAR_LABEL,
+                       (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_LABEL,
+                       (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CV_LABEL,
-                       (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_CONST_LABEL,
-                       (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
-                       (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
+                       (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_LABEL,
+                       (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_LABEL,
+                       (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
+                       (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_CV_LABEL,
-                       (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_CONST_LABEL,
-                       (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
-                       (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
+                       (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
+                       (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_LABEL,
+                       (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
+                       (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_CV_LABEL,
+                       (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CONST_LABEL,
-                       (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_TMPVAR_LABEL,
-                       (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_TMPVAR_LABEL,
+                       (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_LABEL,
+                       (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
+                       (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CV_LABEL,
+                       (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
@@ -52740,6 +51919,14 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_SR_SPEC_CONST_TMPVARCV)
                                ZEND_SR_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV):
+                               VM_TRACE(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV)
+                               ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV):
+                               VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV)
+                               ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV):
                                VM_TRACE(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV)
                                ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -52816,14 +52003,6 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_CONCAT_SPEC_CONST_TMPVAR)
                                ZEND_CONCAT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
-                       HYBRID_CASE(ZEND_IS_SMALLER_SPEC_CONST_TMPVAR):
-                               VM_TRACE(ZEND_IS_SMALLER_SPEC_CONST_TMPVAR)
-                               ZEND_IS_SMALLER_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-                               HYBRID_BREAK();
-                       HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVAR):
-                               VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVAR)
-                               ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_SPACESHIP_SPEC_CONST_TMPVAR):
                                VM_TRACE(ZEND_SPACESHIP_SPEC_CONST_TMPVAR)
                                ZEND_SPACESHIP_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -52992,14 +52171,6 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_CONCAT_SPEC_CONST_CV)
                                ZEND_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
-                       HYBRID_CASE(ZEND_IS_SMALLER_SPEC_CONST_CV):
-                               VM_TRACE(ZEND_IS_SMALLER_SPEC_CONST_CV)
-                               ZEND_IS_SMALLER_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-                               HYBRID_BREAK();
-                       HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CV):
-                               VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CV)
-                               ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_SPACESHIP_SPEC_CONST_CV):
                                VM_TRACE(ZEND_SPACESHIP_SPEC_CONST_CV)
                                ZEND_SPACESHIP_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -53176,6 +52347,14 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_SR_SPEC_TMPVARCV_CONST)
                                ZEND_SR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST):
+                               VM_TRACE(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST)
+                               ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST):
+                               VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST)
+                               ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_BW_OR_SPEC_TMPVARCV_CONST):
                                VM_TRACE(ZEND_BW_OR_SPEC_TMPVARCV_CONST)
                                ZEND_BW_OR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -53356,6 +52535,14 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_SR_SPEC_TMPVARCV_TMPVARCV)
                                ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV):
+                               VM_TRACE(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV)
+                               ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV):
+                               VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV)
+                               ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV):
                                VM_TRACE(ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV)
                                ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -53596,14 +52783,6 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST)
                                ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
-                       HYBRID_CASE(ZEND_IS_SMALLER_SPEC_TMPVAR_CONST):
-                               VM_TRACE(ZEND_IS_SMALLER_SPEC_TMPVAR_CONST)
-                               ZEND_IS_SMALLER_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-                               HYBRID_BREAK();
-                       HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_CONST):
-                               VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_CONST)
-                               ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_SPACESHIP_SPEC_TMPVAR_CONST):
                                VM_TRACE(ZEND_SPACESHIP_SPEC_TMPVAR_CONST)
                                ZEND_SPACESHIP_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -53684,14 +52863,6 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR)
                                ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
-                       HYBRID_CASE(ZEND_IS_SMALLER_SPEC_TMPVAR_TMPVAR):
-                               VM_TRACE(ZEND_IS_SMALLER_SPEC_TMPVAR_TMPVAR)
-                               ZEND_IS_SMALLER_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-                               HYBRID_BREAK();
-                       HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_TMPVAR):
-                               VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_TMPVAR)
-                               ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR):
                                VM_TRACE(ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR)
                                ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -53796,14 +52967,6 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_CONCAT_SPEC_TMPVAR_CV)
                                ZEND_CONCAT_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
-                       HYBRID_CASE(ZEND_IS_SMALLER_SPEC_TMPVAR_CV):
-                               VM_TRACE(ZEND_IS_SMALLER_SPEC_TMPVAR_CV)
-                               ZEND_IS_SMALLER_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-                               HYBRID_BREAK();
-                       HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_CV):
-                               VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_CV)
-                               ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_SPACESHIP_SPEC_TMPVAR_CV):
                                VM_TRACE(ZEND_SPACESHIP_SPEC_TMPVAR_CV)
                                ZEND_SPACESHIP_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -55410,14 +54573,6 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST)
                                ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
-                       HYBRID_CASE(ZEND_IS_SMALLER_SPEC_CV_CONST):
-                               VM_TRACE(ZEND_IS_SMALLER_SPEC_CV_CONST)
-                               ZEND_IS_SMALLER_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-                               HYBRID_BREAK();
-                       HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CONST):
-                               VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CONST)
-                               ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_SPACESHIP_SPEC_CV_CONST):
                                VM_TRACE(ZEND_SPACESHIP_SPEC_CV_CONST)
                                ZEND_SPACESHIP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -55622,14 +54777,6 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR)
                                ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
-                       HYBRID_CASE(ZEND_IS_SMALLER_SPEC_CV_TMPVAR):
-                               VM_TRACE(ZEND_IS_SMALLER_SPEC_CV_TMPVAR)
-                               ZEND_IS_SMALLER_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-                               HYBRID_BREAK();
-                       HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_TMPVAR):
-                               VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_TMPVAR)
-                               ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_SPACESHIP_SPEC_CV_TMPVAR):
                                VM_TRACE(ZEND_SPACESHIP_SPEC_CV_TMPVAR)
                                ZEND_SPACESHIP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -55978,14 +55125,6 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_CV)
                                ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
-                       HYBRID_CASE(ZEND_IS_SMALLER_SPEC_CV_CV):
-                               VM_TRACE(ZEND_IS_SMALLER_SPEC_CV_CV)
-                               ZEND_IS_SMALLER_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-                               HYBRID_BREAK();
-                       HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CV):
-                               VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CV)
-                               ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_SPACESHIP_SPEC_CV_CV):
                                VM_TRACE(ZEND_SPACESHIP_SPEC_CV_CV)
                                ZEND_SPACESHIP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -56665,55 +55804,55 @@ void zend_vm_init(void)
                ZEND_NULL_HANDLER,
                ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER,
                ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER,
-               ZEND_IS_SMALLER_SPEC_CONST_TMPVAR_HANDLER,
-               ZEND_IS_SMALLER_SPEC_CONST_TMPVAR_HANDLER,
+               ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_HANDLER,
+               ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_HANDLER,
                ZEND_NULL_HANDLER,
-               ZEND_IS_SMALLER_SPEC_CONST_CV_HANDLER,
-               ZEND_IS_SMALLER_SPEC_TMPVAR_CONST_HANDLER,
-               ZEND_IS_SMALLER_SPEC_TMPVAR_TMPVAR_HANDLER,
-               ZEND_IS_SMALLER_SPEC_TMPVAR_TMPVAR_HANDLER,
+               ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_HANDLER,
+               ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_HANDLER,
+               ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
+               ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
                ZEND_NULL_HANDLER,
-               ZEND_IS_SMALLER_SPEC_TMPVAR_CV_HANDLER,
-               ZEND_IS_SMALLER_SPEC_TMPVAR_CONST_HANDLER,
-               ZEND_IS_SMALLER_SPEC_TMPVAR_TMPVAR_HANDLER,
-               ZEND_IS_SMALLER_SPEC_TMPVAR_TMPVAR_HANDLER,
+               ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
+               ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_HANDLER,
+               ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
+               ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
                ZEND_NULL_HANDLER,
-               ZEND_IS_SMALLER_SPEC_TMPVAR_CV_HANDLER,
+               ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
-               ZEND_IS_SMALLER_SPEC_CV_CONST_HANDLER,
-               ZEND_IS_SMALLER_SPEC_CV_TMPVAR_HANDLER,
-               ZEND_IS_SMALLER_SPEC_CV_TMPVAR_HANDLER,
+               ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_HANDLER,
+               ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
+               ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
                ZEND_NULL_HANDLER,
-               ZEND_IS_SMALLER_SPEC_CV_CV_HANDLER,
+               ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
                ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER,
-               ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVAR_HANDLER,
-               ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVAR_HANDLER,
+               ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_HANDLER,
+               ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_HANDLER,
                ZEND_NULL_HANDLER,
-               ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CV_HANDLER,
-               ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_CONST_HANDLER,
-               ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
-               ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
+               ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_HANDLER,
+               ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_HANDLER,
+               ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
+               ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
                ZEND_NULL_HANDLER,
-               ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_CV_HANDLER,
-               ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_CONST_HANDLER,
-               ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
-               ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
+               ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
+               ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_HANDLER,
+               ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
+               ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
                ZEND_NULL_HANDLER,
-               ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_CV_HANDLER,
+               ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
-               ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CONST_HANDLER,
-               ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_TMPVAR_HANDLER,
-               ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_TMPVAR_HANDLER,
+               ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_HANDLER,
+               ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
+               ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
                ZEND_NULL_HANDLER,
-               ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CV_HANDLER,
+               ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,

diff --git a/Zend/zend_vm_gen.php b/Zend/zend_vm_gen.php
index c1051f2717afe81396dc78e50aee7f8fb3a2f5d1..3d6748c887cc9c200b11e5d60fbcbb5b35eab695 100755 (executable)
--- a/Zend/zend_vm_gen.php
+++ b/Zend/zend_vm_gen.php
@@ -839,6 +839,18 @@ function gen_code($f, $spec, $kind, $export, $code, $op1, $op2, $name, $extra_sp
                                :       ($extra_spec['SMART_BRANCH'] == 2 ?
                                                "ZEND_VM_SMART_BRANCH_JMPNZ(\\1, \\2)" : ""))
                        :       "ZEND_VM_SMART_BRANCH(\\1, \\2)",
+               "/ZEND_VM_SMART_BRANCH_TRUE\(\s*\)/" => isset($extra_spec['SMART_BRANCH']) ?
+                       ($extra_spec['SMART_BRANCH'] == 1 ?
+                                       "ZEND_VM_SMART_BRANCH_TRUE_JMPZ()"
+                               :       ($extra_spec['SMART_BRANCH'] == 2 ?
+                                               "ZEND_VM_SMART_BRANCH_TRUE_JMPNZ()" : ""))
+                       :       "ZEND_VM_SMART_BRANCH_TRUE()",
+               "/ZEND_VM_SMART_BRANCH_FALSE\(\s*\)/" => isset($extra_spec['SMART_BRANCH']) ?
+                       ($extra_spec['SMART_BRANCH'] == 1 ?
+                                       "ZEND_VM_SMART_BRANCH_FALSE_JMPZ()"
+                               :       ($extra_spec['SMART_BRANCH'] == 2 ?
+                                               "ZEND_VM_SMART_BRANCH_FALSE_JMPNZ()" : ""))
+                       :       "ZEND_VM_SMART_BRANCH_FALSE()",
                "/opline->extended_value\s*&\s*ZEND_ISEMPTY/" => isset($extra_spec['ISSET']) ?
                        ($extra_spec['ISSET'] == 0 ? "0" : "1")
                        : "\\0",

diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h
index 02569fdcde60befbb1f4fb221e88259670c4b0c6..56423868f604d0cec6f795a170d9ce75834fd49e 100644 (file)
--- a/Zend/zend_vm_handlers.h
+++ b/Zend/zend_vm_handlers.h
@@ -241,37 +241,37 @@
        _(433, ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR) \
        _(435, ZEND_IS_NOT_EQUAL_SPEC_CV_CV) \
        _(436, ZEND_IS_SMALLER_SPEC_CONST_CONST) \
-       _(437, ZEND_IS_SMALLER_SPEC_CONST_TMPVAR) \
-       _(438, ZEND_IS_SMALLER_SPEC_CONST_TMPVAR) \
-       _(440, ZEND_IS_SMALLER_SPEC_CONST_CV) \
-       _(441, ZEND_IS_SMALLER_SPEC_TMPVAR_CONST) \
-       _(442, ZEND_IS_SMALLER_SPEC_TMPVAR_TMPVAR) \
-       _(443, ZEND_IS_SMALLER_SPEC_TMPVAR_TMPVAR) \
-       _(445, ZEND_IS_SMALLER_SPEC_TMPVAR_CV) \
-       _(446, ZEND_IS_SMALLER_SPEC_TMPVAR_CONST) \
-       _(447, ZEND_IS_SMALLER_SPEC_TMPVAR_TMPVAR) \
-       _(448, ZEND_IS_SMALLER_SPEC_TMPVAR_TMPVAR) \
-       _(450, ZEND_IS_SMALLER_SPEC_TMPVAR_CV) \
-       _(456, ZEND_IS_SMALLER_SPEC_CV_CONST) \
-       _(457, ZEND_IS_SMALLER_SPEC_CV_TMPVAR) \
-       _(458, ZEND_IS_SMALLER_SPEC_CV_TMPVAR) \
-       _(460, ZEND_IS_SMALLER_SPEC_CV_CV) \
+       _(437, ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV) \
+       _(438, ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV) \
+       _(440, ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV) \
+       _(441, ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST) \
+       _(442, ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV) \
+       _(443, ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV) \
+       _(445, ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV) \
+       _(446, ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST) \
+       _(447, ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV) \
+       _(448, ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV) \
+       _(450, ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV) \
+       _(456, ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST) \
+       _(457, ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV) \
+       _(458, ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV) \
+       _(460, ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV) \
        _(461, ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST) \
-       _(462, ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVAR) \
-       _(463, ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVAR) \
-       _(465, ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CV) \
-       _(466, ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_CONST) \
-       _(467, ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_TMPVAR) \
-       _(468, ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_TMPVAR) \
-       _(470, ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_CV) \
-       _(471, ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_CONST) \
-       _(472, ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_TMPVAR) \
-       _(473, ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_TMPVAR) \
-       _(475, ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_CV) \
-       _(481, ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CONST) \
-       _(482, ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_TMPVAR) \
-       _(483, ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_TMPVAR) \
-       _(485, ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CV) \
+       _(462, ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV) \
+       _(463, ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV) \
+       _(465, ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV) \
+       _(466, ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST) \
+       _(467, ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV) \
+       _(468, ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV) \
+       _(470, ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV) \
+       _(471, ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST) \
+       _(472, ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV) \
+       _(473, ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV) \
+       _(475, ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV) \
+       _(481, ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST) \
+       _(482, ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV) \
+       _(483, ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV) \
+       _(485, ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV) \
        _(506, ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED) \
        _(507, ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED) \
        _(508, ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED) \

diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c
index a0d6a1d04a1347c5a24a371007d1e82d08908cdd..31262e089c12161a5fafeee6e22e9dbd0efd1b5b 100644 (file)
--- a/Zend/zend_vm_opcodes.c
+++ b/Zend/zend_vm_opcodes.c
@@ -241,8 +241,8 @@ static uint32_t zend_vm_opcodes_flags[195] = {
        0x80000303,
        0x80000707,
        0x80000707,
-       0x00000707,
-       0x00000707,
+       0x00000b0b,
+       0x00000b0b,
        0x00000301,
        0x00006701,
        0x00040751,