Encapsulate all SMART BRANCH related logic inside macros. Result of SMART BRANCH...

diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
index dc029aa3877e9241a1295d21b52f976d35aae6e3..a860c0856049165d5bfa0a677564d64c6f0393ce 100644 (file)
--- a/Zend/zend_execute.c
+++ b/Zend/zend_execute.c
@@ -4246,21 +4246,13 @@ static zend_never_inline int ZEND_FASTCALL zend_quick_check_constant(
        OPLINE++
 
 
-#ifndef VM_SMART_OPCODES
-# define VM_SMART_OPCODES 1
-#endif
-
-#if VM_SMART_OPCODES
-# define ZEND_VM_REPEATABLE_OPCODE \
+#define ZEND_VM_REPEATABLE_OPCODE \
        do {
-# define ZEND_VM_REPEAT_OPCODE(_opcode) \
+#define ZEND_VM_REPEAT_OPCODE(_opcode) \
        } while (UNEXPECTED((++opline)->opcode == _opcode)); \
        OPLINE = opline; \
        ZEND_VM_CONTINUE()
-# define ZEND_VM_SMART_BRANCH(_result, _check) do { \
-               if ((_check) && UNEXPECTED(EG(exception))) { \
-                       break; \
-               } \
+#define ZEND_VM_SMART_BRANCH(_result, _check) do { \
                if (EXPECTED((opline+1)->opcode == ZEND_JMPZ)) { \
                        if (_result) { \
                                ZEND_VM_SET_NEXT_OPCODE(opline + 2); \
@@ -4274,40 +4266,49 @@ static zend_never_inline int ZEND_FASTCALL zend_quick_check_constant(
                                ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline + 1, (opline+1)->op2)); \
                        } \
                } else { \
-                       break; \
+                       ZVAL_BOOL(EX_VAR(opline->result.var), _result); \
+                       ZEND_VM_SET_NEXT_OPCODE(opline + 1); \
+               } \
+               if ((_check) && UNEXPECTED(EG(exception))) { \
+                       OPLINE = EX(opline); \
                } \
                ZEND_VM_CONTINUE(); \
        } while (0)
-# define ZEND_VM_SMART_BRANCH_JMPZ(_result, _check) do { \
+#define ZEND_VM_SMART_BRANCH_JMPZ(_result, _check) do { \
                if ((_check) && UNEXPECTED(EG(exception))) { \
-                       break; \
-               } \
-               if (_result) { \
+                       OPLINE = EX(opline); \
+               } else if (_result) { \
                        ZEND_VM_SET_NEXT_OPCODE(opline + 2); \
                } else { \
                        ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline + 1, (opline+1)->op2)); \
                } \
                ZEND_VM_CONTINUE(); \
        } while (0)
-# define ZEND_VM_SMART_BRANCH_JMPNZ(_result, _check) do { \
+#define ZEND_VM_SMART_BRANCH_JMPNZ(_result, _check) do { \
                if ((_check) && UNEXPECTED(EG(exception))) { \
-                       break; \
-               } \
-               if (!(_result)) { \
+                       OPLINE = EX(opline); \
+               } else if (!(_result)) { \
                        ZEND_VM_SET_NEXT_OPCODE(opline + 2); \
                } else { \
                        ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline + 1, (opline+1)->op2)); \
                } \
                ZEND_VM_CONTINUE(); \
        } while (0)
+#define ZEND_VM_SMART_BRANCH_NONE(_result, _check) do { \
+               ZVAL_BOOL(EX_VAR(opline->result.var), _result); \
+               ZEND_VM_NEXT_OPCODE_EX(_check, 1); \
+               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(); \
+               } else { \
+                       ZVAL_TRUE(EX_VAR(opline->result.var)); \
+                       ZEND_VM_SET_NEXT_OPCODE(opline + 1); \
                } \
+               ZEND_VM_CONTINUE(); \
        } while (0)
 #define ZEND_VM_SMART_BRANCH_TRUE_JMPZ() do { \
                ZEND_VM_SET_NEXT_OPCODE(opline + 2); \
@@ -4317,14 +4318,20 @@ static zend_never_inline int ZEND_FASTCALL zend_quick_check_constant(
                ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline + 1, (opline+1)->op2)); \
                ZEND_VM_CONTINUE(); \
        } while (0)
+#define ZEND_VM_SMART_BRANCH_TRUE_NONE() do { \
+               ZVAL_TRUE(EX_VAR(opline->result.var)); \
+               ZEND_VM_NEXT_OPCODE(); \
+       } 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(); \
+               } else { \
+                       ZVAL_FALSE(EX_VAR(opline->result.var)); \
+                       ZEND_VM_SET_NEXT_OPCODE(opline + 1); \
                } \
+               ZEND_VM_CONTINUE(); \
        } while (0)
 #define ZEND_VM_SMART_BRANCH_FALSE_JMPZ() do { \
                ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline + 1, (opline+1)->op2)); \
@@ -4334,15 +4341,10 @@ static zend_never_inline int ZEND_FASTCALL zend_quick_check_constant(
                ZEND_VM_SET_NEXT_OPCODE(opline + 2); \
                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_FALSE()
-#endif
+#define ZEND_VM_SMART_BRANCH_FALSE_NONE() do { \
+               ZVAL_FALSE(EX_VAR(opline->result.var)); \
+               ZEND_VM_NEXT_OPCODE(); \
+       } while (0)
 
 #ifdef __GNUC__
 # define ZEND_VM_GUARD(name) __asm__("#" #name)

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index 9680f4553a2fc9b059dc095c6c1b3d6117943cd1..e7915ab1d844d4490d743b59e41295de0a5c4fc6 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -455,8 +455,6 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(16, ZEND_IS_IDENTICAL, CONST|TMP|VAR|CV, CONST|T
        FREE_OP1();
        FREE_OP2();
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 ZEND_VM_COLD_CONSTCONST_HANDLER(17, ZEND_IS_NOT_IDENTICAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV, SPEC(COMMUTATIVE))
@@ -472,8 +470,6 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(17, ZEND_IS_NOT_IDENTICAL, CONST|TMP|VAR|CV, CON
        FREE_OP1();
        FREE_OP2();
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 ZEND_VM_HELPER(zend_is_equal_helper, ANY, ANY, zval *op_1, zval *op_2)
@@ -495,19 +491,7 @@ ZEND_VM_HELPER(zend_is_equal_helper, ANY, ANY, zval *op_1, zval *op_2)
        if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
                zval_ptr_dtor_nogc(op_2);
        }
-       if (UNEXPECTED(EG(exception))) {
-               ZVAL_UNDEF(EX_VAR(opline->result.var));
-               HANDLE_EXCEPTION();
-       }
-       if (ret == 0) {
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
+       ZEND_VM_SMART_BRANCH(ret == 0, 1);
 }
 
 ZEND_VM_COLD_CONSTCONST_HANDLER(18, ZEND_IS_EQUAL, CONST|TMPVAR|CV, CONST|TMPVAR|CV, SPEC(SMART_BRANCH,COMMUTATIVE))
@@ -525,13 +509,9 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(18, ZEND_IS_EQUAL, CONST|TMPVAR|CV, CONST|TMPVAR
                        if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
 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_false):
                                ZEND_VM_SMART_BRANCH_FALSE();
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -591,19 +571,7 @@ ZEND_VM_HELPER(zend_is_not_equal_helper, ANY, ANY, zval *op_1, zval *op_2)
        if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
                zval_ptr_dtor_nogc(op_2);
        }
