Optimized "smart branch" instructions

diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
index e71075c9d4da4689d419394f8d85c7e4792ae103..2b1fe19e3ab494005603b68668c7e9a864a3b227 100644 (file)
--- a/Zend/zend_execute.c
+++ b/Zend/zend_execute.c
@@ -4365,12 +4365,32 @@ static zend_never_inline int ZEND_FASTCALL zend_quick_check_constant(
                } \
                ZEND_VM_CONTINUE(); \
        } while (0)
+#define ZEND_VM_SMART_BRANCH_TRUE() do { \
+               if (EXPECTED((opline+1)->opcode == ZEND_JMPNZ)) { \
+                       ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline + 1, (opline+1)->op2)); \
+                       ZEND_VM_CONTINUE(); \
+               } else if (EXPECTED((opline+1)->opcode == ZEND_JMPZ)) { \
+                       ZEND_VM_SET_NEXT_OPCODE(opline + 2); \
+                       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); \
+                       ZEND_VM_CONTINUE(); \
+               } else if (EXPECTED((opline+1)->opcode == ZEND_JMPZ)) { \
+                       ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline + 1, (opline+1)->op2)); \
+                       ZEND_VM_CONTINUE(); \
+               } \
+       } while (0)
 #else
 # define ZEND_VM_REPEATABLE_OPCODE
 # define ZEND_VM_REPEAT_OPCODE(_opcode)
 # define ZEND_VM_SMART_BRANCH(_result, _check)
 # define ZEND_VM_SMART_BRANCH_JMPZ(_result, _check)
 # define ZEND_VM_SMART_BRANCH_JMPNZ(_result, _check)
+# define ZEND_VM_SMART_BRANCH_TRUE()
+# define ZEND_VM_SMART_BRANCH_FASLE()
 #endif
 
 #ifdef __GNUC__

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index e4e31acedeaf9ac4fe06234e29298c8cac8b2afe..54257933cd9899f5e4a4406e7f0d988ed843a3e4 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -390,54 +390,73 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(17, ZEND_IS_EQUAL, CONST|TMPVAR|CV, CONST|TMPVAR
        USE_OPLINE
        zend_free_op free_op1, free_op2;
        zval *op1, *op2;
-       int result;
+       double d1, d2;
 
        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 (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
+                       if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
+                               ZEND_VM_C_GOTO(is_equal_true);
+                       } else {
+                               ZEND_VM_C_GOTO(is_equal_false);
+                       }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       result = ((double)Z_LVAL_P(op1) == Z_DVAL_P(op2));
-               } else {
-                       ZEND_VM_C_GOTO(is_equal_slow);
+                       d1 = (double)Z_LVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+                       ZEND_VM_C_GOTO(is_equal_double);
                }
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
+                       d1 = Z_DVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+ZEND_VM_C_LABEL(is_equal_double):
+                       if (d1 == d2) {
+                               ZEND_VM_C_GOTO(is_equal_true);
+                       } else {
+                               ZEND_VM_C_GOTO(is_equal_false);
+                       }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       result = (Z_DVAL_P(op1) == ((double)Z_LVAL_P(op2)));
-               } else {
-                       ZEND_VM_C_GOTO(is_equal_slow);
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       ZEND_VM_C_GOTO(is_equal_double);
                }
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
-                       result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
+                       int result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
                        FREE_OP1();
                        FREE_OP2();
-               } else {
-                       ZEND_VM_C_GOTO(is_equal_slow);
+                       if (result) {
+                               ZEND_VM_C_GOTO(is_equal_true);
+                       } else {
+                               ZEND_VM_C_GOTO(is_equal_false);
+                       }
                }
+       }
+       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_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):
+               ZEND_VM_SMART_BRANCH_TRUE();
+               ZVAL_TRUE(EX_VAR(opline->result.var));
+               ZEND_VM_NEXT_OPCODE();
        } else {
-ZEND_VM_C_LABEL(is_equal_slow):
-               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_OP1();
-               FREE_OP2();
-               if (UNEXPECTED(EG(exception))) {
-                       HANDLE_EXCEPTION();
-               }
-               result = Z_LVAL_P(EX_VAR(opline->result.var)) == 0;
+ZEND_VM_C_LABEL(is_equal_false):
+               ZEND_VM_SMART_BRANCH_FALSE();
+               ZVAL_FALSE(EX_VAR(opline->result.var));
+               ZEND_VM_NEXT_OPCODE();
        }
-       ZEND_VM_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 ZEND_VM_COLD_CONSTCONST_HANDLER(18, ZEND_IS_NOT_EQUAL, CONST|TMPVAR|CV, CONST|TMPVAR|CV, SPEC(COMMUTATIVE))
@@ -445,54 +464,73 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(18, ZEND_IS_NOT_EQUAL, CONST|TMPVAR|CV, CONST|TM
        USE_OPLINE
        zend_free_op free_op1, free_op2;
        zval *op1, *op2;
-       int result;
+       double d1, d2;
 
        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 (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
+                       if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
+                               ZEND_VM_C_GOTO(is_not_equal_true);
+                       } else {
+                               ZEND_VM_C_GOTO(is_not_equal_false);
+                       }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       result = ((double)Z_LVAL_P(op1) != Z_DVAL_P(op2));
-               } else {
-                       ZEND_VM_C_GOTO(is_not_equal_slow);
+                       d1 = (double)Z_LVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+                       ZEND_VM_C_GOTO(is_not_equal_double);
                }
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
+                       d1 = Z_DVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+ZEND_VM_C_LABEL(is_not_equal_double):
+                       if (d1 != d2) {
+                               ZEND_VM_C_GOTO(is_not_equal_true);
+                       } else {
+                               ZEND_VM_C_GOTO(is_not_equal_false);
+                       }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       result = (Z_DVAL_P(op1) != ((double)Z_LVAL_P(op2)));
-               } else {
-                       ZEND_VM_C_GOTO(is_not_equal_slow);
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       ZEND_VM_C_GOTO(is_not_equal_double);
                }
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
-                       result = !zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
+                       int result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
                        FREE_OP1();
                        FREE_OP2();
-               } else {
-                       ZEND_VM_C_GOTO(is_not_equal_slow);
+                       if (!result) {
+                               ZEND_VM_C_GOTO(is_not_equal_true);
+                       } else {
+                               ZEND_VM_C_GOTO(is_not_equal_false);
+                       }
                }
+       }
+       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_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):
+               ZEND_VM_SMART_BRANCH_TRUE();
+               ZVAL_TRUE(EX_VAR(opline->result.var));
+               ZEND_VM_NEXT_OPCODE();
        } else {
-ZEND_VM_C_LABEL(is_not_equal_slow):
-               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_OP1();
-               FREE_OP2();
-               if (UNEXPECTED(EG(exception))) {
-                       HANDLE_EXCEPTION();
-               }
-               result = Z_LVAL_P(EX_VAR(opline->result.var)) != 0;
+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_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 ZEND_VM_COLD_CONSTCONST_HANDLER(19, ZEND_IS_SMALLER, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
@@ -500,46 +538,62 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(19, ZEND_IS_SMALLER, CONST|TMPVAR|CV, CONST|TMPV
        USE_OPLINE
        zend_free_op free_op1, free_op2;
        zval *op1, *op2;
-       int result;
+       double d1, d2;
 
        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 (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
-                       result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
+                       if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
+                               ZEND_VM_C_GOTO(is_smaller_true);
+                       } else {
+                               ZEND_VM_C_GOTO(is_smaller_false);
+                       }
                } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
-                       result = ((double)Z_LVAL_P(op1) < Z_DVAL_P(op2));
-               } else {
-                       ZEND_VM_C_GOTO(is_smaller_slow);
+                       d1 = (double)Z_LVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+                       ZEND_VM_C_GOTO(is_smaller_double);
                }
        } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
