Separate ISSET_ISEMPTY_CV/UNSET_CV from ISSET_ISEMPTY_VAR/UNSET_VAR

diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index 69fea4c2cf3dacf645f38c1211fba37159027fd6..e1d7b899b7497214538155ffe7ee0746e1cbb0f5 100644 (file)
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -2220,6 +2220,7 @@ ZEND_API int zend_is_smart_branch(zend_op *opline) /* {{{ */
                case ZEND_IS_SMALLER:
                case ZEND_IS_SMALLER_OR_EQUAL:
                case ZEND_CASE:
+               case ZEND_ISSET_ISEMPTY_CV:
                case ZEND_ISSET_ISEMPTY_VAR:
                case ZEND_ISSET_ISEMPTY_DIM_OBJ:
                case ZEND_ISSET_ISEMPTY_PROP_OBJ:
@@ -4290,8 +4291,7 @@ void zend_compile_unset(zend_ast *ast) /* {{{ */
                        if (is_this_fetch(var_ast)) {
                                zend_error_noreturn(E_COMPILE_ERROR, "Cannot unset $this");
                        } else if (zend_try_compile_cv(&var_node, var_ast) == SUCCESS) {
-                               opline = zend_emit_op(NULL, ZEND_UNSET_VAR, &var_node, NULL);
-                               opline->extended_value = ZEND_FETCH_LOCAL | ZEND_QUICK_SET;
+                               opline = zend_emit_op(NULL, ZEND_UNSET_CV, &var_node, NULL);
                        } else {
                                opline = zend_compile_simple_var_no_cv(NULL, var_ast, BP_VAR_UNSET, 0);
                                opline->opcode = ZEND_UNSET_VAR;
@@ -7469,8 +7469,7 @@ void zend_compile_isset_or_empty(znode *result, zend_ast *ast) /* {{{ */
                        if (is_this_fetch(var_ast)) {
                                opline = zend_emit_op(result, ZEND_ISSET_ISEMPTY_THIS, NULL, NULL);
                        } else if (zend_try_compile_cv(&var_node, var_ast) == SUCCESS) {
-                               opline = zend_emit_op(result, ZEND_ISSET_ISEMPTY_VAR, &var_node, NULL);
-                               opline->extended_value = ZEND_FETCH_LOCAL | ZEND_QUICK_SET;
+                               opline = zend_emit_op(result, ZEND_ISSET_ISEMPTY_CV, &var_node, NULL);
                        } else {
                                opline = zend_compile_simple_var_no_cv(result, var_ast, BP_VAR_IS, 0);
                                opline->opcode = ZEND_ISSET_ISEMPTY_VAR;

diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h
index af67018bdc7cca33bc7485562f59711dd1966824..55526d67390219722475dfaf68d1a55bcff3ed32 100644 (file)
--- a/Zend/zend_compile.h
+++ b/Zend/zend_compile.h
@@ -906,7 +906,6 @@ void zend_assert_valid_class_name(const zend_string *const_name);
 #define ZEND_ISSET                                 0x02000000
 #define ZEND_ISEMPTY                       0x01000000
 #define ZEND_ISSET_ISEMPTY_MASK            (ZEND_ISSET | ZEND_ISEMPTY)
-#define ZEND_QUICK_SET                     0x00800000
 
 #define ZEND_FETCH_ARG_MASK         0x000fffff
 

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index b3d6c99577143eb31685effd6625d2b9b0526393..fa4b6822090169bceacb91924051c73f88c03719 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -5327,32 +5327,36 @@ ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMPVAR|CV, ANY, EVAL)
        ZEND_VM_CONTINUE();
 }
 
-ZEND_VM_HANDLER(74, ZEND_UNSET_VAR, CONST|TMPVAR|CV, UNUSED, VAR_FETCH|ISSET)
+ZEND_VM_HANDLER(196, ZEND_UNSET_CV, CV, UNUSED)
 {
        USE_OPLINE
-       zval tmp, *varname;
-       HashTable *target_symbol_table;
-       zend_free_op free_op1;
+       zval *var = EX_VAR(opline->op1.var);
 
-       SAVE_OPLINE();
-       if (OP1_TYPE == IS_CV &&
-           (opline->extended_value & ZEND_QUICK_SET)) {
-               zval *var = EX_VAR(opline->op1.var);
-
-               if (Z_REFCOUNTED_P(var)) {
-                       zend_refcounted *garbage = Z_COUNTED_P(var);
+       if (Z_REFCOUNTED_P(var)) {
+               zend_refcounted *garbage = Z_COUNTED_P(var);
 
-                       ZVAL_UNDEF(var);
-                       if (!--GC_REFCOUNT(garbage)) {
-                               zval_dtor_func(garbage);
-                       } else {
-                               gc_check_possible_root(garbage);
-                       }
+               ZVAL_UNDEF(var);
+               if (!--GC_REFCOUNT(garbage)) {
+                       SAVE_OPLINE();
+                       zval_dtor_func(garbage);
+                       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
                } else {
-                       ZVAL_UNDEF(var);
+                       gc_check_possible_root(garbage);
                }
-               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+       } else {
+               ZVAL_UNDEF(var);
        }
+       ZEND_VM_NEXT_OPCODE();
+}
+
+ZEND_VM_HANDLER(74, ZEND_UNSET_VAR, CONST|TMPVAR|CV, UNUSED, VAR_FETCH)
+{
+       USE_OPLINE
+       zval tmp, *varname;
+       HashTable *target_symbol_table;
+       zend_free_op free_op1;
+
+       SAVE_OPLINE();
 
        varname = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
 
@@ -6131,63 +6135,66 @@ ZEND_VM_C_LABEL(fe_fetch_w_exit):
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
-ZEND_VM_HANDLER(114, ZEND_ISSET_ISEMPTY_VAR, CONST|TMPVAR|CV, UNUSED, VAR_FETCH|ISSET)
+ZEND_VM_HANDLER(197, ZEND_ISSET_ISEMPTY_CV, CV, UNUSED, ISSET)
 {
        USE_OPLINE
        zval *value;
        int result;
 
-       if (OP1_TYPE == IS_CV &&
-           (opline->extended_value & ZEND_QUICK_SET)) {
-               value = EX_VAR(opline->op1.var);
-               if (opline->extended_value & ZEND_ISSET) {
-                       result =
-                               Z_TYPE_P(value) > IS_NULL &&
-                           (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
-               } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-                       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_SET_NEXT_OPCODE(opline + 1);
-               ZEND_VM_CONTINUE();
-       } else {
-               zend_free_op free_op1;
-               zval tmp, *varname;
-               HashTable *target_symbol_table;
-
+       value = EX_VAR(opline->op1.var);
+       if (opline->extended_value & ZEND_ISSET) {
+               result =
+                       Z_TYPE_P(value) > IS_NULL &&
+                   (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
+       } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
                SAVE_OPLINE();
-               varname = GET_OP1_ZVAL_PTR(BP_VAR_IS);
-               ZVAL_UNDEF(&tmp);
-               if (OP1_TYPE != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
-                       ZVAL_STR(&tmp, zval_get_string(varname));
-                       varname = &tmp;
+               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_SET_NEXT_OPCODE(opline + 1);
+       ZEND_VM_CONTINUE();
+}
 
-               target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK EXECUTE_DATA_CC);
-               value = zend_hash_find_ind(target_symbol_table, Z_STR_P(varname));
+ZEND_VM_HANDLER(114, ZEND_ISSET_ISEMPTY_VAR, CONST|TMPVAR|CV, UNUSED, VAR_FETCH|ISSET)
+{
+       USE_OPLINE
+       zval *value;
+       int result;
+       zend_free_op free_op1;
+       zval tmp, *varname;
+       HashTable *target_symbol_table;
 
-               if (OP1_TYPE != IS_CONST && Z_TYPE(tmp) != IS_UNDEF) {
-                       zend_string_release(Z_STR(tmp));
-               }
-               FREE_OP1();
+       SAVE_OPLINE();
+       varname = GET_OP1_ZVAL_PTR(BP_VAR_IS);
+       ZVAL_UNDEF(&tmp);
+       if (OP1_TYPE != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
+               ZVAL_STR(&tmp, zval_get_string(varname));
+               varname = &tmp;
+       }
 
-               if (opline->extended_value & ZEND_ISSET) {
-                       result = value && Z_TYPE_P(value) > IS_NULL &&
-                           (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
-               } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-                       result = !value || !i_zend_is_true(value);
-               }
+       target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK EXECUTE_DATA_CC);
+       value = zend_hash_find_ind(target_symbol_table, Z_STR_P(varname));
 
-               ZEND_VM_SMART_BRANCH(result, 1);
-               ZVAL_BOOL(EX_VAR(opline->result.var), result);
-               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+       if (OP1_TYPE != IS_CONST && Z_TYPE(tmp) != IS_UNDEF) {
+               zend_string_release(Z_STR(tmp));
+       }
+       FREE_OP1();
+
+       if (opline->extended_value & ZEND_ISSET) {
+               result = value && Z_TYPE_P(value) > IS_NULL &&
+                   (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
+       } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
+               result = !value || !i_zend_is_true(value);
        }
+
+       ZEND_VM_SMART_BRANCH(result, 1);
+       ZVAL_BOOL(EX_VAR(opline->result.var), result);
+       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
 ZEND_VM_HANDLER(180, ZEND_ISSET_ISEMPTY_STATIC_PROP, CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR, ISSET)

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index 0024f852236989262c76f37ea7cf485b8d8564a6..bbe6dffc07c9bfb681d6cb940bb0f41bbe57f048 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -7644,24 +7644,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HA
 
 
        SAVE_OPLINE();
-       if (IS_CONST == IS_CV &&
-           (opline->extended_value & ZEND_QUICK_SET)) {
-               zval *var = EX_VAR(opline->op1.var);
-
-               if (Z_REFCOUNTED_P(var)) {
-                       zend_refcounted *garbage = Z_COUNTED_P(var);
-
-                       ZVAL_UNDEF(var);
-                       if (!--GC_REFCOUNT(garbage)) {
-                               zval_dtor_func(garbage);
-                       } else {
-                               gc_check_possible_root(garbage);
-                       }
-               } else {
-                       ZVAL_UNDEF(var);
-               }
-               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
-       }
 
        varname = EX_CONSTANT(opline->op1);
 
@@ -7746,56 +7728,34 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_U
        zval *value;
        int result;
 
-       if (IS_CONST == IS_CV &&
-           (opline->extended_value & ZEND_QUICK_SET)) {
-               value = EX_VAR(opline->op1.var);
-               if (opline->extended_value & ZEND_ISSET) {
-                       result =
-                               Z_TYPE_P(value) > IS_NULL &&
-                           (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
-               } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-                       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_SET_NEXT_OPCODE(opline + 1);
-               ZEND_VM_CONTINUE();
-       } else {
-
-               zval tmp, *varname;
-               HashTable *target_symbol_table;
-
-               SAVE_OPLINE();
-               varname = EX_CONSTANT(opline->op1);
-               ZVAL_UNDEF(&tmp);
-               if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
-                       ZVAL_STR(&tmp, zval_get_string(varname));
-                       varname = &tmp;
-               }
+       zval tmp, *varname;
+       HashTable *target_symbol_table;
 
-               target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK EXECUTE_DATA_CC);
-               value = zend_hash_find_ind(target_symbol_table, Z_STR_P(varname));
+       SAVE_OPLINE();
+       varname = EX_CONSTANT(opline->op1);
+       ZVAL_UNDEF(&tmp);
+       if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
+               ZVAL_STR(&tmp, zval_get_string(varname));
+               varname = &tmp;
+       }
 
-               if (IS_CONST != IS_CONST && Z_TYPE(tmp) != IS_UNDEF) {
-                       zend_string_release(Z_STR(tmp));
-               }
+       target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK EXECUTE_DATA_CC);
+       value = zend_hash_find_ind(target_symbol_table, Z_STR_P(varname));
 
-               if (opline->extended_value & ZEND_ISSET) {
-                       result = value && Z_TYPE_P(value) > IS_NULL &&
-                           (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
-               } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-                       result = !value || !i_zend_is_true(value);
-               }
+       if (IS_CONST != IS_CONST && Z_TYPE(tmp) != IS_UNDEF) {
+               zend_string_release(Z_STR(tmp));
+       }
 
-               ZEND_VM_SMART_BRANCH(result, 1);
-               ZVAL_BOOL(EX_VAR(opline->result.var), result);
-               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+       if (opline->extended_value & ZEND_ISSET) {
+               result = value && Z_TYPE_P(value) > IS_NULL &&
+                   (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
+       } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
+               result = !value || !i_zend_is_true(value);
        }
+
+       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_STATIC_PROP_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -40158,6 +40118,28 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HAND
        ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_CV_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zval *var = EX_VAR(opline->op1.var);
+
+       if (Z_REFCOUNTED_P(var)) {
+               zend_refcounted *garbage = Z_COUNTED_P(var);
+
+               ZVAL_UNDEF(var);
+               if (!--GC_REFCOUNT(garbage)) {
+                       SAVE_OPLINE();
+                       zval_dtor_func(garbage);
+                       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+               } else {
+                       gc_check_possible_root(garbage);
+               }
+       } else {
+               ZVAL_UNDEF(var);
+       }
+       ZEND_VM_NEXT_OPCODE();
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -40166,24 +40148,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDL
 
 
        SAVE_OPLINE();
-       if (IS_CV == IS_CV &&
-           (opline->extended_value & ZEND_QUICK_SET)) {
-               zval *var = EX_VAR(opline->op1.var);
-
-               if (Z_REFCOUNTED_P(var)) {
-                       zend_refcounted *garbage = Z_COUNTED_P(var);
-
-                       ZVAL_UNDEF(var);
-                       if (!--GC_REFCOUNT(garbage)) {
-                               zval_dtor_func(garbage);
-                       } else {
-                               gc_check_possible_root(garbage);
-                       }
-               } else {
-                       ZVAL_UNDEF(var);
-               }
-               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
-       }
 
        varname = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
 
@@ -40262,62 +40226,65 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_STATIC_PROP_SPEC_CV_UNUS
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
        zval *value;
        int result;
 
-       if (IS_CV == IS_CV &&
-           (opline->extended_value & ZEND_QUICK_SET)) {
-               value = EX_VAR(opline->op1.var);
-               if (opline->extended_value & ZEND_ISSET) {
-                       result =
-                               Z_TYPE_P(value) > IS_NULL &&
-                           (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
-               } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-                       SAVE_OPLINE();
-                       result = !i_zend_is_true(value);
-                       if (UNEXPECTED(EG(exception))) {
-                               ZVAL_UNDEF(EX_VAR(opline->result.var));
-                               HANDLE_EXCEPTION();
-                       }
+       value = EX_VAR(opline->op1.var);
+       if (opline->extended_value & ZEND_ISSET) {
+               result =
+                       Z_TYPE_P(value) > IS_NULL &&
+                   (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
+       } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
+               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_SET_NEXT_OPCODE(opline + 1);
-               ZEND_VM_CONTINUE();
-       } else {
+       }
+       ZEND_VM_SMART_BRANCH(result, 0);
+       ZVAL_BOOL(EX_VAR(opline->result.var), result);
+       ZEND_VM_SET_NEXT_OPCODE(opline + 1);
+       ZEND_VM_CONTINUE();
+}
 
-               zval tmp, *varname;
-               HashTable *target_symbol_table;
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zval *value;
+       int result;
 
-               SAVE_OPLINE();
-               varname = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
-               ZVAL_UNDEF(&tmp);
-               if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
-                       ZVAL_STR(&tmp, zval_get_string(varname));
-                       varname = &tmp;
-               }
+       zval tmp, *varname;
+       HashTable *target_symbol_table;
 
-               target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK EXECUTE_DATA_CC);
-               value = zend_hash_find_ind(target_symbol_table, Z_STR_P(varname));
+       SAVE_OPLINE();
+       varname = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
+       ZVAL_UNDEF(&tmp);
+       if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
+               ZVAL_STR(&tmp, zval_get_string(varname));
+               varname = &tmp;
+       }
 
-               if (IS_CV != IS_CONST && Z_TYPE(tmp) != IS_UNDEF) {
-                       zend_string_release(Z_STR(tmp));
-               }
+       target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK EXECUTE_DATA_CC);
+       value = zend_hash_find_ind(target_symbol_table, Z_STR_P(varname));
 
-               if (opline->extended_value & ZEND_ISSET) {
-                       result = value && Z_TYPE_P(value) > IS_NULL &&
-                           (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
-               } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-                       result = !value || !i_zend_is_true(value);
-               }
+       if (IS_CV != IS_CONST && Z_TYPE(tmp) != IS_UNDEF) {
+               zend_string_release(Z_STR(tmp));
+       }
 
-               ZEND_VM_SMART_BRANCH(result, 1);
-               ZVAL_BOOL(EX_VAR(opline->result.var), result);
-               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+       if (opline->extended_value & ZEND_ISSET) {
+               result = value && Z_TYPE_P(value) > IS_NULL &&
+                   (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
+       } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
+               result = !value || !i_zend_is_true(value);
        }
+
+       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_STATIC_PROP_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -50375,24 +50342,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_H
        zend_free_op free_op1;
 
        SAVE_OPLINE();
-       if ((IS_TMP_VAR|IS_VAR) == IS_CV &&
-           (opline->extended_value & ZEND_QUICK_SET)) {
-               zval *var = EX_VAR(opline->op1.var);
-
-               if (Z_REFCOUNTED_P(var)) {
-                       zend_refcounted *garbage = Z_COUNTED_P(var);
-
-                       ZVAL_UNDEF(var);
-                       if (!--GC_REFCOUNT(garbage)) {
-                               zval_dtor_func(garbage);
-                       } else {
-                               gc_check_possible_root(garbage);
-                       }
-               } else {
-                       ZVAL_UNDEF(var);
-               }
-               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
-       }
 
        varname = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
@@ -50476,58 +50425,36 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_
        USE_OPLINE
        zval *value;
        int result;
+       zend_free_op free_op1;
+       zval tmp, *varname;
+       HashTable *target_symbol_table;
 
-       if ((IS_TMP_VAR|IS_VAR) == IS_CV &&
-           (opline->extended_value & ZEND_QUICK_SET)) {
-               value = EX_VAR(opline->op1.var);
-               if (opline->extended_value & ZEND_ISSET) {
-                       result =
-                               Z_TYPE_P(value) > IS_NULL &&
-                           (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
-               } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-                       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_SET_NEXT_OPCODE(opline + 1);
-               ZEND_VM_CONTINUE();
-       } else {
-               zend_free_op free_op1;
-               zval tmp, *varname;
-               HashTable *target_symbol_table;
-
-               SAVE_OPLINE();
-               varname = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
-               ZVAL_UNDEF(&tmp);
-               if ((IS_TMP_VAR|IS_VAR) != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
-                       ZVAL_STR(&tmp, zval_get_string(varname));
-                       varname = &tmp;
-               }
-
-               target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK EXECUTE_DATA_CC);
-               value = zend_hash_find_ind(target_symbol_table, Z_STR_P(varname));
+       SAVE_OPLINE();
+       varname = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       ZVAL_UNDEF(&tmp);
+       if ((IS_TMP_VAR|IS_VAR) != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
+               ZVAL_STR(&tmp, zval_get_string(varname));
+               varname = &tmp;
+       }
 
-               if ((IS_TMP_VAR|IS_VAR) != IS_CONST && Z_TYPE(tmp) != IS_UNDEF) {
-                       zend_string_release(Z_STR(tmp));
-               }
-               zval_ptr_dtor_nogc(free_op1);
+       target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK EXECUTE_DATA_CC);
+       value = zend_hash_find_ind(target_symbol_table, Z_STR_P(varname));
 
-               if (opline->extended_value & ZEND_ISSET) {
-                       result = value && Z_TYPE_P(value) > IS_NULL &&
-                           (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
-               } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-                       result = !value || !i_zend_is_true(value);
-               }
+       if ((IS_TMP_VAR|IS_VAR) != IS_CONST && Z_TYPE(tmp) != IS_UNDEF) {
+               zend_string_release(Z_STR(tmp));
+       }
+       zval_ptr_dtor_nogc(free_op1);
 
-               ZEND_VM_SMART_BRANCH(result, 1);
-               ZVAL_BOOL(EX_VAR(opline->result.var), result);
-               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+       if (opline->extended_value & ZEND_ISSET) {
+               result = value && Z_TYPE_P(value) > IS_NULL &&
+                   (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
+       } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
+               result = !value || !i_zend_is_true(value);
        }
+
+       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_STATIC_PROP_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -58044,6 +57971,56 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_UNSET_CV_SPEC_CV_UNUSED_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_LABEL,
                        (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
@@ -61864,12 +61841,18 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CV_UNUSED):
                                ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_UNSET_CV_SPEC_CV_UNUSED):