-       if (UNEXPECTED(EG(exception))) {
-               ZVAL_UNDEF(EX_VAR(opline->result.var));
-               HANDLE_EXCEPTION();
-       }
-       if (ret != 0) {
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
+       ZEND_VM_SMART_BRANCH(ret != 0, 1);
 }
 
 ZEND_VM_COLD_CONSTCONST_HANDLER(19, ZEND_IS_NOT_EQUAL, CONST|TMPVAR|CV, CONST|TMPVAR|CV, SPEC(SMART_BRANCH,COMMUTATIVE))
@@ -621,13 +589,9 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(19, ZEND_IS_NOT_EQUAL, CONST|TMPVAR|CV, CONST|TM
                        if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
 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_false):
                                ZEND_VM_SMART_BRANCH_FALSE();
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -687,19 +651,7 @@ ZEND_VM_HELPER(zend_is_smaller_helper, ANY, ANY, zval *op_1, zval *op_2)
        if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
                zval_ptr_dtor_nogc(op_2);
        }
-       if (UNEXPECTED(EG(exception))) {
-               ZVAL_UNDEF(EX_VAR(opline->result.var));
-               HANDLE_EXCEPTION();
-       }
-       if (ret < 0) {
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
+       ZEND_VM_SMART_BRANCH(ret < 0, 1);
 }
 
 ZEND_VM_HOT_NOCONSTCONST_HANDLER(20, ZEND_IS_SMALLER, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(SMART_BRANCH))
@@ -717,13 +669,9 @@ ZEND_VM_HOT_NOCONSTCONST_HANDLER(20, ZEND_IS_SMALLER, CONST|TMPVARCV, CONST|TMPV
                        if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
 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_false):
                                ZEND_VM_SMART_BRANCH_FALSE();
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -768,19 +716,7 @@ ZEND_VM_HELPER(zend_is_smaller_or_equal_helper, ANY, ANY, zval *op_1, zval *op_2
        if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
                zval_ptr_dtor_nogc(op_2);
        }
-       if (UNEXPECTED(EG(exception))) {
-               ZVAL_UNDEF(EX_VAR(opline->result.var));
-               HANDLE_EXCEPTION();
-       }
-       if (ret <= 0) {
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
+       ZEND_VM_SMART_BRANCH(ret <= 0, 1);
 }
 
 ZEND_VM_HOT_NOCONSTCONST_HANDLER(21, ZEND_IS_SMALLER_OR_EQUAL, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(SMART_BRANCH))
@@ -5274,19 +5210,7 @@ ZEND_VM_HELPER(zend_case_helper, ANY, ANY, zval *op_1, zval *op_2)
        if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
                zval_ptr_dtor_nogc(op_2);
        }
-       if (UNEXPECTED(EG(exception))) {
-               ZVAL_UNDEF(EX_VAR(opline->result.var));
-               HANDLE_EXCEPTION();
-       }
-       if (ret == 0) {
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
+       ZEND_VM_SMART_BRANCH(ret == 0, 1);
 }
 
 ZEND_VM_HANDLER(48, ZEND_CASE, TMPVAR, CONST|TMPVAR|CV)
@@ -5302,13 +5226,9 @@ ZEND_VM_HANDLER(48, ZEND_CASE, TMPVAR, CONST|TMPVAR|CV)
                        if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
 ZEND_VM_C_LABEL(case_true):
                                ZEND_VM_SMART_BRANCH_TRUE();
-                               ZVAL_TRUE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        } else {
 ZEND_VM_C_LABEL(case_false):
                                ZEND_VM_SMART_BRANCH_FALSE();
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -6703,25 +6623,15 @@ ZEND_VM_HOT_HANDLER(154, ZEND_ISSET_ISEMPTY_CV, CV, UNUSED, ISSET, SPEC(ISSET))
                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, 1);
        }
 }
 
@@ -6767,8 +6677,6 @@ ZEND_VM_HANDLER(114, ZEND_ISSET_ISEMPTY_VAR, CONST|TMPVAR|CV, UNUSED, VAR_FETCH|
        }
 
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
@@ -6790,8 +6698,6 @@ ZEND_VM_HANDLER(180, ZEND_ISSET_ISEMPTY_STATIC_PROP, ANY, CLASS_FETCH, ISSET|CAC
        }
 
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 ZEND_VM_COLD_CONSTCONST_HANDLER(115, ZEND_ISSET_ISEMPTY_DIM_OBJ, CONST|TMPVAR|CV, CONST|TMPVAR|CV, ISSET)
@@ -6846,8 +6752,6 @@ ZEND_VM_C_LABEL(num_index_prop):
                                /* avoid exception check */
                                FREE_OP2();
                                ZEND_VM_SMART_BRANCH(result, 0);
-                               ZVAL_BOOL(EX_VAR(opline->result.var), result);
-                               ZEND_VM_NEXT_OPCODE();
                        }
                } else {
                        result = (value == NULL || !i_zend_is_true(value));
@@ -6873,8 +6777,6 @@ ZEND_VM_C_LABEL(isset_dim_obj_exit):
        FREE_OP2();
        FREE_OP1();
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 ZEND_VM_COLD_CONST_HANDLER(148, ZEND_ISSET_ISEMPTY_PROP_OBJ, CONST|TMPVAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, ISSET|CACHE_SLOT)
@@ -6930,8 +6832,6 @@ ZEND_VM_C_LABEL(isset_object_finish):
        FREE_OP2();
        FREE_OP1();
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 ZEND_VM_HANDLER(194, ZEND_ARRAY_KEY_EXISTS, CV|TMPVAR|CONST, CV|TMPVAR|CONST)
@@ -6964,8 +6864,6 @@ ZEND_VM_C_LABEL(array_key_exists_array):
        FREE_OP2();
        FREE_OP1();
        ZEND_VM_SMART_BRANCH(result == IS_TRUE, 1);
-       Z_TYPE_INFO_P(EX_VAR(opline->result.var)) = result;
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 /* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */
@@ -7334,8 +7232,6 @@ ZEND_VM_C_LABEL(try_instanceof):
        }
        FREE_OP1();
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 ZEND_VM_HOT_HANDLER(104, ZEND_EXT_NOP, ANY, ANY)
@@ -7460,7 +7356,10 @@ ZEND_VM_HANDLER(149, ZEND_HANDLE_EXCEPTION, ANY, ANY)
                                break; /* return value is zend_class_entry pointer */
 
                        default:
