From: Xinchen Hui Date: Tue, 10 Mar 2015 07:49:02 +0000 (+0800) Subject: Merge branch 'PHP-5.6' X-Git-Tag: PRE_PHP7_NSAPI_REMOVAL~724 X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=a5317e9d4167cd5a76a990efb1f27104e6319e8c;p=php Merge branch 'PHP-5.6' Conflicts: Zend/zend_vm_def.h Zend/zend_vm_execute.h --- a5317e9d4167cd5a76a990efb1f27104e6319e8c diff --cc Zend/zend_vm_def.h index c08280aaa2,aa34efa5b3..2fbe9d53c1 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@@ -380,45 -375,49 +380,47 @@@ ZEND_VM_HELPER_EX(zend_binary_assign_op } } - if (!have_get_ptr) { - zval *z = NULL; + /* here we are sure we are dealing with an object */ + if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) { - Z_ADDREF_P(object); - if (opline->extended_value == ZEND_ASSIGN_OBJ) { - if (Z_OBJ_HT_P(object)->read_property) { - z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - } - } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { - if (Z_OBJ_HT_P(object)->read_dimension) { - z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC); - } + ZVAL_DEREF(zptr); + SEPARATE_ZVAL_NOREF(zptr); + + binary_op(zptr, zptr, value); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), zptr); } - if (z) { + } else { + zval *z; - zval rv; ++ zval rv, obj; + - if (Z_OBJ_HT_P(object)->read_property && - (z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv)) != NULL) { ++ ZVAL_COPY(&obj, object); ++ if (Z_OBJ_HT(obj)->read_property && ++ (z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv)) != NULL) { if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv); if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); - zval_dtor(z); - FREE_ZVAL(z); + zend_objects_store_del(Z_OBJ_P(z)); } - z = value; - } - Z_ADDREF_P(z); - SEPARATE_ZVAL_IF_NOT_REF(&z); - binary_op(z, z, value TSRMLS_CC); - if (opline->extended_value == ZEND_ASSIGN_OBJ) { - Z_OBJ_HT_P(object)->write_property(object, property, z, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { - Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC); + ZVAL_COPY_VALUE(z, value); } - zval_ptr_dtor(&object); - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(z); - EX_T(opline->result.var).var.ptr = z; + zptr = z; + ZVAL_DEREF(z); + SEPARATE_ZVAL_NOREF(z); + binary_op(z, z, value); - Z_OBJ_HT_P(object)->write_property(object, property, z, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ Z_OBJ_HT(obj)->write_property(&obj, property, z, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ zval_ptr_dtor(&obj); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), z); } - zval_ptr_dtor(&z); + zval_ptr_dtor(zptr); } else { zend_error(E_WARNING, "Attempt to assign property of non-object"); - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); } } } @@@ -766,80 -586,95 +768,84 @@@ ZEND_VM_HELPER_EX(zend_pre_incdec_prope { USE_OPLINE zend_free_op free_op1, free_op2; - zval **object_ptr; zval *object; zval *property; - zval **retval; - int have_get_ptr = 0; + zval *retval; + zval *zptr; SAVE_OPLINE(); - object_ptr = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_RW); + object = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_RW); property = GET_OP2_ZVAL_PTR(BP_VAR_R); - retval = &EX_T(opline->result.var).var.ptr; - - if (OP1_TYPE == IS_VAR && UNEXPECTED(object_ptr == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); - } + retval = EX_VAR(opline->result.var); - make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ - object = *object_ptr; - - if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { - zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + if (OP1_TYPE == IS_VAR && UNEXPECTED(object == NULL)) { + zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); FREE_OP2(); - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - *retval = &EG(uninitialized_zval); - } FREE_OP1_VAR_PTR(); - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); + HANDLE_EXCEPTION(); } - /* here we are sure we are dealing with an object */ + do { + if (OP1_TYPE != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + ZVAL_DEREF(object); + if (UNEXPECTED(!make_real_object(object))) { + zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(retval); + } + break; + } + } - if (IS_OP2_TMP_FREE()) { - MAKE_REAL_ZVAL_PTR(property); - } + /* here we are sure we are dealing with an object */ - if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - if (zptr != NULL) { /* NULL means no success in getting PTR */ - SEPARATE_ZVAL_IF_NOT_REF(zptr); + if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) { - have_get_ptr = 1; - incdec_op(*zptr); - if (RETURN_VALUE_USED(opline)) { - *retval = *zptr; - PZVAL_LOCK(*retval); + ZVAL_DEREF(zptr); + SEPARATE_ZVAL_NOREF(zptr); + + incdec_op(zptr); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(retval, zptr); } - } - } + } else { + zval rv; - if (!have_get_ptr) { - if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z; - - Z_ADDREF_P(object); - z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv); ++ zval *z, obj; ++ ++ ZVAL_COPY(&obj, object); ++ z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv); - if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv); - if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); - zval_dtor(z); - FREE_ZVAL(z); + if (Z_REFCOUNT_P(z) == 0) { + zend_objects_store_del(Z_OBJ_P(z)); + } + ZVAL_COPY_VALUE(z, value); + } + ZVAL_DEREF(z); + SEPARATE_ZVAL_NOREF(z); + incdec_op(z); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(retval, z); + } - Z_OBJ_HT_P(object)->write_property(object, property, z, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ Z_OBJ_HT(obj)->write_property(&obj, property, z, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ zval_ptr_dtor(&obj); + zval_ptr_dtor(z); + } else { + zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(retval); } - z = value; - } - Z_ADDREF_P(z); - SEPARATE_ZVAL_IF_NOT_REF(&z); - incdec_op(z); - *retval = z; - Z_OBJ_HT_P(object)->write_property(object, property, z, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - zval_ptr_dtor(&object); - SELECTIVE_PZVAL_LOCK(*retval, opline); - zval_ptr_dtor(&z); - } else { - zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - *retval = &EG(uninitialized_zval); } } - } + } while (0); - if (IS_OP2_TMP_FREE()) { - zval_ptr_dtor(&property); - } else { - FREE_OP2(); - } + FREE_OP2(); FREE_OP1_VAR_PTR(); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@@ -862,70 -697,88 +868,72 @@@ ZEND_VM_HELPER_EX(zend_post_incdec_prop zval *object; zval *property; zval *retval; - int have_get_ptr = 0; + zval *zptr; SAVE_OPLINE(); - object_ptr = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_RW); + object = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_RW); property = GET_OP2_ZVAL_PTR(BP_VAR_R); - retval = &EX_T(opline->result.var).tmp_var; - - if (OP1_TYPE == IS_VAR && UNEXPECTED(object_ptr == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); - } - - make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ - object = *object_ptr; + retval = EX_VAR(opline->result.var); - if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { - zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + if (OP1_TYPE == IS_VAR && UNEXPECTED(object == NULL)) { + zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); FREE_OP2(); - ZVAL_NULL(retval); FREE_OP1_VAR_PTR(); - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); - } - - /* here we are sure we are dealing with an object */ - - if (IS_OP2_TMP_FREE()) { - MAKE_REAL_ZVAL_PTR(property); + HANDLE_EXCEPTION(); } - if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - if (zptr != NULL) { /* NULL means no success in getting PTR */ - have_get_ptr = 1; - SEPARATE_ZVAL_IF_NOT_REF(zptr); - - ZVAL_COPY_VALUE(retval, *zptr); - zendi_zval_copy_ctor(*retval); + do { + if (OP1_TYPE != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + ZVAL_DEREF(object); + if (UNEXPECTED(!make_real_object(object))) { + zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + ZVAL_NULL(retval); + break; + } + } - incdec_op(*zptr); + /* here we are sure we are dealing with an object */ - } - } + if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) { - if (!have_get_ptr) { - if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z, *z_copy; + ZVAL_DEREF(zptr); + ZVAL_COPY_VALUE(retval, zptr); + zval_opt_copy_ctor(zptr); - + incdec_op(zptr); + } else { + if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval rv; - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv); ++ zval rv, obj; ++ zval *z; + - Z_ADDREF_P(object); - z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); ++ ZVAL_COPY(&obj, object); ++ z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv); + zval z_copy; - if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); - zval_dtor(z); - FREE_ZVAL(z); + if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv); - + if (Z_REFCOUNT_P(z) == 0) { + zend_objects_store_del(Z_OBJ_P(z)); + } + ZVAL_COPY_VALUE(z, value); } - z = value; - } - ZVAL_COPY_VALUE(retval, z); - zendi_zval_copy_ctor(*retval); - ALLOC_ZVAL(z_copy); - INIT_PZVAL_COPY(z_copy, z); - zendi_zval_copy_ctor(*z_copy); - incdec_op(z_copy); - Z_ADDREF_P(z); - Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - zval_ptr_dtor(&object); - zval_ptr_dtor(&z_copy); - zval_ptr_dtor(&z); - } else { - zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); - ZVAL_NULL(retval); + ZVAL_DUP(retval, z); + ZVAL_DUP(&z_copy, z); + incdec_op(&z_copy); + if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); - Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ Z_OBJ_HT(obj)->write_property(&obj, property, &z_copy, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ zval_ptr_dtor(&obj); + zval_ptr_dtor(&z_copy); + zval_ptr_dtor(z); + } else { + zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + ZVAL_NULL(retval); + } } - } + } while (0); - if (IS_OP2_TMP_FREE()) { - zval_ptr_dtor(&property); - } else { - FREE_OP2(); - } + FREE_OP2(); FREE_OP1_VAR_PTR(); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); diff --cc Zend/zend_vm_execute.h index 320779c2e8,a89e1d558c..ea41b3610a --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@@ -13266,87 -12888,50 +13266,89 @@@ static int ZEND_FASTCALL ZEND_IS_NOT_I ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_PRE_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2), ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_free_op free_op1; - zval **var_ptr; + zend_free_op free_op1, free_op_data1; + zval *object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1); + zval *property = EX_CONSTANT(opline->op2); + zval *value; + zval *zptr; - SAVE_OPLINE(); - var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + if (IS_VAR == IS_VAR && UNEXPECTED(object == NULL)) { + zend_error(E_EXCEPTION | E_ERROR, "Cannot use string offset as an object"); + FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var); - if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); + if (free_op1) {zval_ptr_dtor_nogc(free_op1);}; + HANDLE_EXCEPTION(); } - if (IS_VAR == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) { - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + + do { + value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); + + if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + ZVAL_DEREF(object); + if (UNEXPECTED(!make_real_object(object))) { + zend_error(E_WARNING, "Attempt to assign property of non-object"); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } + break; + } } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); - } - SEPARATE_ZVAL_IF_NOT_REF(var_ptr); + /* here we are sure we are dealing with an object */ + if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) { - if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) - && Z_OBJ_HANDLER_PP(var_ptr, get) - && Z_OBJ_HANDLER_PP(var_ptr, set)) { - /* proxy object */ - zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); - Z_ADDREF_P(val); - fast_decrement_function(val); - Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC); - zval_ptr_dtor(&val); - } else { - fast_decrement_function(*var_ptr); - } + ZVAL_DEREF(zptr); + SEPARATE_ZVAL_NOREF(zptr); - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(*var_ptr); - EX_T(opline->result.var).var.ptr = *var_ptr; - } + binary_op(zptr, zptr, value); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), zptr); + } + } else { + zval *z; - zval rv; ++ zval rv, obj; + - if (Z_OBJ_HT_P(object)->read_property && - (z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv)) != NULL) { ++ ZVAL_COPY(&obj, object); ++ if (Z_OBJ_HT(obj)->read_property && ++ (z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv)) != NULL) { + if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv); + + if (Z_REFCOUNT_P(z) == 0) { + zend_objects_store_del(Z_OBJ_P(z)); + } + ZVAL_COPY_VALUE(z, value); + } + zptr = z; + ZVAL_DEREF(z); + SEPARATE_ZVAL_NOREF(z); + binary_op(z, z, value); - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ Z_OBJ_HT(obj)->write_property(&obj, property, z, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ zval_ptr_dtor(&obj); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), z); + } + zval_ptr_dtor(zptr); + } else { + zend_error(E_WARNING, "Attempt to assign property of non-object"); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } + } + } + } while (0); - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + FREE_OP(free_op_data1); + + if (free_op1) {zval_ptr_dtor_nogc(free_op1);}; + /* assign_obj has two opcodes! */ CHECK_EXCEPTION(); + ZEND_VM_INC_OPCODE(); ZEND_VM_NEXT_OPCODE(); } @@@ -13457,447 -13021,378 +13459,453 @@@ static int ZEND_FASTCALL zend_binary_as ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_ECHO_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 || (IS_CONST != IS_UNUSED) USE_OPLINE - zend_free_op free_op1; - zval *z; - - SAVE_OPLINE(); - z = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_TMP_VAR && Z_TYPE_P(z) == IS_OBJECT) { - INIT_PZVAL(z); +# if 0 || (IS_VAR != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } - zend_print_variable(z); - - zval_ptr_dtor_nogc(&free_op1.var); - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_PRINT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 || (IS_CONST != IS_UNUSED) USE_OPLINE - ZVAL_LONG(&EX_T(opline->result.var).tmp_var, 1); - return ZEND_ECHO_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +# if 0 || (IS_VAR != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_JMPZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 || (IS_CONST != IS_UNUSED) USE_OPLINE - zend_free_op free_op1; - zval *val; - int ret; - SAVE_OPLINE(); - val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - - if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { - ret = Z_LVAL_P(val); - } else { - ret = i_zend_is_true(val); - zval_ptr_dtor_nogc(&free_op1.var); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } +# if 0 || (IS_VAR != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } - if (!ret) { -#if DEBUG_ZEND>=2 - printf("Conditional jmp to %d\n", opline->op2.opline_num); -#endif - ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); - ZEND_VM_CONTINUE(); +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } - - ZEND_VM_NEXT_OPCODE(); +#else + return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_JMPNZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 || (IS_CONST != IS_UNUSED) USE_OPLINE - zend_free_op free_op1; - zval *val; - int ret; - SAVE_OPLINE(); - val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - - if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { - ret = Z_LVAL_P(val); - } else { - ret = i_zend_is_true(val); - zval_ptr_dtor_nogc(&free_op1.var); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } +# if 0 || (IS_VAR != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } - if (ret) { -#if DEBUG_ZEND>=2 - printf("Conditional jmp to %d\n", opline->op2.opline_num); -#endif - ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); - ZEND_VM_CONTINUE(); +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } - - ZEND_VM_NEXT_OPCODE(); +#else + return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_JMPZNZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 || (IS_CONST != IS_UNUSED) USE_OPLINE - zend_free_op free_op1; - zval *val; - int retval; - SAVE_OPLINE(); - val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - - if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { - retval = Z_LVAL_P(val); - } else { - retval = i_zend_is_true(val); - zval_ptr_dtor_nogc(&free_op1.var); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } +# if 0 || (IS_VAR != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } - if (EXPECTED(retval != 0)) { -#if DEBUG_ZEND>=2 - printf("Conditional jmp on true to %d\n", opline->extended_value); -#endif - ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]); - ZEND_VM_CONTINUE(); /* CHECK_ME */ - } else { -#if DEBUG_ZEND>=2 - printf("Conditional jmp on false to %d\n", opline->op2.opline_num); -#endif - ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->op2.opline_num]); - ZEND_VM_CONTINUE(); /* CHECK_ME */ +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } +#else + return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 || (IS_CONST != IS_UNUSED) USE_OPLINE - zend_free_op free_op1; - zval *val; - int retval; - SAVE_OPLINE(); - val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - - if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { - retval = Z_LVAL_P(val); - } else { - retval = i_zend_is_true(val); - zval_ptr_dtor_nogc(&free_op1.var); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } +# if 0 || (IS_VAR != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } - Z_LVAL(EX_T(opline->result.var).tmp_var) = retval; - Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; - if (!retval) { -#if DEBUG_ZEND>=2 - printf("Conditional jmp to %d\n", opline->op2.opline_num); +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); #endif - ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); - ZEND_VM_CONTINUE(); +} + +static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || (IS_CONST != IS_UNUSED) + USE_OPLINE + +# if 0 || (IS_VAR != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } - ZEND_VM_NEXT_OPCODE(); +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 || (IS_CONST != IS_UNUSED) USE_OPLINE - zend_free_op free_op1; - zval *val; - int retval; - SAVE_OPLINE(); - val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); +# if 0 || (IS_VAR != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif +} - if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { - retval = Z_LVAL_P(val); - } else { - retval = i_zend_is_true(val); - zval_ptr_dtor_nogc(&free_op1.var); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } +static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || (IS_CONST != IS_UNUSED) + USE_OPLINE + +# if 0 || (IS_VAR != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } - Z_LVAL(EX_T(opline->result.var).tmp_var) = retval; - Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; - if (retval) { -#if DEBUG_ZEND>=2 - printf("Conditional jmp to %d\n", opline->op2.opline_num); +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); #endif - ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); - ZEND_VM_CONTINUE(); +} + +static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || (IS_CONST != IS_UNUSED) + USE_OPLINE + +# if 0 || (IS_VAR != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } - ZEND_VM_NEXT_OPCODE(); +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_FREE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 || (IS_CONST != IS_UNUSED) USE_OPLINE - SAVE_OPLINE(); - if (IS_VAR == IS_TMP_VAR) { - zendi_zval_dtor(EX_T(opline->op1.var).tmp_var); - } else { - zval_ptr_dtor(&EX_T(opline->op1.var).var.ptr); +# if 0 || (IS_VAR != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *retval_ptr; zend_free_op free_op1; + zval *object; + zval *property; + zval *retval; + zval *zptr; SAVE_OPLINE(); - retval_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1); + property = EX_CONSTANT(opline->op2); + retval = EX_VAR(opline->result.var); - if (!EG(return_value_ptr_ptr)) { - zval_ptr_dtor_nogc(&free_op1.var); - } else { - if (IS_VAR == IS_CONST || - IS_VAR == IS_TMP_VAR || - PZVAL_IS_REF(retval_ptr)) { - zval *ret; + if (IS_VAR == IS_VAR && UNEXPECTED(object == NULL)) { + zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); - ALLOC_ZVAL(ret); - INIT_PZVAL_COPY(ret, retval_ptr); - if (IS_VAR != IS_TMP_VAR) { - zval_copy_ctor(ret); + if (free_op1) {zval_ptr_dtor_nogc(free_op1);}; + HANDLE_EXCEPTION(); + } + + do { + if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + ZVAL_DEREF(object); + if (UNEXPECTED(!make_real_object(object))) { + zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(retval); + } + break; } - *EG(return_value_ptr_ptr) = ret; - zval_ptr_dtor_nogc(&free_op1.var); - } else if ((IS_VAR == IS_CV || IS_VAR == IS_VAR) && - retval_ptr == &EG(uninitialized_zval)) { - zval *ret; + } - if (IS_VAR == IS_VAR) { - Z_DELREF_P(retval_ptr); + /* here we are sure we are dealing with an object */ + + if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) { + + ZVAL_DEREF(zptr); + SEPARATE_ZVAL_NOREF(zptr); + + incdec_op(zptr); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(retval, zptr); } - ALLOC_INIT_ZVAL(ret); - *EG(return_value_ptr_ptr) = ret; } else { - *EG(return_value_ptr_ptr) = retval_ptr; - if (IS_VAR == IS_CV) { - Z_ADDREF_P(retval_ptr); + zval rv; + + if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv); ++ zval *z, obj; ++ ++ ZVAL_COPY(&obj, object); ++ z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv); + + if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv); + + if (Z_REFCOUNT_P(z) == 0) { + zend_objects_store_del(Z_OBJ_P(z)); + } + ZVAL_COPY_VALUE(z, value); + } + ZVAL_DEREF(z); + SEPARATE_ZVAL_NOREF(z); + incdec_op(z); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(retval, z); + } - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ Z_OBJ_HT(obj)->write_property(&obj, property, z, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ zval_ptr_dtor(&obj); + zval_ptr_dtor(z); + } else { + zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(retval); + } } } - } - return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } while (0); + + if (free_op1) {zval_ptr_dtor_nogc(free_op1);}; + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + return zend_pre_incdec_property_helper_SPEC_VAR_CONST(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +} + +static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + return zend_pre_incdec_property_helper_SPEC_VAR_CONST(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +} + +static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *retval_ptr; - zval **retval_ptr_ptr; zend_free_op free_op1; + zval *object; + zval *property; + zval *retval; + zval *zptr; SAVE_OPLINE(); + object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1); + property = EX_CONSTANT(opline->op2); + retval = EX_VAR(opline->result.var); - do { - if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR || - (IS_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) { - /* Not supposed to happen, but we'll allow it */ - zend_error(E_NOTICE, "Only variable references should be returned by reference"); - - retval_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (!EG(return_value_ptr_ptr)) { - if (IS_VAR == IS_TMP_VAR) { - zval_ptr_dtor_nogc(&free_op1.var); - } - } else if (!0) { /* Not a temp var */ - zval *ret; + if (IS_VAR == IS_VAR && UNEXPECTED(object == NULL)) { + zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); - ALLOC_ZVAL(ret); - INIT_PZVAL_COPY(ret, retval_ptr); - zval_copy_ctor(ret); - *EG(return_value_ptr_ptr) = ret; - } else { - zval *ret; + if (free_op1) {zval_ptr_dtor_nogc(free_op1);}; + HANDLE_EXCEPTION(); + } - ALLOC_ZVAL(ret); - INIT_PZVAL_COPY(ret, retval_ptr); - *EG(return_value_ptr_ptr) = ret; + do { + if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + ZVAL_DEREF(object); + if (UNEXPECTED(!make_real_object(object))) { + zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + ZVAL_NULL(retval); + break; } - break; } - retval_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + /* here we are sure we are dealing with an object */ + + if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) { - if (IS_VAR == IS_VAR && UNEXPECTED(retval_ptr_ptr == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference"); - } + ZVAL_DEREF(zptr); + ZVAL_COPY_VALUE(retval, zptr); + zval_opt_copy_ctor(zptr); - + incdec_op(zptr); + } else { + if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval rv; - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv); ++ zval rv, obj; ++ zval *z; + - if (IS_VAR == IS_VAR && !Z_ISREF_PP(retval_ptr_ptr)) { - if (opline->extended_value == ZEND_RETURNS_FUNCTION && - EX_T(opline->op1.var).var.fcall_returned_reference) { - } else if (EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) { - zend_error(E_NOTICE, "Only variable references should be returned by reference"); - if (EG(return_value_ptr_ptr)) { - zval *ret; ++ ZVAL_COPY(&obj, object); ++ z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv); + zval z_copy; - ALLOC_ZVAL(ret); - INIT_PZVAL_COPY(ret, *retval_ptr_ptr); - zval_copy_ctor(ret); - *EG(return_value_ptr_ptr) = ret; + if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv); - + if (Z_REFCOUNT_P(z) == 0) { + zend_objects_store_del(Z_OBJ_P(z)); + } + ZVAL_COPY_VALUE(z, value); } - break; + ZVAL_DUP(retval, z); + ZVAL_DUP(&z_copy, z); + incdec_op(&z_copy); + if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); - Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ Z_OBJ_HT(obj)->write_property(&obj, property, &z_copy, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ zval_ptr_dtor(&obj); + zval_ptr_dtor(&z_copy); + zval_ptr_dtor(z); + } else { + zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + ZVAL_NULL(retval); } } + } while (0); - if (EG(return_value_ptr_ptr)) { - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr); - Z_ADDREF_PP(retval_ptr_ptr); + if (free_op1) {zval_ptr_dtor_nogc(free_op1);}; + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} - *EG(return_value_ptr_ptr) = *retval_ptr_ptr; - } - } while (0); +static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + return zend_post_incdec_property_helper_SPEC_VAR_CONST(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +} - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + return zend_post_incdec_property_helper_SPEC_VAR_CONST(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } -static int ZEND_FASTCALL ZEND_THROW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *value; - zval *exception; zend_free_op free_op1; + zval *container; SAVE_OPLINE(); - value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1); - if (IS_VAR == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) { - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - zend_error_noreturn(E_ERROR, "Can only throw objects"); + if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { + zend_error(E_EXCEPTION | E_ERROR, "Cannot use string offset as an array"); + if (free_op1) {zval_ptr_dtor_nogc(free_op1);}; + HANDLE_EXCEPTION(); } + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST); - zend_exception_save(TSRMLS_C); - /* Not sure if a complete copy is what we want here */ - ALLOC_ZVAL(exception); - INIT_PZVAL_COPY(exception, value); - if (!0) { - zval_copy_ctor(exception); + if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) { + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - - zend_throw_exception_object(exception TSRMLS_CC); - zend_exception_restore(TSRMLS_C); - zval_ptr_dtor_nogc(&free_op1.var); - HANDLE_EXCEPTION(); + if (free_op1) {zval_ptr_dtor_nogc(free_op1);}; + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_send_by_var_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *varptr; zend_free_op free_op1; - varptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + zval *container; - if (varptr == &EG(uninitialized_zval)) { - if (IS_VAR == IS_VAR) { - Z_DELREF_P(varptr); - } - ALLOC_INIT_ZVAL(varptr); - } else if (PZVAL_IS_REF(varptr)) { - if (IS_VAR == IS_CV || - (IS_VAR == IS_VAR && Z_REFCOUNT_P(varptr) > 2)) { - zval *original_var = varptr; + SAVE_OPLINE(); + container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1); - ALLOC_ZVAL(varptr); - INIT_PZVAL_COPY(varptr, original_var); - zval_copy_ctor(varptr); - zval_ptr_dtor_nogc(&free_op1.var); - } else { - Z_UNSET_ISREF_P(varptr); - } - } else if (IS_VAR == IS_CV) { - Z_ADDREF_P(varptr); + if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { + zend_error(E_EXCEPTION | E_ERROR, "Cannot use string offset as an array"); + if (free_op1) {zval_ptr_dtor_nogc(free_op1);}; + HANDLE_EXCEPTION(); } - zend_vm_stack_push(varptr TSRMLS_CC); + zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST); + if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) { + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); + } + if (free_op1) {zval_ptr_dtor_nogc(free_op1);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@@ -16179,256 -15529,253 +16187,258 @@@ static int ZEND_FASTCALL ZEND_SEPARATE ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_free_op free_op1; - zval **object_ptr; - zval *property_name; - SAVE_OPLINE(); - object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - property_name = opline->op2.zv; + /* The generator object is stored in EX(return_value) */ + zend_generator *generator = (zend_generator *) EX(return_value); - if (0) { - MAKE_REAL_ZVAL_PTR(property_name); - } - if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); - } - zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property_name); - } else { + if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) { + zend_error(E_EXCEPTION | E_ERROR, "Cannot yield from finally in a force-closed generator"); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - /* assign_obj has two opcodes! */ - CHECK_EXCEPTION(); - ZEND_VM_INC_OPCODE(); - ZEND_VM_NEXT_OPCODE(); -} -static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zend_free_op free_op1; - zval **object_ptr; + /* Destroy the previously yielded value */ + zval_ptr_dtor(&generator->value); - SAVE_OPLINE(); - object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + /* Destroy the previously yielded key */ + zval_ptr_dtor(&generator->key); - if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); - } - if (Z_TYPE_PP(object_ptr) == IS_OBJECT) { + /* Set the new yielded value */ + if (IS_VAR != IS_UNUSED) { + zend_free_op free_op1; - zval *property_name = opline->op2.zv; + if (EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE) { + /* Constants and temporary variables aren't yieldable by reference, + * but we still allow them with a notice. */ + if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) { + zval *value; - if (0) { - MAKE_REAL_ZVAL_PTR(property_name); - } - zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property_name); - } else { + zend_error(E_NOTICE, "Only variable references should be yielded by reference"); - } - } else { - zend_free_op free_op_data1, free_op_data2; - zval *value; - zval *dim = opline->op2.zv; - zval **variable_ptr_ptr; + value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1); + ZVAL_COPY_VALUE(&generator->value, value); + if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1); + + /* Temporary variables don't need ctor copying */ + if (IS_VAR != IS_TMP_VAR) { + zval_opt_copy_ctor(&generator->value); + } + } else { + zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1); - zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_CONST, BP_VAR_W TSRMLS_CC); + if (IS_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) { + zend_error(E_EXCEPTION | E_ERROR, "Cannot yield string offsets by reference"); - value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); - variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); - if (UNEXPECTED(variable_ptr_ptr == NULL)) { - if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) { - if (RETURN_VALUE_USED(opline)) { - zval *retval; + zval_ptr_dtor_nogc(free_op1); + HANDLE_EXCEPTION(); + } - ALLOC_ZVAL(retval); - ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1); - INIT_PZVAL(retval); - EX_T(opline->result.var).var.ptr = retval; + /* If a function call result is yielded and the function did + * not return by reference we throw a notice. */ + if (IS_VAR == IS_VAR && + (value_ptr == &EG(uninitialized_zval) || + (opline->extended_value == ZEND_RETURNS_FUNCTION && + !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF)))) { + zend_error(E_NOTICE, "Only variable references should be yielded by reference"); + } else { + ZVAL_MAKE_REF(value_ptr); } - } else if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - } - } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) { - if (IS_TMP_FREE(free_op_data1)) { - zval_dtor(value); - } - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_COPY(&generator->value, value_ptr); + + if (free_op1) {zval_ptr_dtor_nogc(free_op1);}; } } else { - if ((opline+1)->op1_type == IS_TMP_VAR) { - value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); - } else if ((opline+1)->op1_type == IS_CONST) { - value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC); - } else { - value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC); - } - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(value); - EX_T(opline->result.var).var.ptr = value; + zval *value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1); + + /* Consts, temporary variables and references need copying */ + if (IS_VAR == IS_CONST) { + ZVAL_DUP(&generator->value, value); + } else if (IS_VAR == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->value, value); + } else if ((IS_VAR == IS_CV || IS_VAR == IS_VAR) && Z_ISREF_P(value)) { + ZVAL_DUP(&generator->value, Z_REFVAL_P(value)); + zval_ptr_dtor_nogc(free_op1); + } else { + ZVAL_COPY_VALUE(&generator->value, value); + if (IS_VAR == IS_CV) { + if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value); + } } } - FREE_OP_VAR_PTR(free_op_data2); - FREE_OP_IF_VAR(free_op_data1); + } else { + /* If no value was specified yield null */ + ZVAL_NULL(&generator->value); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - /* assign_dim has two opcodes! */ - CHECK_EXCEPTION(); - ZEND_VM_INC_OPCODE(); - ZEND_VM_NEXT_OPCODE(); -} -static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zend_free_op free_op1; - zval *value; - zval **variable_ptr_ptr; + /* Set the new yielded key */ + if (IS_UNUSED != IS_UNUSED) { - SAVE_OPLINE(); - value = opline->op2.zv; - variable_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + zval *key = NULL; - if (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) { - if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_CONST TSRMLS_CC)) { - if (RETURN_VALUE_USED(opline)) { - zval *retval; + /* Consts, temporary variables and references need copying */ + if (IS_UNUSED == IS_CONST) { + ZVAL_DUP(&generator->key, key); + } else if (IS_UNUSED == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->key, key); + } else if ((IS_UNUSED == IS_VAR || IS_UNUSED == IS_CV) && Z_ISREF_P(key)) { + ZVAL_DUP(&generator->key, Z_REFVAL_P(key)); - ALLOC_ZVAL(retval); - ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1); - INIT_PZVAL(retval); - EX_T(opline->result.var).var.ptr = retval; + } else { + ZVAL_COPY_VALUE(&generator->key, key); + if (IS_UNUSED == IS_CV) { + if (Z_OPT_REFCOUNTED_P(key)) Z_ADDREF_P(key); } - } else if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); } - } else if (IS_VAR == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) { - if (0) { - zval_dtor(value); - } - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + + if (Z_TYPE(generator->key) == IS_LONG + && Z_LVAL(generator->key) > generator->largest_used_integer_key + ) { + generator->largest_used_integer_key = Z_LVAL(generator->key); } } else { - if (IS_CONST == IS_TMP_VAR) { - value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); - } else if (IS_CONST == IS_CONST) { - value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC); - } else { - value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC); - } - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(value); - EX_T(opline->result.var).var.ptr = value; - } + /* If no key was specified we use auto-increment keys */ + generator->largest_used_integer_key++; + ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - - /* zend_assign_to_variable() always takes care of op2, never free it! */ + if (RETURN_VALUE_USED(opline)) { + /* If the return value of yield is used set the send + * target and initialize it to NULL */ + generator->send_target = EX_VAR(opline->result.var); + ZVAL_NULL(generator->send_target); + } else { + generator->send_target = NULL; + } - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); -} + /* We increment to the next op, so we are at the correct position when the + * generator is resumed. */ + ZEND_VM_INC_OPCODE(); -static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) + /* The GOTO VM uses a local opline variable. We need to set the opline + * variable in execute_data so we don't resume at an old position. */ + SAVE_OPLINE(); + + ZEND_VM_RETURN(); +} + +static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *function_name; - char *function_name_strval; - int function_name_strlen; zend_free_op free_op1; - call_slot *call = EX(call_slots) + opline->result.num; SAVE_OPLINE(); + fast_is_identical_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var)); + zval_ptr_dtor_nogc(free_op1); - function_name = opline->op2.zv; + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} - if (IS_CONST != IS_CONST && - UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - zend_error_noreturn(E_ERROR, "Method name must be a string"); - } +static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_free_op free_op1; + zval *result = EX_VAR(opline->result.var); - function_name_strval = Z_STRVAL_P(function_name); - function_name_strlen = Z_STRLEN_P(function_name); + SAVE_OPLINE(); + fast_is_not_identical_function(result, + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var)); + zval_ptr_dtor_nogc(free_op1); - call->object = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} - if (EXPECTED(call->object != NULL) && - EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) { - call->called_scope = Z_OBJCE_P(call->object); +static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CV(int (*binary_op)(zval *result, zval *op1, zval *op2), ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_free_op free_op1, free_op_data1; + zval *object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1); + zval *property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + zval *value; + zval *zptr; - if (IS_CONST != IS_CONST || - (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) { - zval *object = call->object; + if (IS_VAR == IS_VAR && UNEXPECTED(object == NULL)) { + zend_error(E_EXCEPTION | E_ERROR, "Cannot use string offset as an object"); + FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var); - if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) { - zend_error_noreturn(E_ERROR, "Object does not support method calls"); - } + if (free_op1) {zval_ptr_dtor_nogc(free_op1);}; + HANDLE_EXCEPTION(); + } - /* First, locate the function. */ - call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); - if (UNEXPECTED(call->fbc == NULL)) { - zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval); - } - if (IS_CONST == IS_CONST && - EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) && - EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) && - EXPECTED(call->object == object)) { - CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc); + do { + value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); + + if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + ZVAL_DEREF(object); + if (UNEXPECTED(!make_real_object(object))) { + zend_error(E_WARNING, "Attempt to assign property of non-object"); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } + break; } } - } else { - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - zend_error_noreturn(E_ERROR, "Call to a member function %s() on %s", function_name_strval, zend_get_type_by_const(Z_TYPE_P(call->object))); - } + /* here we are sure we are dealing with an object */ + if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) { - if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) { - call->object = NULL; - } else { - if (!PZVAL_IS_REF(call->object)) { - Z_ADDREF_P(call->object); /* For $this pointer */ + ZVAL_DEREF(zptr); + SEPARATE_ZVAL_NOREF(zptr); + + binary_op(zptr, zptr, value); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), zptr); + } } else { - zval *this_ptr; - ALLOC_ZVAL(this_ptr); - INIT_PZVAL_COPY(this_ptr, call->object); - zval_copy_ctor(this_ptr); - call->object = this_ptr; - } - } + zval *z; - zval rv; ++ zval rv, obj; - if (Z_OBJ_HT_P(object)->read_property && - (z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv)) != NULL) { - call->num_additional_args = 0; - call->is_ctor_call = 0; - EX(call) = call; ++ ZVAL_COPY(&obj, object); ++ if (Z_OBJ_HT(obj)->read_property && ++ (z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv)) != NULL) { + if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv); + + if (Z_REFCOUNT_P(z) == 0) { + zend_objects_store_del(Z_OBJ_P(z)); + } + ZVAL_COPY_VALUE(z, value); + } + zptr = z; + ZVAL_DEREF(z); + SEPARATE_ZVAL_NOREF(z); + binary_op(z, z, value); - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ Z_OBJ_HT(obj)->write_property(&obj, property, z, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ zval_ptr_dtor(&obj); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), z); + } + zval_ptr_dtor(zptr); + } else { + zend_error(E_WARNING, "Attempt to assign property of non-object"); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } + } + } + } while (0); - zval_ptr_dtor_nogc(&free_op1.var); + FREE_OP(free_op_data1); + if (free_op1) {zval_ptr_dtor_nogc(free_op1);}; + /* assign_obj has two opcodes! */ CHECK_EXCEPTION(); + ZEND_VM_INC_OPCODE(); ZEND_VM_NEXT_OPCODE(); } @@@ -16763,80 -16283,124 +16773,84 @@@ static int ZEND_FASTCALL zend_pre_incde { USE_OPLINE zend_free_op free_op1; - zval **container; - zval *offset; + zval *object; + zval *property; + zval *retval; + zval *zptr; SAVE_OPLINE(); - container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - offset = opline->op2.zv; + object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1); + property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + retval = EX_VAR(opline->result.var); - if (IS_VAR != IS_VAR || container) { - if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(container); - } - if (Z_TYPE_PP(container) == IS_OBJECT) { - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - if (Z_OBJ_HT_P(*container)->unset_property) { - Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to unset property of non-object"); - } - if (0) { - zval_ptr_dtor(&offset); - } else { + if (IS_VAR == IS_VAR && UNEXPECTED(object == NULL)) { + zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); - } - } else { + if (free_op1) {zval_ptr_dtor_nogc(free_op1);}; + HANDLE_EXCEPTION(); + } + do { + if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + ZVAL_DEREF(object); + if (UNEXPECTED(!make_real_object(object))) { + zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(retval); + } + break; + } } - } else { - - } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); -} + /* here we are sure we are dealing with an object */ -static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval **value; - zend_bool isset = 1; + if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) { - SAVE_OPLINE(); - if (IS_VAR == IS_CV && - IS_CONST == IS_UNUSED && - (opline->extended_value & ZEND_QUICK_SET)) { - if (EX_CV(opline->op1.var)) { - value = EX_CV(opline->op1.var); - } else if (EG(active_symbol_table)) { - zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); + ZVAL_DEREF(zptr); + SEPARATE_ZVAL_NOREF(zptr); - if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) { - isset = 0; + incdec_op(zptr); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(retval, zptr); } } else { - isset = 0; - } - } else { - HashTable *target_symbol_table; - zend_free_op free_op1; - zval tmp, *varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + zval rv; - if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { - ZVAL_COPY_VALUE(&tmp, varname); - zval_copy_ctor(&tmp); - convert_to_string(&tmp); - varname = &tmp; - } + if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv); ++ zval *z, obj; + - if (IS_CONST != IS_UNUSED) { - zend_class_entry *ce; ++ ZVAL_COPY(&obj, object); ++ z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv); - if (IS_CONST == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); - } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); - if (UNEXPECTED(ce == NULL)) { - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); + if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv); + + if (Z_REFCOUNT_P(z) == 0) { + zend_objects_store_del(Z_OBJ_P(z)); } - CACHE_PTR(opline->op2.literal->cache_slot, ce); + ZVAL_COPY_VALUE(z, value); } + ZVAL_DEREF(z); + SEPARATE_ZVAL_NOREF(z); + incdec_op(z); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(retval, z); + } - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ Z_OBJ_HT(obj)->write_property(&obj, property, z, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ zval_ptr_dtor(&obj); + zval_ptr_dtor(z); } else { - ce = EX_T(opline->op2.var).class_entry; - } - value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); - if (!value) { - isset = 0; - } - } else { - target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); - if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) { - isset = 0; + zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(retval); + } } } + } while (0); - if (IS_VAR != IS_CONST && varname == &tmp) { - zval_dtor(&tmp); - } - zval_ptr_dtor_nogc(&free_op1.var); - } - - if (opline->extended_value & ZEND_ISSET) { - if (isset && Z_TYPE_PP(value) != IS_NULL) { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); - } else { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); - } - } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { - if (!isset || !i_zend_is_true(*value)) { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); - } else { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); - } - } - + if (free_op1) {zval_ptr_dtor_nogc(free_op1);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@@ -16882,46 -16460,84 +16896,48 @@@ static int ZEND_FASTCALL zend_post_incd } } - } else if (Z_TYPE_P(container) == IS_OBJECT) { - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - if (prop_dim) { - if (Z_OBJ_HT_P(container)->has_property) { - result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check property of non-object"); - result = 0; - } - } else { - if (Z_OBJ_HT_P(container)->has_dimension) { - result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check element of non-array"); - result = 0; - } - } - if (0) { - zval_ptr_dtor(&offset); + /* here we are sure we are dealing with an object */ + + if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) { + + ZVAL_DEREF(zptr); + ZVAL_COPY_VALUE(retval, zptr); + zval_opt_copy_ctor(zptr); - + incdec_op(zptr); } else { + if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval rv; - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv); ++ zval rv, obj; ++ zval *z; + - } - } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */ - zval tmp; ++ ZVAL_COPY(&obj, object); ++ z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv); + zval z_copy; - if (Z_TYPE_P(offset) != IS_LONG) { - if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */ - || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ - && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { - ZVAL_COPY_VALUE(&tmp, offset); - zval_copy_ctor(&tmp); - convert_to_long(&tmp); - offset = &tmp; - } else { - /* can not be converted to proper offset, return "not set" */ - result = 0; - } - } - if (Z_TYPE_P(offset) == IS_LONG) { - if (opline->extended_value & ZEND_ISSET) { - if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { - result = 1; - } - } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { - if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') { - result = 1; + if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv); - + if (Z_REFCOUNT_P(z) == 0) { + zend_objects_store_del(Z_OBJ_P(z)); + } + ZVAL_COPY_VALUE(z, value); } + ZVAL_DUP(retval, z); + ZVAL_DUP(&z_copy, z); + incdec_op(&z_copy); + if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); - Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ Z_OBJ_HT(obj)->write_property(&obj, property, &z_copy, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ zval_ptr_dtor(&obj); + zval_ptr_dtor(&z_copy); + zval_ptr_dtor(z); + } else { + zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + ZVAL_NULL(retval); } } + } while (0); - } else { - - } - - Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; - if (opline->extended_value & ZEND_ISSET) { - Z_LVAL(EX_T(opline->result.var).tmp_var) = result; - } else { - Z_LVAL(EX_T(opline->result.var).tmp_var) = !result; - } - - zval_ptr_dtor_nogc(&free_op1.var); - + if (free_op1) {zval_ptr_dtor_nogc(free_op1);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@@ -18016,55 -17785,20 +18032,57 @@@ static int ZEND_FASTCALL zend_binary_as } /* here we are sure we are dealing with an object */ - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) { - PZVAL_LOCK(retval); - EX_T(opline->result.var).var.ptr = retval; + ZVAL_DEREF(zptr); + SEPARATE_ZVAL_NOREF(zptr); - if (1) { - zval_ptr_dtor(&offset); + binary_op(zptr, zptr, value); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), zptr); + } } else { - zval_dtor(free_op2.var); + zval *z; - zval rv; ++ zval rv, obj; + - if (Z_OBJ_HT_P(object)->read_property && - (z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv)) != NULL) { ++ ZVAL_COPY(&obj, object); ++ if (Z_OBJ_HT(obj)->read_property && ++ (z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv)) != NULL) { + if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv); + + if (Z_REFCOUNT_P(z) == 0) { + zend_objects_store_del(Z_OBJ_P(z)); + } + ZVAL_COPY_VALUE(z, value); + } + zptr = z; + ZVAL_DEREF(z); + SEPARATE_ZVAL_NOREF(z); + binary_op(z, z, value); - Z_OBJ_HT_P(object)->write_property(object, property, z, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ Z_OBJ_HT(obj)->write_property(&obj, property, z, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ zval_ptr_dtor(&obj); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), z); + } + zval_ptr_dtor(zptr); + } else { + zend_error(E_WARNING, "Attempt to assign property of non-object"); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } + } } - } + } while (0); - zval_ptr_dtor_nogc(&free_op1.var); + FREE_OP(free_op_data1); + zval_ptr_dtor_nogc(free_op2); + if (free_op1) {zval_ptr_dtor_nogc(free_op1);}; + /* assign_obj has two opcodes! */ CHECK_EXCEPTION(); + ZEND_VM_INC_OPCODE(); ZEND_VM_NEXT_OPCODE(); } @@@ -18177,391 -17882,376 +18195,397 @@@ static int ZEND_FASTCALL zend_binary_as ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) USE_OPLINE - zend_free_op free_op1, free_op2; - zval **object_ptr; - zval *property_name; - SAVE_OPLINE(); - object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - property_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); +# if 0 || (IS_VAR != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_TMPVAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_TMPVAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif +} + +static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) + USE_OPLINE - if (1) { - MAKE_REAL_ZVAL_PTR(property_name); +# if 0 || (IS_VAR != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_TMPVAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } - if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_TMPVAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } - zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - if (1) { - zval_ptr_dtor(&property_name); - } else { - zval_dtor(free_op2.var); +#else + return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif +} + +static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) + USE_OPLINE + +# if 0 || (IS_VAR != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_TMPVAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - /* assign_obj has two opcodes! */ - CHECK_EXCEPTION(); - ZEND_VM_INC_OPCODE(); - ZEND_VM_NEXT_OPCODE(); +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_TMPVAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) USE_OPLINE - zend_free_op free_op1; - zval **object_ptr; - SAVE_OPLINE(); - object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); +# if 0 || (IS_VAR != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_TMPVAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_TMPVAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif +} - if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); +static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) + USE_OPLINE + +# if 0 || (IS_VAR != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_TMPVAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } - if (Z_TYPE_PP(object_ptr) == IS_OBJECT) { - zend_free_op free_op2; - zval *property_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_TMPVAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif +} - if (1) { - MAKE_REAL_ZVAL_PTR(property_name); - } - zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - if (1) { - zval_ptr_dtor(&property_name); - } else { - zval_dtor(free_op2.var); - } - } else { - zend_free_op free_op2, free_op_data1, free_op_data2; - zval *value; - zval *dim = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - zval **variable_ptr_ptr; +static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) + USE_OPLINE - zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_TMP_VAR, BP_VAR_W TSRMLS_CC); - zval_dtor(free_op2.var); +# if 0 || (IS_VAR != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_TMPVAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_TMPVAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif +} - value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); - variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); - if (UNEXPECTED(variable_ptr_ptr == NULL)) { - if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) { - if (RETURN_VALUE_USED(opline)) { - zval *retval; +static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) + USE_OPLINE - ALLOC_ZVAL(retval); - ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1); - INIT_PZVAL(retval); - EX_T(opline->result.var).var.ptr = retval; - } - } else if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - } - } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) { - if (IS_TMP_FREE(free_op_data1)) { - zval_dtor(value); - } - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - } - } else { - if ((opline+1)->op1_type == IS_TMP_VAR) { - value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); - } else if ((opline+1)->op1_type == IS_CONST) { - value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC); - } else { - value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC); - } - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(value); - EX_T(opline->result.var).var.ptr = value; - } - } - FREE_OP_VAR_PTR(free_op_data2); - FREE_OP_IF_VAR(free_op_data1); +# if 0 || (IS_VAR != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_TMPVAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - /* assign_dim has two opcodes! */ - CHECK_EXCEPTION(); - ZEND_VM_INC_OPCODE(); - ZEND_VM_NEXT_OPCODE(); +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_TMPVAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) USE_OPLINE - zend_free_op free_op1, free_op2; - zval *value; - zval **variable_ptr_ptr; - SAVE_OPLINE(); - value = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - variable_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); +# if 0 || (IS_VAR != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_TMPVAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_TMPVAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif +} - if (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) { - if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_TMP_VAR TSRMLS_CC)) { - if (RETURN_VALUE_USED(opline)) { - zval *retval; +static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) + USE_OPLINE - ALLOC_ZVAL(retval); - ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1); - INIT_PZVAL(retval); - EX_T(opline->result.var).var.ptr = retval; - } - } else if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - } - } else if (IS_VAR == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) { - if (1) { - zval_dtor(value); - } - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - } - } else { - if (IS_TMP_VAR == IS_TMP_VAR) { - value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); - } else if (IS_TMP_VAR == IS_CONST) { - value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC); - } else { - value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC); - } - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(value); - EX_T(opline->result.var).var.ptr = value; - } +# if 0 || (IS_VAR != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_TMPVAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_TMPVAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif +} - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; +static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) + USE_OPLINE - /* zend_assign_to_variable() always takes care of op2, never free it! */ +# if 0 || (IS_VAR != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_TMPVAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_TMPVAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif +} - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); +static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) + USE_OPLINE + +# if 0 || (IS_VAR != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_TMPVAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_TMPVAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_TMPVAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *function_name; - char *function_name_strval; - int function_name_strlen; zend_free_op free_op1, free_op2; - call_slot *call = EX(call_slots) + opline->result.num; + zval *object; + zval *property; + zval *retval; + zval *zptr; SAVE_OPLINE(); + object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1); + property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); + retval = EX_VAR(opline->result.var); - function_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - - if (IS_TMP_VAR != IS_CONST && - UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - zend_error_noreturn(E_ERROR, "Method name must be a string"); + if (IS_VAR == IS_VAR && UNEXPECTED(object == NULL)) { + zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); + zval_ptr_dtor_nogc(free_op2); + if (free_op1) {zval_ptr_dtor_nogc(free_op1);}; + HANDLE_EXCEPTION(); } - function_name_strval = Z_STRVAL_P(function_name); - function_name_strlen = Z_STRLEN_P(function_name); + do { + if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + ZVAL_DEREF(object); + if (UNEXPECTED(!make_real_object(object))) { + zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(retval); + } + break; + } + } - call->object = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + /* here we are sure we are dealing with an object */ - if (EXPECTED(call->object != NULL) && - EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) { - call->called_scope = Z_OBJCE_P(call->object); + if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) { - if (IS_TMP_VAR != IS_CONST || - (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) { - zval *object = call->object; + ZVAL_DEREF(zptr); + SEPARATE_ZVAL_NOREF(zptr); - if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) { - zend_error_noreturn(E_ERROR, "Object does not support method calls"); + incdec_op(zptr); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(retval, zptr); } + } else { + zval rv; - /* First, locate the function. */ - call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); - if (UNEXPECTED(call->fbc == NULL)) { - zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval); - } - if (IS_TMP_VAR == IS_CONST && - EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) && - EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) && - EXPECTED(call->object == object)) { - CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc); - } - } - } else { - if (UNEXPECTED(EG(exception) != NULL)) { - zval_dtor(free_op2.var); - HANDLE_EXCEPTION(); - } - zend_error_noreturn(E_ERROR, "Call to a member function %s() on %s", function_name_strval, zend_get_type_by_const(Z_TYPE_P(call->object))); - } + if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv); ++ zval *z, obj; + - if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) { - call->object = NULL; - } else { - if (!PZVAL_IS_REF(call->object)) { - Z_ADDREF_P(call->object); /* For $this pointer */ - } else { - zval *this_ptr; - ALLOC_ZVAL(this_ptr); - INIT_PZVAL_COPY(this_ptr, call->object); - zval_copy_ctor(this_ptr); - call->object = this_ptr; - } - } ++ ZVAL_COPY(&obj, object); ++ z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv); - call->num_additional_args = 0; - call->is_ctor_call = 0; - EX(call) = call; + if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv); - zval_dtor(free_op2.var); - zval_ptr_dtor_nogc(&free_op1.var); + if (Z_REFCOUNT_P(z) == 0) { + zend_objects_store_del(Z_OBJ_P(z)); + } + ZVAL_COPY_VALUE(z, value); + } + ZVAL_DEREF(z); + SEPARATE_ZVAL_NOREF(z); + incdec_op(z); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(retval, z); + } - Z_OBJ_HT_P(object)->write_property(object, property, z, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ Z_OBJ_HT(obj)->write_property(&obj, property, z, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ zval_ptr_dtor(&obj); + zval_ptr_dtor(z); + } else { + zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(retval); + } + } + } + } while (0); + zval_ptr_dtor_nogc(free_op2); + if (free_op1) {zval_ptr_dtor_nogc(free_op1);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + return zend_pre_incdec_property_helper_SPEC_VAR_TMPVAR(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +} + +static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + return zend_pre_incdec_property_helper_SPEC_VAR_TMPVAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +} + +static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_TMPVAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *function_name; - zend_class_entry *ce; - call_slot *call = EX(call_slots) + opline->result.num; + zend_free_op free_op1, free_op2; + zval *object; + zval *property; + zval *retval; + zval *zptr; SAVE_OPLINE(); + object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1); + property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); + retval = EX_VAR(opline->result.var); - if (IS_VAR == IS_CONST) { - /* no function found. try a static method in class */ - if (CACHED_PTR(opline->op1.literal->cache_slot)) { - ce = CACHED_PTR(opline->op1.literal->cache_slot); - } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - if (UNEXPECTED(ce == NULL)) { - zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv)); + if (IS_VAR == IS_VAR && UNEXPECTED(object == NULL)) { + zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); + zval_ptr_dtor_nogc(free_op2); + if (free_op1) {zval_ptr_dtor_nogc(free_op1);}; + HANDLE_EXCEPTION(); + } + + do { + if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + ZVAL_DEREF(object); + if (UNEXPECTED(!make_real_object(object))) { + zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + ZVAL_NULL(retval); + break; } - CACHE_PTR(opline->op1.literal->cache_slot, ce); } - call->called_scope = ce; - } else { - ce = EX_T(opline->op1.var).class_entry; - if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) { - call->called_scope = EG(called_scope); - } else { - call->called_scope = ce; - } - } + /* here we are sure we are dealing with an object */ - if (IS_VAR == IS_CONST && - IS_TMP_VAR == IS_CONST && - CACHED_PTR(opline->op2.literal->cache_slot)) { - call->fbc = CACHED_PTR(opline->op2.literal->cache_slot); - } else if (IS_VAR != IS_CONST && - IS_TMP_VAR == IS_CONST && - (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) { - /* do nothing */ - } else if (IS_TMP_VAR != IS_UNUSED) { - char *function_name_strval = NULL; - int function_name_strlen = 0; - zend_free_op free_op2; + if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) { - if (IS_TMP_VAR == IS_CONST) { - function_name_strval = Z_STRVAL_P(opline->op2.zv); - function_name_strlen = Z_STRLEN_P(opline->op2.zv); + ZVAL_DEREF(zptr); + ZVAL_COPY_VALUE(retval, zptr); + zval_opt_copy_ctor(zptr); - + incdec_op(zptr); } else { - function_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval rv; - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv); ++ zval rv, obj; ++ zval *z; + - if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - zend_error_noreturn(E_ERROR, "Function name must be a string"); - } else { - function_name_strval = Z_STRVAL_P(function_name); - function_name_strlen = Z_STRLEN_P(function_name); - } - } ++ ZVAL_COPY(&obj, object); ++ z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv); + zval z_copy; - if (function_name_strval) { - if (ce->get_static_method) { - call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC); - } else { - call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); - } - if (UNEXPECTED(call->fbc == NULL)) { - zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval); - } - if (IS_TMP_VAR == IS_CONST && - EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) && - EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) { - if (IS_VAR == IS_CONST) { - CACHE_PTR(opline->op2.literal->cache_slot, call->fbc); - } else { - CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc); + if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv); - + if (Z_REFCOUNT_P(z) == 0) { + zend_objects_store_del(Z_OBJ_P(z)); + } + ZVAL_COPY_VALUE(z, value); } - } - } - if (IS_TMP_VAR != IS_CONST) { - zval_dtor(free_op2.var); - } - } else { - if (UNEXPECTED(ce->constructor == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot call constructor"); - } - if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { - zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name); - } - call->fbc = ce->constructor; - } - - if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) { - call->object = NULL; - } else { - if (EG(This) && - Z_OBJ_HT_P(EG(This))->get_class_entry && - !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) { - /* We are calling method of the other (incompatible) class, - but passing $this. This is done for compatibility with php-4. */ - if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { - zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name); + ZVAL_DUP(retval, z); + ZVAL_DUP(&z_copy, z); + incdec_op(&z_copy); + if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); - Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ Z_OBJ_HT(obj)->write_property(&obj, property, &z_copy, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ zval_ptr_dtor(&obj); + zval_ptr_dtor(&z_copy); + zval_ptr_dtor(z); } else { - /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */ - zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name); + zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + ZVAL_NULL(retval); } } - if ((call->object = EG(This))) { - Z_ADDREF_P(call->object); - call->called_scope = Z_OBJCE_P(call->object); - } - } - - call->num_additional_args = 0; - call->is_ctor_call = 0; - EX(call) = call; + } while (0); + zval_ptr_dtor_nogc(free_op2); + if (free_op1) {zval_ptr_dtor_nogc(free_op1);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@@ -19529,45 -19154,49 +19553,47 @@@ static int ZEND_FASTCALL zend_binary_as } } - if (!have_get_ptr) { - zval *z = NULL; + /* here we are sure we are dealing with an object */ + if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) { + + ZVAL_DEREF(zptr); + SEPARATE_ZVAL_NOREF(zptr); - Z_ADDREF_P(object); - if (opline->extended_value == ZEND_ASSIGN_OBJ) { - if (Z_OBJ_HT_P(object)->read_property) { - z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - } - } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { - if (Z_OBJ_HT_P(object)->read_dimension) { - z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC); - } + binary_op(zptr, zptr, value); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), zptr); } - if (z) { + } else { + zval *z; - zval rv; ++ zval rv, obj; + - if (Z_OBJ_HT_P(object)->read_property && - (z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv)) != NULL) { ++ ZVAL_COPY(&obj, object); ++ if (Z_OBJ_HT(obj)->read_property && ++ (z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv)) != NULL) { if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv); if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); - zval_dtor(z); - FREE_ZVAL(z); + zend_objects_store_del(Z_OBJ_P(z)); } - z = value; - } - Z_ADDREF_P(z); - SEPARATE_ZVAL_IF_NOT_REF(&z); - binary_op(z, z, value TSRMLS_CC); - if (opline->extended_value == ZEND_ASSIGN_OBJ) { - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { - Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC); - } - zval_ptr_dtor(&object); - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(z); - EX_T(opline->result.var).var.ptr = z; - } - zval_ptr_dtor(&z); + ZVAL_COPY_VALUE(z, value); + } + zptr = z; + ZVAL_DEREF(z); + SEPARATE_ZVAL_NOREF(z); + binary_op(z, z, value); - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ Z_OBJ_HT(obj)->write_property(&obj, property, z, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ zval_ptr_dtor(&obj); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), z); + } + zval_ptr_dtor(zptr); } else { zend_error(E_WARNING, "Attempt to assign property of non-object"); - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); } } } @@@ -19878,162 -19477,228 +19904,168 @@@ static int ZEND_FASTCALL zend_pre_incde zval *object; zval *property; zval *retval; - int have_get_ptr = 0; + zval *zptr; SAVE_OPLINE(); - object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - retval = &EX_T(opline->result.var).tmp_var; + object = _get_obj_zval_ptr_unused(execute_data); + property = EX_CONSTANT(opline->op2); + retval = EX_VAR(opline->result.var); - if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); - } + if (IS_UNUSED == IS_VAR && UNEXPECTED(object == NULL)) { + zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); - make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ - object = *object_ptr; - if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { - zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); - zval_ptr_dtor_nogc(&free_op2.var); - ZVAL_NULL(retval); - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); + HANDLE_EXCEPTION(); } - /* here we are sure we are dealing with an object */ + do { + if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + ZVAL_DEREF(object); + if (UNEXPECTED(!make_real_object(object))) { + zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(retval); + } + break; + } + } - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } + /* here we are sure we are dealing with an object */ - if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - if (zptr != NULL) { /* NULL means no success in getting PTR */ - have_get_ptr = 1; - SEPARATE_ZVAL_IF_NOT_REF(zptr); + if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) { - ZVAL_COPY_VALUE(retval, *zptr); - zendi_zval_copy_ctor(*retval); + ZVAL_DEREF(zptr); + SEPARATE_ZVAL_NOREF(zptr); - incdec_op(*zptr); + incdec_op(zptr); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(retval, zptr); + } + } else { + zval rv; - } - } + if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv); ++ zval *z, obj; + - if (!have_get_ptr) { - if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z, *z_copy; ++ ZVAL_COPY(&obj, object); ++ z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv); - Z_ADDREF_P(object); - z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv); - if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); - zval_dtor(z); - FREE_ZVAL(z); + if (Z_REFCOUNT_P(z) == 0) { + zend_objects_store_del(Z_OBJ_P(z)); + } + ZVAL_COPY_VALUE(z, value); + } + ZVAL_DEREF(z); + SEPARATE_ZVAL_NOREF(z); + incdec_op(z); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(retval, z); + } - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ Z_OBJ_HT(obj)->write_property(&obj, property, z, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ zval_ptr_dtor(&obj); + zval_ptr_dtor(z); + } else { + zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(retval); } - z = value; } - ZVAL_COPY_VALUE(retval, z); - zendi_zval_copy_ctor(*retval); - ALLOC_ZVAL(z_copy); - INIT_PZVAL_COPY(z_copy, z); - zendi_zval_copy_ctor(*z_copy); - incdec_op(z_copy); - Z_ADDREF_P(z); - Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - zval_ptr_dtor(&object); - zval_ptr_dtor(&z_copy); - zval_ptr_dtor(&z); - } else { - zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); - ZVAL_NULL(retval); } - } + } while (0); + - if (0) { - zval_ptr_dtor(&property); - } else { - zval_ptr_dtor_nogc(&free_op2.var); - } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_post_incdec_property_helper_SPEC_VAR_VAR(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + return zend_pre_incdec_property_helper_SPEC_UNUSED_CONST(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } -static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_post_incdec_property_helper_SPEC_VAR_VAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + return zend_pre_incdec_property_helper_SPEC_UNUSED_CONST(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } -static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_VAR(int type, ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_free_op free_op1; - zval *varname; - zval **retval; - zval tmp_varname; - HashTable *target_symbol_table; - ulong hash_value; + + zval *object; + zval *property; + zval *retval; + zval *zptr; SAVE_OPLINE(); - varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + object = _get_obj_zval_ptr_unused(execute_data); + property = EX_CONSTANT(opline->op2); + retval = EX_VAR(opline->result.var); - if (IS_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) { - ZVAL_COPY_VALUE(&tmp_varname, varname); - zval_copy_ctor(&tmp_varname); - Z_SET_REFCOUNT(tmp_varname, 1); - Z_UNSET_ISREF(tmp_varname); - convert_to_string(&tmp_varname); - varname = &tmp_varname; - } + if (IS_UNUSED == IS_VAR && UNEXPECTED(object == NULL)) { + zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); - if (IS_VAR != IS_UNUSED) { - zend_class_entry *ce; - if (IS_VAR == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); - } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); - if (UNEXPECTED(ce == NULL)) { - if (IS_VAR != IS_CONST && varname == &tmp_varname) { - zval_dtor(&tmp_varname); - } - zval_ptr_dtor_nogc(&free_op1.var); - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); - } - CACHE_PTR(opline->op2.literal->cache_slot, ce); - } - } else { - ce = EX_T(opline->op2.var).class_entry; - } - retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); - } else { - target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); -/* - if (!target_symbol_table) { - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); - } -*/ - if (IS_VAR == IS_CONST) { - hash_value = Z_HASH_P(varname); - } else { - hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname)); - } + HANDLE_EXCEPTION(); + } - if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) { - switch (type) { - case BP_VAR_R: - case BP_VAR_UNSET: - zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); - /* break missing intentionally */ - case BP_VAR_IS: - retval = &EG(uninitialized_zval_ptr); - break; - case BP_VAR_RW: - zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); - /* break missing intentionally */ - case BP_VAR_W: - Z_ADDREF_P(&EG(uninitialized_zval)); - zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval); - break; - EMPTY_SWITCH_DEFAULT_CASE() - } - } - switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) { - case ZEND_FETCH_GLOBAL: - if (IS_VAR != IS_TMP_VAR) { - zval_ptr_dtor_nogc(&free_op1.var); - } - break; - case ZEND_FETCH_LOCAL: - zval_ptr_dtor_nogc(&free_op1.var); - break; - case ZEND_FETCH_STATIC: - zval_update_constant(retval, 1 TSRMLS_CC); - break; - case ZEND_FETCH_GLOBAL_LOCK: - if (IS_VAR == IS_VAR && !free_op1.var) { - PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); - } + do { + if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + ZVAL_DEREF(object); + if (UNEXPECTED(!make_real_object(object))) { + zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + ZVAL_NULL(retval); break; + } } - } + /* here we are sure we are dealing with an object */ + + if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) { - if (IS_VAR != IS_CONST && varname == &tmp_varname) { - zval_dtor(&tmp_varname); - } - if (opline->extended_value & ZEND_FETCH_MAKE_REF) { - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval); - } - PZVAL_LOCK(*retval); - switch (type) { - case BP_VAR_R: - case BP_VAR_IS: - EX_T(opline->result.var).var.ptr = *retval; - break; - case BP_VAR_UNSET: { - zend_free_op free_res; + ZVAL_DEREF(zptr); + ZVAL_COPY_VALUE(retval, zptr); + zval_opt_copy_ctor(zptr); - + incdec_op(zptr); + } else { + if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval rv; - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv); ++ zval rv, obj; ++ zval *z; ++ ++ ZVAL_COPY(&obj, object); ++ z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv); + zval z_copy; - PZVAL_UNLOCK(*retval, &free_res); - if (retval != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(retval); + if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv); - + if (Z_REFCOUNT_P(z) == 0) { + zend_objects_store_del(Z_OBJ_P(z)); + } + ZVAL_COPY_VALUE(z, value); + } + ZVAL_DUP(retval, z); + ZVAL_DUP(&z_copy, z); + incdec_op(&z_copy); + if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); - Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ Z_OBJ_HT(obj)->write_property(&obj, property, &z_copy, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ zval_ptr_dtor(&obj); + zval_ptr_dtor(&z_copy); + zval_ptr_dtor(z); + } else { + zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + ZVAL_NULL(retval); } - PZVAL_LOCK(*retval); - FREE_OP_VAR_PTR(free_res); } - /* break missing intentionally */ - default: - EX_T(opline->result.var).var.ptr_ptr = retval; - break; - } + } while (0); + + CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@@ -21350,492 -21508,387 +21382,494 @@@ static int ZEND_FASTCALL zend_binary_as ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#if 0 || (IS_UNUSED != IS_UNUSED) + USE_OPLINE + +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#if 0 || (IS_UNUSED != IS_UNUSED) + USE_OPLINE + +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#if 0 || (IS_UNUSED != IS_UNUSED) + USE_OPLINE + +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#if 0 || (IS_UNUSED != IS_UNUSED) + USE_OPLINE + +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#if 0 || (IS_UNUSED != IS_UNUSED) + USE_OPLINE + +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#if 0 || (IS_UNUSED != IS_UNUSED) + USE_OPLINE + +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#if 0 || (IS_UNUSED != IS_UNUSED) + USE_OPLINE + +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#if 0 || (IS_UNUSED != IS_UNUSED) + USE_OPLINE + +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#if 0 || (IS_UNUSED != IS_UNUSED) + USE_OPLINE + +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#if 0 || (IS_UNUSED != IS_UNUSED) + USE_OPLINE + +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#if 0 || (IS_UNUSED != IS_UNUSED) + USE_OPLINE + +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_UNUSED(int type, ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 || (IS_UNUSED != IS_UNUSED) USE_OPLINE - zend_free_op free_op1; - zval *varname; - zval **retval; - zval tmp_varname; - HashTable *target_symbol_table; - ulong hash_value; - +#endif SAVE_OPLINE(); - varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + if (IS_UNUSED == IS_UNUSED) { + zend_verify_missing_return_type(EX(func)); + } else { + zval *retval_ptr; - if (IS_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) { - ZVAL_COPY_VALUE(&tmp_varname, varname); - zval_copy_ctor(&tmp_varname); - Z_SET_REFCOUNT(tmp_varname, 1); - Z_UNSET_ISREF(tmp_varname); - convert_to_string(&tmp_varname); - varname = &tmp_varname; + + retval_ptr = NULL; + zend_verify_return_type(EX(func), retval_ptr); } + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} - if (IS_UNUSED != IS_UNUSED) { - zend_class_entry *ce; +static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + zval *array; + uint32_t size; + USE_OPLINE - if (IS_UNUSED == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); - } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); - if (UNEXPECTED(ce == NULL)) { - if (IS_VAR != IS_CONST && varname == &tmp_varname) { - zval_dtor(&tmp_varname); - } - zval_ptr_dtor_nogc(&free_op1.var); - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); - } - CACHE_PTR(opline->op2.literal->cache_slot, ce); - } - } else { - ce = EX_T(opline->op2.var).class_entry; - } - retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + array = EX_VAR(opline->result.var); + if (IS_UNUSED != IS_UNUSED) { + size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; } else { - target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); -/* - if (!target_symbol_table) { - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); - } -*/ - if (IS_VAR == IS_CONST) { - hash_value = Z_HASH_P(varname); - } else { - hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname)); + size = 0; + } + ZVAL_NEW_ARR(array); + zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); + + if (IS_UNUSED != IS_UNUSED) { + /* Explicitly initialize array as not-packed if flag is set */ + if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) { + zend_hash_real_init(Z_ARRVAL_P(array), 0); } + } - if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) { - switch (type) { - case BP_VAR_R: - case BP_VAR_UNSET: - zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); - /* break missing intentionally */ - case BP_VAR_IS: - retval = &EG(uninitialized_zval_ptr); - break; - case BP_VAR_RW: - zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); - /* break missing intentionally */ - case BP_VAR_W: - Z_ADDREF_P(&EG(uninitialized_zval)); - zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval); - break; - EMPTY_SWITCH_DEFAULT_CASE() - } - } - switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) { - case ZEND_FETCH_GLOBAL: - if (IS_VAR != IS_TMP_VAR) { - zval_ptr_dtor_nogc(&free_op1.var); - } - break; - case ZEND_FETCH_LOCAL: - zval_ptr_dtor_nogc(&free_op1.var); - break; - case ZEND_FETCH_STATIC: - zval_update_constant(retval, 1 TSRMLS_CC); - break; - case ZEND_FETCH_GLOBAL_LOCK: - if (IS_VAR == IS_VAR && !free_op1.var) { - PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); - } - break; - } + if (IS_UNUSED == IS_UNUSED) { + ZEND_VM_NEXT_OPCODE(); +#if 0 || (IS_UNUSED != IS_UNUSED) + } else { + return ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } +} +static int ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE - if (IS_VAR != IS_CONST && varname == &tmp_varname) { - zval_dtor(&tmp_varname); - } - if (opline->extended_value & ZEND_FETCH_MAKE_REF) { - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval); - } - PZVAL_LOCK(*retval); - switch (type) { - case BP_VAR_R: - case BP_VAR_IS: - EX_T(opline->result.var).var.ptr = *retval; - break; - case BP_VAR_UNSET: { - zend_free_op free_res; + /* The generator object is stored in EX(return_value) */ + zend_generator *generator = (zend_generator *) EX(return_value); - PZVAL_UNLOCK(*retval, &free_res); - if (retval != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(retval); - } - PZVAL_LOCK(*retval); - FREE_OP_VAR_PTR(free_res); - } - /* break missing intentionally */ - default: - EX_T(opline->result.var).var.ptr_ptr = retval; - break; - } - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); -} + if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) { + zend_error(E_EXCEPTION | E_ERROR, "Cannot yield from finally in a force-closed generator"); -static int ZEND_FASTCALL ZEND_FETCH_R_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} -static int ZEND_FASTCALL ZEND_FETCH_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} + HANDLE_EXCEPTION(); + } -static int ZEND_FASTCALL ZEND_FETCH_RW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} + /* Destroy the previously yielded value */ + zval_ptr_dtor(&generator->value); -static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE + /* Destroy the previously yielded key */ + zval_ptr_dtor(&generator->key); - return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} + /* Set the new yielded value */ + if (IS_UNUSED != IS_UNUSED) { -static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} -static int ZEND_FASTCALL ZEND_FETCH_IS_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} + if (EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE) { + /* Constants and temporary variables aren't yieldable by reference, + * but we still allow them with a notice. */ + if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR) { + zval *value; -static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zend_free_op free_op1; - zval **container; + zend_error(E_NOTICE, "Only variable references should be yielded by reference"); - SAVE_OPLINE(); - container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + value = NULL; + ZVAL_COPY_VALUE(&generator->value, value); + if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1); - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); - } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_W TSRMLS_CC); + /* Temporary variables don't need ctor copying */ + if (IS_UNUSED != IS_TMP_VAR) { + zval_opt_copy_ctor(&generator->value); + } + } else { + zval *value_ptr = NULL; - if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); - } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (IS_UNUSED == IS_VAR && UNEXPECTED(value_ptr == NULL)) { + zend_error(E_EXCEPTION | E_ERROR, "Cannot yield string offsets by reference"); - /* We are going to assign the result by reference */ - if (UNEXPECTED(opline->extended_value != 0)) { - zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; - if (retval_ptr) { - Z_DELREF_PP(retval_ptr); - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); - Z_ADDREF_PP(retval_ptr); - } - } + HANDLE_EXCEPTION(); + } - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); -} + /* If a function call result is yielded and the function did + * not return by reference we throw a notice. */ + if (IS_UNUSED == IS_VAR && + (value_ptr == &EG(uninitialized_zval) || + (opline->extended_value == ZEND_RETURNS_FUNCTION && + !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF)))) { + zend_error(E_NOTICE, "Only variable references should be yielded by reference"); + } else { + ZVAL_MAKE_REF(value_ptr); + } + ZVAL_COPY(&generator->value, value_ptr); -static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zend_free_op free_op1; - zval **container; + } + } else { + zval *value = NULL; - SAVE_OPLINE(); - container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + /* Consts, temporary variables and references need copying */ + if (IS_UNUSED == IS_CONST) { + ZVAL_DUP(&generator->value, value); + } else if (IS_UNUSED == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->value, value); + } else if ((IS_UNUSED == IS_CV || IS_UNUSED == IS_VAR) && Z_ISREF_P(value)) { + ZVAL_DUP(&generator->value, Z_REFVAL_P(value)); - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); + } else { + ZVAL_COPY_VALUE(&generator->value, value); + if (IS_UNUSED == IS_CV) { + if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value); + } + } + } + } else { + /* If no value was specified yield null */ + ZVAL_NULL(&generator->value); } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_RW TSRMLS_CC); - if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); - } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); -} + /* Set the new yielded key */ + if (IS_UNUSED != IS_UNUSED) { -static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zend_free_op free_op1; + zval *key = NULL; - SAVE_OPLINE(); + /* Consts, temporary variables and references need copying */ + if (IS_UNUSED == IS_CONST) { + ZVAL_DUP(&generator->key, key); + } else if (IS_UNUSED == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->key, key); + } else if ((IS_UNUSED == IS_VAR || IS_UNUSED == IS_CV) && Z_ISREF_P(key)) { + ZVAL_DUP(&generator->key, Z_REFVAL_P(key)); - if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { - zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); + } else { + ZVAL_COPY_VALUE(&generator->key, key); + if (IS_UNUSED == IS_CV) { + if (Z_OPT_REFCOUNTED_P(key)) Z_ADDREF_P(key); + } } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_W TSRMLS_CC); - if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + + if (Z_TYPE(generator->key) == IS_LONG + && Z_LVAL(generator->key) > generator->largest_used_integer_key + ) { + generator->largest_used_integer_key = Z_LVAL(generator->key); } + } else { + /* If no key was specified we use auto-increment keys */ + generator->largest_used_integer_key++; + ZVAL_LONG(&generator->key, generator->largest_used_integer_key); + } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (RETURN_VALUE_USED(opline)) { + /* If the return value of yield is used set the send + * target and initialize it to NULL */ + generator->send_target = EX_VAR(opline->result.var); + ZVAL_NULL(generator->send_target); } else { - zval *container; + generator->send_target = NULL; + } - if (IS_UNUSED == IS_UNUSED) { - zend_error_noreturn(E_ERROR, "Cannot use [] for reading"); - } - container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_R TSRMLS_CC); + /* We increment to the next op, so we are at the correct position when the + * generator is resumed. */ + ZEND_VM_INC_OPCODE(); - zval_ptr_dtor_nogc(&free_op1.var); - } - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); + /* The GOTO VM uses a local opline variable. We need to set the opline + * variable in execute_data so we don't resume at an old position. */ + SAVE_OPLINE(); + + ZEND_VM_RETURN(); } -static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(int (*binary_op)(zval *result, zval *op1, zval *op2), ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_free_op free_op1; - zval **object_ptr; + zend_free_op free_op_data1; + zval *object = _get_obj_zval_ptr_unused(execute_data); + zval *property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + zval *value; + zval *zptr; - SAVE_OPLINE(); - object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + if (IS_UNUSED == IS_VAR && UNEXPECTED(object == NULL)) { + zend_error(E_EXCEPTION | E_ERROR, "Cannot use string offset as an object"); + FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var); - if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); - } - if (Z_TYPE_PP(object_ptr) == IS_OBJECT) { - zval *property_name = NULL; + HANDLE_EXCEPTION(); + } - if (0) { - MAKE_REAL_ZVAL_PTR(property_name); - } - zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property_name); - } else { + do { + value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); + if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + ZVAL_DEREF(object); + if (UNEXPECTED(!make_real_object(object))) { + zend_error(E_WARNING, "Attempt to assign property of non-object"); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } + break; + } } - } else { - zend_free_op free_op_data1, free_op_data2; - zval *value; - zval *dim = NULL; - zval **variable_ptr_ptr; - zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_UNUSED, BP_VAR_W TSRMLS_CC); + /* here we are sure we are dealing with an object */ + if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) { - value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); - variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); - if (UNEXPECTED(variable_ptr_ptr == NULL)) { - if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) { - if (RETURN_VALUE_USED(opline)) { - zval *retval; + ZVAL_DEREF(zptr); + SEPARATE_ZVAL_NOREF(zptr); - ALLOC_ZVAL(retval); - ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1); - INIT_PZVAL(retval); - EX_T(opline->result.var).var.ptr = retval; - } - } else if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - } - } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) { - if (IS_TMP_FREE(free_op_data1)) { - zval_dtor(value); - } - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + binary_op(zptr, zptr, value); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), zptr); } } else { - if ((opline+1)->op1_type == IS_TMP_VAR) { - value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); - } else if ((opline+1)->op1_type == IS_CONST) { - value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC); + zval *z; - zval rv; ++ zval rv, obj; + - if (Z_OBJ_HT_P(object)->read_property && - (z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv)) != NULL) { ++ ZVAL_COPY(&obj, object); ++ if (Z_OBJ_HT(obj)->read_property && ++ (z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv)) != NULL) { + if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv); + + if (Z_REFCOUNT_P(z) == 0) { + zend_objects_store_del(Z_OBJ_P(z)); + } + ZVAL_COPY_VALUE(z, value); + } + zptr = z; + ZVAL_DEREF(z); + SEPARATE_ZVAL_NOREF(z); + binary_op(z, z, value); - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ Z_OBJ_HT(obj)->write_property(&obj, property, z, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ zval_ptr_dtor(&obj); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), z); + } + zval_ptr_dtor(zptr); } else { - value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC); - } - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(value); - EX_T(opline->result.var).var.ptr = value; + zend_error(E_WARNING, "Attempt to assign property of non-object"); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } } } - FREE_OP_VAR_PTR(free_op_data2); - FREE_OP_IF_VAR(free_op_data1); - } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - /* assign_dim has two opcodes! */ + } while (0); + + FREE_OP(free_op_data1); + + + /* assign_obj has two opcodes! */ CHECK_EXCEPTION(); ZEND_VM_INC_OPCODE(); ZEND_VM_NEXT_OPCODE(); @@@ -21910,388 -22019,460 +21944,394 @@@ static int ZEND_FASTCALL zend_binary_as ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 || (IS_CV != IS_UNUSED) USE_OPLINE - zend_free_op free_op1; - zval *expr_ptr; - SAVE_OPLINE(); - if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) { - zval **expr_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - - if (IS_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets"); - } - SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); - expr_ptr = *expr_ptr_ptr; - Z_ADDREF_P(expr_ptr); - } else { - expr_ptr=_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (0) { /* temporary variable */ - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - } else if (IS_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) { - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - zendi_zval_copy_ctor(*expr_ptr); - zval_ptr_dtor_nogc(&free_op1.var); - } else if (IS_VAR == IS_CV) { - Z_ADDREF_P(expr_ptr); - } +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif +} - if (IS_UNUSED != IS_UNUSED) { - - zval *offset = NULL; - ulong hval; - - switch (Z_TYPE_P(offset)) { - case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); - goto num_index; - case IS_LONG: - case IS_BOOL: - hval = Z_LVAL_P(offset); -num_index: - zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL); - break; - case IS_STRING: - if (IS_UNUSED == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); - } - zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL); - break; - case IS_NULL: - zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); - break; - default: - zend_error(E_WARNING, "Illegal offset type"); - zval_ptr_dtor(&expr_ptr); - /* do nothing */ - break; - } +static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || (IS_CV != IS_UNUSED) + USE_OPLINE - } else { - zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL); +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } - if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) { - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 || (IS_CV != IS_UNUSED) USE_OPLINE - array_init(&EX_T(opline->result.var).tmp_var); - if (IS_VAR == IS_UNUSED) { - ZEND_VM_NEXT_OPCODE(); -#if 0 || IS_VAR != IS_UNUSED - } else { - return ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -#endif +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 || (IS_CV != IS_UNUSED) USE_OPLINE - zval tmp, *varname; - HashTable *target_symbol_table; - zend_free_op free_op1; - - SAVE_OPLINE(); - if (IS_VAR == IS_CV && - IS_UNUSED == IS_UNUSED && - (opline->extended_value & ZEND_QUICK_SET)) { - if (EG(active_symbol_table)) { - zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); - zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC); - EX_CV(opline->op1.var) = NULL; - } else if (EX_CV(opline->op1.var)) { - zval_ptr_dtor(EX_CV(opline->op1.var)); - EX_CV(opline->op1.var) = NULL; - } - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } - - varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - - if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { - ZVAL_COPY_VALUE(&tmp, varname); - zval_copy_ctor(&tmp); - convert_to_string(&tmp); - varname = &tmp; - } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) { - Z_ADDREF_P(varname); +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif +} - if (IS_UNUSED != IS_UNUSED) { - zend_class_entry *ce; - - if (IS_UNUSED == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); - } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); - if (UNEXPECTED(EG(exception) != NULL)) { - if (IS_VAR != IS_CONST && varname == &tmp) { - zval_dtor(&tmp); - } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) { - zval_ptr_dtor(&varname); - } - zval_ptr_dtor_nogc(&free_op1.var); - HANDLE_EXCEPTION(); - } - if (UNEXPECTED(ce == NULL)) { - zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv)); - } - CACHE_PTR(opline->op2.literal->cache_slot, ce); - } - } else { - ce = EX_T(opline->op2.var).class_entry; - } - zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); - } else { - ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1); +static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || (IS_CV != IS_UNUSED) + USE_OPLINE - target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); - zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC); +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } - - if (IS_VAR != IS_CONST && varname == &tmp) { - zval_dtor(&tmp); - } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) { - zval_ptr_dtor(&varname); +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } - zval_ptr_dtor_nogc(&free_op1.var); - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 || (IS_CV != IS_UNUSED) USE_OPLINE - zval **value; - zend_bool isset = 1; - - SAVE_OPLINE(); - if (IS_VAR == IS_CV && - IS_UNUSED == IS_UNUSED && - (opline->extended_value & ZEND_QUICK_SET)) { - if (EX_CV(opline->op1.var)) { - value = EX_CV(opline->op1.var); - } else if (EG(active_symbol_table)) { - zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); - if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) { - isset = 0; - } - } else { - isset = 0; - } - } else { - HashTable *target_symbol_table; - zend_free_op free_op1; - zval tmp, *varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif +} - if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { - ZVAL_COPY_VALUE(&tmp, varname); - zval_copy_ctor(&tmp); - convert_to_string(&tmp); - varname = &tmp; - } +static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || (IS_CV != IS_UNUSED) + USE_OPLINE - if (IS_UNUSED != IS_UNUSED) { - zend_class_entry *ce; +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif +} - if (IS_UNUSED == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); - } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); - if (UNEXPECTED(ce == NULL)) { - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); - } - CACHE_PTR(opline->op2.literal->cache_slot, ce); - } - } else { - ce = EX_T(opline->op2.var).class_entry; - } - value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); - if (!value) { - isset = 0; - } - } else { - target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); - if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) { - isset = 0; - } - } +static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || (IS_CV != IS_UNUSED) + USE_OPLINE - if (IS_VAR != IS_CONST && varname == &tmp) { - zval_dtor(&tmp); - } - zval_ptr_dtor_nogc(&free_op1.var); +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } - - if (opline->extended_value & ZEND_ISSET) { - if (isset && Z_TYPE_PP(value) != IS_NULL) { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); - } else { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); - } - } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { - if (!isset || !i_zend_is_true(*value)) { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); - } else { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); - } +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } - - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_SEPARATE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 || (IS_CV != IS_UNUSED) USE_OPLINE - zval *var_ptr, *new_zv; - - SAVE_OPLINE(); - var_ptr = EX_T(opline->op1.var).var.ptr; - if (Z_TYPE_P(var_ptr) != IS_OBJECT && - !PZVAL_IS_REF(var_ptr) && - Z_REFCOUNT_P(var_ptr) > 1) { - Z_DELREF_P(var_ptr); - ALLOC_ZVAL(new_zv); - INIT_PZVAL_COPY(new_zv, var_ptr); - var_ptr = new_zv; - zval_copy_ctor(var_ptr); - EX_T(opline->op1.var).var.ptr = var_ptr; +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } - ZEND_VM_NEXT_OPCODE(); +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 || (IS_CV != IS_UNUSED) USE_OPLINE - /* The generator object is stored in return_value_ptr_ptr */ - zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr); - - if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) { - zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator"); +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } - - /* Destroy the previously yielded value */ - if (generator->value) { - zval_ptr_dtor(&generator->value); +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif +} - /* Destroy the previously yielded key */ - if (generator->key) { - zval_ptr_dtor(&generator->key); +static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || (IS_CV != IS_UNUSED) + USE_OPLINE + +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif +} - /* Set the new yielded value */ - if (IS_VAR != IS_UNUSED) { - zend_free_op free_op1; +static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE - if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) { - /* Constants and temporary variables aren't yieldable by reference, - * but we still allow them with a notice. */ - if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) { - zval *value, *copy; + zval *object; + zval *property; + zval *retval; + zval *zptr; - zend_error(E_NOTICE, "Only variable references should be yielded by reference"); + SAVE_OPLINE(); + object = _get_obj_zval_ptr_unused(execute_data); + property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + retval = EX_VAR(opline->result.var); - value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); + if (IS_UNUSED == IS_VAR && UNEXPECTED(object == NULL)) { + zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } - generator->value = copy; - } else { - zval **value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + HANDLE_EXCEPTION(); + } - if (IS_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference"); + do { + if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + ZVAL_DEREF(object); + if (UNEXPECTED(!make_real_object(object))) { + zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(retval); } + break; + } + } - /* If a function call result is yielded and the function did - * not return by reference we throw a notice. */ - if (IS_VAR == IS_VAR && !Z_ISREF_PP(value_ptr) - && !(opline->extended_value == ZEND_RETURNS_FUNCTION - && EX_T(opline->op1.var).var.fcall_returned_reference) - && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) { - zend_error(E_NOTICE, "Only variable references should be yielded by reference"); + /* here we are sure we are dealing with an object */ - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; - } else { - SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr); - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; - } + if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) { - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + ZVAL_DEREF(zptr); + SEPARATE_ZVAL_NOREF(zptr); + + incdec_op(zptr); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(retval, zptr); } } else { - zval *value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + zval rv; - /* Consts, temporary variables and references need copying */ - if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR - || PZVAL_IS_REF(value) - ) { - zval *copy; + if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv); ++ zval *z, obj; + - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); ++ ZVAL_COPY(&obj, object); ++ z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv); - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } + if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv); - generator->value = copy; - zval_ptr_dtor_nogc(&free_op1.var); + if (Z_REFCOUNT_P(z) == 0) { + zend_objects_store_del(Z_OBJ_P(z)); + } + ZVAL_COPY_VALUE(z, value); + } + ZVAL_DEREF(z); + SEPARATE_ZVAL_NOREF(z); + incdec_op(z); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(retval, z); + } - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ Z_OBJ_HT(obj)->write_property(&obj, property, z, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ zval_ptr_dtor(&obj); + zval_ptr_dtor(z); } else { - if (IS_VAR == IS_CV) { - Z_ADDREF_P(value); + zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(retval); } - generator->value = value; } } - } else { - /* If no value was specified yield null */ - Z_ADDREF(EG(uninitialized_zval)); - generator->value = &EG(uninitialized_zval); - } + } while (0); - /* Set the new yielded key */ - if (IS_UNUSED != IS_UNUSED) { - zval *key = NULL; + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} - /* Consts, temporary variables and references need copying */ - if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR - || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0) - ) { - zval *copy; +static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + return zend_pre_incdec_property_helper_SPEC_UNUSED_CV(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +} - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, key); +static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + return zend_pre_incdec_property_helper_SPEC_UNUSED_CV(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +} - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } +static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE - generator->key = copy; - } else { - Z_ADDREF_P(key); - generator->key = key; - } + zval *object; + zval *property; + zval *retval; + zval *zptr; - if (Z_TYPE_P(generator->key) == IS_LONG - && Z_LVAL_P(generator->key) > generator->largest_used_integer_key - ) { - generator->largest_used_integer_key = Z_LVAL_P(generator->key); - } + SAVE_OPLINE(); + object = _get_obj_zval_ptr_unused(execute_data); + property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + retval = EX_VAR(opline->result.var); - } else { - /* If no key was specified we use auto-increment keys */ - generator->largest_used_integer_key++; + if (IS_UNUSED == IS_VAR && UNEXPECTED(object == NULL)) { + zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); - ALLOC_INIT_ZVAL(generator->key); - ZVAL_LONG(generator->key, generator->largest_used_integer_key); + + HANDLE_EXCEPTION(); } - if (RETURN_VALUE_USED(opline)) { - /* If the return value of yield is used set the send - * target and initialize it to NULL */ - generator->send_target = &EX_T(opline->result.var).var.ptr; - Z_ADDREF(EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - } else { - generator->send_target = NULL; - } + do { + if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + ZVAL_DEREF(object); + if (UNEXPECTED(!make_real_object(object))) { + zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + ZVAL_NULL(retval); + break; + } + } - /* We increment to the next op, so we are at the correct position when the - * generator is resumed. */ - ZEND_VM_INC_OPCODE(); + /* here we are sure we are dealing with an object */ - /* The GOTO VM uses a local opline variable. We need to set the opline - * variable in execute_data so we don't resume at an old position. */ - SAVE_OPLINE(); + if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) { - ZEND_VM_RETURN(); -} + ZVAL_DEREF(zptr); + ZVAL_COPY_VALUE(retval, zptr); + zval_opt_copy_ctor(zptr); - + incdec_op(zptr); + } else { + if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval rv; - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv); ++ zval rv, obj; ++ zval *z; + -static int ZEND_FASTCALL ZEND_ASSIGN_POW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(pow_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} ++ ZVAL_COPY(&obj, object); ++ z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv); + zval z_copy; -static int ZEND_FASTCALL ZEND_ADD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zend_free_op free_op1; + if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv); - + if (Z_REFCOUNT_P(z) == 0) { + zend_objects_store_del(Z_OBJ_P(z)); + } + ZVAL_COPY_VALUE(z, value); + } + ZVAL_DUP(retval, z); + ZVAL_DUP(&z_copy, z); + incdec_op(&z_copy); + if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); - Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ Z_OBJ_HT(obj)->write_property(&obj, property, &z_copy, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ zval_ptr_dtor(&obj); + zval_ptr_dtor(&z_copy); + zval_ptr_dtor(z); + } else { + zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + ZVAL_NULL(retval); + } + } + } while (0); - SAVE_OPLINE(); - fast_add_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@@ -23030,224 -23091,168 +23070,226 @@@ isset_no_object ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_pre_incdec_property_helper_SPEC_VAR_CV(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} + USE_OPLINE -static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_pre_incdec_property_helper_SPEC_VAR_CV(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} + /* The generator object is stored in EX(return_value) */ + zend_generator *generator = (zend_generator *) EX(return_value); -static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zend_free_op free_op1; - zval **object_ptr; - zval *object; - zval *property; - zval *retval; - int have_get_ptr = 0; + if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) { + zend_error(E_EXCEPTION | E_ERROR, "Cannot yield from finally in a force-closed generator"); - SAVE_OPLINE(); - object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - retval = &EX_T(opline->result.var).tmp_var; - if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); + HANDLE_EXCEPTION(); } - make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ - object = *object_ptr; + /* Destroy the previously yielded value */ + zval_ptr_dtor(&generator->value); - if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { - zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + /* Destroy the previously yielded key */ + zval_ptr_dtor(&generator->key); - ZVAL_NULL(retval); - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); - } + /* Set the new yielded value */ + if (IS_UNUSED != IS_UNUSED) { - /* here we are sure we are dealing with an object */ - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } + if (EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE) { + /* Constants and temporary variables aren't yieldable by reference, + * but we still allow them with a notice. */ + if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR) { + zval *value; - if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - if (zptr != NULL) { /* NULL means no success in getting PTR */ - have_get_ptr = 1; - SEPARATE_ZVAL_IF_NOT_REF(zptr); + zend_error(E_NOTICE, "Only variable references should be yielded by reference"); - ZVAL_COPY_VALUE(retval, *zptr); - zendi_zval_copy_ctor(*retval); + value = NULL; + ZVAL_COPY_VALUE(&generator->value, value); + if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1); - incdec_op(*zptr); + /* Temporary variables don't need ctor copying */ + if (IS_UNUSED != IS_TMP_VAR) { + zval_opt_copy_ctor(&generator->value); + } + } else { + zval *value_ptr = NULL; - } - } + if (IS_UNUSED == IS_VAR && UNEXPECTED(value_ptr == NULL)) { + zend_error(E_EXCEPTION | E_ERROR, "Cannot yield string offsets by reference"); - if (!have_get_ptr) { - if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z, *z_copy; - Z_ADDREF_P(object); - z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + HANDLE_EXCEPTION(); + } - if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); - zval_dtor(z); - FREE_ZVAL(z); + /* If a function call result is yielded and the function did + * not return by reference we throw a notice. */ + if (IS_UNUSED == IS_VAR && + (value_ptr == &EG(uninitialized_zval) || + (opline->extended_value == ZEND_RETURNS_FUNCTION && + !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF)))) { + zend_error(E_NOTICE, "Only variable references should be yielded by reference"); + } else { + ZVAL_MAKE_REF(value_ptr); } - z = value; + ZVAL_COPY(&generator->value, value_ptr); + } - ZVAL_COPY_VALUE(retval, z); - zendi_zval_copy_ctor(*retval); - ALLOC_ZVAL(z_copy); - INIT_PZVAL_COPY(z_copy, z); - zendi_zval_copy_ctor(*z_copy); - incdec_op(z_copy); - Z_ADDREF_P(z); - Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - zval_ptr_dtor(&object); - zval_ptr_dtor(&z_copy); - zval_ptr_dtor(&z); } else { - zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); - ZVAL_NULL(retval); + zval *value = NULL; + + /* Consts, temporary variables and references need copying */ + if (IS_UNUSED == IS_CONST) { + ZVAL_DUP(&generator->value, value); + } else if (IS_UNUSED == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->value, value); + } else if ((IS_UNUSED == IS_CV || IS_UNUSED == IS_VAR) && Z_ISREF_P(value)) { + ZVAL_DUP(&generator->value, Z_REFVAL_P(value)); + + } else { + ZVAL_COPY_VALUE(&generator->value, value); + if (IS_UNUSED == IS_CV) { + if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value); + } + } } + } else { + /* If no value was specified yield null */ + ZVAL_NULL(&generator->value); } - if (0) { - zval_ptr_dtor(&property); + /* Set the new yielded key */ + if (IS_CV != IS_UNUSED) { + + zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + + /* Consts, temporary variables and references need copying */ + if (IS_CV == IS_CONST) { + ZVAL_DUP(&generator->key, key); + } else if (IS_CV == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->key, key); + } else if ((IS_CV == IS_VAR || IS_CV == IS_CV) && Z_ISREF_P(key)) { + ZVAL_DUP(&generator->key, Z_REFVAL_P(key)); + + } else { + ZVAL_COPY_VALUE(&generator->key, key); + if (IS_CV == IS_CV) { + if (Z_OPT_REFCOUNTED_P(key)) Z_ADDREF_P(key); + } + } + + if (Z_TYPE(generator->key) == IS_LONG + && Z_LVAL(generator->key) > generator->largest_used_integer_key + ) { + generator->largest_used_integer_key = Z_LVAL(generator->key); + } } else { + /* If no key was specified we use auto-increment keys */ + generator->largest_used_integer_key++; + ZVAL_LONG(&generator->key, generator->largest_used_integer_key); + } + if (RETURN_VALUE_USED(opline)) { + /* If the return value of yield is used set the send + * target and initialize it to NULL */ + generator->send_target = EX_VAR(opline->result.var); + ZVAL_NULL(generator->send_target); + } else { + generator->send_target = NULL; } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); -} -static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_post_incdec_property_helper_SPEC_VAR_CV(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} + /* We increment to the next op, so we are at the correct position when the + * generator is resumed. */ + ZEND_VM_INC_OPCODE(); -static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_post_incdec_property_helper_SPEC_VAR_CV(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + /* The GOTO VM uses a local opline variable. We need to set the opline + * variable in execute_data so we don't resume at an old position. */ + SAVE_OPLINE(); + + ZEND_VM_RETURN(); } -static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMPVAR(int (*binary_op)(zval *result, zval *op1, zval *op2), ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_free_op free_op1; - zval *container; + zend_free_op free_op2, free_op_data1; + zval *object = _get_obj_zval_ptr_unused(execute_data); + zval *property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); + zval *value; + zval *zptr; - SAVE_OPLINE(); - container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC); + if (IS_UNUSED == IS_VAR && UNEXPECTED(object == NULL)) { + zend_error(E_EXCEPTION | E_ERROR, "Cannot use string offset as an object"); + FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var); + zval_ptr_dtor_nogc(free_op2); - if (IS_VAR != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) { - zval_ptr_dtor_nogc(&free_op1.var); + HANDLE_EXCEPTION(); } - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); -} -static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zend_free_op free_op1; - zval **container; + do { + value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); - SAVE_OPLINE(); - container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + ZVAL_DEREF(object); + if (UNEXPECTED(!make_real_object(object))) { + zend_error(E_WARNING, "Attempt to assign property of non-object"); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } + break; + } + } - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); - } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_W TSRMLS_CC); + /* here we are sure we are dealing with an object */ + if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) { - if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); - } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + ZVAL_DEREF(zptr); + SEPARATE_ZVAL_NOREF(zptr); + + binary_op(zptr, zptr, value); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), zptr); + } + } else { + zval *z; - zval rv; ++ zval rv, obj; - if (Z_OBJ_HT_P(object)->read_property && - (z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv)) != NULL) { - /* We are going to assign the result by reference */ - if (UNEXPECTED(opline->extended_value != 0)) { - zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; ++ ZVAL_COPY(&obj, object); ++ if (Z_OBJ_HT(obj)->read_property && ++ (z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv)) != NULL) { + if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv); - if (retval_ptr) { - Z_DELREF_PP(retval_ptr); - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); - Z_ADDREF_PP(retval_ptr); + if (Z_REFCOUNT_P(z) == 0) { + zend_objects_store_del(Z_OBJ_P(z)); + } + ZVAL_COPY_VALUE(z, value); + } + zptr = z; + ZVAL_DEREF(z); + SEPARATE_ZVAL_NOREF(z); + binary_op(z, z, value); - Z_OBJ_HT_P(object)->write_property(object, property, z, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ Z_OBJ_HT(obj)->write_property(&obj, property, z, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ zval_ptr_dtor(&obj); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), z); + } + zval_ptr_dtor(zptr); + } else { + zend_error(E_WARNING, "Attempt to assign property of non-object"); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } + } } - } + } while (0); + + FREE_OP(free_op_data1); + zval_ptr_dtor_nogc(free_op2); + /* assign_obj has two opcodes! */ CHECK_EXCEPTION(); + ZEND_VM_INC_OPCODE(); ZEND_VM_NEXT_OPCODE(); } @@@ -23575,138 -23515,130 +23617,144 @@@ static int ZEND_FASTCALL zend_pre_incde } /* here we are sure we are dealing with an object */ - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - PZVAL_LOCK(retval); - EX_T(opline->result.var).var.ptr = retval; + if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) { + + ZVAL_DEREF(zptr); + SEPARATE_ZVAL_NOREF(zptr); - if (0) { - zval_ptr_dtor(&offset); + incdec_op(zptr); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(retval, zptr); + } } else { + zval rv; + + if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv); ++ zval *z, obj; ++ ++ ZVAL_COPY(&obj, object); ++ z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv); + + if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv); + if (Z_REFCOUNT_P(z) == 0) { + zend_objects_store_del(Z_OBJ_P(z)); + } + ZVAL_COPY_VALUE(z, value); + } + ZVAL_DEREF(z); + SEPARATE_ZVAL_NOREF(z); + incdec_op(z); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(retval, z); + } - Z_OBJ_HT_P(object)->write_property(object, property, z, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ Z_OBJ_HT(obj)->write_property(&obj, property, z, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ zval_ptr_dtor(&obj); + zval_ptr_dtor(z); + } else { + zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(retval); + } + } } - } + } while (0); + + zval_ptr_dtor_nogc(free_op2); - zval_ptr_dtor_nogc(&free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - USE_OPLINE - - if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { - /* Behave like FETCH_OBJ_W */ - zend_free_op free_op1; - zval *property; - zval **container; - - SAVE_OPLINE(); - property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); - } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property); - } else { + return zend_pre_incdec_property_helper_SPEC_UNUSED_TMPVAR(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +} - } - if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); - } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); - } else { - return zend_fetch_property_address_read_helper_SPEC_VAR_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - } +static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + return zend_pre_incdec_property_helper_SPEC_UNUSED_TMPVAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } -static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_TMPVAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_free_op free_op1, free_res; - zval **container; + zend_free_op free_op2; + zval *object; zval *property; + zval *retval; + zval *zptr; SAVE_OPLINE(); - container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); + object = _get_obj_zval_ptr_unused(execute_data); + property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); + retval = EX_VAR(opline->result.var); - if (IS_VAR == IS_CV) { - if (container != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(container); - } - } - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); - } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property); - } else { + if (IS_UNUSED == IS_VAR && UNEXPECTED(object == NULL)) { + zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); + zval_ptr_dtor_nogc(free_op2); + HANDLE_EXCEPTION(); } - if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); - } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res); - if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr); - } - PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr); - FREE_OP_VAR_PTR(free_res); - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); -} + do { + if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + ZVAL_DEREF(object); + if (UNEXPECTED(!make_real_object(object))) { + zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + ZVAL_NULL(retval); + break; + } + } -static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zend_free_op free_op1; - zval **object_ptr; - zval *property_name; + /* here we are sure we are dealing with an object */ - SAVE_OPLINE(); - object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); + if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) { - if (0) { - MAKE_REAL_ZVAL_PTR(property_name); - } - if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); - } - zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property_name); - } else { + ZVAL_DEREF(zptr); + ZVAL_COPY_VALUE(retval, zptr); + zval_opt_copy_ctor(zptr); - + incdec_op(zptr); + } else { + if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval rv; - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv); ++ zval rv, obj; ++ zval *z; ++ ++ ZVAL_COPY(&obj, object); ++ z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv); + zval z_copy; + + if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv); - + if (Z_REFCOUNT_P(z) == 0) { + zend_objects_store_del(Z_OBJ_P(z)); + } + ZVAL_COPY_VALUE(z, value); + } + ZVAL_DUP(retval, z); + ZVAL_DUP(&z_copy, z); + incdec_op(&z_copy); + if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); - Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ Z_OBJ_HT(obj)->write_property(&obj, property, &z_copy, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ zval_ptr_dtor(&obj); + zval_ptr_dtor(&z_copy); + zval_ptr_dtor(z); + } else { + zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + ZVAL_NULL(retval); + } + } + } while (0); + + zval_ptr_dtor_nogc(free_op2); - } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - /* assign_obj has two opcodes! */ CHECK_EXCEPTION(); - ZEND_VM_INC_OPCODE(); ZEND_VM_NEXT_OPCODE(); } @@@ -26190,163 -26310,156 +26238,165 @@@ static int ZEND_FASTCALL ZEND_IS_SMALL ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} + USE_OPLINE -static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} + zval *result = EX_VAR(opline->result.var); -static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} + SAVE_OPLINE(); + compare_function(result, + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var), + EX_CONSTANT(opline->op2)); -static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} -static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} + USE_OPLINE -static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} -static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} + SAVE_OPLINE(); + bitwise_or_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var), + EX_CONSTANT(opline->op2)); -static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + + SAVE_OPLINE(); + bitwise_and_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var), + EX_CONSTANT(opline->op2)); + + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + + SAVE_OPLINE(); + bitwise_xor_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var), + EX_CONSTANT(opline->op2)); + + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_TMP(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_free_op free_op2; - zval **object_ptr; - zval *object; - zval *property; - zval **retval; - int have_get_ptr = 0; + SAVE_OPLINE(); - object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); - property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - retval = &EX_T(opline->result.var).var.ptr; + boolean_xor_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var), + EX_CONSTANT(opline->op2)); - if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); - } - make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ - object = *object_ptr; + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} - if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { - zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); - zval_dtor(free_op2.var); - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - *retval = &EG(uninitialized_zval); - } +static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2), ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_free_op free_op_data1; + zval *object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var); + zval *property = EX_CONSTANT(opline->op2); + zval *value; + zval *zptr; - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); - } + if (IS_CV == IS_VAR && UNEXPECTED(object == NULL)) { + zend_error(E_EXCEPTION | E_ERROR, "Cannot use string offset as an object"); + FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var); - /* here we are sure we are dealing with an object */ - if (1) { - MAKE_REAL_ZVAL_PTR(property); + HANDLE_EXCEPTION(); } - if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - if (zptr != NULL) { /* NULL means no success in getting PTR */ - SEPARATE_ZVAL_IF_NOT_REF(zptr); + do { + value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); - have_get_ptr = 1; - incdec_op(*zptr); - if (RETURN_VALUE_USED(opline)) { - *retval = *zptr; - PZVAL_LOCK(*retval); + if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + ZVAL_DEREF(object); + if (UNEXPECTED(!make_real_object(object))) { + zend_error(E_WARNING, "Attempt to assign property of non-object"); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } + break; } } - } - - if (!have_get_ptr) { - if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z; - Z_ADDREF_P(object); - z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + /* here we are sure we are dealing with an object */ + if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) { - if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + ZVAL_DEREF(zptr); + SEPARATE_ZVAL_NOREF(zptr); - if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); - zval_dtor(z); - FREE_ZVAL(z); - } - z = value; + binary_op(zptr, zptr, value); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), zptr); } - Z_ADDREF_P(z); - SEPARATE_ZVAL_IF_NOT_REF(&z); - incdec_op(z); - *retval = z; - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - zval_ptr_dtor(&object); - SELECTIVE_PZVAL_LOCK(*retval, opline); - zval_ptr_dtor(&z); } else { - zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - *retval = &EG(uninitialized_zval); + zval *z; - zval rv; ++ zval rv, obj; + - if (Z_OBJ_HT_P(object)->read_property && - (z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv)) != NULL) { ++ ZVAL_COPY(&obj, object); ++ if (Z_OBJ_HT(obj)->read_property && ++ (z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv)) != NULL) { + if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv); + + if (Z_REFCOUNT_P(z) == 0) { + zend_objects_store_del(Z_OBJ_P(z)); + } + ZVAL_COPY_VALUE(z, value); + } + zptr = z; + ZVAL_DEREF(z); + SEPARATE_ZVAL_NOREF(z); + binary_op(z, z, value); - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ Z_OBJ_HT(obj)->write_property(&obj, property, z, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ zval_ptr_dtor(&obj); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), z); + } + zval_ptr_dtor(zptr); + } else { + zend_error(E_WARNING, "Attempt to assign property of non-object"); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } } } - } + } while (0); + + FREE_OP(free_op_data1); - if (1) { - zval_ptr_dtor(&property); - } else { - zval_dtor(free_op2.var); - } + /* assign_obj has two opcodes! */ CHECK_EXCEPTION(); + ZEND_VM_INC_OPCODE(); ZEND_VM_NEXT_OPCODE(); } @@@ -26457,388 -26619,506 +26507,394 @@@ static int ZEND_FASTCALL zend_binary_as ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_fetch_property_address_read_helper_SPEC_UNUSED_TMP(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#if 0 || (IS_CONST != IS_UNUSED) + USE_OPLINE + +# if 0 || (IS_CV != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 || (IS_CONST != IS_UNUSED) USE_OPLINE - zend_free_op free_op1, free_op2; - zval *property; - zval **container; - - SAVE_OPLINE(); - property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (1) { - MAKE_REAL_ZVAL_PTR(property); +# if 0 || (IS_CV != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } - container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); - if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } +#else + return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif +} - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); - if (1) { - zval_ptr_dtor(&property); - } else { - zval_dtor(free_op2.var); +static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || (IS_CONST != IS_UNUSED) + USE_OPLINE + +# if 0 || (IS_CV != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } - if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } +#else + return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif +} - /* We are going to assign the result by reference */ - if (opline->extended_value & ZEND_FETCH_MAKE_REF) { - zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; +static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || (IS_CONST != IS_UNUSED) + USE_OPLINE - Z_DELREF_PP(retval_ptr); - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); - Z_ADDREF_PP(retval_ptr); - EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr; - EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; +# if 0 || (IS_CV != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } - - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 || (IS_CONST != IS_UNUSED) USE_OPLINE - zend_free_op free_op1, free_op2; - zval *property; - zval **container; - SAVE_OPLINE(); - property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); - - if (1) { - MAKE_REAL_ZVAL_PTR(property); - } - if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); - } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC); - if (1) { - zval_ptr_dtor(&property); - } else { - zval_dtor(free_op2.var); +# if 0 || (IS_CV != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } - if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } - - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); +#else + return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 || (IS_CONST != IS_UNUSED) USE_OPLINE - zval *container; - zend_free_op free_op2; - zval *offset; - - SAVE_OPLINE(); - container = _get_obj_zval_ptr_unused(TSRMLS_C); - offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - - if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || - UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - zval_dtor(free_op2.var); - } else { - zval *retval; - - if (1) { - MAKE_REAL_ZVAL_PTR(offset); - } - - /* here we are sure we are dealing with an object */ - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - - PZVAL_LOCK(retval); - EX_T(opline->result.var).var.ptr = retval; - - if (1) { - zval_ptr_dtor(&offset); - } else { - zval_dtor(free_op2.var); - } +# if 0 || (IS_CV != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } - - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 || (IS_CONST != IS_UNUSED) USE_OPLINE - if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { - /* Behave like FETCH_OBJ_W */ - zend_free_op free_op1, free_op2; - zval *property; - zval **container; - - SAVE_OPLINE(); - property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); - - if (1) { - MAKE_REAL_ZVAL_PTR(property); - } - if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); - } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); - if (1) { - zval_ptr_dtor(&property); - } else { - zval_dtor(free_op2.var); - } - if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); - } - - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); - } else { - return zend_fetch_property_address_read_helper_SPEC_UNUSED_TMP(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +# if 0 || (IS_CV != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 || (IS_CONST != IS_UNUSED) USE_OPLINE - zend_free_op free_op1, free_op2, free_res; - zval **container; - zval *property; - - SAVE_OPLINE(); - container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); - property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (IS_UNUSED == IS_CV) { - if (container != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(container); - } - } - if (1) { - MAKE_REAL_ZVAL_PTR(property); - } - if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); - } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC); - if (1) { - zval_ptr_dtor(&property); - } else { - zval_dtor(free_op2.var); - } - if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); +# if 0 || (IS_CV != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } - - PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res); - if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr); +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } - PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr); - FREE_OP_VAR_PTR(free_res); - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); +#else + return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 || (IS_CONST != IS_UNUSED) USE_OPLINE - zend_free_op free_op2; - zval **object_ptr; - zval *property_name; - SAVE_OPLINE(); - object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); - property_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - - if (1) { - MAKE_REAL_ZVAL_PTR(property_name); +# if 0 || (IS_CV != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } - if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); - } - zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - if (1) { - zval_ptr_dtor(&property_name); - } else { - zval_dtor(free_op2.var); +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } - - /* assign_obj has two opcodes! */ - CHECK_EXCEPTION(); - ZEND_VM_INC_OPCODE(); - ZEND_VM_NEXT_OPCODE(); +#else + return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_ADD_VAR_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 || (IS_CONST != IS_UNUSED) USE_OPLINE - zend_free_op free_op2; - zval *str = &EX_T(opline->result.var).tmp_var; - zval *var; - zval var_copy; - int use_copy = 0; - SAVE_OPLINE(); - var = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - - if (IS_UNUSED == IS_UNUSED) { - /* Initialize for erealloc in add_string_to_string */ - Z_STRVAL_P(str) = NULL; - Z_STRLEN_P(str) = 0; - Z_TYPE_P(str) = IS_STRING; - - INIT_PZVAL(str); +# if 0 || (IS_CV != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } +#else + return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif +} - if (Z_TYPE_P(var) != IS_STRING) { - zend_make_printable_zval(var, &var_copy, &use_copy); +static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || (IS_CONST != IS_UNUSED) + USE_OPLINE - if (use_copy) { - var = &var_copy; - } +# if 0 || (IS_CV != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } - add_string_to_string(str, str, var); - - if (use_copy) { - zval_dtor(var); +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } - /* original comment, possibly problematic: - * FREE_OP is missing intentionally here - we're always working on the same temporary variable - * (Zeev): I don't think it's problematic, we only use variables - * which aren't affected by FREE_OP(Ts, )'s anyway, unless they're - * string offsets or overloaded objects - */ - zval_dtor(free_op2.var); - - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); +#else + return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *function_name; - char *function_name_strval; - int function_name_strlen; - zend_free_op free_op2; - call_slot *call = EX(call_slots) + opline->result.num; + + zval *object; + zval *property; + zval *retval; + zval *zptr; SAVE_OPLINE(); + object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var); + property = EX_CONSTANT(opline->op2); + retval = EX_VAR(opline->result.var); - function_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + if (IS_CV == IS_VAR && UNEXPECTED(object == NULL)) { + zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); - if (IS_TMP_VAR != IS_CONST && - UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - zend_error_noreturn(E_ERROR, "Method name must be a string"); + + HANDLE_EXCEPTION(); } - function_name_strval = Z_STRVAL_P(function_name); - function_name_strlen = Z_STRLEN_P(function_name); + do { + if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + ZVAL_DEREF(object); + if (UNEXPECTED(!make_real_object(object))) { + zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(retval); + } + break; + } + } - call->object = _get_obj_zval_ptr_unused(TSRMLS_C); + /* here we are sure we are dealing with an object */ - if (EXPECTED(call->object != NULL) && - EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) { - call->called_scope = Z_OBJCE_P(call->object); + if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) { - if (IS_TMP_VAR != IS_CONST || - (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) { - zval *object = call->object; + ZVAL_DEREF(zptr); + SEPARATE_ZVAL_NOREF(zptr); - if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) { - zend_error_noreturn(E_ERROR, "Object does not support method calls"); + incdec_op(zptr); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(retval, zptr); } + } else { + zval rv; - /* First, locate the function. */ - call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); - if (UNEXPECTED(call->fbc == NULL)) { - zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval); - } - if (IS_TMP_VAR == IS_CONST && - EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) && - EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) && - EXPECTED(call->object == object)) { - CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc); - } - } - } else { - if (UNEXPECTED(EG(exception) != NULL)) { - zval_dtor(free_op2.var); - HANDLE_EXCEPTION(); - } - zend_error_noreturn(E_ERROR, "Call to a member function %s() on %s", function_name_strval, zend_get_type_by_const(Z_TYPE_P(call->object))); - } + if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv); ++ zval *z, obj; + - if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) { - call->object = NULL; - } else { - if (!PZVAL_IS_REF(call->object)) { - Z_ADDREF_P(call->object); /* For $this pointer */ - } else { - zval *this_ptr; - ALLOC_ZVAL(this_ptr); - INIT_PZVAL_COPY(this_ptr, call->object); - zval_copy_ctor(this_ptr); - call->object = this_ptr; - } - } ++ ZVAL_COPY(&obj, object); ++ z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv); + + if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv); - call->num_additional_args = 0; - call->is_ctor_call = 0; - EX(call) = call; + if (Z_REFCOUNT_P(z) == 0) { + zend_objects_store_del(Z_OBJ_P(z)); + } + ZVAL_COPY_VALUE(z, value); + } + ZVAL_DEREF(z); + SEPARATE_ZVAL_NOREF(z); + incdec_op(z); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(retval, z); + } - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ Z_OBJ_HT(obj)->write_property(&obj, property, z, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ zval_ptr_dtor(&obj); + zval_ptr_dtor(z); + } else { + zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(retval); + } + } + } + } while (0); - zval_dtor(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - USE_OPLINE + return zend_pre_incdec_property_helper_SPEC_CV_CONST(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +} - array_init(&EX_T(opline->result.var).tmp_var); - if (IS_UNUSED == IS_UNUSED) { - ZEND_VM_NEXT_OPCODE(); -#if 0 || IS_UNUSED != IS_UNUSED - } else { - return ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -#endif - } +static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + return zend_pre_incdec_property_helper_SPEC_CV_CONST(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } -static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_free_op free_op2; - zval **container; - zval *offset; - ulong hval; + + zval *object; + zval *property; + zval *retval; + zval *zptr; SAVE_OPLINE(); - container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); - if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(container); - } - offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var); + property = EX_CONSTANT(opline->op2); + retval = EX_VAR(opline->result.var); - if (IS_UNUSED != IS_VAR || container) { - switch (Z_TYPE_PP(container)) { - case IS_ARRAY: { - HashTable *ht = Z_ARRVAL_PP(container); + if (IS_CV == IS_VAR && UNEXPECTED(object == NULL)) { + zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); - switch (Z_TYPE_P(offset)) { - case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); - zend_hash_index_del(ht, hval); - break; - case IS_RESOURCE: - case IS_BOOL: - case IS_LONG: - hval = Z_LVAL_P(offset); - zend_hash_index_del(ht, hval); - break; - case IS_STRING: - if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { - Z_ADDREF_P(offset); - } - if (IS_TMP_VAR == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); - } - if (ht == &EG(symbol_table)) { - zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC); - } else { - zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval); - } - if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { - zval_ptr_dtor(&offset); - } - break; -num_index_dim: - zend_hash_index_del(ht, hval); - if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { - zval_ptr_dtor(&offset); - } - break; - case IS_NULL: - zend_hash_del(ht, "", sizeof("")); - break; - default: - zend_error(E_WARNING, "Illegal offset type in unset"); - break; - } - zval_dtor(free_op2.var); + + HANDLE_EXCEPTION(); + } + + do { + if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + ZVAL_DEREF(object); + if (UNEXPECTED(!make_real_object(object))) { + zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + ZVAL_NULL(retval); break; } - case IS_OBJECT: - if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use object as array"); - } - if (1) { - MAKE_REAL_ZVAL_PTR(offset); - } - Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC); - if (1) { - zval_ptr_dtor(&offset); - } else { - zval_dtor(free_op2.var); - } - break; - case IS_STRING: - zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); - ZEND_VM_CONTINUE(); /* bailed out before */ - default: - zval_dtor(free_op2.var); - break; } - } else { - zval_dtor(free_op2.var); - } - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); -} + /* here we are sure we are dealing with an object */ -static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zend_free_op free_op2; - zval **container; - zval *offset; + if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) { - SAVE_OPLINE(); - container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); - offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + ZVAL_DEREF(zptr); + ZVAL_COPY_VALUE(retval, zptr); + zval_opt_copy_ctor(zptr); - + incdec_op(zptr); + } else { + if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval rv; - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv); ++ zval rv, obj; ++ zval *z; + - if (IS_UNUSED != IS_VAR || container) { - if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(container); - } - if (Z_TYPE_PP(container) == IS_OBJECT) { - if (1) { - MAKE_REAL_ZVAL_PTR(offset); - } - if (Z_OBJ_HT_P(*container)->unset_property) { - Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to unset property of non-object"); - } - if (1) { - zval_ptr_dtor(&offset); ++ ZVAL_COPY(&obj, object); ++ z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv); + zval z_copy; + + if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv); - + if (Z_REFCOUNT_P(z) == 0) { + zend_objects_store_del(Z_OBJ_P(z)); + } + ZVAL_COPY_VALUE(z, value); + } + ZVAL_DUP(retval, z); + ZVAL_DUP(&z_copy, z); + incdec_op(&z_copy); + if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); - Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ Z_OBJ_HT(obj)->write_property(&obj, property, &z_copy, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ zval_ptr_dtor(&obj); + zval_ptr_dtor(&z_copy); + zval_ptr_dtor(z); } else { - zval_dtor(free_op2.var); + zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + ZVAL_NULL(retval); } - } else { - zval_dtor(free_op2.var); } - } else { - zval_dtor(free_op2.var); - } + } while (0); + CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@@ -30852,47 -30993,11 +30908,49 @@@ static int ZEND_FASTCALL zend_binary_as } } - if (EG(return_value_ptr_ptr)) { - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr); - Z_ADDREF_PP(retval_ptr_ptr); + /* here we are sure we are dealing with an object */ + if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) { + + ZVAL_DEREF(zptr); + SEPARATE_ZVAL_NOREF(zptr); + + binary_op(zptr, zptr, value); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), zptr); + } + } else { + zval *z; - zval rv; ++ zval rv, obj; + - if (Z_OBJ_HT_P(object)->read_property && - (z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv)) != NULL) { ++ ZVAL_COPY(&obj, object); ++ if (Z_OBJ_HT(obj)->read_property && ++ (z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv)) != NULL) { + if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv); - *EG(return_value_ptr_ptr) = *retval_ptr_ptr; + if (Z_REFCOUNT_P(z) == 0) { + zend_objects_store_del(Z_OBJ_P(z)); + } + ZVAL_COPY_VALUE(z, value); + } + zptr = z; + ZVAL_DEREF(z); + SEPARATE_ZVAL_NOREF(z); + binary_op(z, z, value); - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ Z_OBJ_HT(obj)->write_property(&obj, property, z, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ zval_ptr_dtor(&obj); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), z); + } + zval_ptr_dtor(zptr); + } else { + zend_error(E_WARNING, "Attempt to assign property of non-object"); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } + } } } while (0); @@@ -31236,166 -31249,191 +31294,172 @@@ static int ZEND_FASTCALL zend_pre_incde { USE_OPLINE - zval *expr; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *object; + zval *property; + zval *retval; + zval *zptr; SAVE_OPLINE(); - expr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); + object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var); + property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + retval = EX_VAR(opline->result.var); - if (opline->extended_value != IS_STRING) { - ZVAL_COPY_VALUE(result, expr); - if (!0) { - zendi_zval_copy_ctor(*result); - } + if (IS_CV == IS_VAR && UNEXPECTED(object == NULL)) { + zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); + + + HANDLE_EXCEPTION(); } - switch (opline->extended_value) { - case IS_NULL: - convert_to_null(result); - break; - case IS_BOOL: - convert_to_boolean(result); - break; - case IS_LONG: - convert_to_long(result); - break; - case IS_DOUBLE: - convert_to_double(result); - break; - case IS_STRING: { - zval var_copy; - int use_copy; - zend_make_printable_zval(expr, &var_copy, &use_copy); - if (use_copy) { - ZVAL_COPY_VALUE(result, &var_copy); - if (0) { + do { + if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + ZVAL_DEREF(object); + if (UNEXPECTED(!make_real_object(object))) { + zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(retval); + } + break; + } + } + + /* here we are sure we are dealing with an object */ + + if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) { + + ZVAL_DEREF(zptr); + SEPARATE_ZVAL_NOREF(zptr); + + incdec_op(zptr); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(retval, zptr); + } + } else { + zval rv; + + if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv); ++ zval *z, obj; ++ ++ ZVAL_COPY(&obj, object); ++ z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv); + if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv); + + if (Z_REFCOUNT_P(z) == 0) { + zend_objects_store_del(Z_OBJ_P(z)); + } + ZVAL_COPY_VALUE(z, value); + } + ZVAL_DEREF(z); + SEPARATE_ZVAL_NOREF(z); + incdec_op(z); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(retval, z); } - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ Z_OBJ_HT(obj)->write_property(&obj, property, z, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ zval_ptr_dtor(&obj); + zval_ptr_dtor(z); } else { - ZVAL_COPY_VALUE(result, expr); - if (!0) { - zendi_zval_copy_ctor(*result); + zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(retval); } } - break; } - case IS_ARRAY: - convert_to_array(result); - break; - case IS_OBJECT: - convert_to_object(result); - break; - } + } while (0); + CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - USE_OPLINE - zend_op_array *new_op_array=NULL; - - zval *inc_filename; - zval *tmp_inc_filename = NULL; - zend_bool failure_retval=0; - - SAVE_OPLINE(); - inc_filename = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); + return zend_pre_incdec_property_helper_SPEC_CV_CV(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +} - if (inc_filename->type!=IS_STRING) { - MAKE_STD_ZVAL(tmp_inc_filename); - ZVAL_COPY_VALUE(tmp_inc_filename, inc_filename); - zval_copy_ctor(tmp_inc_filename); - convert_to_string(tmp_inc_filename); - inc_filename = tmp_inc_filename; - } +static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + return zend_pre_incdec_property_helper_SPEC_CV_CV(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +} - if (opline->extended_value != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRLEN_P(inc_filename)) { - if (opline->extended_value == ZEND_INCLUDE_ONCE || opline->extended_value == ZEND_INCLUDE) { - zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC); - } else { - zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC); - } - } else { - switch (opline->extended_value) { - case ZEND_INCLUDE_ONCE: - case ZEND_REQUIRE_ONCE: { - zend_file_handle file_handle; - char *resolved_path; +static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE - resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename) TSRMLS_CC); - if (resolved_path) { - failure_retval = zend_hash_exists(&EG(included_files), resolved_path, strlen(resolved_path)+1); - } else { - resolved_path = Z_STRVAL_P(inc_filename); - } + zval *object; + zval *property; + zval *retval; + zval *zptr; - if (failure_retval) { - /* do nothing, file already included */ - } else if (SUCCESS == zend_stream_open(resolved_path, &file_handle TSRMLS_CC)) { + SAVE_OPLINE(); + object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var); + property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + retval = EX_VAR(opline->result.var); - if (!file_handle.opened_path) { - file_handle.opened_path = estrdup(resolved_path); - } + if (IS_CV == IS_VAR && UNEXPECTED(object == NULL)) { + zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); - if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1)==SUCCESS) { - new_op_array = zend_compile_file(&file_handle, (opline->extended_value==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) TSRMLS_CC); - zend_destroy_file_handle(&file_handle TSRMLS_CC); - } else { - zend_file_handle_dtor(&file_handle TSRMLS_CC); - failure_retval=1; - } - } else { - if (opline->extended_value == ZEND_INCLUDE_ONCE) { - zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC); - } else { - zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC); - } - } - if (resolved_path != Z_STRVAL_P(inc_filename)) { - efree(resolved_path); - } - } - break; - case ZEND_INCLUDE: - case ZEND_REQUIRE: - new_op_array = compile_filename(opline->extended_value, inc_filename TSRMLS_CC); - break; - case ZEND_EVAL: { - char *eval_desc = zend_make_compiled_string_description("eval()'d code" TSRMLS_CC); - new_op_array = zend_compile_string(inc_filename, eval_desc TSRMLS_CC); - efree(eval_desc); - } - break; - EMPTY_SWITCH_DEFAULT_CASE() - } - } - if (tmp_inc_filename) { - zval_ptr_dtor(&tmp_inc_filename); + HANDLE_EXCEPTION(); } - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } else if (EXPECTED(new_op_array != NULL)) { - EX(original_return_value) = EG(return_value_ptr_ptr); - EG(active_op_array) = new_op_array; - if (RETURN_VALUE_USED(opline)) { - EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; - EG(return_value_ptr_ptr) = EX_T(opline->result.var).var.ptr_ptr; - } else { - EG(return_value_ptr_ptr) = NULL; + do { + if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + ZVAL_DEREF(object); + if (UNEXPECTED(!make_real_object(object))) { + zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + ZVAL_NULL(retval); + break; + } } - EX(function_state).function = (zend_function *) new_op_array; - EX(object) = NULL; + /* here we are sure we are dealing with an object */ - if (!EG(active_symbol_table)) { - zend_rebuild_symbol_table(TSRMLS_C); - } + if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) { - if (EXPECTED(zend_execute_ex == execute_ex)) { - ZEND_VM_ENTER(); + ZVAL_DEREF(zptr); + ZVAL_COPY_VALUE(retval, zptr); + zval_opt_copy_ctor(zptr); - + incdec_op(zptr); } else { - zend_execute(new_op_array TSRMLS_CC); - } + if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval rv; - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv); ++ zval rv, obj; ++ zval *z; + - EX(function_state).function = (zend_function *) EX(op_array); ++ ZVAL_COPY(&obj, object); ++ z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv); + zval z_copy; - EG(opline_ptr) = &EX(opline); - EG(active_op_array) = EX(op_array); - EG(return_value_ptr_ptr) = EX(original_return_value); - destroy_op_array(new_op_array TSRMLS_CC); - efree(new_op_array); - if (UNEXPECTED(EG(exception) != NULL)) { - zend_throw_exception_internal(NULL TSRMLS_CC); - HANDLE_EXCEPTION(); + if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv); - + if (Z_REFCOUNT_P(z) == 0) { + zend_objects_store_del(Z_OBJ_P(z)); + } + ZVAL_COPY_VALUE(z, value); + } + ZVAL_DUP(retval, z); + ZVAL_DUP(&z_copy, z); + incdec_op(&z_copy); + if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); - Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ Z_OBJ_HT(obj)->write_property(&obj, property, &z_copy, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ zval_ptr_dtor(&obj); + zval_ptr_dtor(&z_copy); + zval_ptr_dtor(z); + } else { + zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + ZVAL_NULL(retval); + } } + } while (0); - } else if (RETURN_VALUE_USED(opline)) { - zval *retval; - ALLOC_ZVAL(retval); - ZVAL_BOOL(retval, failure_retval); - INIT_PZVAL(retval); - EX_T(opline->result.var).var.ptr = retval; - } + CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@@ -32941,102 -33390,95 +33005,104 @@@ static int ZEND_FASTCALL ZEND_BW_XOR_S ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE + zend_free_op free_op2; - array_init(&EX_T(opline->result.var).tmp_var); - if (IS_CV == IS_UNUSED) { - ZEND_VM_NEXT_OPCODE(); -#if 0 || IS_CV != IS_UNUSED - } else { - return ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -#endif - } + SAVE_OPLINE(); + boolean_xor_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var), + _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2)); + + zval_ptr_dtor_nogc(free_op2); + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_TMPVAR(int (*binary_op)(zval *result, zval *op1, zval *op2), ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval tmp, *varname; - HashTable *target_symbol_table; + zend_free_op free_op2, free_op_data1; + zval *object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var); + zval *property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); + zval *value; + zval *zptr; + if (IS_CV == IS_VAR && UNEXPECTED(object == NULL)) { + zend_error(E_EXCEPTION | E_ERROR, "Cannot use string offset as an object"); + FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var); + zval_ptr_dtor_nogc(free_op2); - SAVE_OPLINE(); - if (IS_CV == IS_CV && - IS_CONST == IS_UNUSED && - (opline->extended_value & ZEND_QUICK_SET)) { - if (EG(active_symbol_table)) { - zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); + HANDLE_EXCEPTION(); + } + + do { + value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); - zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC); - EX_CV(opline->op1.var) = NULL; - } else if (EX_CV(opline->op1.var)) { - zval_ptr_dtor(EX_CV(opline->op1.var)); - EX_CV(opline->op1.var) = NULL; + if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + ZVAL_DEREF(object); + if (UNEXPECTED(!make_real_object(object))) { + zend_error(E_WARNING, "Attempt to assign property of non-object"); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } + break; + } } - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); - } - varname = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); + /* here we are sure we are dealing with an object */ + if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) { - if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { - ZVAL_COPY_VALUE(&tmp, varname); - zval_copy_ctor(&tmp); - convert_to_string(&tmp); - varname = &tmp; - } else if (IS_CV == IS_VAR || IS_CV == IS_CV) { - Z_ADDREF_P(varname); - } + ZVAL_DEREF(zptr); + SEPARATE_ZVAL_NOREF(zptr); - if (IS_CONST != IS_UNUSED) { - zend_class_entry *ce; + binary_op(zptr, zptr, value); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), zptr); + } + } else { + zval *z; - zval rv; ++ zval rv, obj; - if (Z_OBJ_HT_P(object)->read_property && - (z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv)) != NULL) { - if (IS_CONST == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); - } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); - if (UNEXPECTED(EG(exception) != NULL)) { - if (IS_CV != IS_CONST && varname == &tmp) { - zval_dtor(&tmp); - } else if (IS_CV == IS_VAR || IS_CV == IS_CV) { - zval_ptr_dtor(&varname); - } ++ ZVAL_COPY(&obj, object); ++ if (Z_OBJ_HT(obj)->read_property && ++ (z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv)) != NULL) { + if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv); - HANDLE_EXCEPTION(); + if (Z_REFCOUNT_P(z) == 0) { + zend_objects_store_del(Z_OBJ_P(z)); + } + ZVAL_COPY_VALUE(z, value); } - if (UNEXPECTED(ce == NULL)) { - zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv)); + zptr = z; + ZVAL_DEREF(z); + SEPARATE_ZVAL_NOREF(z); + binary_op(z, z, value); - Z_OBJ_HT_P(object)->write_property(object, property, z, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ Z_OBJ_HT(obj)->write_property(&obj, property, z, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ zval_ptr_dtor(&obj); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), z); + } + zval_ptr_dtor(zptr); + } else { + zend_error(E_WARNING, "Attempt to assign property of non-object"); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); } - CACHE_PTR(opline->op2.literal->cache_slot, ce); } - } else { - ce = EX_T(opline->op2.var).class_entry; } - zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); - } else { - ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1); - - target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); - zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC); - } + } while (0); - if (IS_CV != IS_CONST && varname == &tmp) { - zval_dtor(&tmp); - } else if (IS_CV == IS_VAR || IS_CV == IS_CV) { - zval_ptr_dtor(&varname); - } + FREE_OP(free_op_data1); + zval_ptr_dtor_nogc(free_op2); + /* assign_obj has two opcodes! */ CHECK_EXCEPTION(); + ZEND_VM_INC_OPCODE(); ZEND_VM_NEXT_OPCODE(); } @@@ -33402,45 -33754,70 +33468,49 @@@ static int ZEND_FASTCALL zend_pre_incde } } - } else if (Z_TYPE_P(container) == IS_OBJECT) { - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - if (prop_dim) { - if (Z_OBJ_HT_P(container)->has_property) { - result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check property of non-object"); - result = 0; - } - } else { - if (Z_OBJ_HT_P(container)->has_dimension) { - result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check element of non-array"); - result = 0; + /* here we are sure we are dealing with an object */ + + if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) { + + ZVAL_DEREF(zptr); + SEPARATE_ZVAL_NOREF(zptr); + + incdec_op(zptr); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(retval, zptr); } - } - if (0) { - zval_ptr_dtor(&offset); } else { + zval rv; - } - } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */ - zval tmp; + if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv); ++ zval *z, obj; + - if (Z_TYPE_P(offset) != IS_LONG) { - if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */ - || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ - && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { - ZVAL_COPY_VALUE(&tmp, offset); - zval_copy_ctor(&tmp); - convert_to_long(&tmp); - offset = &tmp; - } else { - /* can not be converted to proper offset, return "not set" */ - result = 0; - } - } - if (Z_TYPE_P(offset) == IS_LONG) { - if (opline->extended_value & ZEND_ISSET) { - if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { - result = 1; ++ ZVAL_COPY(&obj, object); ++ z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv); + + if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv); + + if (Z_REFCOUNT_P(z) == 0) { + zend_objects_store_del(Z_OBJ_P(z)); + } + ZVAL_COPY_VALUE(z, value); } - } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { - if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') { - result = 1; + ZVAL_DEREF(z); + SEPARATE_ZVAL_NOREF(z); + incdec_op(z); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(retval, z); + } - Z_OBJ_HT_P(object)->write_property(object, property, z, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ Z_OBJ_HT(obj)->write_property(&obj, property, z, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ zval_ptr_dtor(&obj); + zval_ptr_dtor(z); + } else { + zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(retval); } } } @@@ -33452,160 -33837,185 +33522,162 @@@ ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + return zend_pre_incdec_property_helper_SPEC_CV_TMPVAR(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } -static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + return zend_pre_incdec_property_helper_SPEC_CV_TMPVAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } -static int ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_TMPVAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE + zend_free_op free_op2; + zval *object; + zval *property; + zval *retval; + zval *zptr; - /* The generator object is stored in return_value_ptr_ptr */ - zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr); - - if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) { - zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator"); - } + SAVE_OPLINE(); + object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var); + property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); + retval = EX_VAR(opline->result.var); - /* Destroy the previously yielded value */ - if (generator->value) { - zval_ptr_dtor(&generator->value); - } + if (IS_CV == IS_VAR && UNEXPECTED(object == NULL)) { + zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); + zval_ptr_dtor_nogc(free_op2); - /* Destroy the previously yielded key */ - if (generator->key) { - zval_ptr_dtor(&generator->key); + HANDLE_EXCEPTION(); } - /* Set the new yielded value */ - if (IS_CV != IS_UNUSED) { + do { + if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + ZVAL_DEREF(object); + if (UNEXPECTED(!make_real_object(object))) { + zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + ZVAL_NULL(retval); + break; + } + } + /* here we are sure we are dealing with an object */ - if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) { - /* Constants and temporary variables aren't yieldable by reference, - * but we still allow them with a notice. */ - if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) { - zval *value, *copy; + if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) { - zend_error(E_NOTICE, "Only variable references should be yielded by reference"); + ZVAL_DEREF(zptr); + ZVAL_COPY_VALUE(retval, zptr); + zval_opt_copy_ctor(zptr); - + incdec_op(zptr); + } else { + if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval rv; - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv); ++ zval rv, obj; ++ zval *z; + - value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); ++ ZVAL_COPY(&obj, object); ++ z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv); + zval z_copy; - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); + if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv); - + if (Z_REFCOUNT_P(z) == 0) { + zend_objects_store_del(Z_OBJ_P(z)); + } + ZVAL_COPY_VALUE(z, value); } - - generator->value = copy; + ZVAL_DUP(retval, z); + ZVAL_DUP(&z_copy, z); + incdec_op(&z_copy); + if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); - Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ Z_OBJ_HT(obj)->write_property(&obj, property, &z_copy, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); ++ zval_ptr_dtor(&obj); + zval_ptr_dtor(&z_copy); + zval_ptr_dtor(z); } else { - zval **value_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + ZVAL_NULL(retval); + } + } + } while (0); - if (IS_CV == IS_VAR && UNEXPECTED(value_ptr == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference"); - } + zval_ptr_dtor_nogc(free_op2); - /* If a function call result is yielded and the function did - * not return by reference we throw a notice. */ - if (IS_CV == IS_VAR && !Z_ISREF_PP(value_ptr) - && !(opline->extended_value == ZEND_RETURNS_FUNCTION - && EX_T(opline->op1.var).var.fcall_returned_reference) - && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) { - zend_error(E_NOTICE, "Only variable references should be yielded by reference"); + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; - } else { - SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr); - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; - } +static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + return zend_post_incdec_property_helper_SPEC_CV_TMPVAR(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +} - } - } else { - zval *value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); +static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + return zend_post_incdec_property_helper_SPEC_CV_TMPVAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +} - /* Consts, temporary variables and references need copying */ - if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR - || PZVAL_IS_REF(value) - ) { - zval *copy; +static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_free_op free_op2; + zval *container; - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); + SAVE_OPLINE(); + container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR)); + zval_ptr_dtor_nogc(free_op2); - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} - generator->value = copy; +static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_free_op free_op1, free_op2; + zval *container; - } else { - if (IS_CV == IS_CV) { - Z_ADDREF_P(value); - } - generator->value = value; - } - } - } else { - /* If no value was specified yield null */ - Z_ADDREF(EG(uninitialized_zval)); - generator->value = &EG(uninitialized_zval); - } - - /* Set the new yielded key */ - if (IS_CONST != IS_UNUSED) { - - zval *key = opline->op2.zv; - - /* Consts, temporary variables and references need copying */ - if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR - || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, key); - - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } - - generator->key = copy; - } else { - Z_ADDREF_P(key); - generator->key = key; - } - - if (Z_TYPE_P(generator->key) == IS_LONG - && Z_LVAL_P(generator->key) > generator->largest_used_integer_key - ) { - generator->largest_used_integer_key = Z_LVAL_P(generator->key); - } + SAVE_OPLINE(); + container = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var); - } else { - /* If no key was specified we use auto-increment keys */ - generator->largest_used_integer_key++; + if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { + zend_error(E_EXCEPTION | E_ERROR, "Cannot use string offset as an array"); - ALLOC_INIT_ZVAL(generator->key); - ZVAL_LONG(generator->key, generator->largest_used_integer_key); + HANDLE_EXCEPTION(); } - - if (RETURN_VALUE_USED(opline)) { - /* If the return value of yield is used set the send - * target and initialize it to NULL */ - generator->send_target = &EX_T(opline->result.var).var.ptr; - Z_ADDREF(EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - } else { - generator->send_target = NULL; + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR)); + zval_ptr_dtor_nogc(free_op2); + if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) { + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - /* We increment to the next op, so we are at the correct position when the - * generator is resumed. */ - ZEND_VM_INC_OPCODE(); - - /* The GOTO VM uses a local opline variable. We need to set the opline - * variable in execute_data so we don't resume at an old position. */ - SAVE_OPLINE(); - - ZEND_VM_RETURN(); + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_POW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - + zend_free_op free_op1, free_op2; + zval *container; SAVE_OPLINE(); - pow_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - opline->op2.zv TSRMLS_CC); + container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var); + + if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { + zend_error(E_EXCEPTION | E_ERROR, "Cannot use string offset as an array"); + HANDLE_EXCEPTION(); + } + zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR)); + zval_ptr_dtor_nogc(free_op2); + if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) { + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); + } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE();