From: Xinchen Hui Date: Tue, 10 Mar 2015 09:18:54 +0000 (+0800) Subject: Merge branch 'PHP-5.6' X-Git-Tag: PRE_PHP7_NSAPI_REMOVAL~721 X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=0714e027d01842bcefabca0b6b4ff1dfa757662c;p=php Merge branch 'PHP-5.6' --- 0714e027d01842bcefabca0b6b4ff1dfa757662c diff --cc Zend/zend_vm_def.h index 114e67e8dd,efd98d133e..9958e18cfb --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@@ -380,54 -375,61 +380,55 @@@ 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, obj; + - ZVAL_COPY(&obj, object); ++ ZVAL_OBJ(&obj, Z_OBJ_P(object)); ++ Z_ADDREF(obj); + 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); } - 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(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)); } } - zval_ptr_dtor(&object); - } - - if (IS_OP2_TMP_FREE()) { - zval_ptr_dtor(&property); - } else { - FREE_OP2(); ++ OBJ_RELEASE(Z_OBJ(obj)); } - FREE_OP(free_op_data1); - } + } while (0); + FREE_OP(free_op_data1); + FREE_OP2(); FREE_OP1_VAR_PTR(); /* assign_obj has two opcodes! */ CHECK_EXCEPTION(); @@@ -768,84 -586,95 +769,85 @@@ 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, obj; + - ZVAL_COPY(&obj, object); ++ ZVAL_OBJ(&obj, Z_OBJ_P(object)); ++ Z_ADDREF(obj); + 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(obj)->write_property(&obj, property, z, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); - zval_ptr_dtor(&obj); ++ OBJ_RELEASE(Z_OBJ(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(); @@@ -868,72 -697,88 +870,73 @@@ 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); - - incdec_op(*zptr); - + 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; + } } - } - if (!have_get_ptr) { - if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z, *z_copy; + /* here we are sure we are dealing with an object */ - 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); + 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 (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); - zval_dtor(z); - FREE_ZVAL(z); - } - 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); + ZVAL_DEREF(zptr); + ZVAL_COPY_VALUE(retval, zptr); + zval_opt_copy_ctor(zptr); + incdec_op(zptr); } else { - zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); - ZVAL_NULL(retval); + if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { + zval rv, obj; + zval *z; + - ZVAL_COPY(&obj, object); ++ ZVAL_OBJ(&obj, Z_OBJ_P(object)); ++ Z_ADDREF(obj); + 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 (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(obj)->write_property(&obj, property, &z_copy, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); - zval_ptr_dtor(&obj); ++ OBJ_RELEASE(Z_OBJ(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 7a1bd2d225,e9c7f51849..3f2cb215b2 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@@ -13266,89 -12888,50 +13266,90 @@@ 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, obj; + - ZVAL_COPY(&obj, object); ++ ZVAL_OBJ(&obj, Z_OBJ_P(object)); ++ Z_ADDREF(obj); + 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(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)); + } + } ++ OBJ_RELEASE(Z_OBJ(obj)); + } + } 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(); } @@@ -13459,453 -13021,378 +13460,455 @@@ 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, obj; + - ZVAL_COPY(&obj, object); ++ ZVAL_OBJ(&obj, Z_OBJ_P(object)); ++ Z_ADDREF(obj); + 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(obj)->write_property(&obj, property, z, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); - zval_ptr_dtor(&obj); ++ OBJ_RELEASE(Z_OBJ(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, obj; + zval *z; - ZVAL_COPY(&obj, object); - 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_OBJ(&obj, Z_OBJ_P(object)); ++ Z_ADDREF(obj); + 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(obj)->write_property(&obj, property, &z_copy, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); - zval_ptr_dtor(&obj); ++ OBJ_RELEASE(Z_OBJ(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(); } @@@ -16187,258 -15529,253 +16190,259 @@@ 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); - zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_CONST, BP_VAR_W TSRMLS_CC); + /* 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); - 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; + if (IS_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) { + zend_error(E_EXCEPTION | E_ERROR, "Cannot yield string offsets by reference"); - 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; + zval_ptr_dtor_nogc(free_op1); + HANDLE_EXCEPTION(); } - } 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); + + /* 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); + } + 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, obj; + - ZVAL_COPY(&obj, object); ++ ZVAL_OBJ(&obj, Z_OBJ_P(object)); ++ Z_ADDREF(obj); + 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); - 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); + } + zptr = z; + ZVAL_DEREF(z); + SEPARATE_ZVAL_NOREF(z); + binary_op(z, z, value); + 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)); + } + } ++ OBJ_RELEASE(Z_OBJ(obj)); + } + } 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(); } @@@ -16773,84 -16283,124 +16777,85 @@@ 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, obj; - ZVAL_COPY(&obj, object); - if (IS_CONST != IS_UNUSED) { - zend_class_entry *ce; ++ ZVAL_OBJ(&obj, Z_OBJ_P(object)); ++ Z_ADDREF(obj); + 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(obj)->write_property(&obj, property, z, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); - zval_ptr_dtor(&obj); ++ OBJ_RELEASE(Z_OBJ(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(); } @@@ -16896,48 -16460,84 +16901,49 @@@ 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, obj; + zval *z; - ZVAL_COPY(&obj, object); - } - } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */ - zval tmp; ++ ZVAL_OBJ(&obj, Z_OBJ_P(object)); ++ Z_ADDREF(obj); + 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(obj)->write_property(&obj, property, &z_copy, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); - zval_ptr_dtor(&obj); ++ OBJ_RELEASE(Z_OBJ(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(); } @@@ -18032,57 -17785,20 +18038,58 @@@ 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, obj; + - ZVAL_COPY(&obj, object); ++ ZVAL_OBJ(&obj, Z_OBJ_P(object)); ++ Z_ADDREF(obj); + 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(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)); + } + } ++ OBJ_RELEASE(Z_OBJ(obj)); } - } + } 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(); } @@@ -18195,397 -17882,376 +18202,399 @@@ 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, obj; - ZVAL_COPY(&obj, object); - 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_OBJ(&obj, Z_OBJ_P(object)); ++ Z_ADDREF(obj); + 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(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); ++ OBJ_RELEASE(Z_OBJ(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); + /* 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); + ZVAL_COPY_VALUE(retval, zptr); + zval_opt_copy_ctor(zptr); + incdec_op(zptr); } else { - call->called_scope = ce; - } - } + if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { + zval rv, obj; + zval *z; - ZVAL_COPY(&obj, 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 (IS_TMP_VAR == IS_CONST) { - function_name_strval = Z_STRVAL_P(opline->op2.zv); - function_name_strlen = Z_STRLEN_P(opline->op2.zv); - } else { - function_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - - 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_OBJ(&obj, Z_OBJ_P(object)); ++ Z_ADDREF(obj); + 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(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); ++ OBJ_RELEASE(Z_OBJ(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(); } @@@ -19553,55 -19154,62 +19562,56 @@@ 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, obj; + - ZVAL_COPY(&obj, object); ++ ZVAL_OBJ(&obj, Z_OBJ_P(object)); ++ Z_ADDREF(obj); + 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; + ZVAL_COPY_VALUE(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); + zptr = z; + ZVAL_DEREF(z); + SEPARATE_ZVAL_NOREF(z); + binary_op(z, z, value); + 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); } - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(z); - EX_T(opline->result.var).var.ptr = 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)); } } - zval_ptr_dtor(&object); ++ OBJ_RELEASE(Z_OBJ(obj)); } + } while (0); + + FREE_OP(free_op_data1); - if (0) { - zval_ptr_dtor(&property); - } else { - zval_ptr_dtor_nogc(&free_op2.var); - } - FREE_OP(free_op_data1); - } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; /* assign_obj has two opcodes! */ CHECK_EXCEPTION(); ZEND_VM_INC_OPCODE(); @@@ -19677,308 -19306,155 +19687,309 @@@ static int ZEND_FASTCALL zend_binary_as ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_VAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} +#if 0 || (IS_CONST != IS_UNUSED) + USE_OPLINE -static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_binary_assign_op_helper_SPEC_VAR_VAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_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_UNUSED_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_UNUSED_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_VAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} +#if 0 || (IS_CONST != IS_UNUSED) + USE_OPLINE -static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_binary_assign_op_helper_SPEC_VAR_VAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_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_UNUSED_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_UNUSED_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_VAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} +#if 0 || (IS_CONST != IS_UNUSED) + USE_OPLINE -static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_binary_assign_op_helper_SPEC_VAR_VAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(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_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_UNUSED_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_VAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} +#if 0 || (IS_CONST != IS_UNUSED) + USE_OPLINE -static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_binary_assign_op_helper_SPEC_VAR_VAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(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_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_UNUSED_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_VAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#if 0 || (IS_CONST != IS_UNUSED) + USE_OPLINE + +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(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_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_UNUSED_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_VAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#if 0 || (IS_CONST != IS_UNUSED) + USE_OPLINE + +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(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_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_UNUSED_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_VAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#if 0 || (IS_CONST != IS_UNUSED) + USE_OPLINE + +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_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_UNUSED_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_UNUSED_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_VAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 || (IS_CONST != IS_UNUSED) USE_OPLINE - zend_free_op free_op1, free_op2; - zval **object_ptr; - zval *object; - zval *property; - zval **retval; - int have_get_ptr = 0; - 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).var.ptr; +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_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_UNUSED_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_UNUSED_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif +} - if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); +static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || (IS_CONST != IS_UNUSED) + USE_OPLINE + +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(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_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_UNUSED_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif +} - make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ - object = *object_ptr; +static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || (IS_CONST != IS_UNUSED) + USE_OPLINE - 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); - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - *retval = &EG(uninitialized_zval); - } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - 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_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_UNUSED_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_UNUSED_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif +} - /* here we are sure we are dealing with an object */ +static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || (IS_CONST != IS_UNUSED) + USE_OPLINE - if (0) { - MAKE_REAL_ZVAL_PTR(property); +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(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_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_UNUSED_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif +} - 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 */ - SEPARATE_ZVAL_IF_NOT_REF(zptr); +static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE - have_get_ptr = 1; - incdec_op(*zptr); - if (RETURN_VALUE_USED(opline)) { - *retval = *zptr; - PZVAL_LOCK(*retval); + zval *object; + zval *property; + zval *retval; + zval *zptr; + + SAVE_OPLINE(); + object = _get_obj_zval_ptr_unused(execute_data); + property = EX_CONSTANT(opline->op2); + retval = EX_VAR(opline->result.var); + + if (IS_UNUSED == IS_VAR && UNEXPECTED(object == NULL)) { + zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); + + + HANDLE_EXCEPTION(); + } + + 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 (!have_get_ptr) { - if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z; + /* here we are sure we are dealing with an object */ - 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 (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; + incdec_op(zptr); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(retval, 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_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 rv; + + if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { + zval *z, obj; + - ZVAL_COPY(&obj, object); ++ ZVAL_OBJ(&obj, Z_OBJ_P(object)); ++ Z_ADDREF(obj); + 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(obj)->write_property(&obj, property, z, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); - zval_ptr_dtor(&obj); ++ OBJ_RELEASE(Z_OBJ(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); + - 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(); } @@@ -20000,72 -19477,88 +20011,73 @@@ static int ZEND_FASTCALL zend_post_incd 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; - - if (IS_VAR == 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; + object = _get_obj_zval_ptr_unused(execute_data); + property = EX_CONSTANT(opline->op2); + 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"); - 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(); - } + if (IS_UNUSED == IS_VAR && UNEXPECTED(object == NULL)) { + zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); - /* here we are sure we are dealing with an object */ - if (0) { - 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_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); - - ZVAL_COPY_VALUE(retval, *zptr); - zendi_zval_copy_ctor(*retval); + 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; + } + } - 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, ((IS_CONST == 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, obj; + zval *z; - ZVAL_COPY(&obj, object); - 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); ++ ZVAL_OBJ(&obj, Z_OBJ_P(object)); ++ Z_ADDREF(obj); + 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 (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_DUP(retval, z); + ZVAL_DUP(&z_copy, z); + incdec_op(&z_copy); + if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); + 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); ++ OBJ_RELEASE(Z_OBJ(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); } - 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(); } @@@ -21382,494 -21508,387 +21394,495 @@@ 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(); +} +static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + zval *array; + uint32_t size; + USE_OPLINE + + array = EX_VAR(opline->result.var); if (IS_UNUSED != IS_UNUSED) { - zend_class_entry *ce; + size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; + } else { + size = 0; + } + ZVAL_NEW_ARR(array); + zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); - 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; + 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); } - 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); + } + + if (IS_UNUSED == IS_UNUSED) { + ZEND_VM_NEXT_OPCODE(); +#if 0 || (IS_UNUSED != IS_UNUSED) } 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)); - } - - 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; - } + 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, obj; + - ZVAL_COPY(&obj, object); ++ ZVAL_OBJ(&obj, Z_OBJ_P(object)); ++ Z_ADDREF(obj); + 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(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)); + } } ++ OBJ_RELEASE(Z_OBJ(obj)); } - 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(); @@@ -21944,394 -22019,460 +21957,396 @@@ 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, obj; - ZVAL_COPY(&obj, object); - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); ++ ZVAL_OBJ(&obj, Z_OBJ_P(object)); ++ Z_ADDREF(obj); + 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(obj)->write_property(&obj, property, z, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); - zval_ptr_dtor(&obj); ++ OBJ_RELEASE(Z_OBJ(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); - } - 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; + HANDLE_EXCEPTION(); } - /* We increment to the next op, so we are at the correct position when the - * generator is resumed. */ - ZEND_VM_INC_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; + } + } - /* 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(); + /* here we are sure we are dealing with an object */ - ZEND_VM_RETURN(); -} + 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)) { -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_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, obj; + zval *z; - ZVAL_COPY(&obj, object); -static int ZEND_FASTCALL ZEND_ADD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zend_free_op free_op1; ++ ZVAL_OBJ(&obj, Z_OBJ_P(object)); ++ Z_ADDREF(obj); + 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 (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(obj)->write_property(&obj, property, &z_copy, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); - zval_ptr_dtor(&obj); ++ OBJ_RELEASE(Z_OBJ(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(); @@@ -23070,226 -23278,215 +23085,227 @@@ isset_no_object ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_free_op free_op1; - zval *container; - 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_IS TSRMLS_CC); + /* The generator object is stored in EX(return_value) */ + zend_generator *generator = (zend_generator *) EX(return_value); - zval_ptr_dtor_nogc(&free_op1.var); - 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_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zend_free_op free_op1; - SAVE_OPLINE(); + HANDLE_EXCEPTION(); + } - 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"); - } - 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); - if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); - } + /* Destroy the previously yielded value */ + zval_ptr_dtor(&generator->value); - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - } else { - zval *container; + /* Destroy the previously yielded key */ + zval_ptr_dtor(&generator->key); - if (IS_CV == 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, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC); + /* Set the new yielded value */ + if (IS_UNUSED != IS_UNUSED) { - zval_ptr_dtor_nogc(&free_op1.var); - } - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); -} -static int ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zend_free_op free_op1; - zval **container; + 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; - SAVE_OPLINE(); - container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + zend_error(E_NOTICE, "Only variable references should be yielded by reference"); - if (IS_VAR == IS_CV) { - if (container != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(container); - } - } - 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_UNSET 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 && (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 (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); - ZEND_VM_NEXT_OPCODE(); - } else { - zend_free_op free_res; - zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; + /* Temporary variables don't need ctor copying */ + if (IS_UNUSED != IS_TMP_VAR) { + zval_opt_copy_ctor(&generator->value); + } + } else { + zval *value_ptr = NULL; - PZVAL_UNLOCK(*retval_ptr, &free_res); - if (retval_ptr != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(retval_ptr); - } - PZVAL_LOCK(*retval_ptr); - FREE_OP_VAR_PTR(free_res); - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); - } -} + if (IS_UNUSED == IS_VAR && UNEXPECTED(value_ptr == NULL)) { + zend_error(E_EXCEPTION | E_ERROR, "Cannot yield string offsets by reference"); -static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_CV(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zend_free_op free_op1; - zval *container; - zval *offset; + HANDLE_EXCEPTION(); + } - SAVE_OPLINE(); - container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); + /* 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); - if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || - UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { - zend_error(E_NOTICE, "Trying to get property of non-object"); - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + } + } else { + zval *value = NULL; - } else { - zval *retval; + /* 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 (0) { - MAKE_REAL_ZVAL_PTR(offset); + } 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); + } - /* here we are sure we are dealing with an object */ - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + /* Set the new yielded key */ + if (IS_CV != IS_UNUSED) { + + zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); - PZVAL_LOCK(retval); - EX_T(opline->result.var).var.ptr = retval; + /* 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)); - if (0) { - zval_ptr_dtor(&offset); } 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); } - zval_ptr_dtor_nogc(&free_op1.var); - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); -} + 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; + } -static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_fetch_property_address_read_helper_SPEC_VAR_CV(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(); + + /* 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_OBJ_W_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 *property; - 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(); - property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var 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 (0) { - MAKE_REAL_ZVAL_PTR(property); - } - 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 object"); + HANDLE_EXCEPTION(); } - 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 { + do { + value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); - } - 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_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; + } + } - /* 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; + /* 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)) { - 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; - } + ZVAL_DEREF(zptr); + SEPARATE_ZVAL_NOREF(zptr); - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); -} + binary_op(zptr, zptr, value); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), zptr); + } + } else { + zval *z; + zval rv, obj; - ZVAL_COPY(&obj, object); -static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zend_free_op free_op1; - zval *property; - zval **container; ++ ZVAL_OBJ(&obj, Z_OBJ_P(object)); ++ Z_ADDREF(obj); + 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); - 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 (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(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)); + } + } ++ OBJ_RELEASE(Z_OBJ(obj)); + } + } while (0); - 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_RW TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property); - } else { + FREE_OP(free_op_data1); + zval_ptr_dtor_nogc(free_op2); - } - 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);}; + /* assign_obj has two opcodes! */ CHECK_EXCEPTION(); + ZEND_VM_INC_OPCODE(); ZEND_VM_NEXT_OPCODE(); } @@@ -23363,396 -23532,246 +23379,398 @@@ static int ZEND_FASTCALL zend_binary_as 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_ASSIGN_ADD_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 || ((IS_TMP_VAR|IS_VAR) != 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; - zval *property; - zval **container; +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_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_UNUSED_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_UNUSED_TMPVAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_TMPVAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif +} - 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); +static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) + USE_OPLINE - 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 { +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_TMPVAR(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_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_UNUSED_TMPVAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_TMPVAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif +} - } - 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_ASSIGN_MUL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) + USE_OPLINE + +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_TMPVAR(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_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_UNUSED_TMPVAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_TMPVAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) USE_OPLINE - zend_free_op free_op1, free_res; - zval **container; - zval *property; - 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); +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_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_UNUSED_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_UNUSED_TMPVAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_TMPVAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif +} - if (IS_VAR == IS_CV) { - if (container != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(container); - } +static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) + USE_OPLINE + +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_TMPVAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } - if (0) { - MAKE_REAL_ZVAL_PTR(property); +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_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_UNUSED_TMPVAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_TMPVAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif +} + +static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) + USE_OPLINE + +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_TMPVAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } - 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 { +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_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_UNUSED_TMPVAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_TMPVAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif +} +static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) + USE_OPLINE + +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_TMPVAR(shift_right_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)); +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_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_UNUSED_TMPVAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_TMPVAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif +} + +static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) + USE_OPLINE - 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); +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_TMPVAR(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(); +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_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_UNUSED_TMPVAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_TMPVAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_UNUSED_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; - 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_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_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_UNUSED_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_UNUSED_TMPVAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_TMPVAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif +} - if (0) { - MAKE_REAL_ZVAL_PTR(property_name); +static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) + USE_OPLINE + +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_TMPVAR(bitwise_and_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_UNUSED_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_UNUSED_TMPVAR(bitwise_and_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_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property_name); - } else { +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_TMPVAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif +} + +static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) + USE_OPLINE +# if 0 || (IS_UNUSED != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_TMPVAR(bitwise_xor_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_UNUSED_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_UNUSED_TMPVAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_TMPVAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_TMPVAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_free_op free_op1; - zval **object_ptr; + zend_free_op free_op2; + zval *object; + zval *property; + zval *retval; + zval *zptr; SAVE_OPLINE(); - object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 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_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) { + 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); - zval *property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); + HANDLE_EXCEPTION(); + } - if (0) { - MAKE_REAL_ZVAL_PTR(property_name); + 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; + } } - 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_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property_name); - } else { - } - } else { - zend_free_op free_op_data1, free_op_data2; - zval *value; - zval *dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - zval **variable_ptr_ptr; + /* here we are sure we are dealing with an object */ - zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_CV, BP_VAR_W 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)) { - 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); + incdec_op(zptr); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(retval, 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 rv; + + if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { + zval *z, obj; + - ZVAL_COPY(&obj, object); ++ ZVAL_OBJ(&obj, Z_OBJ_P(object)); ++ Z_ADDREF(obj); + 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(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); ++ OBJ_RELEASE(Z_OBJ(obj)); + zval_ptr_dtor(z); } 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 increment/decrement property of non-object"); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(retval); + } } } - 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); + + zval_ptr_dtor_nogc(free_op2); + CHECK_EXCEPTION(); - ZEND_VM_INC_OPCODE(); ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + return zend_pre_incdec_property_helper_SPEC_UNUSED_TMPVAR(increment_function, 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_post_incdec_property_helper_SPEC_UNUSED_TMPVAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_free_op free_op1; - zval *value; - zval **variable_ptr_ptr; + zend_free_op free_op2; + zval *object; + zval *property; + zval *retval; + zval *zptr; SAVE_OPLINE(); - value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - variable_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 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_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) { - if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_CV TSRMLS_CC)) { - if (RETURN_VALUE_USED(opline)) { - zval *retval; + 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(); + } - 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; + 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; } - } 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); - } - } else { - if (IS_CV == IS_TMP_VAR) { - value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); - } else if (IS_CV == IS_CONST) { - value = zend_assign_const_to_variable(variable_ptr_ptr, value 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)) { + + ZVAL_DEREF(zptr); + ZVAL_COPY_VALUE(retval, zptr); + zval_opt_copy_ctor(zptr); + incdec_op(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; - } - } + if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { + zval rv, obj; + zval *z; - ZVAL_COPY(&obj, object); - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; ++ ZVAL_OBJ(&obj, Z_OBJ_P(object)); ++ Z_ADDREF(obj); + 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; - /* zend_assign_to_variable() always takes care of op2, never free it! */ + 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(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); ++ OBJ_RELEASE(Z_OBJ(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); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@@ -26346,57 -26723,98 +26364,58 @@@ 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_CONST == 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); - } - } - - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); -} - -static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE + zval *z; + zval rv, obj; - ZVAL_COPY(&obj, object); - 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; ++ ZVAL_OBJ(&obj, Z_OBJ_P(object)); ++ Z_ADDREF(obj); + 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); - 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)); + 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(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)); + } + } ++ OBJ_RELEASE(Z_OBJ(obj)); } + } while (0); - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); - } else { - return zend_fetch_property_address_read_helper_SPEC_UNUSED_TMP(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - } -} - -static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - 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); + FREE_OP(free_op_data1); - 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)); - } - 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); + /* assign_obj has two opcodes! */ CHECK_EXCEPTION(); + ZEND_VM_INC_OPCODE(); ZEND_VM_NEXT_OPCODE(); } @@@ -26507,302 -26893,353 +26526,303 @@@ static int ZEND_FASTCALL zend_binary_as ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 || (IS_CONST != IS_UNUSED) 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; - SAVE_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 +} - function_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); +static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || (IS_CONST != IS_UNUSED) + USE_OPLINE - 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 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); + } +# 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 +} - function_name_strval = Z_STRVAL_P(function_name); - function_name_strlen = Z_STRLEN_P(function_name); +static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || (IS_CONST != IS_UNUSED) + USE_OPLINE - call->object = _get_obj_zval_ptr_unused(TSRMLS_C); +# 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); + } +# 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 +} - 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_ASSIGN_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || (IS_CONST != IS_UNUSED) + USE_OPLINE - if (IS_TMP_VAR != IS_CONST || - (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) { - zval *object = call->object; +# 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); + } +# 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 +} - if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) { - zend_error_noreturn(E_ERROR, "Object does not support method calls"); - } +static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || (IS_CONST != IS_UNUSED) + USE_OPLINE - /* 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 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 ((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; - } +# 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); } +#else + return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif +} - call->num_additional_args = 0; - call->is_ctor_call = 0; - EX(call) = call; - - zval_dtor(free_op2.var); +static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || (IS_CONST != IS_UNUSED) + USE_OPLINE - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); +# 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); + } +# 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_INIT_ARRAY_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 - 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 +# 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_UNSET_DIM_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_op2; - zval **container; - zval *offset; - ulong hval; - 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); +# 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); + } +# 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); } - offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); +#else + return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif +} - if (IS_UNUSED != IS_VAR || container) { - switch (Z_TYPE_PP(container)) { - case IS_ARRAY: { - HashTable *ht = Z_ARRVAL_PP(container); +static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || (IS_CONST != IS_UNUSED) + USE_OPLINE - 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); - 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); +# 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); } - - 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(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); + } +#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_UNSET_OBJ_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 **container; - zval *offset; - - 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); - 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); - } else { - zval_dtor(free_op2.var); - } - } else { - zval_dtor(free_op2.var); - } - } 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(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 +} - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); +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 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); + } +# 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); + } +#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_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_TMP(int prop_dim, 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 - zend_free_op free_op2; - zval *container; - zval **value = NULL; - int result = 0; - ulong hval; - zval *offset; + + zval *object; + zval *property; + zval *retval; + zval *zptr; SAVE_OPLINE(); - container = _get_obj_zval_ptr_unused(TSRMLS_C); - 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 (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) { - HashTable *ht; - int isset = 0; + if (IS_CV == IS_VAR && UNEXPECTED(object == NULL)) { + zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); - ht = Z_ARRVAL_P(container); - switch (Z_TYPE_P(offset)) { - case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); - goto num_index_prop; - case IS_RESOURCE: - case IS_BOOL: - case IS_LONG: - hval = Z_LVAL_P(offset); -num_index_prop: - if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) { - isset = 1; - } - break; - case IS_STRING: - 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_prop); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); - } - if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) { - isset = 1; - } - break; - case IS_NULL: - if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) { - isset = 1; + 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"); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(retval); } break; - default: - zend_error(E_WARNING, "Illegal offset type in isset or empty"); - break; - } - - if (opline->extended_value & ZEND_ISSET) { - if (isset && Z_TYPE_PP(value) == IS_NULL) { - result = 0; - } else { - result = isset; - } - } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { - if (!isset || !i_zend_is_true(*value)) { - result = 0; - } else { - result = 1; } } - zval_dtor(free_op2.var); - } else if (Z_TYPE_P(container) == IS_OBJECT) { - if (1) { - 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_TMP_VAR == 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_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); } - } - if (1) { - zval_ptr_dtor(&offset); } else { - zval_dtor(free_op2.var); - } - } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */ - zval tmp; + zval rv; - 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; + if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { + zval *z, obj; + - ZVAL_COPY(&obj, object); ++ ZVAL_OBJ(&obj, Z_OBJ_P(object)); ++ Z_ADDREF(obj); + 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); } - } 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(obj)->write_property(&obj, property, z, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); - zval_ptr_dtor(&obj); ++ OBJ_RELEASE(Z_OBJ(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); } } } @@@ -26827,155 -27273,130 +26847,156 @@@ static int ZEND_FASTCALL zend_post_incd { USE_OPLINE - /* The generator object is stored in return_value_ptr_ptr */ - zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr); + zval *object; + zval *property; + zval *retval; + zval *zptr; - 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 = EX_CONSTANT(opline->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"); - /* Destroy the previously yielded key */ - if (generator->key) { - zval_ptr_dtor(&generator->key); + + HANDLE_EXCEPTION(); } - /* Set the new yielded value */ - if (IS_UNUSED != 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_UNUSED == IS_CONST || IS_UNUSED == 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_CONST == 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, obj; + zval *z; - ZVAL_COPY(&obj, object); - value = NULL; - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); ++ ZVAL_OBJ(&obj, Z_OBJ_P(object)); ++ Z_ADDREF(obj); + 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; - /* 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(obj)->write_property(&obj, property, &z_copy, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); - zval_ptr_dtor(&obj); ++ OBJ_RELEASE(Z_OBJ(obj)); + zval_ptr_dtor(&z_copy); + zval_ptr_dtor(z); } else { - zval **value_ptr = NULL; - - if (IS_UNUSED == IS_VAR && UNEXPECTED(value_ptr == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference"); - } + zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + ZVAL_NULL(retval); + } + } + } while (0); - /* If a function call result is yielded and the function did - * not return by reference we throw a notice. */ - if (IS_UNUSED == 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"); - 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; - } + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); +} - } - } else { - zval *value = NULL; +static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + return zend_post_incdec_property_helper_SPEC_CV_CONST(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +} - /* Consts, temporary variables and references need copying */ - if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR - || PZVAL_IS_REF(value) - ) { - zval *copy; +static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + return zend_post_incdec_property_helper_SPEC_CV_CONST(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +} - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); +static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_CONST(int type, ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } + zval *varname; + zval *retval; + zend_string *name; + HashTable *target_symbol_table; - generator->value = copy; + SAVE_OPLINE(); + varname = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var); - } else { - if (IS_UNUSED == IS_CV) { - Z_ADDREF_P(value); - } - generator->value = value; - } - } + if (IS_CV == IS_CONST) { + name = Z_STR_P(varname); + } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) { + name = Z_STR_P(varname); + zend_string_addref(name); } else { - /* If no value was specified yield null */ - Z_ADDREF(EG(uninitialized_zval)); - generator->value = &EG(uninitialized_zval); + name = zval_get_string(varname); } - /* Set the new yielded key */ - if (IS_TMP_VAR != IS_UNUSED) { - zend_free_op free_op2; - zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + if (IS_CONST != IS_UNUSED) { + zend_class_entry *ce; - /* Consts, temporary variables and references need copying */ - if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR - || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0) - ) { - zval *copy; + if (IS_CONST == IS_CONST) { + if (IS_CV == IS_CONST && CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)))) { - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, key); + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1))); + retval = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)) + sizeof(void*)); - /* Temporary variables don't need ctor copying */ - if (!1) { - zval_copy_ctor(copy); - } + /* check if static properties were destoyed */ + if (UNEXPECTED(CE_STATIC_MEMBERS(ce) == NULL)) { + zend_error_noreturn(E_ERROR, "Access to undeclared static property: %s::$%s", ce->name->val, name->val); + } + + goto fetch_var_return; + } else if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); + } else { + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, 0); + if (UNEXPECTED(ce == NULL)) { + if (IS_CV != IS_CONST) { + zend_string_release(name); + } - generator->key = copy; + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); + } + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce); + } } else { - Z_ADDREF_P(key); - generator->key = key; - } + ce = Z_CE_P(EX_VAR(opline->op2.var)); + if (IS_CV == IS_CONST && + (retval = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)), ce)) != NULL) { - 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); + /* check if static properties were destoyed */ + if (UNEXPECTED(CE_STATIC_MEMBERS(ce) == NULL)) { + zend_error_noreturn(E_ERROR, "Access to undeclared static property: %s::$%s", ce->name->val, name->val); + } + + goto fetch_var_return; + } + } + retval = zend_std_get_static_property(ce, name, 0); + if (IS_CV == IS_CONST && retval) { + CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)), ce, retval); } } else { @@@ -30877,89 -31725,54 +30898,90 @@@ static int ZEND_FASTCALL ZEND_BOOL_XOR ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CV(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 = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var); + zval *value; + zval *zptr; - zval *expr; - zend_bool result; + 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); - SAVE_OPLINE(); - expr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); - if (Z_TYPE_P(expr) == IS_OBJECT && Z_OBJ_HT_P(expr)->get_class_entry) { - result = instanceof_function(Z_OBJCE_P(expr), EX_T(opline->op2.var).class_entry TSRMLS_CC); - } else { - result = 0; + HANDLE_EXCEPTION(); } - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, result); - - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); -} -static int ZEND_FASTCALL ZEND_ADD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE + do { + value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); + 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; + } + } - SAVE_OPLINE(); - fast_add_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); + /* 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); - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); -} + binary_op(zptr, zptr, value); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), zptr); + } + } else { + zval *z; + zval rv, obj; - ZVAL_COPY(&obj, object); -static int ZEND_FASTCALL ZEND_SUB_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE ++ ZVAL_OBJ(&obj, Z_OBJ_P(object)); ++ Z_ADDREF(obj); + 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(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)); + } + } ++ OBJ_RELEASE(Z_OBJ(obj)); + } + } while (0); - SAVE_OPLINE(); - fast_sub_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); + FREE_OP(free_op_data1); + /* assign_obj has two opcodes! */ CHECK_EXCEPTION(); + ZEND_VM_INC_OPCODE(); ZEND_VM_NEXT_OPCODE(); } @@@ -31070,396 -31851,372 +31092,398 @@@ static int ZEND_FASTCALL zend_binary_as ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 || (IS_CV != IS_UNUSED) USE_OPLINE - - SAVE_OPLINE(); - concat_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); - - - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); +# if 0 || (IS_CV != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_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_CV_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_CV_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_CV_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 || (IS_CV != IS_UNUSED) USE_OPLINE - - SAVE_OPLINE(); - is_identical_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); - - - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); +# if 0 || (IS_CV != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_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_CV_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_CV_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 || (IS_CV != IS_UNUSED) USE_OPLINE - zval *result = &EX_T(opline->result.var).tmp_var; - - SAVE_OPLINE(); - is_identical_function(result, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - opline->op2.zv TSRMLS_CC); - Z_LVAL_P(result) = !Z_LVAL_P(result); - - - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); +# if 0 || (IS_CV != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_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_CV_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_CV_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_CV_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 || (IS_CV != IS_UNUSED) USE_OPLINE - zval *result = &EX_T(opline->result.var).tmp_var; - - SAVE_OPLINE(); - ZVAL_BOOL(result, fast_equal_function(result, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - opline->op2.zv TSRMLS_CC)); - - - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); +# if 0 || (IS_CV != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_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_CV_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_CV_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 || (IS_CV != IS_UNUSED) USE_OPLINE - zval *result = &EX_T(opline->result.var).tmp_var; - - SAVE_OPLINE(); - ZVAL_BOOL(result, fast_not_equal_function(result, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - opline->op2.zv TSRMLS_CC)); - - - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); +# if 0 || (IS_CV != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_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_CV_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_CV_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 || (IS_CV != IS_UNUSED) USE_OPLINE - zval *result = &EX_T(opline->result.var).tmp_var; - - SAVE_OPLINE(); - ZVAL_BOOL(result, fast_is_smaller_function(result, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - opline->op2.zv TSRMLS_CC)); - - - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); +# if 0 || (IS_CV != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_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_CV_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_CV_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_CV_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 || (IS_CV != IS_UNUSED) USE_OPLINE - zval *result = &EX_T(opline->result.var).tmp_var; - - SAVE_OPLINE(); - ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - opline->op2.zv TSRMLS_CC)); - - - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); +# if 0 || (IS_CV != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_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_CV_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_CV_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_CV_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 || (IS_CV != IS_UNUSED) USE_OPLINE - - SAVE_OPLINE(); - bitwise_or_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); - - - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); +# if 0 || (IS_CV != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_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_CV_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_CV_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 || (IS_CV != IS_UNUSED) USE_OPLINE - - SAVE_OPLINE(); - bitwise_and_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); - - - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); +# if 0 || (IS_CV != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_CV(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_CV_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_CV_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_CV_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 || (IS_CV != IS_UNUSED) USE_OPLINE - - SAVE_OPLINE(); - bitwise_xor_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); - - - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); +# if 0 || (IS_CV != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_CV(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_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_CV_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_CV_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 || (IS_CV != IS_UNUSED) USE_OPLINE - - SAVE_OPLINE(); - boolean_xor_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); - - - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); +# if 0 || (IS_CV != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_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_CV_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_CV_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_CV_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_free_op free_op_data1; - zval **object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); + zval *object; - zval *property = opline->op2.zv; - zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); - int have_get_ptr = 0; + zval *property; + zval *retval; + zval *zptr; - if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); - } + 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); - make_real_object(object_ptr TSRMLS_CC); - object = *object_ptr; + if (IS_CV == IS_VAR && UNEXPECTED(object == NULL)) { + zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); - if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { - zend_error(E_WARNING, "Attempt to assign property of non-object"); - FREE_OP(free_op_data1); + HANDLE_EXCEPTION(); + } - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + 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; + } } - } else { + /* here we are sure we are dealing with an object */ - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - /* here property is a string */ - if (opline->extended_value == ZEND_ASSIGN_OBJ - && 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_CONST == 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, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) { - have_get_ptr = 1; - binary_op(*zptr, *zptr, value TSRMLS_CC); - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(*zptr); - EX_T(opline->result.var).var.ptr = *zptr; - } + 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) { - zval *z = NULL; + if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { + zval *z, obj; - ZVAL_COPY(&obj, object); - 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_CONST == 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); - } - } - if (z) { - 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_OBJ(&obj, Z_OBJ_P(object)); ++ Z_ADDREF(obj); + 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) { - 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_CONST == 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); } - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(z); - EX_T(opline->result.var).var.ptr = z; + ZVAL_DEREF(z); + SEPARATE_ZVAL_NOREF(z); + incdec_op(z); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(retval, z); } - zval_ptr_dtor(&z); + 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); ++ OBJ_RELEASE(Z_OBJ(obj)); + zval_ptr_dtor(z); } 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); + zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(retval); } } - zval_ptr_dtor(&object); } + } while (0); - if (0) { - zval_ptr_dtor(&property); - } else { - - } - FREE_OP(free_op_data1); - } - /* assign_obj has two opcodes! */ CHECK_EXCEPTION(); - ZEND_VM_INC_OPCODE(); ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + return zend_pre_incdec_property_helper_SPEC_CV_CV(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +} + +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); +} + +static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_free_op free_op_data2, free_op_data1; - zval **var_ptr; - zval *value; + + zval *object; + zval *property; + zval *retval; + zval *zptr; SAVE_OPLINE(); - switch (opline->extended_value) { - case ZEND_ASSIGN_OBJ: - return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - break; - case ZEND_ASSIGN_DIM: { - zval **container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); - - if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); - } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) { - if (IS_CV == IS_VAR && !0) { - Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */ - } - return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - } else { - zval *dim = opline->op2.zv; + 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 (IS_CV == IS_VAR && UNEXPECTED(object == NULL)) { + zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); - zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_CONST, BP_VAR_RW TSRMLS_CC); - value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); - var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); - } - } - break; - default: - value = opline->op2.zv; - var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); - /* do nothing */ - break; - } - if (UNEXPECTED(var_ptr == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); + HANDLE_EXCEPTION(); } - if (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 { + 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 */ - CHECK_EXCEPTION(); - if (opline->extended_value == ZEND_ASSIGN_DIM) { - ZEND_VM_INC_OPCODE(); - } - ZEND_VM_NEXT_OPCODE(); - } - - SEPARATE_ZVAL_IF_NOT_REF(var_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 (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 *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); - Z_ADDREF_P(objval); - binary_op(objval, objval, value TSRMLS_CC); - Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC); - zval_ptr_dtor(&objval); - } else { - binary_op(*var_ptr, *var_ptr, value 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, obj; + zval *z; - ZVAL_COPY(&obj, object); - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(*var_ptr); - EX_T(opline->result.var).var.ptr = *var_ptr; - } ++ ZVAL_OBJ(&obj, Z_OBJ_P(object)); ++ Z_ADDREF(obj); + 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 (opline->extended_value == ZEND_ASSIGN_DIM) { - FREE_OP(free_op_data1); - FREE_OP_VAR_PTR(free_op_data2); + 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(obj)->write_property(&obj, property, &z_copy, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL)); - zval_ptr_dtor(&obj); ++ OBJ_RELEASE(Z_OBJ(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); - CHECK_EXCEPTION(); - ZEND_VM_INC_OPCODE(); - } else { - CHECK_EXCEPTION(); - } + CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@@ -33051,58 -33678,27 +33075,59 @@@ static int ZEND_FASTCALL zend_binary_as } } - if (IS_CV != IS_CONST && varname == &tmp) { - zval_dtor(&tmp); - } + /* 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); - 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); + binary_op(zptr, zptr, value); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), zptr); + } } else { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); + zval *z; + zval rv, obj; + - ZVAL_COPY(&obj, object); ++ ZVAL_OBJ(&obj, Z_OBJ_P(object)); ++ Z_ADDREF(obj); + 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(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)); + } + } ++ OBJ_RELEASE(Z_OBJ(obj)); } - } + } 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(); } @@@ -33215,308 -33837,185 +33240,309 @@@ static int ZEND_FASTCALL zend_binary_as 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_ASSIGN_ADD_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); -} +#if 0 || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) + USE_OPLINE -static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(1, 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_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_CV_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_CV_TMPVAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_CV_TMPVAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif } -static int ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 || ((IS_TMP_VAR|IS_VAR) != 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_CV != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_TMPVAR(sub_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_CV_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_CV_TMPVAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } +#else + return zend_binary_assign_op_dim_helper_SPEC_CV_TMPVAR(sub_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_MUL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) + USE_OPLINE + +# if 0 || (IS_CV != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_TMPVAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_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_CV_TMPVAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_CV_TMPVAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif +} - /* Set the new yielded value */ - if (IS_CV != IS_UNUSED) { +static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) + USE_OPLINE +# if 0 || (IS_CV != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_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_CV_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_CV_TMPVAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_CV_TMPVAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif +} - 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; +static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) + USE_OPLINE - zend_error(E_NOTICE, "Only variable references should be yielded by reference"); +# if 0 || (IS_CV != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_TMPVAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +# endif + if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_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_CV_TMPVAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_CV_TMPVAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif +} - value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); +static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) + USE_OPLINE - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } +# if 0 || (IS_CV != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_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_CV_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_CV_TMPVAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_CV_TMPVAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif +} - generator->value = copy; - } else { - zval **value_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); +static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) + USE_OPLINE - if (IS_CV == IS_VAR && UNEXPECTED(value_ptr == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference"); - } +# if 0 || (IS_CV != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_TMPVAR(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_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_CV_TMPVAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_CV_TMPVAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif +} - /* 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"); +static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) + USE_OPLINE - 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 0 || (IS_CV != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_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_CV_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_CV_TMPVAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_CV_TMPVAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif +} - } - } else { - zval *value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); +static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) + USE_OPLINE - /* Consts, temporary variables and references need copying */ - if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR - || PZVAL_IS_REF(value) - ) { - zval *copy; +# if 0 || (IS_CV != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_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_CV_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_CV_TMPVAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_CV_TMPVAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif +} - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); +static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) + USE_OPLINE - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } +# if 0 || (IS_CV != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_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_CV_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_CV_TMPVAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } +#else + return zend_binary_assign_op_dim_helper_SPEC_CV_TMPVAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif +} - generator->value = copy; +static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) + USE_OPLINE - } 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); +# if 0 || (IS_CV != IS_UNUSED) + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_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_CV_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_CV_TMPVAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } +#else + return zend_binary_assign_op_dim_helper_SPEC_CV_TMPVAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); +#endif +} - /* Set the new yielded key */ - if (IS_CONST != IS_UNUSED) { +static int ZEND_FASTCALL zend_pre_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; - zval *key = opline->op2.zv; + 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); - /* 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; + 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); - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, key); + HANDLE_EXCEPTION(); + } - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); + 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; } - - 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); - } - - } else { - /* If no key was specified we use auto-increment keys */ - generator->largest_used_integer_key++; - - ALLOC_INIT_ZVAL(generator->key); - ZVAL_LONG(generator->key, generator->largest_used_integer_key); - } + /* here we are sure we are dealing with an object */ - 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; - } + 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)) { - /* We increment to the next op, so we are at the correct position when the - * generator is resumed. */ - ZEND_VM_INC_OPCODE(); + ZVAL_DEREF(zptr); + SEPARATE_ZVAL_NOREF(zptr); - /* 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(); + incdec_op(zptr); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(retval, zptr); + } + } else { + zval rv; - ZEND_VM_RETURN(); -} + if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { + zval *z, obj; - ZVAL_COPY(&obj, object); -static int ZEND_FASTCALL ZEND_POW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE ++ ZVAL_OBJ(&obj, Z_OBJ_P(object)); ++ Z_ADDREF(obj); + 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); - 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); + 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(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); ++ OBJ_RELEASE(Z_OBJ(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); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@@ -33536,76 -34045,58 +33562,77 @@@ static int ZEND_FASTCALL zend_post_incd { USE_OPLINE zend_free_op free_op2; + zval *object; + zval *property; + zval *retval; + zval *zptr; SAVE_OPLINE(); - fast_sub_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + 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); - zval_dtor(free_op2.var); - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); -} + 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); -static int ZEND_FASTCALL ZEND_MUL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zend_free_op free_op2; + HANDLE_EXCEPTION(); + } - SAVE_OPLINE(); - fast_mul_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + 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; + } + } - 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_DIV_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - 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)) { - SAVE_OPLINE(); - fast_div_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) 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, obj; + zval *z; - ZVAL_COPY(&obj, object); - zval_dtor(free_op2.var); - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); -} ++ ZVAL_OBJ(&obj, Z_OBJ_P(object)); ++ Z_ADDREF(obj); + 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; -static int ZEND_FASTCALL ZEND_MOD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zend_free_op free_op2; + 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(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); ++ OBJ_RELEASE(Z_OBJ(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_mod_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op2); - zval_dtor(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); }