-                               zval_ptr_dtor_nogc(EX_VAR(throw_op->result.var));
+                               /* smart branch opcodes may not initialize result */
+                               if (!zend_is_smart_branch(throw_op)) {
+                                       zval_ptr_dtor_nogc(EX_VAR(throw_op->result.var));
+                               }
                }
        }
 
@@ -8052,12 +7951,8 @@ ZEND_VM_C_LABEL(type_check_resource):
                SAVE_OPLINE();
                FREE_OP1();
                ZEND_VM_SMART_BRANCH(result, 1);
-               ZVAL_BOOL(EX_VAR(opline->result.var), result);
-               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
        } else {
                ZEND_VM_SMART_BRANCH(result, 0);
-               ZVAL_BOOL(EX_VAR(opline->result.var), result);
-               ZEND_VM_NEXT_OPCODE();
        }
 }
 
@@ -8071,13 +7966,9 @@ ZEND_VM_HOT_HANDLER(122, ZEND_DEFINED, CONST, ANY, CACHE_SLOT)
                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();
                }
        }
        if (zend_quick_check_constant(RT_CONSTANT(opline, opline->op1) OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
@@ -8521,8 +8412,6 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(189, ZEND_IN_ARRAY, CONST|TMP|VAR|CV, CONST, NUM
        }
        FREE_OP1();
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result != NULL);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 ZEND_VM_COLD_CONST_HANDLER(190, ZEND_COUNT, CONST|TMPVAR|CV, UNUSED)
@@ -8879,8 +8768,6 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_EQUAL, (op1_info == MAY_BE_LONG && op2_inf
        op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
        result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
        ZEND_VM_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_EQUAL, (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE), ZEND_IS_EQUAL_DOUBLE, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(SMART_BRANCH,NO_CONST_CONST,COMMUTATIVE))
@@ -8893,8 +8780,6 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_EQUAL, (op1_info == MAY_BE_DOUBLE && op2_i
        op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
        result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
        ZEND_VM_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_NOT_EQUAL, (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG), ZEND_IS_NOT_EQUAL_LONG, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(SMART_BRANCH,NO_CONST_CONST,COMMUTATIVE))
@@ -8907,8 +8792,6 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_NOT_EQUAL, (op1_info == MAY_BE_LONG && op2
        op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
        result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
        ZEND_VM_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_NOT_EQUAL, (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE), ZEND_IS_NOT_EQUAL_DOUBLE, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(SMART_BRANCH,NO_CONST_CONST,COMMUTATIVE))
@@ -8921,8 +8804,6 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_NOT_EQUAL, (op1_info == MAY_BE_DOUBLE && o
        op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
        result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
        ZEND_VM_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_SMALLER, (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG), ZEND_IS_SMALLER_LONG, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(SMART_BRANCH,NO_CONST_CONST))
@@ -8935,8 +8816,6 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_SMALLER, (op1_info == MAY_BE_LONG && op2_i
        op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
        result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
        ZEND_VM_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_SMALLER, (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE), ZEND_IS_SMALLER_DOUBLE, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(SMART_BRANCH,NO_CONST_CONST))
@@ -8949,8 +8828,6 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_SMALLER, (op1_info == MAY_BE_DOUBLE && op2
        op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
        result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
        ZEND_VM_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_SMALLER_OR_EQUAL, (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG), ZEND_IS_SMALLER_OR_EQUAL_LONG, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(SMART_BRANCH,NO_CONST_CONST))
@@ -8963,8 +8840,6 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_SMALLER_OR_EQUAL, (op1_info == MAY_BE_LONG
        op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
        result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
        ZEND_VM_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_SMALLER_OR_EQUAL, (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE), ZEND_IS_SMALLER_OR_EQUAL_DOUBLE, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(SMART_BRANCH,NO_CONST_CONST))
@@ -8977,8 +8852,6 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_SMALLER_OR_EQUAL, (op1_info == MAY_BE_DOUB
        op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
        result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
        ZEND_VM_SMART_BRANCH(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_PRE_INC, (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG), ZEND_PRE_INC_LONG_NO_OVERFLOW, CV, ANY, SPEC(RETVAL))

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index 07bc67cfd68f26208994c6fd356de23d31db3ae6..31951ba22f802515e1ba8b75ef974c1c375558b6 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -595,19 +595,7 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_equal_hel
        if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
                zval_ptr_dtor_nogc(op_2);
        }
-       if (UNEXPECTED(EG(exception))) {
-               ZVAL_UNDEF(EX_VAR(opline->result.var));
-               HANDLE_EXCEPTION();
-       }
-       if (ret == 0) {
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
+       ZEND_VM_SMART_BRANCH(ret == 0, 1);
 }
 
 static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_not_equal_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
@@ -629,19 +617,7 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_not_equal
        if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
                zval_ptr_dtor_nogc(op_2);
        }
-       if (UNEXPECTED(EG(exception))) {
-               ZVAL_UNDEF(EX_VAR(opline->result.var));
-               HANDLE_EXCEPTION();
-       }
-       if (ret != 0) {
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
+       ZEND_VM_SMART_BRANCH(ret != 0, 1);
 }
 
 static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_smaller_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
@@ -663,19 +639,7 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_smaller_h
        if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
                zval_ptr_dtor_nogc(op_2);
        }
-       if (UNEXPECTED(EG(exception))) {
-               ZVAL_UNDEF(EX_VAR(opline->result.var));
-               HANDLE_EXCEPTION();
-       }
-       if (ret < 0) {
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
+       ZEND_VM_SMART_BRANCH(ret < 0, 1);
 }
 
 static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_smaller_or_equal_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
@@ -697,19 +661,7 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_smaller_o
        if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
                zval_ptr_dtor_nogc(op_2);
        }
-       if (UNEXPECTED(EG(exception))) {
-               ZVAL_UNDEF(EX_VAR(opline->result.var));
-               HANDLE_EXCEPTION();
-       }
-       if (ret <= 0) {
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
+       ZEND_VM_SMART_BRANCH(ret <= 0, 1);
 }
 
 static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_or_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
@@ -2123,19 +2075,7 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_case_helper_
        if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
                zval_ptr_dtor_nogc(op_2);
        }
