From: Dmitry Stogov Date: Mon, 17 Jul 2017 11:11:50 +0000 (+0300) Subject: Separate ISSET_ISEMPTY_CV/UNSET_CV from ISSET_ISEMPTY_VAR/UNSET_VAR X-Git-Tag: php-7.2.0beta1~12 X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=1180d8c8019bf84c1803d65750f1735becbba2a7;p=php 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 69fea4c2cf..e1d7b899b7 100644 --- 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 af67018bdc..55526d6739 100644 --- 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 b3d6c99577..fa4b682209 100644 --- 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 0024f85223..bbe6dffc07 100644 --- 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 ed888e73c9..ecfe4645fa 100644 --- a/Zend/zend_vm_opcodes.c +++ b/Zend/zend_vm_opcodes.c @@ -21,7 +21,7 @@ #include #include -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 6001400bf8..3be364150f 100644 --- 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 2c21154ef7..e3b4285197 100644 --- 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 1e023f1b1b..06a4406fe8 100644 --- 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 25d0acb6ce..4914c9e45e 100644 --- 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 e51c3a583a..a65d82cf4b 100644 --- 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 49d579721c..364c7b1980 100644 --- 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 1e52474897..c9e782c352 100644 --- 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 b0eb87995d..b0c087b1bd 100644 --- 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 c7724fa032..f5855f2453 100644 --- 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) {