-                       result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
+                       d1 = Z_DVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+ZEND_VM_C_LABEL(is_smaller_double):
+                       if (d1 < d2) {
+                               ZEND_VM_C_GOTO(is_smaller_true);
+                       } else {
+                               ZEND_VM_C_GOTO(is_smaller_false);
+                       }
                } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
-                       result = (Z_DVAL_P(op1) < ((double)Z_LVAL_P(op2)));
-               } else {
-                       ZEND_VM_C_GOTO(is_smaller_slow);
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       ZEND_VM_C_GOTO(is_smaller_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_true):
+               ZEND_VM_SMART_BRANCH_TRUE();
+               ZVAL_TRUE(EX_VAR(opline->result.var));
+               ZEND_VM_NEXT_OPCODE();
        } else {
-ZEND_VM_C_LABEL(is_smaller_slow):
-               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();
-               }
-               result = Z_LVAL_P(EX_VAR(opline->result.var)) < 0;
+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_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 ZEND_VM_COLD_CONSTCONST_HANDLER(20, ZEND_IS_SMALLER_OR_EQUAL, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
@@ -547,46 +601,62 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(20, ZEND_IS_SMALLER_OR_EQUAL, CONST|TMPVAR|CV, C
        USE_OPLINE
        zend_free_op free_op1, free_op2;
        zval *op1, *op2;
-       int result;
+       double d1, d2;
 
        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 (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
-                       result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
+                       if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
+                               ZEND_VM_C_GOTO(is_smaller_or_equal_true);
+                       } else {
+                               ZEND_VM_C_GOTO(is_smaller_or_equal_false);
+                       }
                } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
-                       result = ((double)Z_LVAL_P(op1) <= Z_DVAL_P(op2));
-               } else {
-                       ZEND_VM_C_GOTO(is_smaller_or_equal_slow);
+                       d1 = (double)Z_LVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+                       ZEND_VM_C_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)) {
-                       result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
+                       d1 = Z_DVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+ZEND_VM_C_LABEL(is_smaller_or_equal_double):
+                       if (d1 <= d2) {
+                               ZEND_VM_C_GOTO(is_smaller_or_equal_true);
+                       } else {
+                               ZEND_VM_C_GOTO(is_smaller_or_equal_false);
+                       }
                } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
-                       result = (Z_DVAL_P(op1) <= ((double)Z_LVAL_P(op2)));
-               } else {
-                       ZEND_VM_C_GOTO(is_smaller_or_equal_slow);
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       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_slow):
-               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();
-               }
-               result = Z_LVAL_P(EX_VAR(opline->result.var)) <= 0;
+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_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 ZEND_VM_COLD_CONSTCONST_HANDLER(170, ZEND_SPACESHIP, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
@@ -5126,52 +5196,71 @@ ZEND_VM_HANDLER(48, ZEND_CASE, TMPVAR, CONST|TMPVAR|CV)
        USE_OPLINE
        zend_free_op free_op1, free_op2;
        zval *op1, *op2;
-       int result;
+       double d1, d2;
 
        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 (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
+                       if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
+                               ZEND_VM_C_GOTO(case_true);
+                       } else {
+                               ZEND_VM_C_GOTO(case_false);
+                       }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       result = ((double)Z_LVAL_P(op1) == Z_DVAL_P(op2));
-               } else {
-                       ZEND_VM_C_GOTO(case_slow);
+                       d1 = (double)Z_LVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+                       ZEND_VM_C_GOTO(case_double);
                }
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
+                       d1 = Z_DVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+ZEND_VM_C_LABEL(case_double):
+                       if (d1 == d2) {
+                               ZEND_VM_C_GOTO(case_true);
+                       } else {
+                               ZEND_VM_C_GOTO(case_false);
+                       }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       result = (Z_DVAL_P(op1) == ((double)Z_LVAL_P(op2)));
-               } else {
-                       ZEND_VM_C_GOTO(case_slow);
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       ZEND_VM_C_GOTO(case_double);
                }
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
-                       result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
+                       int result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
                        FREE_OP2();
-               } else {
-                       ZEND_VM_C_GOTO(case_slow);
+                       if (result) {
+                               ZEND_VM_C_GOTO(case_true);
+                       } else {
+                               ZEND_VM_C_GOTO(case_false);
+                       }
                }
+       }
+       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_slow):
-               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();
-               }
-               result = Z_LVAL_P(EX_VAR(opline->result.var)) == 0;
+ZEND_VM_C_LABEL(case_false):
+               ZEND_VM_SMART_BRANCH_FALSE();
+               ZVAL_FALSE(EX_VAR(opline->result.var));
+               ZEND_VM_NEXT_OPCODE();
        }