-       if (UNEXPECTED(EG(exception))) {
-               ZVAL_UNDEF(EX_VAR(opline->result.var));
-               HANDLE_EXCEPTION();
-       }
-       if (ret == 0) {
-               ZEND_VM_SMART_BRANCH_TRUE();
-               ZVAL_TRUE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       } else {
-               ZEND_VM_SMART_BRANCH_FALSE();
-               ZVAL_FALSE(EX_VAR(opline->result.var));
-               ZEND_VM_NEXT_OPCODE();
-       }
+       ZEND_VM_SMART_BRANCH(ret == 0, 1);
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -2316,8 +2256,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC
        }
 
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_EXIT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -2589,7 +2527,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(
                                break; /* return value is zend_class_entry pointer */
 
                        default:
-                               zval_ptr_dtor_nogc(EX_VAR(throw_op->result.var));
+                               /* smart branch opcodes may not initialize result */
+                               if (!zend_is_smart_branch(throw_op)) {
+                                       zval_ptr_dtor_nogc(EX_VAR(throw_op->result.var));
+                               }
                }
        }
 
@@ -4525,12 +4466,8 @@ type_check_resource:
                SAVE_OPLINE();
 
                ZEND_VM_SMART_BRANCH(result, 1);
-               ZVAL_BOOL(EX_VAR(opline->result.var), result);
-               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
        } else {
                ZEND_VM_SMART_BRANCH(result, 0);
-               ZVAL_BOOL(EX_VAR(opline->result.var), result);
-               ZEND_VM_NEXT_OPCODE();
        }
 }
 
@@ -4544,13 +4481,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DEFINED_SPEC_CONST
                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();
                }
        }
        if (zend_quick_check_constant(RT_CONSTANT(opline, opline->op1) OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
@@ -4842,8 +4775,6 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC
 
 
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -4859,8 +4790,6 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_
 
 
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -4878,13 +4807,9 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CON
                        if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
 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();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -4940,13 +4865,9 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC
                        if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
 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();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -5002,13 +4923,9 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_C
                        if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
 is_smaller_true:
                                ZEND_VM_SMART_BRANCH_TRUE();
-                               ZVAL_TRUE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        } else {
 is_smaller_false:
                                ZEND_VM_SMART_BRANCH_FALSE();
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -6201,8 +6118,6 @@ num_index_prop:
                                /* avoid exception check */
 
                                ZEND_VM_SMART_BRANCH(result, 0);
-                               ZVAL_BOOL(EX_VAR(opline->result.var), result);
-                               ZEND_VM_NEXT_OPCODE();
                        }
                } else {
                        result = (value == NULL || !i_zend_is_true(value));
@@ -6228,8 +6143,6 @@ isset_dim_obj_exit:
 
 
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -6285,8 +6198,6 @@ isset_object_finish:
 
 
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -6318,8 +6229,6 @@ array_key_exists_array:
 
 
        ZEND_VM_SMART_BRANCH(result == IS_TRUE, 1);
-       Z_TYPE_INFO_P(EX_VAR(opline->result.var)) = result;
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 /* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */
@@ -6614,8 +6523,6 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_CON
        }
 
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result != NULL);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -6775,14 +6682,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                        if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
 is_smaller_true:
-
-                               ZVAL_TRUE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
+                               ZEND_VM_SMART_BRANCH_TRUE_NONE();
                        } else {
 is_smaller_false:
-
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
+                               ZEND_VM_SMART_BRANCH_FALSE_NONE();
                        }
                } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -6823,13 +6726,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CO
                        if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
 is_smaller_true:
                                ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
-                               ZVAL_TRUE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        } else {
 is_smaller_false:
                                ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -6870,13 +6769,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CO
                        if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
 is_smaller_true:
                                ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
-                               ZVAL_TRUE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        } else {
 is_smaller_false:
                                ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -6916,12 +6811,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                        if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
 is_smaller_or_equal_true:
-
+                               ZEND_VM_SMART_BRANCH_TRUE_NONE();
                                ZVAL_TRUE(EX_VAR(opline->result.var));
                                ZEND_VM_NEXT_OPCODE();
                        } else {
 is_smaller_or_equal_false:
-
+                               ZEND_VM_SMART_BRANCH_FALSE_NONE();
                                ZVAL_FALSE(EX_VAR(opline->result.var));
                                ZEND_VM_NEXT_OPCODE();
                        }
@@ -7088,9 +6983,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_CONST_TMP
        op1 = RT_CONSTANT(opline, opline->op1);
        op2 = EX_VAR(opline->op2.var);
        result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
-
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
+       ZEND_VM_SMART_BRANCH_NONE(result, 0);
 }
 
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -7103,8 +6996,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SP
        op2 = EX_VAR(opline->op2.var);
        result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
        ZEND_VM_SMART_BRANCH_JMPZ(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_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -7117,8 +7008,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SP
        op2 = EX_VAR(opline->op2.var);
        result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
        ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -7130,9 +7019,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_T
        op1 = RT_CONSTANT(opline, opline->op1);
        op2 = EX_VAR(opline->op2.var);
        result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
-
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
+       ZEND_VM_SMART_BRANCH_NONE(result, 0);
 }
 
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -7145,8 +7032,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_
        op2 = EX_VAR(opline->op2.var);
        result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
        ZEND_VM_SMART_BRANCH_JMPZ(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_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -7159,8 +7044,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_
        op2 = EX_VAR(opline->op2.var);
        result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
        ZEND_VM_SMART_BRANCH_JMPNZ(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_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -7172,9 +7055,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_
        op1 = RT_CONSTANT(opline, opline->op1);
        op2 = EX_VAR(opline->op2.var);
        result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
-
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
+       ZEND_VM_SMART_BRANCH_NONE(result, 0);
 }
 
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -7187,8 +7068,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUA
        op2 = EX_VAR(opline->op2.var);
        result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
        ZEND_VM_SMART_BRANCH_JMPZ(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_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -7201,8 +7080,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUA
        op2 = EX_VAR(opline->op2.var);
        result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
        ZEND_VM_SMART_BRANCH_JMPNZ(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_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -7214,9 +7091,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPE
        op1 = RT_CONSTANT(opline, opline->op1);
        op2 = EX_VAR(opline->op2.var);
        result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
-
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
+       ZEND_VM_SMART_BRANCH_NONE(result, 0);
 }
 
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -7229,8 +7104,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUA
        op2 = EX_VAR(opline->op2.var);
        result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
        ZEND_VM_SMART_BRANCH_JMPZ(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_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -7243,8 +7116,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUA
        op2 = EX_VAR(opline->op2.var);
        result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
        ZEND_VM_SMART_BRANCH_JMPNZ(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_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -8380,8 +8251,6 @@ num_index_prop:
                                /* avoid exception check */
                                zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
                                ZEND_VM_SMART_BRANCH(result, 0);
-                               ZVAL_BOOL(EX_VAR(opline->result.var), result);
-                               ZEND_VM_NEXT_OPCODE();
                        }
                } else {
                        result = (value == NULL || !i_zend_is_true(value));
@@ -8407,8 +8276,6 @@ isset_dim_obj_exit:
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
 
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -8464,8 +8331,6 @@ isset_object_finish:
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
 
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -8498,8 +8363,6 @@ array_key_exists_array:
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
 
        ZEND_VM_SMART_BRANCH(result == IS_TRUE, 1);
-       Z_TYPE_INFO_P(EX_VAR(opline->result.var)) = result;
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 /* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */
@@ -9368,8 +9231,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_U
        }
 
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
@@ -10815,8 +10676,6 @@ num_index_prop:
                                /* avoid exception check */
 
                                ZEND_VM_SMART_BRANCH(result, 0);
-                               ZVAL_BOOL(EX_VAR(opline->result.var), result);
-                               ZEND_VM_NEXT_OPCODE();
                        }
                } else {
                        result = (value == NULL || !i_zend_is_true(value));
@@ -10842,8 +10701,6 @@ isset_dim_obj_exit:
 
 
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -10899,8 +10756,6 @@ isset_object_finish:
 
 
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -10932,8 +10787,6 @@ array_key_exists_array:
 
 
        ZEND_VM_SMART_BRANCH(result == IS_TRUE, 1);
-       Z_TYPE_INFO_P(EX_VAR(opline->result.var)) = result;
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 /* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */
@@ -11302,14 +11155,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                        if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
 is_smaller_true:
-
-                               ZVAL_TRUE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
+                               ZEND_VM_SMART_BRANCH_TRUE_NONE();
                        } else {
 is_smaller_false:
-
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
+                               ZEND_VM_SMART_BRANCH_FALSE_NONE();
                        }
                } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -11350,13 +11199,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TM
                        if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
 is_smaller_true:
                                ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