+                               ZEND_UNSET_CV_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_UNSET_VAR_SPEC_CV_UNUSED):
                                ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
                        HYBRID_CASE(ZEND_UNSET_STATIC_PROP_SPEC_CV_UNUSED):
                                ZEND_UNSET_STATIC_PROP_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED):
+                               ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED):
                                ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
@@ -66978,6 +66961,56 @@ void zend_init_opcodes_handlers(void)
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_UNSET_CV_SPEC_CV_UNUSED_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ADD_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_HANDLER,
                ZEND_ADD_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_HANDLER,
                ZEND_NULL_HANDLER,
@@ -68095,7 +68128,7 @@ void zend_init_opcodes_handlers(void)
                2257 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
                2282 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
                2307 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               4871,
+               4921,
                2332,
                2333,
                2334,
@@ -68180,7 +68213,7 @@ void zend_init_opcodes_handlers(void)
                3531 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
                3556 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
                3581 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               4871,
+               4921,
                3606 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
                3631 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
                3656 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
@@ -68191,7 +68224,9 @@ void zend_init_opcodes_handlers(void)
                3781 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
                3806 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
                3831 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               4871
+               3856 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               3881 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               4921
        };
 #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
        zend_opcode_handler_funcs = labels;
@@ -68386,7 +68421,7 @@ ZEND_API void zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t op1_info, uint
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 3856 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+                               spec = 3906 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
                                if (op->op1_type > op->op2_type) {
                                        zend_swap_operands(op);
                                }