-       ZEND_VM_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 ZEND_VM_HANDLER(68, ZEND_NEW, UNUSED|CLASS_FETCH|CONST|VAR, UNUSED|CACHE_SLOT, NUM)
@@ -6399,24 +6488,32 @@ ZEND_VM_HOT_HANDLER(197, ZEND_ISSET_ISEMPTY_CV, CV, UNUSED, ISSET, SPEC(ISSET))
 {
        USE_OPLINE
        zval *value;
-       int result;
 
        value = EX_VAR(opline->op1.var);
        if (!(opline->extended_value & ZEND_ISEMPTY)) {
-               result =
-                       Z_TYPE_P(value) > IS_NULL &&
-                   (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
+               if (Z_TYPE_P(value) > IS_NULL &&
+                   (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL)) {
+                       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();
+               }
        } else {
+               int result;
+
                SAVE_OPLINE();
                result = !i_zend_is_true(value);
                if (UNEXPECTED(EG(exception))) {
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
                }
+               ZEND_VM_SMART_BRANCH(result, 0);
+               ZVAL_BOOL(EX_VAR(opline->result.var), result);
+               ZEND_VM_NEXT_OPCODE();
        }
-       ZEND_VM_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 ZEND_VM_HANDLER(114, ZEND_ISSET_ISEMPTY_VAR, CONST|TMPVAR|CV, UNUSED, VAR_FETCH|ISSET)
@@ -7754,9 +7851,10 @@ ZEND_VM_C_LABEL(type_check_resource):
                result = ((1 << IS_NULL) & opline->extended_value) != 0;
                SAVE_OPLINE();
                ZVAL_UNDEFINED_OP1();
-               ZEND_VM_SMART_BRANCH(result, 1);
-               ZVAL_BOOL(EX_VAR(opline->result.var), result);
-               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+               if (UNEXPECTED(EG(exception))) {
+                       ZVAL_UNDEF(EX_VAR(opline->result.var));
+                       HANDLE_EXCEPTION();
+               }
        }
        if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
                SAVE_OPLINE();
@@ -7775,29 +7873,27 @@ ZEND_VM_HOT_HANDLER(122, ZEND_DEFINED, CONST, ANY, CACHE_SLOT)
 {
        USE_OPLINE
        zend_constant *c;
-       int result;
 
        c = CACHED_PTR(opline->extended_value);
-       do {
-               if (EXPECTED(c != NULL)) {
-                       if (!IS_SPECIAL_CACHE_VAL(c)) {
-                               result = 1;
-                               break;
-                       } else if (EXPECTED(zend_hash_num_elements(EG(zend_constants)) == DECODE_SPECIAL_CACHE_NUM(c))) {
-                               result = 0;
-                               break;
-                       }
-               }
-               if (zend_quick_check_constant(RT_CONSTANT(opline, opline->op1) OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
-                       CACHE_PTR(opline->extended_value, ENCODE_SPECIAL_CACHE_NUM(zend_hash_num_elements(EG(zend_constants))));
-                       result = 0;
-               } else {
-                       result = 1;
+       if (EXPECTED(c != NULL)) {
+               if (!IS_SPECIAL_CACHE_VAL(c)) {
+ZEND_VM_C_LABEL(defined_true):
+                       ZEND_VM_SMART_BRANCH_TRUE();
+                       ZVAL_TRUE(EX_VAR(opline->result.var));
+                       ZEND_VM_NEXT_OPCODE();
+               } else if (EXPECTED(zend_hash_num_elements(EG(zend_constants)) == DECODE_SPECIAL_CACHE_NUM(c))) {
+ZEND_VM_C_LABEL(defined_false):
+                       ZEND_VM_SMART_BRANCH_FALSE();
+                       ZVAL_FALSE(EX_VAR(opline->result.var));
+                       ZEND_VM_NEXT_OPCODE();
                }
-       } while (0);
-       ZEND_VM_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
+       }
+       if (zend_quick_check_constant(RT_CONSTANT(opline, opline->op1) OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               CACHE_PTR(opline->extended_value, ENCODE_SPECIAL_CACHE_NUM(zend_hash_num_elements(EG(zend_constants))));
+               ZEND_VM_C_GOTO(defined_false);
+       } else {
+               ZEND_VM_C_GOTO(defined_true);
+       }
 }
 
 ZEND_VM_HANDLER(151, ZEND_ASSERT_CHECK, ANY, JMP_ADDR)

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index dec888cb356c3e769cbe37f199a763997b3955f3..afbf6a4ad838c581d11dadf2cf2f450e9ec4f6bb 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -4022,9 +4022,10 @@ type_check_resource:
                result = ((1 << IS_NULL) & opline->extended_value) != 0;
                SAVE_OPLINE();
                ZVAL_UNDEFINED_OP1();
-               ZEND_VM_SMART_BRANCH(result, 1);
-               ZVAL_BOOL(EX_VAR(opline->result.var), result);
-               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+               if (UNEXPECTED(EG(exception))) {
+                       ZVAL_UNDEF(EX_VAR(opline->result.var));
+                       HANDLE_EXCEPTION();
+               }
        }
        if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
                SAVE_OPLINE();
@@ -4043,29 +4044,27 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DEFINED_SPEC_CONST
 {
        USE_OPLINE
        zend_constant *c;
-       int result;
 
        c = CACHED_PTR(opline->extended_value);
-       do {
-               if (EXPECTED(c != NULL)) {
-                       if (!IS_SPECIAL_CACHE_VAL(c)) {
-                               result = 1;
-                               break;
-                       } else if (EXPECTED(zend_hash_num_elements(EG(zend_constants)) == DECODE_SPECIAL_CACHE_NUM(c))) {
-                               result = 0;
-                               break;
-                       }
-               }
-               if (zend_quick_check_constant(RT_CONSTANT(opline, opline->op1) OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
-                       CACHE_PTR(opline->extended_value, ENCODE_SPECIAL_CACHE_NUM(zend_hash_num_elements(EG(zend_constants))));
-                       result = 0;
-               } else {
-                       result = 1;
+       if (EXPECTED(c != NULL)) {
+               if (!IS_SPECIAL_CACHE_VAL(c)) {
+defined_true:
+                       ZEND_VM_SMART_BRANCH_TRUE();
+                       ZVAL_TRUE(EX_VAR(opline->result.var));
+                       ZEND_VM_NEXT_OPCODE();
+               } else if (EXPECTED(zend_hash_num_elements(EG(zend_constants)) == DECODE_SPECIAL_CACHE_NUM(c))) {
+defined_false:
+                       ZEND_VM_SMART_BRANCH_FALSE();
+                       ZVAL_FALSE(EX_VAR(opline->result.var));
+                       ZEND_VM_NEXT_OPCODE();
                }
-       } while (0);
-       ZEND_VM_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
+       }
+       if (zend_quick_check_constant(RT_CONSTANT(opline, opline->op1) OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               CACHE_PTR(opline->extended_value, ENCODE_SPECIAL_CACHE_NUM(zend_hash_num_elements(EG(zend_constants))));
+               goto defined_false;
+       } else {
+               goto defined_true;
+       }
 }
 
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -4413,54 +4412,73 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CON
        USE_OPLINE
 
        zval *op1, *op2;
-       int result;
+       double d1, d2;
 
        op1 = RT_CONSTANT(opline, opline->op1);
        op2 = RT_CONSTANT(opline, opline->op2);
        if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
+                       if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
+                               goto is_equal_true;
+                       } else {
+                               goto is_equal_false;
+                       }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       result = ((double)Z_LVAL_P(op1) == Z_DVAL_P(op2));
-               } else {
-                       goto is_equal_slow;
+                       d1 = (double)Z_LVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+                       goto is_equal_double;
                }
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
+                       d1 = Z_DVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+is_equal_double:
+                       if (d1 == d2) {
+                               goto is_equal_true;
+                       } else {
+                               goto is_equal_false;
+                       }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       result = (Z_DVAL_P(op1) == ((double)Z_LVAL_P(op2)));
-               } else {
-                       goto is_equal_slow;
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       goto is_equal_double;
                }
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
-                       result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
+                       int result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
 
 
-               } else {
-                       goto is_equal_slow;
-               }
-       } else {
-is_equal_slow:
-               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();
+                       if (result) {
+                               goto is_equal_true;
+                       } else {
+                               goto is_equal_false;
+                       }
                }
-               compare_function(EX_VAR(opline->result.var), op1, op2);
+       }
+       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();
-               }
-               result = Z_LVAL_P(EX_VAR(opline->result.var)) == 0;
+       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_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -4468,54 +4486,73 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC
        USE_OPLINE
 
        zval *op1, *op2;
-       int result;
+       double d1, d2;
 
        op1 = RT_CONSTANT(opline, opline->op1);
        op2 = RT_CONSTANT(opline, opline->op2);
        if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
+                       if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
+                               goto is_not_equal_true;
+                       } else {
+                               goto is_not_equal_false;
+                       }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       result = ((double)Z_LVAL_P(op1) != Z_DVAL_P(op2));
-               } else {
-                       goto is_not_equal_slow;
+                       d1 = (double)Z_LVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+                       goto is_not_equal_double;
                }
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
+                       d1 = Z_DVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+is_not_equal_double:
+                       if (d1 != d2) {
+                               goto is_not_equal_true;
+                       } else {
+                               goto is_not_equal_false;
+                       }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       result = (Z_DVAL_P(op1) != ((double)Z_LVAL_P(op2)));
-               } else {
-                       goto is_not_equal_slow;
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       goto is_not_equal_double;
                }
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
-                       result = !zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
+                       int result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
 
 
-               } else {
-                       goto is_not_equal_slow;
-               }
-       } else {
-is_not_equal_slow:
-               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();
+                       if (!result) {
+                               goto is_not_equal_true;
+                       } else {
+                               goto is_not_equal_false;
+                       }
                }
-               compare_function(EX_VAR(opline->result.var), op1, op2);
+       }
+       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();
-               }
-               result = Z_LVAL_P(EX_VAR(opline->result.var)) != 0;
+       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_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -4523,46 +4560,62 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_C
        USE_OPLINE
 
        zval *op1, *op2;
-       int result;
+       double d1, d2;
 
        op1 = RT_CONSTANT(opline, opline->op1);
        op2 = RT_CONSTANT(opline, opline->op2);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
-                       result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
+                       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)) {
-                       result = ((double)Z_LVAL_P(op1) < Z_DVAL_P(op2));
-               } else {
-                       goto is_smaller_slow;
+                       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)) {
-                       result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
+                       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)) {
-                       result = (Z_DVAL_P(op1) < ((double)Z_LVAL_P(op2)));
-               } else {
-                       goto is_smaller_slow;
-               }
-       } else {
-is_smaller_slow:
-               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();
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       goto is_smaller_double;
                }
-               compare_function(EX_VAR(opline->result.var), op1, op2);
+       }
+       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();
-               }
-               result = Z_LVAL_P(EX_VAR(opline->result.var)) < 0;
+       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_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -4570,46 +4623,62 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQU
        USE_OPLINE
 
        zval *op1, *op2;
-       int result;
+       double d1, d2;
 
        op1 = RT_CONSTANT(opline, opline->op1);
        op2 = RT_CONSTANT(opline, opline->op2);
        if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
-                       result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
+                       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)) {
-                       result = ((double)Z_LVAL_P(op1) <= Z_DVAL_P(op2));
-               } else {
-                       goto is_smaller_or_equal_slow;
+                       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)) {
-                       result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
+                       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)) {
-                       result = (Z_DVAL_P(op1) <= ((double)Z_LVAL_P(op2)));
-               } else {
-                       goto is_smaller_or_equal_slow;
-               }
-       } else {
-is_smaller_or_equal_slow:
-               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();
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       goto is_smaller_or_equal_double;
                }
-               compare_function(EX_VAR(opline->result.var), op1, op2);
+       }
+       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();
-               }
-               result = Z_LVAL_P(EX_VAR(opline->result.var)) <= 0;
+       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_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -6888,46 +6957,62 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_TMPVAR_H
        USE_OPLINE
        zend_free_op free_op2;
        zval *op1, *op2;
-       int result;
+       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)) {
-                       result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
+                       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)) {
-                       result = ((double)Z_LVAL_P(op1) < Z_DVAL_P(op2));
-               } else {
-                       goto is_smaller_slow;
+                       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)) {
-                       result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
+                       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)) {
-                       result = (Z_DVAL_P(op1) < ((double)Z_LVAL_P(op2)));
-               } else {
-                       goto is_smaller_slow;
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       goto is_smaller_double;
                }
-       } else {
-is_smaller_slow:
-               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);
+       }
+       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();
-               }
-               result = Z_LVAL_P(EX_VAR(opline->result.var)) < 0;
+       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();
        }
-       ZEND_VM_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -6935,46 +7020,62 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST
        USE_OPLINE
        zend_free_op free_op2;
        zval *op1, *op2;
-       int result;
+       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)) {
-                       result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
+                       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)) {
-                       result = ((double)Z_LVAL_P(op1) <= Z_DVAL_P(op2));
-               } else {
-                       goto is_smaller_or_equal_slow;
+                       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)) {
-                       result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
+                       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)) {
-                       result = (Z_DVAL_P(op1) <= ((double)Z_LVAL_P(op2)));
-               } else {
-                       goto is_smaller_or_equal_slow;
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       goto is_smaller_or_equal_double;
                }
-       } else {
-is_smaller_or_equal_slow:
-               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);
+       }
+       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();
-               }
-               result = Z_LVAL_P(EX_VAR(opline->result.var)) <= 0;
+       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_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -9893,46 +9994,62 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_CV_HANDL
        USE_OPLINE
 
        zval *op1, *op2;
-       int result;
+       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)) {
-                       result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
+                       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)) {
-                       result = ((double)Z_LVAL_P(op1) < Z_DVAL_P(op2));
-               } else {
-                       goto is_smaller_slow;
+                       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)) {
-                       result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
+                       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)) {
-                       result = (Z_DVAL_P(op1) < ((double)Z_LVAL_P(op2)));
-               } else {
-                       goto is_smaller_slow;
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       goto is_smaller_double;
                }
-       } else {
-is_smaller_slow:
-               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);
+       }
+       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();
-               }
-               result = Z_LVAL_P(EX_VAR(opline->result.var)) < 0;
+       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_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -9940,46 +10057,62 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST
        USE_OPLINE
 
        zval *op1, *op2;
-       int result;
+       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)) {
-                       result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
+                       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)) {
-                       result = ((double)Z_LVAL_P(op1) <= Z_DVAL_P(op2));
-               } else {
-                       goto is_smaller_or_equal_slow;
+                       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)) {
-                       result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
+                       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)) {
-                       result = (Z_DVAL_P(op1) <= ((double)Z_LVAL_P(op2)));
-               } else {
-                       goto is_smaller_or_equal_slow;
-               }
-       } else {
-is_smaller_or_equal_slow:
-               SAVE_OPLINE();
-               if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
-                       op1 = ZVAL_UNDEFINED_OP1();
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       goto is_smaller_or_equal_double;
                }
-               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);
+       }
+       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();
-               }
-               result = Z_LVAL_P(EX_VAR(opline->result.var)) <= 0;
+       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_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -13000,9 +13133,10 @@ type_check_resource:
                result = ((1 << IS_NULL) & opline->extended_value) != 0;
                SAVE_OPLINE();
                ZVAL_UNDEFINED_OP1();
-               ZEND_VM_SMART_BRANCH(result, 1);
-               ZVAL_BOOL(EX_VAR(opline->result.var), result);
-               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+               if (UNEXPECTED(EG(exception))) {
+                       ZVAL_UNDEF(EX_VAR(opline->result.var));
+                       HANDLE_EXCEPTION();
+               }
        }
        if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
                SAVE_OPLINE();
@@ -13338,54 +13472,73 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_HAN
        USE_OPLINE
        zend_free_op free_op1;
        zval *op1, *op2;
-       int result;
+       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_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
+                       if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
+                               goto is_equal_true;
+                       } else {
+                               goto is_equal_false;
+                       }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       result = ((double)Z_LVAL_P(op1) == Z_DVAL_P(op2));
-               } else {
-                       goto is_equal_slow;
+                       d1 = (double)Z_LVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+                       goto is_equal_double;
                }
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
+                       d1 = Z_DVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+is_equal_double:
+                       if (d1 == d2) {
+                               goto is_equal_true;
+                       } else {
+                               goto is_equal_false;
+                       }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       result = (Z_DVAL_P(op1) == ((double)Z_LVAL_P(op2)));
-               } else {
-                       goto is_equal_slow;
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       goto is_equal_double;
                }
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
-                       result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
+                       int result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
                        zval_ptr_dtor_nogc(free_op1);
 
-               } else {
-                       goto is_equal_slow;
-               }
-       } else {
-is_equal_slow:
-               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();
+                       if (result) {
+                               goto is_equal_true;
+                       } else {
+                               goto is_equal_false;
+                       }
                }
-               compare_function(EX_VAR(opline->result.var), op1, op2);
-               zval_ptr_dtor_nogc(free_op1);
+       }
+       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();
-               }
-               result = Z_LVAL_P(EX_VAR(opline->result.var)) == 0;
+       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_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -13393,54 +13546,73 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST
        USE_OPLINE
        zend_free_op free_op1;
        zval *op1, *op2;
-       int result;
+       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_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
+                       if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
+                               goto is_not_equal_true;
+                       } else {
+                               goto is_not_equal_false;
+                       }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       result = ((double)Z_LVAL_P(op1) != Z_DVAL_P(op2));
-               } else {
-                       goto is_not_equal_slow;
+                       d1 = (double)Z_LVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+                       goto is_not_equal_double;
                }
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
+                       d1 = Z_DVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+is_not_equal_double:
+                       if (d1 != d2) {
+                               goto is_not_equal_true;
+                       } else {
+                               goto is_not_equal_false;
+                       }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       result = (Z_DVAL_P(op1) != ((double)Z_LVAL_P(op2)));
-               } else {
-                       goto is_not_equal_slow;
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       goto is_not_equal_double;
                }
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
-                       result = !zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
+                       int result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
                        zval_ptr_dtor_nogc(free_op1);
 
-               } else {
-                       goto is_not_equal_slow;
-               }
-       } else {
-is_not_equal_slow:
-               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();
+                       if (!result) {
+                               goto is_not_equal_true;
+                       } else {
+                               goto is_not_equal_false;
+                       }
                }
-               compare_function(EX_VAR(opline->result.var), op1, op2);
-               zval_ptr_dtor_nogc(free_op1);
+       }
+       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();
-               }
-               result = Z_LVAL_P(EX_VAR(opline->result.var)) != 0;
+       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_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -13448,46 +13620,62 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVAR_CONST_H
        USE_OPLINE
        zend_free_op free_op1;
        zval *op1, *op2;
-       int result;
+       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)) {
-                       result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
+                       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)) {
-                       result = ((double)Z_LVAL_P(op1) < Z_DVAL_P(op2));
-               } else {
-                       goto is_smaller_slow;
+                       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)) {
-                       result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
+                       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)) {
-                       result = (Z_DVAL_P(op1) < ((double)Z_LVAL_P(op2)));
-               } else {
-                       goto is_smaller_slow;
-               }
-       } else {
-is_smaller_slow:
-               SAVE_OPLINE();
-               if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
-                       op1 = ZVAL_UNDEFINED_OP1();
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       goto is_smaller_double;
                }
-               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);
+       }
+       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();
-               }
-               result = Z_LVAL_P(EX_VAR(opline->result.var)) < 0;
+       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_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -13495,46 +13683,62 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVA
        USE_OPLINE
        zend_free_op free_op1;
        zval *op1, *op2;
-       int result;
+       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)) {
-                       result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
+                       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)) {
-                       result = ((double)Z_LVAL_P(op1) <= Z_DVAL_P(op2));
-               } else {
-                       goto is_smaller_or_equal_slow;
+                       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)) {
-                       result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
+                       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)) {
-                       result = (Z_DVAL_P(op1) <= ((double)Z_LVAL_P(op2)));
-               } else {
-                       goto is_smaller_or_equal_slow;
-               }
-       } else {
-is_smaller_or_equal_slow:
-               SAVE_OPLINE();
-               if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
-                       op1 = ZVAL_UNDEFINED_OP1();
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       goto is_smaller_or_equal_double;
                }
-               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);
+       }
+       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();
-               }
-               result = Z_LVAL_P(EX_VAR(opline->result.var)) <= 0;
+       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_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -14203,52 +14407,71 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_CONST_HANDLER
        USE_OPLINE
        zend_free_op free_op1;
        zval *op1, *op2;
-       int result;
+       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_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
+                       if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
+                               goto case_true;
+                       } else {
+                               goto case_false;
+                       }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       result = ((double)Z_LVAL_P(op1) == Z_DVAL_P(op2));
-               } else {
-                       goto case_slow;
+                       d1 = (double)Z_LVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+                       goto case_double;
                }
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
+                       d1 = Z_DVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+case_double:
+                       if (d1 == d2) {
+                               goto case_true;
+                       } else {
+                               goto case_false;
+                       }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       result = (Z_DVAL_P(op1) == ((double)Z_LVAL_P(op2)));
-               } else {
-                       goto case_slow;
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       goto case_double;
                }
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
-                       result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
+                       int result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
 
-               } else {
-                       goto case_slow;
-               }
-       } else {
-case_slow:
-               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();
+                       if (result) {
+                               goto case_true;
+                       } else {
+                               goto case_false;
+                       }
                }
-               compare_function(EX_VAR(opline->result.var), op1, op2);
+       }
+       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();
-               }
-               result = Z_LVAL_P(EX_VAR(opline->result.var)) == 0;
+       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_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -14938,54 +15161,73 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HA
        USE_OPLINE
        zend_free_op free_op1, free_op2;
        zval *op1, *op2;
-       int result;
+       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_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
+                       if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
+                               goto is_equal_true;
+                       } else {
+                               goto is_equal_false;
+                       }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       result = ((double)Z_LVAL_P(op1) == Z_DVAL_P(op2));
-               } else {
-                       goto is_equal_slow;
+                       d1 = (double)Z_LVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+                       goto is_equal_double;
                }
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
+                       d1 = Z_DVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+is_equal_double:
+                       if (d1 == d2) {
+                               goto is_equal_true;
+                       } else {
+                               goto is_equal_false;
+                       }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       result = (Z_DVAL_P(op1) == ((double)Z_LVAL_P(op2)));
-               } else {
-                       goto is_equal_slow;
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       goto is_equal_double;
                }
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
-                       result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
+                       int result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
                        zval_ptr_dtor_nogc(free_op1);
                        zval_ptr_dtor_nogc(free_op2);
-               } else {
-                       goto is_equal_slow;
+                       if (result) {
+                               goto is_equal_true;
+                       } else {
+                               goto is_equal_false;
+                       }
                }
+       }
+       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_slow:
-               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();
-               }
-               result = Z_LVAL_P(EX_VAR(opline->result.var)) == 0;
+is_equal_false:
+               ZEND_VM_SMART_BRANCH_FALSE();
+               ZVAL_FALSE(EX_VAR(opline->result.var));
+               ZEND_VM_NEXT_OPCODE();
        }
-       ZEND_VM_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -14993,54 +15235,73 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVA
        USE_OPLINE
        zend_free_op free_op1, free_op2;
        zval *op1, *op2;
-       int result;
+       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_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
+                       if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
+                               goto is_not_equal_true;
+                       } else {
+                               goto is_not_equal_false;
+                       }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       result = ((double)Z_LVAL_P(op1) != Z_DVAL_P(op2));
-               } else {
-                       goto is_not_equal_slow;
+                       d1 = (double)Z_LVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+                       goto is_not_equal_double;
                }
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
+                       d1 = Z_DVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+is_not_equal_double:
+                       if (d1 != d2) {
+                               goto is_not_equal_true;
+                       } else {
+                               goto is_not_equal_false;
+                       }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       result = (Z_DVAL_P(op1) != ((double)Z_LVAL_P(op2)));
-               } else {
-                       goto is_not_equal_slow;
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       goto is_not_equal_double;
                }
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
-                       result = !zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
+                       int result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
                        zval_ptr_dtor_nogc(free_op1);
                        zval_ptr_dtor_nogc(free_op2);
-               } else {
-                       goto is_not_equal_slow;
+                       if (!result) {
+                               goto is_not_equal_true;
+                       } else {
+                               goto is_not_equal_false;
+                       }
                }
+       }
+       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_slow:
-               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();
-               }
-               result = Z_LVAL_P(EX_VAR(opline->result.var)) != 0;
+is_not_equal_false:
+               ZEND_VM_SMART_BRANCH_FALSE();
+               ZVAL_FALSE(EX_VAR(opline->result.var));
+               ZEND_VM_NEXT_OPCODE();
        }
-       ZEND_VM_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -15048,46 +15309,62 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVAR_TMPVAR_
        USE_OPLINE
        zend_free_op free_op1, free_op2;
        zval *op1, *op2;
-       int result;
+       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)) {
-                       result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
+                       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)) {
-                       result = ((double)Z_LVAL_P(op1) < Z_DVAL_P(op2));
-               } else {
-                       goto is_smaller_slow;
+                       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)) {
-                       result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
+                       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)) {
-                       result = (Z_DVAL_P(op1) < ((double)Z_LVAL_P(op2)));
-               } else {
-                       goto is_smaller_slow;
+                       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_slow:
-               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();
-               }
-               result = Z_LVAL_P(EX_VAR(opline->result.var)) < 0;
+is_smaller_false:
+               ZEND_VM_SMART_BRANCH_FALSE();
+               ZVAL_FALSE(EX_VAR(opline->result.var));
+               ZEND_VM_NEXT_OPCODE();
        }
-       ZEND_VM_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -15095,46 +15372,62 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVA
        USE_OPLINE
        zend_free_op free_op1, free_op2;
        zval *op1, *op2;
-       int result;
+       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)) {
-                       result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
+                       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)) {
-                       result = ((double)Z_LVAL_P(op1) <= Z_DVAL_P(op2));
-               } else {
-                       goto is_smaller_or_equal_slow;
+                       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)) {
-                       result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
+                       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)) {
-                       result = (Z_DVAL_P(op1) <= ((double)Z_LVAL_P(op2)));
-               } else {
-                       goto is_smaller_or_equal_slow;
+                       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_slow:
-               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();
-               }
-               result = Z_LVAL_P(EX_VAR(opline->result.var)) <= 0;
+is_smaller_or_equal_false:
+               ZEND_VM_SMART_BRANCH_FALSE();
+               ZVAL_FALSE(EX_VAR(opline->result.var));
+               ZEND_VM_NEXT_OPCODE();
        }
-       ZEND_VM_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -15749,52 +16042,71 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLE
        USE_OPLINE
        zend_free_op free_op1, free_op2;
        zval *op1, *op2;
-       int result;
+       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_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
+                       if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
+                               goto case_true;
+                       } else {
+                               goto case_false;
+                       }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       result = ((double)Z_LVAL_P(op1) == Z_DVAL_P(op2));
-               } else {
-                       goto case_slow;
+                       d1 = (double)Z_LVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+                       goto case_double;
                }
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
+                       d1 = Z_DVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+case_double:
+                       if (d1 == d2) {
+                               goto case_true;
+                       } else {
+                               goto case_false;
+                       }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       result = (Z_DVAL_P(op1) == ((double)Z_LVAL_P(op2)));
-               } else {
-                       goto case_slow;
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       goto case_double;
                }
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
-                       result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
+                       int result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
                        zval_ptr_dtor_nogc(free_op2);
-               } else {
-                       goto case_slow;
+                       if (result) {
+                               goto case_true;
+                       } else {
+                               goto case_false;
+                       }
                }
+       }
+       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_slow:
-               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();
-               }
-               result = Z_LVAL_P(EX_VAR(opline->result.var)) == 0;
+case_false:
+               ZEND_VM_SMART_BRANCH_FALSE();
+               ZVAL_FALSE(EX_VAR(opline->result.var));
+               ZEND_VM_NEXT_OPCODE();
        }
-       ZEND_VM_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -16756,46 +17068,62 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVAR_CV_HAND
        USE_OPLINE
        zend_free_op free_op1;
        zval *op1, *op2;
-       int result;
+       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)) {
-                       result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
+                       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)) {
-                       result = ((double)Z_LVAL_P(op1) < Z_DVAL_P(op2));
-               } else {
-                       goto is_smaller_slow;
+                       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)) {
-                       result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
+                       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)) {
-                       result = (Z_DVAL_P(op1) < ((double)Z_LVAL_P(op2)));
-               } else {
-                       goto is_smaller_slow;
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       goto is_smaller_double;
                }
-       } else {
-is_smaller_slow:
-               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);
+       }
+       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();
-               }
-               result = Z_LVAL_P(EX_VAR(opline->result.var)) < 0;
+       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_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -16803,46 +17131,62 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVA
        USE_OPLINE
        zend_free_op free_op1;
        zval *op1, *op2;
-       int result;
+       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)) {
-                       result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
+                       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)) {
-                       result = ((double)Z_LVAL_P(op1) <= Z_DVAL_P(op2));
-               } else {
-                       goto is_smaller_or_equal_slow;
+                       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)) {
-                       result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
+                       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)) {
-                       result = (Z_DVAL_P(op1) <= ((double)Z_LVAL_P(op2)));
-               } else {
-                       goto is_smaller_or_equal_slow;
-               }
-       } else {
-is_smaller_or_equal_slow:
-               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();
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       goto is_smaller_or_equal_double;
                }
-               compare_function(EX_VAR(opline->result.var), op1, op2);
-               zval_ptr_dtor_nogc(free_op1);
+       }
+       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();
-               }
-               result = Z_LVAL_P(EX_VAR(opline->result.var)) <= 0;
+       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_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -17361,52 +17705,71 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_CV_HANDLER(ZE
        USE_OPLINE
        zend_free_op free_op1;
        zval *op1, *op2;
-       int result;
+       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_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
+                       if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
+                               goto case_true;
+                       } else {
+                               goto case_false;
+                       }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       result = ((double)Z_LVAL_P(op1) == Z_DVAL_P(op2));
-               } else {
-                       goto case_slow;
+                       d1 = (double)Z_LVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+                       goto case_double;
                }
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
+                       d1 = Z_DVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+case_double:
+                       if (d1 == d2) {
+                               goto case_true;
+                       } else {
+                               goto case_false;
+                       }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       result = (Z_DVAL_P(op1) == ((double)Z_LVAL_P(op2)));
-               } else {
-                       goto case_slow;
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       goto case_double;
                }
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
-                       result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
+                       int result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
 
-               } else {
-                       goto case_slow;
-               }
-       } else {
-case_slow:
-               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();
+                       if (result) {
+                               goto case_true;
+                       } else {
+                               goto case_false;
+                       }
                }
-               compare_function(EX_VAR(opline->result.var), op1, op2);
+       }
+       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();
-               }
-               result = Z_LVAL_P(EX_VAR(opline->result.var)) == 0;
+       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_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -40126,9 +40489,10 @@ type_check_resource:
                result = ((1 << IS_NULL) & opline->extended_value) != 0;
                SAVE_OPLINE();
                ZVAL_UNDEFINED_OP1();
-               ZEND_VM_SMART_BRANCH(result, 1);
-               ZVAL_BOOL(EX_VAR(opline->result.var), result);
-               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+               if (UNEXPECTED(EG(exception))) {
+                       ZVAL_UNDEF(EX_VAR(opline->result.var));
+                       HANDLE_EXCEPTION();
+               }
        }
        if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
                SAVE_OPLINE();
@@ -40541,54 +40905,73 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER
        USE_OPLINE
 
        zval *op1, *op2;
-       int result;
+       double d1, d2;
 
        op1 = EX_VAR(opline->op1.var);
        op2 = RT_CONSTANT(opline, opline->op2);
        if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
+                       if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
+                               goto is_equal_true;
+                       } else {
+                               goto is_equal_false;
+                       }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       result = ((double)Z_LVAL_P(op1) == Z_DVAL_P(op2));
-               } else {
-                       goto is_equal_slow;
+                       d1 = (double)Z_LVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+                       goto is_equal_double;
                }
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
+                       d1 = Z_DVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+is_equal_double:
+                       if (d1 == d2) {
+                               goto is_equal_true;
+                       } else {
+                               goto is_equal_false;
+                       }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       result = (Z_DVAL_P(op1) == ((double)Z_LVAL_P(op2)));
-               } else {
-                       goto is_equal_slow;
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       goto is_equal_double;
                }
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
-                       result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
+                       int result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
 
 
-               } else {
-                       goto is_equal_slow;
-               }
-       } else {
-is_equal_slow:
-               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();
+                       if (result) {
+                               goto is_equal_true;
+                       } else {
+                               goto is_equal_false;
+                       }
                }
-               compare_function(EX_VAR(opline->result.var), op1, op2);
+       }
+       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();
-               }
-               result = Z_LVAL_P(EX_VAR(opline->result.var)) == 0;
+       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_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -40596,54 +40979,73 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HAN
        USE_OPLINE
 
        zval *op1, *op2;
-       int result;
+       double d1, d2;
 
        op1 = EX_VAR(opline->op1.var);
        op2 = RT_CONSTANT(opline, opline->op2);
        if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
+                       if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
+                               goto is_not_equal_true;
+                       } else {
+                               goto is_not_equal_false;
+                       }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       result = ((double)Z_LVAL_P(op1) != Z_DVAL_P(op2));
-               } else {
-                       goto is_not_equal_slow;
+                       d1 = (double)Z_LVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+                       goto is_not_equal_double;
                }
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
+                       d1 = Z_DVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+is_not_equal_double:
+                       if (d1 != d2) {
+                               goto is_not_equal_true;
+                       } else {
+                               goto is_not_equal_false;
+                       }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       result = (Z_DVAL_P(op1) != ((double)Z_LVAL_P(op2)));
-               } else {
-                       goto is_not_equal_slow;
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       goto is_not_equal_double;
                }
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
-                       result = !zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
+                       int result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
 
 
-               } else {
-                       goto is_not_equal_slow;
-               }
-       } else {
-is_not_equal_slow:
-               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();
+                       if (!result) {
+                               goto is_not_equal_true;
+                       } else {
+                               goto is_not_equal_false;
+                       }
                }
-               compare_function(EX_VAR(opline->result.var), op1, op2);
+       }
+       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();
-               }
-               result = Z_LVAL_P(EX_VAR(opline->result.var)) != 0;
+       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_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -40651,46 +41053,62 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CV_CONST_HANDL
        USE_OPLINE
 
        zval *op1, *op2;
-       int result;
+       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)) {
-                       result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
+                       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)) {
-                       result = ((double)Z_LVAL_P(op1) < Z_DVAL_P(op2));
-               } else {
-                       goto is_smaller_slow;
+                       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)) {
-                       result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
+                       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)) {
-                       result = (Z_DVAL_P(op1) < ((double)Z_LVAL_P(op2)));
-               } else {
-                       goto is_smaller_slow;
-               }
-       } else {
-is_smaller_slow:
-               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();
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       goto is_smaller_double;
                }
-               compare_function(EX_VAR(opline->result.var), op1, op2);
+       }
+       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();
-               }
-               result = Z_LVAL_P(EX_VAR(opline->result.var)) < 0;
+       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_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -40698,46 +41116,62 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CO
        USE_OPLINE
 
        zval *op1, *op2;
-       int result;
+       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)) {
-                       result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
+                       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)) {
-                       result = ((double)Z_LVAL_P(op1) <= Z_DVAL_P(op2));
-               } else {
-                       goto is_smaller_or_equal_slow;
+                       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)) {
-                       result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
+                       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)) {
-                       result = (Z_DVAL_P(op1) <= ((double)Z_LVAL_P(op2)));
-               } else {
-                       goto is_smaller_or_equal_slow;
-               }
-       } else {
-is_smaller_or_equal_slow:
-               SAVE_OPLINE();
-               if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
-                       op1 = ZVAL_UNDEFINED_OP1();
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       goto is_smaller_or_equal_double;
                }
-               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);
+       }
+       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();
-               }
-               result = Z_LVAL_P(EX_VAR(opline->result.var)) <= 0;
+       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_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -44684,54 +45118,73 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMPVAR_HANDLE
        USE_OPLINE
        zend_free_op free_op2;
        zval *op1, *op2;
-       int result;
+       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_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
+                       if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
+                               goto is_equal_true;
+                       } else {
+                               goto is_equal_false;
+                       }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       result = ((double)Z_LVAL_P(op1) == Z_DVAL_P(op2));
-               } else {
-                       goto is_equal_slow;
+                       d1 = (double)Z_LVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+                       goto is_equal_double;
                }
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
+                       d1 = Z_DVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+is_equal_double:
+                       if (d1 == d2) {
+                               goto is_equal_true;
+                       } else {
+                               goto is_equal_false;
+                       }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       result = (Z_DVAL_P(op1) == ((double)Z_LVAL_P(op2)));
-               } else {
-                       goto is_equal_slow;
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       goto is_equal_double;
                }
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
-                       result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
+                       int result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
 
                        zval_ptr_dtor_nogc(free_op2);
-               } else {
-                       goto is_equal_slow;
-               }
-       } else {
-is_equal_slow:
-               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();
+                       if (result) {
+                               goto is_equal_true;
+                       } else {
+                               goto is_equal_false;
+                       }
                }
-               compare_function(EX_VAR(opline->result.var), op1, op2);
+       }
+       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();
-               }
-               result = Z_LVAL_P(EX_VAR(opline->result.var)) == 0;
+       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_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -44739,54 +45192,73 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HA
        USE_OPLINE
        zend_free_op free_op2;
        zval *op1, *op2;
-       int result;
+       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_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
+                       if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
+                               goto is_not_equal_true;
+                       } else {
+                               goto is_not_equal_false;
+                       }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       result = ((double)Z_LVAL_P(op1) != Z_DVAL_P(op2));
-               } else {
-                       goto is_not_equal_slow;
+                       d1 = (double)Z_LVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+                       goto is_not_equal_double;
                }
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
+                       d1 = Z_DVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+is_not_equal_double:
+                       if (d1 != d2) {
+                               goto is_not_equal_true;
+                       } else {
+                               goto is_not_equal_false;
+                       }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       result = (Z_DVAL_P(op1) != ((double)Z_LVAL_P(op2)));
-               } else {
-                       goto is_not_equal_slow;
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       goto is_not_equal_double;
                }
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
-                       result = !zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
+                       int result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
 
                        zval_ptr_dtor_nogc(free_op2);
-               } else {
-                       goto is_not_equal_slow;
-               }
-       } else {
-is_not_equal_slow:
-               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();
+                       if (!result) {
+                               goto is_not_equal_true;
+                       } else {
+                               goto is_not_equal_false;
+                       }
                }
-               compare_function(EX_VAR(opline->result.var), op1, op2);
+       }
+       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();
-               }
-               result = Z_LVAL_P(EX_VAR(opline->result.var)) != 0;
+       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();
        }
-       ZEND_VM_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -44794,46 +45266,62 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CV_TMPVAR_HAND
        USE_OPLINE
        zend_free_op free_op2;
        zval *op1, *op2;
-       int result;
+       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)) {
-                       result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
+                       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)) {
-                       result = ((double)Z_LVAL_P(op1) < Z_DVAL_P(op2));
-               } else {
-                       goto is_smaller_slow;
+                       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)) {
-                       result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
+                       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)) {
-                       result = (Z_DVAL_P(op1) < ((double)Z_LVAL_P(op2)));
-               } else {
-                       goto is_smaller_slow;
-               }
-       } else {
-is_smaller_slow:
-               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();
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       goto is_smaller_double;
                }