-                               ZVAL_TRUE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        } else {
 is_smaller_false:
                                ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -11397,13 +11242,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TM
                        if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
 is_smaller_true:
                                ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
-                               ZVAL_TRUE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        } else {
 is_smaller_false:
                                ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -11443,12 +11284,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVA
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                        if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
 is_smaller_or_equal_true:
-
+                               ZEND_VM_SMART_BRANCH_TRUE_NONE();
                                ZVAL_TRUE(EX_VAR(opline->result.var));
                                ZEND_VM_NEXT_OPCODE();
                        } else {
 is_smaller_or_equal_false:
-
+                               ZEND_VM_SMART_BRANCH_FALSE_NONE();
                                ZVAL_FALSE(EX_VAR(opline->result.var));
                                ZEND_VM_NEXT_OPCODE();
                        }
@@ -11816,9 +11657,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CO
        op1 = EX_VAR(opline->op1.var);
        op2 = RT_CONSTANT(opline, opline->op2);
        result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
-
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
+       ZEND_VM_SMART_BRANCH_NONE(result, 0);
 }
 
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -11831,8 +11670,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC
        op2 = RT_CONSTANT(opline, opline->op2);
        result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
        ZEND_VM_SMART_BRANCH_JMPZ(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_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -11845,8 +11682,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC
        op2 = RT_CONSTANT(opline, opline->op2);
        result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
        ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -11858,9 +11693,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_
        op1 = EX_VAR(opline->op1.var);
        op2 = RT_CONSTANT(opline, opline->op2);
        result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
-
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
+       ZEND_VM_SMART_BRANCH_NONE(result, 0);
 }
 
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -11873,8 +11706,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SP
        op2 = RT_CONSTANT(opline, opline->op2);
        result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
        ZEND_VM_SMART_BRANCH_JMPZ(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_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -11887,8 +11718,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SP
        op2 = RT_CONSTANT(opline, opline->op2);
        result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
        ZEND_VM_SMART_BRANCH_JMPNZ(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_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -11900,9 +11729,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARC
        op1 = EX_VAR(opline->op1.var);
        op2 = RT_CONSTANT(opline, opline->op2);
        result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
-
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
+       ZEND_VM_SMART_BRANCH_NONE(result, 0);
 }
 
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -11915,8 +11742,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_
        op2 = RT_CONSTANT(opline, opline->op2);
        result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
        ZEND_VM_SMART_BRANCH_JMPZ(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_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -11929,8 +11754,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_
        op2 = RT_CONSTANT(opline, opline->op2);
        result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
        ZEND_VM_SMART_BRANCH_JMPNZ(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_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -11942,9 +11765,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVA
        op1 = EX_VAR(opline->op1.var);
        op2 = RT_CONSTANT(opline, opline->op2);
        result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
-
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
+       ZEND_VM_SMART_BRANCH_NONE(result, 0);
 }
 
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -11957,8 +11778,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBL
        op2 = RT_CONSTANT(opline, opline->op2);
        result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
        ZEND_VM_SMART_BRANCH_JMPZ(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_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -11971,8 +11790,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBL
        op2 = RT_CONSTANT(opline, opline->op2);
        result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
        ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -11984,9 +11801,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_
        op1 = EX_VAR(opline->op1.var);
        op2 = RT_CONSTANT(opline, opline->op2);
        result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
-
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
+       ZEND_VM_SMART_BRANCH_NONE(result, 0);
 }
 
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -11999,8 +11814,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SP
        op2 = RT_CONSTANT(opline, opline->op2);
        result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
        ZEND_VM_SMART_BRANCH_JMPZ(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_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12013,8 +11826,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SP
        op2 = RT_CONSTANT(opline, opline->op2);
        result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
        ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12026,9 +11837,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARC
        op1 = EX_VAR(opline->op1.var);
        op2 = RT_CONSTANT(opline, opline->op2);
        result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
-
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
+       ZEND_VM_SMART_BRANCH_NONE(result, 0);
 }
 
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12041,8 +11850,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_
        op2 = RT_CONSTANT(opline, opline->op2);
        result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
        ZEND_VM_SMART_BRANCH_JMPZ(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_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12055,8 +11862,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_
        op2 = RT_CONSTANT(opline, opline->op2);
        result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
        ZEND_VM_SMART_BRANCH_JMPNZ(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_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12068,9 +11873,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_
        op1 = EX_VAR(opline->op1.var);
        op2 = RT_CONSTANT(opline, opline->op2);
        result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
-
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
+       ZEND_VM_SMART_BRANCH_NONE(result, 0);
 }
 
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12083,8 +11886,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUA
        op2 = RT_CONSTANT(opline, opline->op2);
        result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
        ZEND_VM_SMART_BRANCH_JMPZ(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_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12097,8 +11898,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUA
        op2 = RT_CONSTANT(opline, opline->op2);
        result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
        ZEND_VM_SMART_BRANCH_JMPNZ(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_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12110,9 +11909,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPE
        op1 = EX_VAR(opline->op1.var);
        op2 = RT_CONSTANT(opline, opline->op2);
        result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
-
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
+       ZEND_VM_SMART_BRANCH_NONE(result, 0);
 }
 
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12125,8 +11922,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUA
        op2 = RT_CONSTANT(opline, opline->op2);
        result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
        ZEND_VM_SMART_BRANCH_JMPZ(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_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12139,8 +11934,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUA
        op2 = RT_CONSTANT(opline, opline->op2);
        result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
        ZEND_VM_SMART_BRANCH_JMPNZ(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_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12341,14 +12134,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVA
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                        if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
 is_smaller_true:
-
-                               ZVAL_TRUE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
+                               ZEND_VM_SMART_BRANCH_TRUE_NONE();
                        } else {
 is_smaller_false:
-
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
+                               ZEND_VM_SMART_BRANCH_FALSE_NONE();
                        }
                } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -12389,13 +12178,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TM
                        if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
 is_smaller_true:
                                ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
-                               ZVAL_TRUE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        } else {
 is_smaller_false:
                                ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -12436,13 +12221,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TM
                        if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
 is_smaller_true:
                                ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
-                               ZVAL_TRUE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        } else {
 is_smaller_false:
                                ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -12482,12 +12263,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVA
                if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
                        if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
 is_smaller_or_equal_true:
-
+                               ZEND_VM_SMART_BRANCH_TRUE_NONE();
                                ZVAL_TRUE(EX_VAR(opline->result.var));
                                ZEND_VM_NEXT_OPCODE();
                        } else {
 is_smaller_or_equal_false:
-
+                               ZEND_VM_SMART_BRANCH_FALSE_NONE();
                                ZVAL_FALSE(EX_VAR(opline->result.var));
                                ZEND_VM_NEXT_OPCODE();
                        }
@@ -12782,9 +12563,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TM
        op1 = EX_VAR(opline->op1.var);
        op2 = EX_VAR(opline->op2.var);
        result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
-
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
+       ZEND_VM_SMART_BRANCH_NONE(result, 0);
 }
 
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12797,8 +12576,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC
        op2 = EX_VAR(opline->op2.var);
        result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
        ZEND_VM_SMART_BRANCH_JMPZ(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_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12811,8 +12588,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC
        op2 = EX_VAR(opline->op2.var);
        result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
        ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12824,9 +12599,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_
        op1 = EX_VAR(opline->op1.var);
        op2 = EX_VAR(opline->op2.var);
        result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
-
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
+       ZEND_VM_SMART_BRANCH_NONE(result, 0);
 }
 
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12839,8 +12612,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SP
        op2 = EX_VAR(opline->op2.var);
        result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
        ZEND_VM_SMART_BRANCH_JMPZ(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_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12853,8 +12624,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SP
        op2 = EX_VAR(opline->op2.var);
        result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
        ZEND_VM_SMART_BRANCH_JMPNZ(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_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12866,9 +12635,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARC
        op1 = EX_VAR(opline->op1.var);
        op2 = EX_VAR(opline->op2.var);
        result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
-
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
+       ZEND_VM_SMART_BRANCH_NONE(result, 0);
 }
 
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12881,8 +12648,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_
        op2 = EX_VAR(opline->op2.var);
        result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
        ZEND_VM_SMART_BRANCH_JMPZ(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_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12895,8 +12660,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_
        op2 = EX_VAR(opline->op2.var);
        result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
        ZEND_VM_SMART_BRANCH_JMPNZ(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_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12908,9 +12671,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVA
        op1 = EX_VAR(opline->op1.var);
        op2 = EX_VAR(opline->op2.var);
        result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
-
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
+       ZEND_VM_SMART_BRANCH_NONE(result, 0);
 }
 
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12923,8 +12684,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBL
        op2 = EX_VAR(opline->op2.var);
        result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
        ZEND_VM_SMART_BRANCH_JMPZ(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_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12937,8 +12696,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBL
        op2 = EX_VAR(opline->op2.var);
        result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
        ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12950,9 +12707,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_
        op1 = EX_VAR(opline->op1.var);
        op2 = EX_VAR(opline->op2.var);
        result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
-
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
+       ZEND_VM_SMART_BRANCH_NONE(result, 0);
 }
 
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12965,8 +12720,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SP
        op2 = EX_VAR(opline->op2.var);
        result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
        ZEND_VM_SMART_BRANCH_JMPZ(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_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12979,8 +12732,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SP
        op2 = EX_VAR(opline->op2.var);
        result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
        ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12992,9 +12743,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARC
        op1 = EX_VAR(opline->op1.var);
        op2 = EX_VAR(opline->op2.var);
        result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
-
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
+       ZEND_VM_SMART_BRANCH_NONE(result, 0);
 }
 
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -13007,8 +12756,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_
        op2 = EX_VAR(opline->op2.var);
        result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
        ZEND_VM_SMART_BRANCH_JMPZ(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_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -13021,8 +12768,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_
        op2 = EX_VAR(opline->op2.var);
        result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
        ZEND_VM_SMART_BRANCH_JMPNZ(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_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -13034,9 +12779,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_
        op1 = EX_VAR(opline->op1.var);
        op2 = EX_VAR(opline->op2.var);
        result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
-
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
+       ZEND_VM_SMART_BRANCH_NONE(result, 0);
 }
 
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -13049,8 +12792,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUA
        op2 = EX_VAR(opline->op2.var);
        result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
        ZEND_VM_SMART_BRANCH_JMPZ(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_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -13063,8 +12804,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUA
        op2 = EX_VAR(opline->op2.var);
        result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
        ZEND_VM_SMART_BRANCH_JMPNZ(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_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -13076,9 +12815,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPE
        op1 = EX_VAR(opline->op1.var);
        op2 = EX_VAR(opline->op2.var);
        result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
-
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
+       ZEND_VM_SMART_BRANCH_NONE(result, 0);
 }
 
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -13091,8 +12828,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUA
        op2 = EX_VAR(opline->op2.var);
        result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
        ZEND_VM_SMART_BRANCH_JMPZ(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_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -13105,8 +12840,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUA
        op2 = EX_VAR(opline->op2.var);
        result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
        ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -13657,12 +13390,8 @@ type_check_resource:
                SAVE_OPLINE();
                zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
                ZEND_VM_SMART_BRANCH(result, 1);
-               ZVAL_BOOL(EX_VAR(opline->result.var), result);
-               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
        } else {
                ZEND_VM_SMART_BRANCH(result, 0);
-               ZVAL_BOOL(EX_VAR(opline->result.var), result);
-               ZEND_VM_NEXT_OPCODE();
        }
 }
 
@@ -13779,14 +13508,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_HAN
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
                        if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
 is_equal_true:
-
-                               ZVAL_TRUE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
+                               ZEND_VM_SMART_BRANCH_TRUE_NONE();
                        } else {
 is_equal_false:
-
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
+                               ZEND_VM_SMART_BRANCH_FALSE_NONE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -13842,13 +13567,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMP
                        if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
 is_equal_true:
                                ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
-                               ZVAL_TRUE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        } else {
 is_equal_false:
                                ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -13904,13 +13625,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMP
                        if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
 is_equal_true:
                                ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
-                               ZVAL_TRUE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        } else {
 is_equal_false:
                                ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -13965,14 +13682,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
                        if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
 is_not_equal_true:
-
-                               ZVAL_TRUE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
+                               ZEND_VM_SMART_BRANCH_TRUE_NONE();
                        } else {
 is_not_equal_false:
-
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
+                               ZEND_VM_SMART_BRANCH_FALSE_NONE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -14028,13 +13741,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST
                        if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
 is_not_equal_true:
                                ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
-                               ZVAL_TRUE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        } else {
 is_not_equal_false:
                                ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -14090,13 +13799,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST
                        if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
 is_not_equal_true:
                                ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
-                               ZVAL_TRUE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        } else {
 is_not_equal_false:
                                ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -14735,13 +14440,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_CONST_HANDLER
                        if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
 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();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -14829,8 +14530,6 @@ num_index_prop:
                                /* avoid exception check */
 
                                ZEND_VM_SMART_BRANCH(result, 0);
-                               ZVAL_BOOL(EX_VAR(opline->result.var), result);
-                               ZEND_VM_NEXT_OPCODE();
                        }
                } else {
                        result = (value == NULL || !i_zend_is_true(value));
@@ -14856,8 +14555,6 @@ isset_dim_obj_exit:
 
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -14913,8 +14610,6 @@ isset_object_finish:
 
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -14946,8 +14641,6 @@ array_key_exists_array:
 
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
        ZEND_VM_SMART_BRANCH(result == IS_TRUE, 1);
-       Z_TYPE_INFO_P(EX_VAR(opline->result.var)) = result;
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 /* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */
@@ -14995,8 +14688,6 @@ try_instanceof:
        }
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -15216,14 +14907,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HA
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
                        if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
 is_equal_true:
-
-                               ZVAL_TRUE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
+                               ZEND_VM_SMART_BRANCH_TRUE_NONE();
                        } else {
 is_equal_false:
-
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
+                               ZEND_VM_SMART_BRANCH_FALSE_NONE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -15279,13 +14966,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JM
                        if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
 is_equal_true:
                                ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
-                               ZVAL_TRUE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        } else {
 is_equal_false:
                                ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -15341,13 +15024,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JM
                        if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
 is_equal_true:
                                ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
-                               ZVAL_TRUE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        } else {
 is_equal_false:
                                ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -15402,14 +15081,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVA
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
                        if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
 is_not_equal_true:
-
-                               ZVAL_TRUE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
+                               ZEND_VM_SMART_BRANCH_TRUE_NONE();
                        } else {
 is_not_equal_false:
-
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
+                               ZEND_VM_SMART_BRANCH_FALSE_NONE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -15465,13 +15140,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVA
                        if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
 is_not_equal_true:
                                ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
-                               ZVAL_TRUE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        } else {
 is_not_equal_false:
                                ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -15527,13 +15198,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVA
                        if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
 is_not_equal_true:
                                ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
-                               ZVAL_TRUE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        } else {
 is_not_equal_false:
                                ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -16172,13 +15839,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLE
                        if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
 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();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -16266,8 +15929,6 @@ num_index_prop:
                                /* avoid exception check */
                                zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
                                ZEND_VM_SMART_BRANCH(result, 0);
-                               ZVAL_BOOL(EX_VAR(opline->result.var), result);
-                               ZEND_VM_NEXT_OPCODE();
                        }
                } else {
                        result = (value == NULL || !i_zend_is_true(value));
@@ -16293,8 +15954,6 @@ isset_dim_obj_exit:
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -16350,8 +16009,6 @@ isset_object_finish:
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -16384,8 +16041,6 @@ array_key_exists_array:
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
        ZEND_VM_SMART_BRANCH(result == IS_TRUE, 1);
-       Z_TYPE_INFO_P(EX_VAR(opline->result.var)) = result;
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 /* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */
@@ -16433,8 +16088,6 @@ try_instanceof:
        }
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(int type ZEND_OPCODE_HANDLER_ARGS_DC)
@@ -16641,8 +16294,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_
        }
 
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
@@ -16690,8 +16341,6 @@ try_instanceof:
        }
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COUNT_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -17483,13 +17132,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_CV_HANDLER(ZE
                        if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
 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();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -17577,8 +17222,6 @@ num_index_prop:
                                /* avoid exception check */
 
                                ZEND_VM_SMART_BRANCH(result, 0);
-                               ZVAL_BOOL(EX_VAR(opline->result.var), result);
-                               ZEND_VM_NEXT_OPCODE();
                        }
                } else {
                        result = (value == NULL || !i_zend_is_true(value));
@@ -17604,8 +17247,6 @@ isset_dim_obj_exit:
 
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -17661,8 +17302,6 @@ isset_object_finish:
 
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -17694,8 +17333,6 @@ array_key_exists_array:
 
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
        ZEND_VM_SMART_BRANCH(result == IS_TRUE, 1);
-       Z_TYPE_INFO_P(EX_VAR(opline->result.var)) = result;
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 /* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */
@@ -18475,8 +18112,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HA
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
 
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -18492,8 +18127,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONS
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
 
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -18911,8 +18544,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_TMP_CONST_HANDLE
        }
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result != NULL);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -19172,8 +18803,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HAND
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -19189,8 +18818,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -21831,8 +21458,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HA
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
 
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -21848,8 +21473,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONS
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
 
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -24164,8 +23787,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_VAR_CONST_HANDLE
        }
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result != NULL);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -26217,8 +25838,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HAND
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -26234,8 +25853,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -26429,8 +26046,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HAND
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -26446,8 +26061,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_
        zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -32116,8 +31729,6 @@ isset_object_finish:
 
 
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -33968,8 +33579,6 @@ isset_object_finish:
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
 
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -36571,8 +36180,6 @@ isset_object_finish:
 
 
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -38278,12 +37885,8 @@ type_check_resource:
                SAVE_OPLINE();
 
                ZEND_VM_SMART_BRANCH(result, 1);
-               ZVAL_BOOL(EX_VAR(opline->result.var), result);
-               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
        } else {
                ZEND_VM_SMART_BRANCH(result, 0);
-               ZVAL_BOOL(EX_VAR(opline->result.var), result);
-               ZEND_VM_NEXT_OPCODE();
        }
 }
 
@@ -38586,8 +38189,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_CONST_HAN
 
 
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -38603,8 +38204,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST
 
 
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -38621,14 +38220,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
                        if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
 is_equal_true:
-
-                               ZVAL_TRUE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
+                               ZEND_VM_SMART_BRANCH_TRUE_NONE();
                        } else {
 is_equal_false:
-
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
+                               ZEND_VM_SMART_BRANCH_FALSE_NONE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -38684,13 +38279,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ_HA
                        if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
 is_equal_true:
                                ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
-                               ZVAL_TRUE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        } else {
 is_equal_false:
                                ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -38746,13 +38337,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ_H
                        if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
 is_equal_true:
                                ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
-                               ZVAL_TRUE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        } else {
 is_equal_false:
                                ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -38807,14 +38394,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HAN
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
                        if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
 is_not_equal_true:
-
-                               ZVAL_TRUE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
+                               ZEND_VM_SMART_BRANCH_TRUE_NONE();
                        } else {
 is_not_equal_false:
-
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
+                               ZEND_VM_SMART_BRANCH_FALSE_NONE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -38870,13 +38453,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMP
                        if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
 is_not_equal_true:
                                ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
-                               ZVAL_TRUE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        } else {
 is_not_equal_false:
                                ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -38932,13 +38511,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMP
                        if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
 is_not_equal_true:
                                ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
-                               ZVAL_TRUE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        } else {
 is_not_equal_false:
                                ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -41532,8 +41107,6 @@ num_index_prop:
                                /* avoid exception check */
 
                                ZEND_VM_SMART_BRANCH(result, 0);
-                               ZVAL_BOOL(EX_VAR(opline->result.var), result);
-                               ZEND_VM_NEXT_OPCODE();
                        }
                } else {
                        result = (value == NULL || !i_zend_is_true(value));
@@ -41559,8 +41132,6 @@ isset_dim_obj_exit:
 
 
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -41616,8 +41187,6 @@ isset_object_finish:
 
 
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -41649,8 +41218,6 @@ array_key_exists_array:
 
 
        ZEND_VM_SMART_BRANCH(result == IS_TRUE, 1);
-       Z_TYPE_INFO_P(EX_VAR(opline->result.var)) = result;
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 /* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */
@@ -41698,8 +41265,6 @@ try_instanceof:
        }
 
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -41955,8 +41520,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_CV_CONST_HANDLER
        }
 
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result != NULL);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -42176,14 +41739,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMPVAR_HANDLE
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
                        if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
 is_equal_true:
-
-                               ZVAL_TRUE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
+                               ZEND_VM_SMART_BRANCH_TRUE_NONE();
                        } else {
 is_equal_false:
-
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
+                               ZEND_VM_SMART_BRANCH_FALSE_NONE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -42239,13 +41798,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_H
                        if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
 is_equal_true:
                                ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
-                               ZVAL_TRUE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        } else {
 is_equal_false:
                                ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -42301,13 +41856,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_
                        if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
 is_equal_true:
                                ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
-                               ZVAL_TRUE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        } else {
 is_equal_false:
                                ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -42362,14 +41913,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HA
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
                        if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
 is_not_equal_true:
-
-                               ZVAL_TRUE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
+                               ZEND_VM_SMART_BRANCH_TRUE_NONE();
                        } else {
 is_not_equal_false:
-
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
+                               ZEND_VM_SMART_BRANCH_FALSE_NONE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -42425,13 +41972,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JM
                        if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
 is_not_equal_true:
                                ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
-                               ZVAL_TRUE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        } else {
 is_not_equal_false:
                                ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -42487,13 +42030,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JM
                        if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
 is_not_equal_true:
                                ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
-                               ZVAL_TRUE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        } else {
 is_not_equal_false:
                                ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -45048,8 +44587,6 @@ num_index_prop:
                                /* avoid exception check */
                                zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
                                ZEND_VM_SMART_BRANCH(result, 0);
-                               ZVAL_BOOL(EX_VAR(opline->result.var), result);
-                               ZEND_VM_NEXT_OPCODE();
                        }
                } else {
                        result = (value == NULL || !i_zend_is_true(value));
@@ -45075,8 +44612,6 @@ isset_dim_obj_exit:
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
 
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -45132,8 +44667,6 @@ isset_object_finish:
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
 
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -45166,8 +44699,6 @@ array_key_exists_array:
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
 
        ZEND_VM_SMART_BRANCH(result == IS_TRUE, 1);
-       Z_TYPE_INFO_P(EX_VAR(opline->result.var)) = result;
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 /* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */
@@ -45184,8 +44715,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDL
 
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -45201,8 +44730,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_H
 
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -45395,8 +44922,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDL
 
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -45412,8 +44937,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_H
 
        zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -45535,8 +45058,6 @@ try_instanceof:
        }
 
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -46621,25 +46142,15 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_CV_S
                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, 1);
        }
 }
 