@@ -68394,7 +68429,7 @@ ZEND_API void zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t op1_info, uint
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 3881 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+                               spec = 3931 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
                                if (op->op1_type > op->op2_type) {
                                        zend_swap_operands(op);
                                }
@@ -68402,7 +68437,7 @@ ZEND_API void zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t op1_info, uint
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 3906 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+                               spec = 3956 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
                                if (op->op1_type > op->op2_type) {
                                        zend_swap_operands(op);
                                }
@@ -68413,17 +68448,17 @@ ZEND_API void zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t op1_info, uint
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 3931 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+                               spec = 3981 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
                        } else if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 3956 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+                               spec = 4006 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
                        } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 3981 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+                               spec = 4031 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
                        }
                        break;
                case ZEND_MUL:
@@ -68431,7 +68466,7 @@ ZEND_API void zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t op1_info, uint
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 4006 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+                               spec = 4056 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
                                if (op->op1_type > op->op2_type) {
                                        zend_swap_operands(op);
                                }
@@ -68439,7 +68474,7 @@ ZEND_API void zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t op1_info, uint
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 4031 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+                               spec = 4081 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
                                if (op->op1_type > op->op2_type) {
                                        zend_swap_operands(op);
                                }
@@ -68447,7 +68482,7 @@ ZEND_API void zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t op1_info, uint
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 4056 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+                               spec = 4106 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
                                if (op->op1_type > op->op2_type) {
                                        zend_swap_operands(op);
                                }