-               compare_function(EX_VAR(opline->result.var), op1, op2);
+       }
+       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();
-               }
-               result = Z_LVAL_P(EX_VAR(opline->result.var)) < 0;
+       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();
        }
-       ZEND_VM_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -44841,46 +45329,62 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_TM
        USE_OPLINE
        zend_free_op free_op2;
        zval *op1, *op2;
-       int result;
+       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)) {
-                       result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
+                       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)) {
-                       result = ((double)Z_LVAL_P(op1) <= Z_DVAL_P(op2));
-               } else {
-                       goto is_smaller_or_equal_slow;
+                       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)) {
-                       result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
+                       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)) {
-                       result = (Z_DVAL_P(op1) <= ((double)Z_LVAL_P(op2)));
-               } else {
-                       goto is_smaller_or_equal_slow;
-               }
-       } else {
-is_smaller_or_equal_slow:
-               SAVE_OPLINE();
-               if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
-                       op1 = ZVAL_UNDEFINED_OP1();
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       goto is_smaller_or_equal_double;
                }
-               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);
+       }
+       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();
-               }
-               result = Z_LVAL_P(EX_VAR(opline->result.var)) <= 0;
+       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_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -49844,48 +50348,64 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_CV_S
 {
        USE_OPLINE
        zval *value;
-       int result;
 
        value = EX_VAR(opline->op1.var);
        if (!(0)) {
-               result =
-                       Z_TYPE_P(value) > IS_NULL &&
-                   (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
+               if (Z_TYPE_P(value) > IS_NULL &&
+                   (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL)) {
+                       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();
+               }
        } else {
+               int result;
+
                SAVE_OPLINE();
                result = !i_zend_is_true(value);
                if (UNEXPECTED(EG(exception))) {
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
                }
+               ZEND_VM_SMART_BRANCH(result, 0);
+               ZVAL_BOOL(EX_VAR(opline->result.var), result);
+               ZEND_VM_NEXT_OPCODE();
        }
-       ZEND_VM_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
        zval *value;
-       int result;
 
        value = EX_VAR(opline->op1.var);
        if (!(1)) {
-               result =
-                       Z_TYPE_P(value) > IS_NULL &&
-                   (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
+               if (Z_TYPE_P(value) > IS_NULL &&
+                   (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL)) {
+                       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();
+               }
        } else {
+               int result;
+
                SAVE_OPLINE();
                result = !i_zend_is_true(value);
                if (UNEXPECTED(EG(exception))) {
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
                }
+               ZEND_VM_SMART_BRANCH(result, 0);
+               ZVAL_BOOL(EX_VAR(opline->result.var), result);
+               ZEND_VM_NEXT_OPCODE();
        }
-       ZEND_VM_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -50674,54 +51194,73 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER(ZE
        USE_OPLINE
 
        zval *op1, *op2;
-       int result;
+       double d1, d2;
 
        op1 = EX_VAR(opline->op1.var);
        op2 = EX_VAR(opline->op2.var);
        if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
+                       if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
+                               goto is_equal_true;
+                       } else {
+                               goto is_equal_false;
+                       }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       result = ((double)Z_LVAL_P(op1) == Z_DVAL_P(op2));
-               } else {
-                       goto is_equal_slow;
+                       d1 = (double)Z_LVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+                       goto is_equal_double;
                }
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
+                       d1 = Z_DVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+is_equal_double:
+                       if (d1 == d2) {
+                               goto is_equal_true;
+                       } else {
+                               goto is_equal_false;
+                       }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       result = (Z_DVAL_P(op1) == ((double)Z_LVAL_P(op2)));
-               } else {
-                       goto is_equal_slow;
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       goto is_equal_double;
                }
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
-                       result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
+                       int result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
 
 
-               } else {
-                       goto is_equal_slow;
-               }
-       } else {
-is_equal_slow:
-               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();
+                       if (result) {
+                               goto is_equal_true;
+                       } else {
+                               goto is_equal_false;
+                       }
                }
-               compare_function(EX_VAR(opline->result.var), op1, op2);
+       }
+       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();
-               }
-               result = Z_LVAL_P(EX_VAR(opline->result.var)) == 0;
+       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_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -50729,54 +51268,73 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLE
        USE_OPLINE
 
        zval *op1, *op2;
-       int result;
+       double d1, d2;
 
        op1 = EX_VAR(opline->op1.var);
        op2 = EX_VAR(opline->op2.var);
        if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
+                       if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
+                               goto is_not_equal_true;
+                       } else {
+                               goto is_not_equal_false;
+                       }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       result = ((double)Z_LVAL_P(op1) != Z_DVAL_P(op2));
-               } else {
-                       goto is_not_equal_slow;
+                       d1 = (double)Z_LVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+                       goto is_not_equal_double;
                }
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
+                       d1 = Z_DVAL_P(op1);
+                       d2 = Z_DVAL_P(op2);
+is_not_equal_double:
+                       if (d1 != d2) {
+                               goto is_not_equal_true;
+                       } else {
+                               goto is_not_equal_false;
+                       }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       result = (Z_DVAL_P(op1) != ((double)Z_LVAL_P(op2)));
-               } else {
-                       goto is_not_equal_slow;
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       goto is_not_equal_double;
                }
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
-                       result = !zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
+                       int result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
 
 
-               } else {
-                       goto is_not_equal_slow;
-               }
-       } else {
-is_not_equal_slow:
-               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();
+                       if (!result) {
+                               goto is_not_equal_true;
+                       } else {
+                               goto is_not_equal_false;
+                       }
                }
-               compare_function(EX_VAR(opline->result.var), op1, op2);
+       }
+       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();
-               }
-               result = Z_LVAL_P(EX_VAR(opline->result.var)) != 0;
+       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_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -50784,46 +51342,62 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CV_CV_HANDLER(
        USE_OPLINE
 
        zval *op1, *op2;
-       int result;
+       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)) {
-                       result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
+                       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)) {
-                       result = ((double)Z_LVAL_P(op1) < Z_DVAL_P(op2));
-               } else {
-                       goto is_smaller_slow;
+                       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)) {
-                       result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
+                       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)) {
-                       result = (Z_DVAL_P(op1) < ((double)Z_LVAL_P(op2)));
-               } else {
-                       goto is_smaller_slow;
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       goto is_smaller_double;
                }
-       } else {
-is_smaller_slow:
-               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);
+       }
+       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();
-               }
-               result = Z_LVAL_P(EX_VAR(opline->result.var)) < 0;
+       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_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -50831,46 +51405,62 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CV
        USE_OPLINE
 
        zval *op1, *op2;
-       int result;
+       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)) {
-                       result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
+                       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)) {
-                       result = ((double)Z_LVAL_P(op1) <= Z_DVAL_P(op2));
-               } else {
-                       goto is_smaller_or_equal_slow;
+                       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)) {
-                       result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
+                       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)) {
-                       result = (Z_DVAL_P(op1) <= ((double)Z_LVAL_P(op2)));
-               } else {
-                       goto is_smaller_or_equal_slow;
-               }
-       } else {
-is_smaller_or_equal_slow:
-               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();
+                       d1 = Z_DVAL_P(op1);
+                       d2 = (double)Z_LVAL_P(op2);
+                       goto is_smaller_or_equal_double;
                }
-               compare_function(EX_VAR(opline->result.var), op1, op2);
+       }
+       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();
-               }
-               result = Z_LVAL_P(EX_VAR(opline->result.var)) <= 0;
+       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_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)