@@ -46653,25 +46164,15 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_CV_S
                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, 1);
        }
 }
 
@@ -46716,8 +46217,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUS
        }
 
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
@@ -46765,8 +46264,6 @@ try_instanceof:
        }
 
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -47232,8 +46729,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLE
 
 
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -47249,8 +46744,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HA
 
 
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -47267,14 +46760,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER(ZE
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
                        if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
 is_equal_true:
-
-                               ZVAL_TRUE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
+                               ZEND_VM_SMART_BRANCH_TRUE_NONE();
                        } else {
 is_equal_false:
-
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
+                               ZEND_VM_SMART_BRANCH_FALSE_NONE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -47330,13 +46819,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ_HANDL
                        if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
 is_equal_true:
                                ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
-                               ZVAL_TRUE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        } else {
 is_equal_false:
                                ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -47392,13 +46877,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ_HAND
                        if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
 is_equal_true:
                                ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
-                               ZVAL_TRUE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        } else {
 is_equal_false:
                                ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -47453,14 +46934,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLE
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
                        if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
 is_not_equal_true:
-
-                               ZVAL_TRUE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
+                               ZEND_VM_SMART_BRANCH_TRUE_NONE();
                        } else {
 is_not_equal_false:
-
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
+                               ZEND_VM_SMART_BRANCH_FALSE_NONE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -47516,13 +46993,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ_H
                        if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
 is_not_equal_true:
                                ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
-                               ZVAL_TRUE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        } else {
 is_not_equal_false:
                                ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -47578,13 +47051,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ_
                        if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
 is_not_equal_true:
                                ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
-                               ZVAL_TRUE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        } else {
 is_not_equal_false:
                                ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
-                               ZVAL_FALSE(EX_VAR(opline->result.var));
-                               ZEND_VM_NEXT_OPCODE();
                        }
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
                        d1 = (double)Z_LVAL_P(op1);
@@ -50207,8 +49676,6 @@ num_index_prop:
                                /* avoid exception check */
 
                                ZEND_VM_SMART_BRANCH(result, 0);
-                               ZVAL_BOOL(EX_VAR(opline->result.var), result);
-                               ZEND_VM_NEXT_OPCODE();
                        }
                } else {
                        result = (value == NULL || !i_zend_is_true(value));
@@ -50234,8 +49701,6 @@ isset_dim_obj_exit:
 
 
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -50291,8 +49756,6 @@ isset_object_finish:
 
 
        ZEND_VM_SMART_BRANCH(result, 1);
-       ZVAL_BOOL(EX_VAR(opline->result.var), result);
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -50324,8 +49787,6 @@ array_key_exists_array:
 
 
        ZEND_VM_SMART_BRANCH(result == IS_TRUE, 1);
-       Z_TYPE_INFO_P(EX_VAR(opline->result.var)) = result;
-       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 /* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */

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