@@ -68458,7 +68493,7 @@ ZEND_API void zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t op1_info, uint
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 4081 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+                               spec = 4131 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
                                if (op->op1_type > op->op2_type) {
                                        zend_swap_operands(op);
                                }
@@ -68466,7 +68501,7 @@ ZEND_API void zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t op1_info, uint
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 4156 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+                               spec = 4206 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
                                if (op->op1_type > op->op2_type) {
                                        zend_swap_operands(op);
                                }
@@ -68477,7 +68512,7 @@ ZEND_API void zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t op1_info, uint
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 4231 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+                               spec = 4281 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
                                if (op->op1_type > op->op2_type) {
                                        zend_swap_operands(op);
                                }
@@ -68485,7 +68520,7 @@ ZEND_API void zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t op1_info, uint
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 4306 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+                               spec = 4356 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
                                if (op->op1_type > op->op2_type) {
                                        zend_swap_operands(op);
                                }
@@ -68496,12 +68531,12 @@ ZEND_API void zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t op1_info, uint
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 4381 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+                               spec = 4431 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
                        } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 4456 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+                               spec = 4506 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
                        }
                        break;
                case ZEND_IS_SMALLER_OR_EQUAL:
@@ -68509,75 +68544,75 @@ ZEND_API void zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t op1_info, uint
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 4531 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+                               spec = 4581 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
                        } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
                                if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
                                        break;
                                }
-                               spec = 4606 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+                               spec = 4656 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
                        }
                        break;
                case ZEND_QM_ASSIGN:
                        if (op1_info == MAY_BE_DOUBLE) {
-                               spec = 4771 | SPEC_RULE_OP1;
+                               spec = 4821 | SPEC_RULE_OP1;
                        } else if (!(op1_info & ((MAY_BE_ANY|MAY_BE_UNDEF)-(MAY_BE_NULL|MAY_BE_FALSE|MAY_BE_TRUE|MAY_BE_LONG|MAY_BE_DOUBLE)))) {
-                               spec = 4776 | SPEC_RULE_OP1;
+                               spec = 4826 | SPEC_RULE_OP1;
                        }
                        break;
                case ZEND_PRE_INC:
                        if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-                               spec = 4681 | SPEC_RULE_OP1 | SPEC_RULE_RETVAL;
+                               spec = 4731 | SPEC_RULE_OP1 | SPEC_RULE_RETVAL;
                        } else if (op1_info == MAY_BE_LONG) {
-                               spec = 4691 | SPEC_RULE_OP1 | SPEC_RULE_RETVAL;
+                               spec = 4741 | SPEC_RULE_OP1 | SPEC_RULE_RETVAL;
                        } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) {
-                               spec = 4701 | SPEC_RULE_OP1 | SPEC_RULE_RETVAL;
+                               spec = 4751 | SPEC_RULE_OP1 | SPEC_RULE_RETVAL;
                        }
                        break;
                case ZEND_PRE_DEC:
                        if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-                               spec = 4711 | SPEC_RULE_OP1 | SPEC_RULE_RETVAL;
+                               spec = 4761 | SPEC_RULE_OP1 | SPEC_RULE_RETVAL;
                        } else if (op1_info == MAY_BE_LONG) {
-                               spec = 4721 | SPEC_RULE_OP1 | SPEC_RULE_RETVAL;
+                               spec = 4771 | SPEC_RULE_OP1 | SPEC_RULE_RETVAL;
                        } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) {
-                               spec = 4731 | SPEC_RULE_OP1 | SPEC_RULE_RETVAL;
+                               spec = 4781 | SPEC_RULE_OP1 | SPEC_RULE_RETVAL;
                        }
                        break;
                case ZEND_POST_INC:
                        if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-                               spec = 4741 | SPEC_RULE_OP1;
+                               spec = 4791 | SPEC_RULE_OP1;
                        } else if (op1_info == MAY_BE_LONG) {
-                               spec = 4746 | SPEC_RULE_OP1;
+                               spec = 4796 | SPEC_RULE_OP1;
                        } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) {
-                               spec = 4751 | SPEC_RULE_OP1;
+                               spec = 4801 | SPEC_RULE_OP1;
                        }
                        break;
                case ZEND_POST_DEC:
                        if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-                               spec = 4756 | SPEC_RULE_OP1;
+                               spec = 4806 | SPEC_RULE_OP1;
                        } else if (op1_info == MAY_BE_LONG) {
-                               spec = 4761 | SPEC_RULE_OP1;
+                               spec = 4811 | SPEC_RULE_OP1;
                        } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) {
-                               spec = 4766 | SPEC_RULE_OP1;
+                               spec = 4816 | SPEC_RULE_OP1;
                        }
                        break;
                case ZEND_SEND_VAR_EX:
                        if ((op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) {
-                               spec = 4811 | SPEC_RULE_OP1 | SPEC_RULE_QUICK_ARG;
+                               spec = 4861 | SPEC_RULE_OP1 | SPEC_RULE_QUICK_ARG;
                        }
                        break;
                case ZEND_FE_FETCH_R:
                        if (op->op2_type == IS_CV && (op1_info & (MAY_BE_UNDEF|MAY_BE_ANY|MAY_BE_REF)) == MAY_BE_ARRAY) {
-                               spec = 4821 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_RETVAL;
+                               spec = 4871 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_RETVAL;
                        }
                        break;
                case ZEND_FETCH_DIM_R:
                        if (!(op2_info & (MAY_BE_UNDEF|MAY_BE_NULL|MAY_BE_STRING|MAY_BE_ARRAY|MAY_BE_OBJECT|MAY_BE_RESOURCE|MAY_BE_REF))) {
-                               spec = 4781 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+                               spec = 4831 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
                        }
                        break;
                case ZEND_SEND_VAR:
                        if ((op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) {
-                               spec = 4806 | SPEC_RULE_OP1;
+                               spec = 4856 | SPEC_RULE_OP1;
                        }
                        break;
                default:

diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c
index ed888e73c9b5b063641513374f79c36d5fe9eb87..ecfe4645fa05e27d02df93bed13e79368c5d928c 100644 (file)
--- a/Zend/zend_vm_opcodes.c
+++ b/Zend/zend_vm_opcodes.c
@@ -21,7 +21,7 @@
 #include <stdio.h>
 #include <zend.h>
 
-static const char *zend_vm_opcodes_names[196] = {
+static const char *zend_vm_opcodes_names[198] = {
        "ZEND_NOP",
        "ZEND_ADD",
        "ZEND_SUB",
@@ -218,9 +218,11 @@ static const char *zend_vm_opcodes_names[196] = {
        "ZEND_GET_TYPE",
        "ZEND_FUNC_NUM_ARGS",
        "ZEND_FUNC_GET_ARGS",
+       "ZEND_UNSET_CV",
+       "ZEND_ISSET_ISEMPTY_CV",
 };
 
-static uint32_t zend_vm_opcodes_flags[196] = {
+static uint32_t zend_vm_opcodes_flags[198] = {
        0x00000000,
        0x00000707,
        0x00000707,
@@ -295,7 +297,7 @@ static uint32_t zend_vm_opcodes_flags[196] = {
        0x00186703,
        0x00106703,
        0x08000007,
-       0x00030107,
+       0x00010107,
        0x00000701,
        0x00000751,
        0x00002003,
@@ -417,6 +419,8 @@ static uint32_t zend_vm_opcodes_flags[196] = {
        0x00000103,
        0x00000101,
        0x00000103,
+       0x00000101,
+       0x00020101,
 };
 
 ZEND_API const char* zend_get_opcode_name(zend_uchar opcode) {

diff --git a/Zend/zend_vm_opcodes.h b/Zend/zend_vm_opcodes.h
index 6001400bf8eb7ddb37252a49252fe1d12e7f3725..3be364150f93922035a938474404118a2130c6a9 100644 (file)
--- a/Zend/zend_vm_opcodes.h
+++ b/Zend/zend_vm_opcodes.h
@@ -267,7 +267,9 @@ END_EXTERN_C()
 #define ZEND_GET_TYPE                        193
 #define ZEND_FUNC_NUM_ARGS                   194
 #define ZEND_FUNC_GET_ARGS                   195
+#define ZEND_UNSET_CV                        196
+#define ZEND_ISSET_ISEMPTY_CV                197
 
-#define ZEND_VM_LAST_OPCODE                  195
+#define ZEND_VM_LAST_OPCODE                  197
 
 #endif

diff --git a/ext/opcache/Optimizer/dce.c b/ext/opcache/Optimizer/dce.c
index 2c21154ef795e9490e50a4d42761c33d083677d1..e3b42851974c9f6446fecfb0b11a7e739b0fa04a 100644 (file)
--- a/ext/opcache/Optimizer/dce.c
+++ b/ext/opcache/Optimizer/dce.c
@@ -116,6 +116,7 @@ static inline zend_bool may_have_side_effects(
                case ZEND_ISSET_ISEMPTY_THIS:
                case ZEND_ISSET_ISEMPTY_DIM_OBJ:
                case ZEND_FETCH_DIM_IS:
+               case ZEND_ISSET_ISEMPTY_CV:
                case ZEND_ISSET_ISEMPTY_VAR:
                case ZEND_FETCH_IS:
                        /* No side effects */
@@ -172,11 +173,10 @@ static inline zend_bool may_have_side_effects(
                        return 0;
                }
                case ZEND_UNSET_VAR:
+                       return 1;
+               case ZEND_UNSET_CV:
                {
                        uint32_t t1 = OP1_INFO();
-                       if (!(opline->extended_value & ZEND_QUICK_SET)) {
-                               return 1;
-                       }
                        if (t1 & MAY_BE_REF) {
                                /* We don't consider uses as the LHS of an assignment as real uses during DCE, so
                                 * an unset may be considered dead even if there is a later assignment to the

diff --git a/ext/opcache/Optimizer/sccp.c b/ext/opcache/Optimizer/sccp.c
index 1e023f1b1b3c67444aa0e76b49f08b035ac5a66b..06a4406fe8c5733c08920e6b8e50006572df1ad4 100644 (file)
--- a/ext/opcache/Optimizer/sccp.c
+++ b/ext/opcache/Optimizer/sccp.c
@@ -192,11 +192,9 @@ static zend_bool can_replace_op1(
                case ZEND_BIND_STATIC:
                case ZEND_BIND_GLOBAL:
                case ZEND_MAKE_REF:
+               case ZEND_UNSET_CV:
+               case ZEND_ISSET_ISEMPTY_CV:
                        return 0;
-               case ZEND_UNSET_VAR:
-               case ZEND_ISSET_ISEMPTY_VAR:
-                       /* CV has special meaning here - cannot simply be replaced */
-                       return (opline->extended_value & ZEND_QUICK_SET) == 0;
                case ZEND_INIT_ARRAY:
                case ZEND_ADD_ARRAY_ELEMENT:
                        return !(opline->extended_value & ZEND_ARRAY_ELEMENT_REF);
@@ -440,10 +438,6 @@ static inline int ct_eval_incdec(zval *result, zend_uchar opcode, zval *op1) {
 }
 
 static inline int ct_eval_isset_isempty(zval *result, uint32_t extended_value, zval *op1) {
-       if (!(extended_value & ZEND_QUICK_SET)) {
-               return FAILURE;
-       }
-
        if (extended_value & ZEND_ISSET) {
                ZVAL_BOOL(result, Z_TYPE_P(op1) != IS_NULL);
        } else {
@@ -879,7 +873,7 @@ static void sccp_visit_instr(scdf_ctx *scdf, zend_op *opline, zend_ssa_op *ssa_o
                        }
                        SET_RESULT(result, op1);
                        break;
-               case ZEND_ISSET_ISEMPTY_VAR:
+               case ZEND_ISSET_ISEMPTY_CV:
                        SKIP_IF_TOP(op1);
                        if (ct_eval_isset_isempty(&zv, opline->extended_value, op1) == SUCCESS) {
                                SET_RESULT(result, &zv);

diff --git a/ext/opcache/Optimizer/zend_cfg.c b/ext/opcache/Optimizer/zend_cfg.c
index 25d0acb6ce7e57e2dd8a66884774de0742aca810..4914c9e45e89ed3195be6a1e57ce74add532e01d 100644 (file)
--- a/ext/opcache/Optimizer/zend_cfg.c
+++ b/ext/opcache/Optimizer/zend_cfg.c
@@ -418,8 +418,7 @@ int zend_build_cfg(zend_arena **arena, const zend_op_array *op_array, uint32_t b
                        }
                        case ZEND_UNSET_VAR:
                        case ZEND_ISSET_ISEMPTY_VAR:
-                               if (((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_LOCAL) &&
-                                   !(opline->extended_value & ZEND_QUICK_SET)) {
+                               if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_LOCAL) {
                                        flags |= ZEND_FUNC_INDIRECT_VAR_ACCESS;
                                } else if (((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_GLOBAL ||
                                            (opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_GLOBAL_LOCK) &&

diff --git a/ext/opcache/Optimizer/zend_dfg.c b/ext/opcache/Optimizer/zend_dfg.c
index e51c3a583af5d79593040759babadc0a5402a78d..a65d82cf4bf1d8e4ea886fcfc56f1c40a78ef7a8 100644 (file)
--- a/ext/opcache/Optimizer/zend_dfg.c
+++ b/ext/opcache/Optimizer/zend_dfg.c
@@ -89,9 +89,7 @@ int zend_build_dfg(const zend_op_array *op_array, const zend_cfg *cfg, zend_dfg
                                                        goto op1_def;
                                                }
                                                goto op1_use;
-                                       case ZEND_UNSET_VAR:
-                                               ZEND_ASSERT(opline->extended_value & ZEND_QUICK_SET);
-                                               /* break missing intentionally */
+                                       case ZEND_UNSET_CV:
                                        case ZEND_ASSIGN:
                                        case ZEND_ASSIGN_REF:
                                        case ZEND_BIND_GLOBAL:

diff --git a/ext/opcache/Optimizer/zend_dump.c b/ext/opcache/Optimizer/zend_dump.c
index 49d579721cc7b84dcdecf306bf07c1c88a30c916..364c7b1980c7b3a19ae2599183bc639ed375395c 100644 (file)
--- a/ext/opcache/Optimizer/zend_dump.c
+++ b/ext/opcache/Optimizer/zend_dump.c
@@ -519,9 +519,6 @@ static void zend_dump_op(const zend_op_array *op_array, const zend_basic_block *
                        }
                }
                if (ZEND_VM_EXT_ISSET & flags) {
-                   if (opline->extended_value & ZEND_QUICK_SET) {
-                               fprintf(stderr, " (quick)");
-                   }
                        if (opline->extended_value & ZEND_ISSET) {
                                fprintf(stderr, " (isset)");
                        } else if (opline->extended_value & ZEND_ISEMPTY) {

diff --git a/ext/opcache/Optimizer/zend_inference.c b/ext/opcache/Optimizer/zend_inference.c
index 1e52474897589fa2e66a046f8dabf1cd2cbaf285..c9e782c35235982f4cf248906909c310960b8090 100644 (file)
--- a/ext/opcache/Optimizer/zend_inference.c
+++ b/ext/opcache/Optimizer/zend_inference.c
@@ -2192,6 +2192,7 @@ static int zend_update_type_info(const zend_op_array *op_array,
                case ZEND_JMPNZ_EX:
                case ZEND_CASE:
                case ZEND_BOOL:
+               case ZEND_ISSET_ISEMPTY_CV:
                case ZEND_ISSET_ISEMPTY_VAR:
                case ZEND_ISSET_ISEMPTY_DIM_OBJ:
                case ZEND_ISSET_ISEMPTY_PROP_OBJ:
@@ -2879,8 +2880,7 @@ static int zend_update_type_info(const zend_op_array *op_array,
                                UPDATE_SSA_TYPE(tmp, ssa_ops[i].result_def);
                        }
                        break;
-               case ZEND_UNSET_VAR:
-                       ZEND_ASSERT(opline->extended_value & ZEND_QUICK_SET);
+               case ZEND_UNSET_CV:
                        tmp = MAY_BE_UNDEF;
                        if (!op_array->function_name) {
                                /* In global scope, we know nothing */
@@ -3937,9 +3937,6 @@ int zend_may_throw(const zend_op *opline, zend_op_array *op_array, zend_ssa *ssa
                        switch (opline->opcode) {
                                case ZEND_UNSET_VAR:
                                case ZEND_ISSET_ISEMPTY_VAR:
-                                       if (opline->extended_value & ZEND_QUICK_SET) {
-                                               break;
-                                       }
                                        return 1;
                                case ZEND_ISSET_ISEMPTY_DIM_OBJ:
                                case ZEND_ISSET_ISEMPTY_PROP_OBJ:
@@ -3950,6 +3947,8 @@ int zend_may_throw(const zend_op *opline, zend_op_array *op_array, zend_ssa *ssa
                                case ZEND_FETCH_DIM_IS:
                                case ZEND_FETCH_OBJ_IS:
                                case ZEND_SEND_REF:
+                               case ZEND_UNSET_CV:
+                               case ZEND_ISSET_ISEMPTY_CV:
                                        break;
                                default:
                                        /* undefined variable warning */
@@ -4026,6 +4025,7 @@ int zend_may_throw(const zend_op *opline, zend_op_array *op_array, zend_ssa *ssa
                case ZEND_SWITCH_LONG:
                case ZEND_SWITCH_STRING:
                case ZEND_ISSET_ISEMPTY_VAR:
+               case ZEND_ISSET_ISEMPTY_CV:
                        return 0;
                case ZEND_INIT_FCALL:
                        /* can't throw, because call is resolved at compile time */

diff --git a/ext/opcache/Optimizer/zend_ssa.c b/ext/opcache/Optimizer/zend_ssa.c
index b0eb87995d2ced8ef0ab34234cca2327a8300856..b0c087b1bdffaf541e54335bcbe0b7a6fe51b5ec 100644 (file)
--- a/ext/opcache/Optimizer/zend_ssa.c
+++ b/ext/opcache/Optimizer/zend_ssa.c
@@ -713,12 +713,10 @@ static int zend_ssa_rename(const zend_op_array *op_array, uint32_t build_flags,
                                                //NEW_SSA_VAR(opline->op1.var)
                                        }
                                        break;
-                               case ZEND_UNSET_VAR:
-                                       if (opline->extended_value & ZEND_QUICK_SET) {
-                                               ssa_ops[k].op1_def = ssa_vars_count;
-                                               var[EX_VAR_TO_NUM(opline->op1.var)] = ssa_vars_count;
-                                               ssa_vars_count++;
-                                       }
+                               case ZEND_UNSET_CV:
+                                       ssa_ops[k].op1_def = ssa_vars_count;
+                                       var[EX_VAR_TO_NUM(opline->op1.var)] = ssa_vars_count;
+                                       ssa_vars_count++;
                                        break;
                                case ZEND_UNSET_DIM:
                                case ZEND_UNSET_OBJ:

diff --git a/ext/opcache/Optimizer/zend_ssa.h b/ext/opcache/Optimizer/zend_ssa.h
index c7724fa0320c0c5f2b49def91ee87f7006abd754..f5855f24530e3bea797563997e48e273355cc881 100644 (file)
--- a/ext/opcache/Optimizer/zend_ssa.h
+++ b/ext/opcache/Optimizer/zend_ssa.h
@@ -202,8 +202,7 @@ static zend_always_inline zend_ssa_phi* zend_ssa_next_use_phi(const zend_ssa *ss
 
 static zend_always_inline zend_bool zend_ssa_is_no_val_use(const zend_op *opline, const zend_ssa_op *ssa_op, int var)
 {
-       if (opline->opcode == ZEND_ASSIGN ||
-                       (opline->opcode == ZEND_UNSET_VAR && (opline->extended_value & ZEND_QUICK_SET))) {
+       if (opline->opcode == ZEND_ASSIGN || opline->opcode == ZEND_UNSET_CV) {
                return ssa_op->op1_use == var && ssa_op->op2_use != var;
        }
        if (opline->opcode == ZEND_FE_FETCH_R) {