/* 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)) {
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL))) != NULL)) {
if (UNEXPECTED(Z_ISERROR_P(zptr))) {
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_NULL(EX_VAR(opline->result.var));
}
}
} else {
- zend_assign_op_overloaded_property(object, property, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), value, binary_op, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+ zend_assign_op_overloaded_property(object, property, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL), value, binary_op, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
}
} while (0);
#endif
}
-ZEND_VM_HANDLER(23, ZEND_ASSIGN_ADD, VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ, SPEC(DIM_OBJ))
+ZEND_VM_HANDLER(23, ZEND_ASSIGN_ADD, VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ|CACHE_SLOT, SPEC(DIM_OBJ))
{
ZEND_VM_DISPATCH_TO_HELPER(zend_binary_assign_op_helper, binary_op, add_function);
}
-ZEND_VM_HANDLER(24, ZEND_ASSIGN_SUB, VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ, SPEC(DIM_OBJ))
+ZEND_VM_HANDLER(24, ZEND_ASSIGN_SUB, VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ|CACHE_SLOT, SPEC(DIM_OBJ))
{
ZEND_VM_DISPATCH_TO_HELPER(zend_binary_assign_op_helper, binary_op, sub_function);
}
-ZEND_VM_HANDLER(25, ZEND_ASSIGN_MUL, VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ, SPEC(DIM_OBJ))
+ZEND_VM_HANDLER(25, ZEND_ASSIGN_MUL, VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ|CACHE_SLOT, SPEC(DIM_OBJ))
{
ZEND_VM_DISPATCH_TO_HELPER(zend_binary_assign_op_helper, binary_op, mul_function);
}
-ZEND_VM_HANDLER(26, ZEND_ASSIGN_DIV, VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ, SPEC(DIM_OBJ))
+ZEND_VM_HANDLER(26, ZEND_ASSIGN_DIV, VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ|CACHE_SLOT, SPEC(DIM_OBJ))
{
ZEND_VM_DISPATCH_TO_HELPER(zend_binary_assign_op_helper, binary_op, div_function);
}
-ZEND_VM_HANDLER(27, ZEND_ASSIGN_MOD, VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ, SPEC(DIM_OBJ))
+ZEND_VM_HANDLER(27, ZEND_ASSIGN_MOD, VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ|CACHE_SLOT, SPEC(DIM_OBJ))
{
ZEND_VM_DISPATCH_TO_HELPER(zend_binary_assign_op_helper, binary_op, mod_function);
}
-ZEND_VM_HANDLER(28, ZEND_ASSIGN_SL, VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ, SPEC(DIM_OBJ))
+ZEND_VM_HANDLER(28, ZEND_ASSIGN_SL, VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ|CACHE_SLOT, SPEC(DIM_OBJ))
{
ZEND_VM_DISPATCH_TO_HELPER(zend_binary_assign_op_helper, binary_op, shift_left_function);
}
-ZEND_VM_HANDLER(29, ZEND_ASSIGN_SR, VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ, SPEC(DIM_OBJ))
+ZEND_VM_HANDLER(29, ZEND_ASSIGN_SR, VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ|CACHE_SLOT, SPEC(DIM_OBJ))
{
ZEND_VM_DISPATCH_TO_HELPER(zend_binary_assign_op_helper, binary_op, shift_right_function);
}
-ZEND_VM_HANDLER(30, ZEND_ASSIGN_CONCAT, VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ, SPEC(DIM_OBJ))
+ZEND_VM_HANDLER(30, ZEND_ASSIGN_CONCAT, VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ|CACHE_SLOT, SPEC(DIM_OBJ))
{
ZEND_VM_DISPATCH_TO_HELPER(zend_binary_assign_op_helper, binary_op, concat_function);
}
-ZEND_VM_HANDLER(31, ZEND_ASSIGN_BW_OR, VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ, SPEC(DIM_OBJ))
+ZEND_VM_HANDLER(31, ZEND_ASSIGN_BW_OR, VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ|CACHE_SLOT, SPEC(DIM_OBJ))
{
ZEND_VM_DISPATCH_TO_HELPER(zend_binary_assign_op_helper, binary_op, bitwise_or_function);
}
-ZEND_VM_HANDLER(32, ZEND_ASSIGN_BW_AND, VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ, SPEC(DIM_OBJ))
+ZEND_VM_HANDLER(32, ZEND_ASSIGN_BW_AND, VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ|CACHE_SLOT, SPEC(DIM_OBJ))
{
ZEND_VM_DISPATCH_TO_HELPER(zend_binary_assign_op_helper, binary_op, bitwise_and_function);
}
-ZEND_VM_HANDLER(33, ZEND_ASSIGN_BW_XOR, VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ, SPEC(DIM_OBJ))
+ZEND_VM_HANDLER(33, ZEND_ASSIGN_BW_XOR, VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ|CACHE_SLOT, SPEC(DIM_OBJ))
{
ZEND_VM_DISPATCH_TO_HELPER(zend_binary_assign_op_helper, binary_op, bitwise_xor_function);
}
-ZEND_VM_HANDLER(167, ZEND_ASSIGN_POW, VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ, SPEC(DIM_OBJ))
+ZEND_VM_HANDLER(167, ZEND_ASSIGN_POW, VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ|CACHE_SLOT, SPEC(DIM_OBJ))
{
ZEND_VM_DISPATCH_TO_HELPER(zend_binary_assign_op_helper, binary_op, pow_function);
}
/* 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)) {
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL))) != NULL)) {
if (UNEXPECTED(Z_ISERROR_P(zptr))) {
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_NULL(EX_VAR(opline->result.var));
}
}
} else {
- zend_pre_incdec_overloaded_property(object, property, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), inc, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+ zend_pre_incdec_overloaded_property(object, property, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), inc, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
}
} while (0);
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
-ZEND_VM_HANDLER(132, ZEND_PRE_INC_OBJ, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV)
+ZEND_VM_HANDLER(132, ZEND_PRE_INC_OBJ, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, CACHE_SLOT)
{
ZEND_VM_DISPATCH_TO_HELPER(zend_pre_incdec_property_helper, inc, 1);
}
-ZEND_VM_HANDLER(133, ZEND_PRE_DEC_OBJ, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV)
+ZEND_VM_HANDLER(133, ZEND_PRE_DEC_OBJ, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, CACHE_SLOT)
{
ZEND_VM_DISPATCH_TO_HELPER(zend_pre_incdec_property_helper, inc, 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, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL))) != NULL)) {
if (UNEXPECTED(Z_ISERROR_P(zptr))) {
ZVAL_NULL(EX_VAR(opline->result.var));
} else {
}
}
} else {
- zend_post_incdec_overloaded_property(object, property, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), inc, EX_VAR(opline->result.var));
+ zend_post_incdec_overloaded_property(object, property, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), inc, EX_VAR(opline->result.var));
}
} while (0);
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
-ZEND_VM_HANDLER(134, ZEND_POST_INC_OBJ, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV)
+ZEND_VM_HANDLER(134, ZEND_POST_INC_OBJ, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, CACHE_SLOT)
{
ZEND_VM_DISPATCH_TO_HELPER(zend_post_incdec_property_helper, inc, 1);
}
-ZEND_VM_HANDLER(135, ZEND_POST_DEC_OBJ, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV)
+ZEND_VM_HANDLER(135, ZEND_POST_DEC_OBJ, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, CACHE_SLOT)
{
ZEND_VM_DISPATCH_TO_HELPER(zend_post_incdec_property_helper, inc, 0);
}
zend_free_op free_op1;
zval *varname;
zval *retval;
+ zend_string *name, *tmp_name;
+ zend_class_entry *ce;
SAVE_OPLINE();
- varname = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
- retval = zend_fetch_static_property_address(varname, OP1_TYPE, opline->op2, OP2_TYPE, type EXECUTE_DATA_CC OPLINE_CC);
+ do {
+ if (OP2_TYPE == IS_CONST) {
+ if (OP1_TYPE == IS_CONST && EXPECTED((ce = CACHED_PTR(opline->extended_value)) != NULL)) {
+ retval = CACHED_PTR(opline->extended_value + sizeof(void*));
+
+ /* check if static properties were destoyed */
+ if (EXPECTED(CE_STATIC_MEMBERS(ce) != NULL)) {
+ FREE_UNFETCHED_OP1();
+ break;
+ }
+ } else {
+ zval *class_name = RT_CONSTANT(opline, opline->op2);
+
+ if (UNEXPECTED((ce = CACHED_PTR(opline->extended_value)) == NULL)) {
+ ce = zend_fetch_class_by_name(Z_STR_P(class_name), class_name + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
+ if (UNEXPECTED(ce == NULL)) {
+ FREE_UNFETCHED_OP1();
+ retval = NULL;
+ break;
+ }
+ if (OP1_TYPE != IS_CONST) {
+ CACHE_PTR(opline->extended_value, ce);
+ }
+ }
+ }
+ } else {
+ if (OP2_TYPE == IS_UNUSED) {
+ ce = zend_fetch_class(NULL, opline->op2.num);
+ if (UNEXPECTED(ce == NULL)) {
+ FREE_UNFETCHED_OP1();
+ retval = NULL;
+ break;
+ }
+ } else {
+ ce = Z_CE_P(EX_VAR(opline->op2.var));
+ }
+ if (OP1_TYPE == IS_CONST &&
+ EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
+ retval = CACHED_PTR(opline->extended_value + sizeof(void*));
+
+ /* check if static properties were destoyed */
+ if (EXPECTED(CE_STATIC_MEMBERS(ce) != NULL)) {
+ FREE_UNFETCHED_OP1();
+ break;
+ }
+ }
+ }
+
+ varname = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
+ if (OP1_TYPE == IS_CONST) {
+ name = Z_STR_P(varname);
+ } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
+ name = Z_STR_P(varname);
+ tmp_name = NULL;
+ } else {
+ if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
+ zval_undefined_cv(EX(opline)->op1.var EXECUTE_DATA_CC);
+ }
+ name = zval_get_tmp_string(varname, &tmp_name);
+ }
+
+ retval = zend_std_get_static_property(ce, name, type == BP_VAR_IS);
+
+ if (OP1_TYPE != IS_CONST) {
+ zend_tmp_string_release(tmp_name);
+ }
+
+ if (OP1_TYPE == IS_CONST && EXPECTED(retval)) {
+ CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, retval);
+ }
+
+ FREE_OP1();
+ } while (0);
if (UNEXPECTED(retval == NULL)) {
if (EG(exception)) {
- FREE_OP1();
ZVAL_UNDEF(EX_VAR(opline->result.var));
HANDLE_EXCEPTION();
} else {
}
}
- FREE_OP1();
-
if (type == BP_VAR_R || type == BP_VAR_IS) {
ZVAL_COPY_UNREF(EX_VAR(opline->result.var), retval);
} else {
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
-ZEND_VM_HANDLER(173, ZEND_FETCH_STATIC_PROP_R, CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR)
+ZEND_VM_HANDLER(173, ZEND_FETCH_STATIC_PROP_R, CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR, CACHE_SLOT)
{
ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper, type, BP_VAR_R);
}
-ZEND_VM_HANDLER(174, ZEND_FETCH_STATIC_PROP_W, CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR)
+ZEND_VM_HANDLER(174, ZEND_FETCH_STATIC_PROP_W, CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR, CACHE_SLOT)
{
ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper, type, BP_VAR_W);
}
-ZEND_VM_HANDLER(175, ZEND_FETCH_STATIC_PROP_RW, CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR)
+ZEND_VM_HANDLER(175, ZEND_FETCH_STATIC_PROP_RW, CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR, CACHE_SLOT)
{
ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper, type, BP_VAR_RW);
}
-ZEND_VM_HANDLER(177, ZEND_FETCH_STATIC_PROP_FUNC_ARG, CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR)
+ZEND_VM_HANDLER(177, ZEND_FETCH_STATIC_PROP_FUNC_ARG, CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR, CACHE_SLOT)
{
USE_OPLINE
}
}
-ZEND_VM_HANDLER(178, ZEND_FETCH_STATIC_PROP_UNSET, CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR)
+ZEND_VM_HANDLER(178, ZEND_FETCH_STATIC_PROP_UNSET, CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR, CACHE_SLOT)
{
ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper, type, BP_VAR_UNSET);
}
-ZEND_VM_HANDLER(176, ZEND_FETCH_STATIC_PROP_IS, CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR)
+ZEND_VM_HANDLER(176, ZEND_FETCH_STATIC_PROP_IS, CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR, CACHE_SLOT)
{
ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper, type, BP_VAR_IS);
}
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
-ZEND_VM_HOT_OBJ_HANDLER(82, ZEND_FETCH_OBJ_R, CONST|TMPVAR|UNUSED|THIS|CV, CONST|TMPVAR|CV)
+ZEND_VM_HOT_OBJ_HANDLER(82, ZEND_FETCH_OBJ_R, CONST|TMPVAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, CACHE_SLOT)
{
USE_OPLINE
zend_free_op free_op1;
zval *retval;
if (OP2_TYPE == IS_CONST) {
- cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
+ cache_slot = CACHE_ADDR(opline->extended_value);
if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
-ZEND_VM_HANDLER(85, ZEND_FETCH_OBJ_W, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV)
+ZEND_VM_HANDLER(85, ZEND_FETCH_OBJ_W, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, CACHE_SLOT)
{
USE_OPLINE
zend_free_op free_op1, free_op2;
property = GET_OP2_ZVAL_PTR(BP_VAR_R);
result = EX_VAR(opline->result.var);
- zend_fetch_property_address(result, container, OP1_TYPE, property, OP2_TYPE, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W);
+ zend_fetch_property_address(result, container, OP1_TYPE, property, OP2_TYPE, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_W);
FREE_OP2();
if (OP1_TYPE == IS_VAR) {
FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
-ZEND_VM_HANDLER(88, ZEND_FETCH_OBJ_RW, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV)
+ZEND_VM_HANDLER(88, ZEND_FETCH_OBJ_RW, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, CACHE_SLOT)
{
USE_OPLINE
zend_free_op free_op1, free_op2;
}
property = GET_OP2_ZVAL_PTR(BP_VAR_R);
result = EX_VAR(opline->result.var);
- zend_fetch_property_address(result, container, OP1_TYPE, property, OP2_TYPE, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_RW);
+ zend_fetch_property_address(result, container, OP1_TYPE, property, OP2_TYPE, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW);
FREE_OP2();
if (OP1_TYPE == IS_VAR) {
FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
-ZEND_VM_HANDLER(91, ZEND_FETCH_OBJ_IS, CONST|TMPVAR|UNUSED|THIS|CV, CONST|TMPVAR|CV)
+ZEND_VM_HANDLER(91, ZEND_FETCH_OBJ_IS, CONST|TMPVAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, CACHE_SLOT)
{
USE_OPLINE
zend_free_op free_op1;
zval *retval;
if (OP2_TYPE == IS_CONST) {
- cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
+ cache_slot = CACHE_ADDR(opline->extended_value);
if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
-ZEND_VM_HANDLER(94, ZEND_FETCH_OBJ_FUNC_ARG, CONST|TMP|VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV)
+ZEND_VM_HANDLER(94, ZEND_FETCH_OBJ_FUNC_ARG, CONST|TMP|VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, CACHE_SLOT)
{
USE_OPLINE
}
}
-ZEND_VM_HANDLER(97, ZEND_FETCH_OBJ_UNSET, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV)
+ZEND_VM_HANDLER(97, ZEND_FETCH_OBJ_UNSET, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, CACHE_SLOT)
{
USE_OPLINE
zend_free_op free_op1, free_op2;
property = GET_OP2_ZVAL_PTR(BP_VAR_R);
result = EX_VAR(opline->result.var);
- zend_fetch_property_address(result, container, OP1_TYPE, property, OP2_TYPE, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_UNSET);
+ zend_fetch_property_address(result, container, OP1_TYPE, property, OP2_TYPE, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET);
FREE_OP2();
if (OP1_TYPE == IS_VAR) {
FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
-ZEND_VM_HANDLER(136, ZEND_ASSIGN_OBJ, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, SPEC(OP_DATA=CONST|TMP|VAR|CV))
+ZEND_VM_HANDLER(136, ZEND_ASSIGN_OBJ, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, CACHE_SLOT, SPEC(OP_DATA=CONST|TMP|VAR|CV))
{
USE_OPLINE
zend_free_op free_op1, free_op2, free_op_data;
}
if (OP2_TYPE == IS_CONST &&
- EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
- uintptr_t prop_offset = (uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+ EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
+ uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
zend_object *zobj = Z_OBJ_P(object);
zval *property_val;
ZVAL_DEREF(value);
}
- Z_OBJ_HT_P(object)->write_property(object, property, value, (OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL);
+ Z_OBJ_HT_P(object)->write_property(object, property, value, (OP2_TYPE == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
ZEND_VM_NEXT_OPCODE();
}
-ZEND_VM_HANDLER(109, ZEND_FETCH_CLASS, UNUSED|CLASS_FETCH, CONST|TMPVAR|UNUSED|CV)
+ZEND_VM_HANDLER(109, ZEND_FETCH_CLASS, UNUSED|CLASS_FETCH, CONST|TMPVAR|UNUSED|CV, CACHE_SLOT)
{
+ zend_free_op free_op2;
+ zval *class_name;
USE_OPLINE
SAVE_OPLINE();
if (OP2_TYPE == IS_UNUSED) {
Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->op1.num);
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
- } else {
- zend_free_op free_op2;
- zval *class_name = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
+ } else if (OP2_TYPE == IS_CONST) {
+ zend_class_entry *ce = CACHED_PTR(opline->extended_value);
+ if (UNEXPECTED(ce == NULL)) {
+ class_name = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
+ ce = zend_fetch_class_by_name(Z_STR_P(class_name), class_name + 1, opline->op1.num);
+ CACHE_PTR(opline->extended_value, ce);
+ }
+ Z_CE_P(EX_VAR(opline->result.var)) = ce;
+ } else {
+ class_name = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
ZEND_VM_C_LABEL(try_class_name):
- if (OP2_TYPE == IS_CONST) {
- zend_class_entry *ce = CACHED_PTR(Z_CACHE_SLOT_P(class_name));
-
- if (UNEXPECTED(ce == NULL)) {
- ce = zend_fetch_class_by_name(Z_STR_P(class_name), RT_CONSTANT(opline, opline->op2) + 1, opline->op1.num);
- CACHE_PTR(Z_CACHE_SLOT_P(class_name), ce);
- }
- Z_CE_P(EX_VAR(opline->result.var)) = ce;
- } else if (Z_TYPE_P(class_name) == IS_OBJECT) {
+ if (Z_TYPE_P(class_name) == IS_OBJECT) {
Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
} else if (Z_TYPE_P(class_name) == IS_STRING) {
Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->op1.num);
}
zend_throw_error(NULL, "Class name must be a valid object or a string");
}
-
- FREE_OP2();
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
+
+ FREE_OP2();
+ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
-ZEND_VM_HOT_OBJ_HANDLER(112, ZEND_INIT_METHOD_CALL, CONST|TMPVAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, NUM)
+ZEND_VM_HOT_OBJ_HANDLER(112, ZEND_INIT_METHOD_CALL, CONST|TMPVAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, NUM|CACHE_SLOT)
{
USE_OPLINE
zval *function_name;
ZEND_VM_DISPATCH_TO_HELPER(zend_this_not_in_object_context_helper);
}
- function_name = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
+ if (OP2_TYPE != IS_CONST) {
+ function_name = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
+ }
if (OP2_TYPE != IS_CONST &&
UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
HANDLE_EXCEPTION();
}
}
+ if (OP2_TYPE == IS_CONST) {
+ function_name = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
+ }
zend_throw_error(NULL, "Call to a member function %s() on %s", Z_STRVAL_P(function_name), zend_get_type_by_const(Z_TYPE_P(object)));
FREE_OP2();
FREE_OP1();
called_scope = obj->ce;
if (OP2_TYPE == IS_CONST &&
- EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(function_name)) == called_scope)) {
- fbc = CACHED_PTR(Z_CACHE_SLOT_P(function_name) + sizeof(void*));
+ EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
+ fbc = CACHED_PTR(opline->result.num + sizeof(void*));
} else {
zend_object *orig_obj = obj;
HANDLE_EXCEPTION();
}
+ if (OP2_TYPE == IS_CONST) {
+ function_name = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
+ }
+
/* First, locate the function. */
fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((OP2_TYPE == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
if (UNEXPECTED(fbc == NULL)) {
EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
EXPECTED(obj == orig_obj)) {
- CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), called_scope, fbc);
+ CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
}
if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) {
init_func_run_time_cache(&fbc->op_array);
ZEND_VM_NEXT_OPCODE();
}
-ZEND_VM_HANDLER(113, ZEND_INIT_STATIC_METHOD_CALL, UNUSED|CLASS_FETCH|CONST|VAR, CONST|TMPVAR|UNUSED|CONSTRUCTOR|CV, NUM)
+ZEND_VM_HANDLER(113, ZEND_INIT_STATIC_METHOD_CALL, UNUSED|CLASS_FETCH|CONST|VAR, CONST|TMPVAR|UNUSED|CONSTRUCTOR|CV, NUM|CACHE_SLOT)
{
USE_OPLINE
zval *function_name;
if (OP1_TYPE == IS_CONST) {
/* no function found. try a static method in class */
- ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)));
+ ce = CACHED_PTR(opline->result.num);
if (UNEXPECTED(ce == NULL)) {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), RT_CONSTANT(opline, opline->op1) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
HANDLE_EXCEPTION();
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)), ce);
+ if (OP2_TYPE != IS_CONST) {
+ CACHE_PTR(opline->result.num, ce);
+ }
}
} else if (OP1_TYPE == IS_UNUSED) {
ce = zend_fetch_class(NULL, opline->op1.num);
if (OP1_TYPE == IS_CONST &&
OP2_TYPE == IS_CONST &&
- EXPECTED((fbc = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)))) != NULL)) {
+ EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
/* nothing to do */
} else if (OP1_TYPE != IS_CONST &&
OP2_TYPE == IS_CONST &&
- EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2))) == ce)) {
- fbc = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)) + sizeof(void*));
+ EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
+ fbc = CACHED_PTR(opline->result.num + sizeof(void*));
} else if (OP2_TYPE != IS_UNUSED) {
zend_free_op free_op2;
if (OP2_TYPE == IS_CONST &&
EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE)))) {
- if (OP1_TYPE == IS_CONST) {
- CACHE_PTR(Z_CACHE_SLOT_P(function_name), fbc);
- } else {
- CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), ce, fbc);
- }
+ CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
}
if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) {
init_func_run_time_cache(&fbc->op_array);
ZEND_VM_NEXT_OPCODE();
}
-ZEND_VM_HOT_HANDLER(59, ZEND_INIT_FCALL_BY_NAME, ANY, CONST, NUM)
+ZEND_VM_HOT_HANDLER(59, ZEND_INIT_FCALL_BY_NAME, ANY, CONST, NUM|CACHE_SLOT)
{
USE_OPLINE
zend_function *fbc;
zval *function_name, *func;
zend_execute_data *call;
- function_name = (zval*)RT_CONSTANT(opline, opline->op2);
- fbc = CACHED_PTR(Z_CACHE_SLOT_P(function_name));
+ fbc = CACHED_PTR(opline->result.num);
if (UNEXPECTED(fbc == NULL)) {
+ function_name = (zval*)RT_CONSTANT(opline, opline->op2);
func = zend_hash_find_ex(EG(function_table), Z_STR_P(function_name+1), 1);
if (UNEXPECTED(func == NULL)) {
SAVE_OPLINE();
if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) {
init_func_run_time_cache(&fbc->op_array);
}
- CACHE_PTR(Z_CACHE_SLOT_P(function_name), fbc);
+ CACHE_PTR(opline->result.num, fbc);
}
call = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
fbc, opline->extended_value, NULL, NULL);
ZEND_VM_NEXT_OPCODE();
}
-ZEND_VM_HANDLER(69, ZEND_INIT_NS_FCALL_BY_NAME, ANY, CONST, NUM)
+ZEND_VM_HANDLER(69, ZEND_INIT_NS_FCALL_BY_NAME, ANY, CONST, NUM|CACHE_SLOT)
{
USE_OPLINE
zval *func_name;
zend_function *fbc;
zend_execute_data *call;
- func_name = RT_CONSTANT(opline, opline->op2) + 1;
- fbc = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)));
+ fbc = CACHED_PTR(opline->result.num);
if (UNEXPECTED(fbc == NULL)) {
+ func_name = RT_CONSTANT(opline, opline->op2) + 1;
func = zend_hash_find_ex(EG(function_table), Z_STR_P(func_name), 1);
if (func == NULL) {
func_name++;
}
}
fbc = Z_FUNC_P(func);
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), fbc);
+ CACHE_PTR(opline->result.num, fbc);
if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) {
init_func_run_time_cache(&fbc->op_array);
}
ZEND_VM_NEXT_OPCODE();
}
-ZEND_VM_HOT_HANDLER(61, ZEND_INIT_FCALL, NUM, CONST, NUM)
+ZEND_VM_HOT_HANDLER(61, ZEND_INIT_FCALL, NUM, CONST, NUM|CACHE_SLOT)
{
USE_OPLINE
zend_free_op free_op2;
- zval *fname = GET_OP2_ZVAL_PTR(BP_VAR_R);
+ zval *fname;
zval *func;
zend_function *fbc;
zend_execute_data *call;
- fbc = CACHED_PTR(Z_CACHE_SLOT_P(fname));
+ fbc = CACHED_PTR(opline->result.num);
if (UNEXPECTED(fbc == NULL)) {
+ fname = GET_OP2_ZVAL_PTR(BP_VAR_R);
func = zend_hash_find_ex(EG(function_table), Z_STR_P(fname), 1);
if (UNEXPECTED(func == NULL)) {
SAVE_OPLINE();
HANDLE_EXCEPTION();
}
fbc = Z_FUNC_P(func);
- CACHE_PTR(Z_CACHE_SLOT_P(fname), fbc);
+ CACHE_PTR(opline->result.num, fbc);
if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) {
init_func_run_time_cache(&fbc->op_array);
}
ZEND_VM_CONTINUE();
}
-ZEND_VM_HANDLER(124, ZEND_VERIFY_RETURN_TYPE, CONST|TMP|VAR|UNUSED|CV, UNUSED)
+ZEND_VM_HANDLER(124, ZEND_VERIFY_RETURN_TYPE, CONST|TMP|VAR|UNUSED|CV, UNUSED|CACHE_SLOT)
{
USE_OPLINE
HANDLE_EXCEPTION();
}
-ZEND_VM_HANDLER(107, ZEND_CATCH, CONST, JMP_ADDR, LAST_CATCH)
+ZEND_VM_HANDLER(107, ZEND_CATCH, CONST, JMP_ADDR, LAST_CATCH|CACHE_SLOT)
{
USE_OPLINE
zend_class_entry *ce, *catch_ce;
ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op2));
ZEND_VM_CONTINUE();
}
- catch_ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)));
+ catch_ce = CACHED_PTR(opline->extended_value & ~ZEND_LAST_CATCH);
if (UNEXPECTED(catch_ce == NULL)) {
catch_ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), RT_CONSTANT(opline, opline->op1) + 1, ZEND_FETCH_CLASS_NO_AUTOLOAD);
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)), catch_ce);
+ CACHE_PTR(opline->extended_value & ~ZEND_LAST_CATCH, catch_ce);
}
ce = EG(exception)->ce;
if (ce != catch_ce) {
if (!catch_ce || !instanceof_function(ce, catch_ce)) {
- if (opline->extended_value == ZEND_LAST_CATCH) {
+ if (opline->extended_value & ZEND_LAST_CATCH) {
zend_rethrow_exception(execute_data);
HANDLE_EXCEPTION();
}
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
-ZEND_VM_HANDLER(63, ZEND_RECV, NUM, ANY)
+ZEND_VM_HANDLER(63, ZEND_RECV, NUM, UNUSED|CACHE_SLOT)
{
USE_OPLINE
uint32_t arg_num = opline->op1.num;
ZEND_VM_NEXT_OPCODE();
}
-ZEND_VM_HOT_HANDLER(64, ZEND_RECV_INIT, NUM, CONST)
+ZEND_VM_HOT_HANDLER(64, ZEND_RECV_INIT, NUM, CONST, CACHE_SLOT)
{
USE_OPLINE
uint32_t arg_num;
zval *default_value = RT_CONSTANT(opline, opline->op2);
SAVE_OPLINE();
- if (UNEXPECTED(!zend_verify_arg_type(EX(func), arg_num, param, default_value, CACHE_ADDR(Z_CACHE_SLOT_P(default_value))) || EG(exception))) {
+ if (UNEXPECTED(!zend_verify_arg_type(EX(func), arg_num, param, default_value, CACHE_ADDR(opline->extended_value)) || EG(exception))) {
HANDLE_EXCEPTION();
}
}
ZEND_VM_NEXT_OPCODE();
}
-ZEND_VM_HANDLER(164, ZEND_RECV_VARIADIC, NUM, ANY)
+ZEND_VM_HANDLER(164, ZEND_RECV_VARIADIC, NUM, UNUSED|CACHE_SLOT)
{
USE_OPLINE
uint32_t arg_num = opline->op1.num;
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
-ZEND_VM_HANDLER(68, ZEND_NEW, UNUSED|CLASS_FETCH|CONST|VAR, ANY, NUM)
+ZEND_VM_HANDLER(68, ZEND_NEW, UNUSED|CLASS_FETCH|CONST|VAR, UNUSED|CACHE_SLOT, NUM)
{
USE_OPLINE
zval *result;
SAVE_OPLINE();
if (OP1_TYPE == IS_CONST) {
- ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)));
+ ce = CACHED_PTR(opline->op2.num);
if (UNEXPECTED(ce == NULL)) {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), RT_CONSTANT(opline, opline->op1) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
if (UNEXPECTED(ce == NULL)) {
ZVAL_UNDEF(EX_VAR(opline->result.var));
HANDLE_EXCEPTION();
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)), ce);
+ CACHE_PTR(opline->op2.num, ce);
}
} else if (OP1_TYPE == IS_UNUSED) {
ce = zend_fetch_class(NULL, opline->op1.num);
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
-ZEND_VM_HANDLER(99, ZEND_FETCH_CONSTANT, UNUSED|CONST_FETCH, CONST)
+ZEND_VM_HANDLER(99, ZEND_FETCH_CONSTANT, UNUSED|CONST_FETCH, CONST, CACHE_SLOT)
{
USE_OPLINE
zend_constant *c;
- if (EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2))))) {
- c = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)));
+ if (EXPECTED(CACHED_PTR(opline->extended_value))) {
+ c = CACHED_PTR(opline->extended_value);
} else if ((c = zend_quick_get_constant(RT_CONSTANT(opline, opline->op2) + 1, opline->op1.num)) == NULL) {
SAVE_OPLINE();
HANDLE_EXCEPTION();
}
} else {
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), c);
+ CACHE_PTR(opline->extended_value, c);
}
ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), &c->value);
ZEND_VM_NEXT_OPCODE();
}
-ZEND_VM_HANDLER(181, ZEND_FETCH_CLASS_CONSTANT, VAR|CONST|UNUSED|CLASS_FETCH, CONST)
+ZEND_VM_HANDLER(181, ZEND_FETCH_CLASS_CONSTANT, VAR|CONST|UNUSED|CLASS_FETCH, CONST, CACHE_SLOT)
{
zend_class_entry *ce, *scope;
zend_class_constant *c;
do {
if (OP1_TYPE == IS_CONST) {
- if (EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2))))) {
- value = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)));
+ if (EXPECTED(CACHED_PTR(opline->extended_value + sizeof(void*)))) {
+ value = CACHED_PTR(opline->extended_value + sizeof(void*));
break;
- } else if (EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1))))) {
- ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)));
+ } else if (EXPECTED(CACHED_PTR(opline->extended_value))) {
+ ce = CACHED_PTR(opline->extended_value);
} else {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), RT_CONSTANT(opline, opline->op1) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
if (UNEXPECTED(ce == NULL)) {
ZVAL_UNDEF(EX_VAR(opline->result.var));
HANDLE_EXCEPTION();
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)), ce);
}
} else {
if (OP1_TYPE == IS_UNUSED) {
} else {
ce = Z_CE_P(EX_VAR(opline->op1.var));
}
- if (EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2))) == ce)) {
- value = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)) + sizeof(void*));
+ if (EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
+ value = CACHED_PTR(opline->extended_value + sizeof(void*));
break;
}
}
HANDLE_EXCEPTION();
}
}
- if (OP1_TYPE == IS_CONST) {
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), value);
- } else {
- CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), ce, value);
- }
+ CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, value);
} else {
zend_throw_error(NULL, "Undefined class constant '%s'", Z_STRVAL_P(RT_CONSTANT(opline, opline->op2)));
ZVAL_UNDEF(EX_VAR(opline->result.var));
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
-ZEND_VM_HANDLER(179, ZEND_UNSET_STATIC_PROP, CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR)
+ZEND_VM_HANDLER(179, ZEND_UNSET_STATIC_PROP, CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR, CACHE_SLOT)
{
USE_OPLINE
zval *varname;
SAVE_OPLINE();
- varname = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
-
- if (OP1_TYPE == IS_CONST) {
- name = Z_STR_P(varname);
- } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
- name = Z_STR_P(varname);
- tmp_name = NULL;
- } else {
- if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
- varname = GET_OP1_UNDEF_CV(varname, BP_VAR_R);
- }
- name = zval_get_tmp_string(varname, &tmp_name);
- }
-
if (OP2_TYPE == IS_CONST) {
- ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)));
+ ce = CACHED_PTR(opline->extended_value);
if (UNEXPECTED(ce == NULL)) {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), RT_CONSTANT(opline, opline->op2) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
- if (OP1_TYPE != IS_CONST) {
- zend_tmp_string_release(tmp_name);
- }
- FREE_OP1();
+ FREE_UNFETCHED_OP1();
HANDLE_EXCEPTION();
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), ce);
+ /*CACHE_PTR(opline->extended_value, ce);*/
}
} else if (OP2_TYPE == IS_UNUSED) {
ce = zend_fetch_class(NULL, opline->op2.num);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
- if (OP1_TYPE != IS_CONST) {
- zend_tmp_string_release(tmp_name);
- }
- FREE_OP1();
+ FREE_UNFETCHED_OP1();
HANDLE_EXCEPTION();
}
} else {
ce = Z_CE_P(EX_VAR(opline->op2.var));
}
+
+ varname = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
+ if (OP1_TYPE == IS_CONST) {
+ name = Z_STR_P(varname);
+ } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
+ name = Z_STR_P(varname);
+ tmp_name = NULL;
+ } else {
+ if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
+ varname = GET_OP1_UNDEF_CV(varname, BP_VAR_R);
+ }
+ name = zval_get_tmp_string(varname, &tmp_name);
+ }
+
zend_std_unset_static_property(ce, name);
if (OP1_TYPE != IS_CONST) {
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
-ZEND_VM_HANDLER(76, ZEND_UNSET_OBJ, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV)
+ZEND_VM_HANDLER(76, ZEND_UNSET_OBJ, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, CACHE_SLOT)
{
USE_OPLINE
zend_free_op free_op1, free_op2;
}
}
if (Z_OBJ_HT_P(container)->unset_property) {
- Z_OBJ_HT_P(container)->unset_property(container, offset, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(offset)) : NULL));
+ Z_OBJ_HT_P(container)->unset_property(container, offset, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
} else {
zend_wrong_property_unset(offset);
}
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
-ZEND_VM_HANDLER(180, ZEND_ISSET_ISEMPTY_STATIC_PROP, CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR, ISSET)
+ZEND_VM_HANDLER(180, ZEND_ISSET_ISEMPTY_STATIC_PROP, CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR, ISSET|CACHE_SLOT)
{
USE_OPLINE
zval *value;
zend_class_entry *ce;
SAVE_OPLINE();
- varname = GET_OP1_ZVAL_PTR(BP_VAR_IS);
- if (OP1_TYPE == IS_CONST) {
- name = Z_STR_P(varname);
- } else {
- name = zval_get_tmp_string(varname, &tmp_name);
- }
-
if (OP2_TYPE == IS_CONST) {
- if (OP1_TYPE == IS_CONST && EXPECTED((ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)))) != NULL)) {
- value = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)) + sizeof(void*));
+ if (OP1_TYPE == IS_CONST && EXPECTED((ce = CACHED_PTR(opline->extended_value & ~ZEND_ISSET)) != NULL)) {
+ value = CACHED_PTR((opline->extended_value & ~ZEND_ISSET) + sizeof(void*));
/* check if static properties were destoyed */
if (UNEXPECTED(CE_STATIC_MEMBERS(ce) == NULL)) {
}
ZEND_VM_C_GOTO(is_static_prop_return);
- } else if (UNEXPECTED((ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)))) == NULL)) {
+ } else if (UNEXPECTED((ce = CACHED_PTR(opline->extended_value & ~ZEND_ISSET)) == NULL)) {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), RT_CONSTANT(opline, opline->op2) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
ZVAL_UNDEF(EX_VAR(opline->result.var));
HANDLE_EXCEPTION();
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), ce);
+ if (OP1_TYPE != IS_CONST) {
+ CACHE_PTR(opline->extended_value & ~ZEND_ISSET, ce);
+ }
}
} else {
if (OP2_TYPE == IS_UNUSED) {
ce = zend_fetch_class(NULL, opline->op2.num);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
- if (OP1_TYPE != IS_CONST) {
- zend_tmp_string_release(tmp_name);
- }
- FREE_OP1();
+ FREE_UNFETCHED_OP1();
ZVAL_UNDEF(EX_VAR(opline->result.var));
HANDLE_EXCEPTION();
}
ce = Z_CE_P(EX_VAR(opline->op2.var));
}
if (OP1_TYPE == IS_CONST &&
- EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1))) == ce)) {
+ EXPECTED(CACHED_PTR(opline->extended_value & ~ZEND_ISSET) == ce)) {
- value = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)) + sizeof(void*));
+ value = CACHED_PTR((opline->extended_value & ~ZEND_ISSET) + sizeof(void*));
/* check if static properties were destoyed */
if (UNEXPECTED(CE_STATIC_MEMBERS(ce) == NULL)) {
}
}
+ varname = GET_OP1_ZVAL_PTR(BP_VAR_IS);
+ if (OP1_TYPE == IS_CONST) {
+ name = Z_STR_P(varname);
+ } else {
+ name = zval_get_tmp_string(varname, &tmp_name);
+ }
+
value = zend_std_get_static_property(ce, name, 1);
if (OP1_TYPE == IS_CONST && value) {
- CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)), ce, value);
+ CACHE_POLYMORPHIC_PTR(opline->extended_value & ~ZEND_ISSET, ce, value);
}
if (OP1_TYPE != IS_CONST) {
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
-ZEND_VM_HANDLER(148, ZEND_ISSET_ISEMPTY_PROP_OBJ, CONST|TMPVAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, ISSET)
+ZEND_VM_HANDLER(148, ZEND_ISSET_ISEMPTY_PROP_OBJ, CONST|TMPVAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, ISSET|CACHE_SLOT)
{
USE_OPLINE
zend_free_op free_op1, free_op2;
} else {
result =
((opline->extended_value & ZEND_ISSET) == 0) ^
- Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(offset)) : NULL));
+ Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISSET) : NULL));
}
FREE_OP2();
ZEND_VM_NEXT_OPCODE();
}
-ZEND_VM_HANDLER(138, ZEND_INSTANCEOF, TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR)
+ZEND_VM_HANDLER(138, ZEND_INSTANCEOF, TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR, CACHE_SLOT)
{
USE_OPLINE
zend_free_op free_op1;
zend_class_entry *ce;
if (OP2_TYPE == IS_CONST) {
- ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)));
+ ce = CACHED_PTR(opline->extended_value);
if (UNEXPECTED(ce == NULL)) {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), RT_CONSTANT(opline, opline->op2) + 1, ZEND_FETCH_CLASS_NO_AUTOLOAD);
if (EXPECTED(ce)) {
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), ce);
+ CACHE_PTR(opline->extended_value, ce);
}
}
} else if (OP2_TYPE == IS_UNUSED) {
ZEND_VM_NEXT_OPCODE();
}
-ZEND_VM_HANDLER(144, ZEND_ADD_INTERFACE, ANY, CONST)
+ZEND_VM_HANDLER(144, ZEND_ADD_INTERFACE, ANY, CONST, CACHE_SLOT)
{
USE_OPLINE
zend_class_entry *ce = Z_CE_P(EX_VAR(opline->op1.var));
zend_class_entry *iface;
SAVE_OPLINE();
- iface = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)));
+ iface = CACHED_PTR(opline->extended_value);
if (UNEXPECTED(iface == NULL)) {
iface = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), RT_CONSTANT(opline, opline->op2) + 1, ZEND_FETCH_CLASS_INTERFACE);
if (UNEXPECTED(iface == NULL)) {
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), iface);
+ CACHE_PTR(opline->extended_value, iface);
}
if (UNEXPECTED((iface->ce_flags & ZEND_ACC_INTERFACE) == 0)) {
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
-ZEND_VM_HANDLER(154, ZEND_ADD_TRAIT, ANY, ANY)
+ZEND_VM_HANDLER(154, ZEND_ADD_TRAIT, ANY, ANY, CACHE_SLOT)
{
USE_OPLINE
zend_class_entry *ce = Z_CE_P(EX_VAR(opline->op1.var));
zend_class_entry *trait;
SAVE_OPLINE();
- trait = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)));
+ trait = CACHED_PTR(opline->extended_value);
if (UNEXPECTED(trait == NULL)) {
trait = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)),
RT_CONSTANT(opline, opline->op2) + 1,
if (!(trait->ce_flags & ZEND_ACC_TRAIT)) {
zend_error_noreturn(E_ERROR, "%s cannot use %s - it is not a trait", ZSTR_VAL(ce->name), ZSTR_VAL(trait->name));
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), trait);
+ CACHE_PTR(opline->extended_value, trait);
}
zend_do_implement_trait(ce, trait);
ZEND_VM_DISPATCH_TO_HELPER(zend_dispatch_try_catch_finally_helper, try_catch_offset, current_try_catch_offset, op_num, current_op_num);
}
-ZEND_VM_HOT_HANDLER(168, ZEND_BIND_GLOBAL, CV, CONST)
+ZEND_VM_HOT_HANDLER(168, ZEND_BIND_GLOBAL, CV, CONST, CACHE_SLOT)
{
USE_OPLINE
zend_free_op free_op1, free_op2;
varname = GET_OP2_ZVAL_PTR(BP_VAR_R);
/* We store "hash slot index" + 1 (NULL is a mark of uninitialized cache slot) */
- idx = (uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(varname)) - 1;
+ idx = (uintptr_t)CACHED_PTR(opline->extended_value) - 1;
if (EXPECTED(idx < EG(symbol_table).nNumUsed * sizeof(Bucket))) {
Bucket *p = (Bucket*)((char*)EG(symbol_table).arData + idx);
value = zend_hash_add_new(&EG(symbol_table), Z_STR_P(varname), &EG(uninitialized_zval));
idx = (char*)value - (char*)EG(symbol_table).arData;
/* Store "hash slot index" + 1 (NULL is a mark of uninitialized cache slot) */
- CACHE_PTR(Z_CACHE_SLOT_P(varname), (void*)(idx + 1));
+ CACHE_PTR(opline->extended_value, (void*)(idx + 1));
} else {
idx = (char*)value - (char*)EG(symbol_table).arData;
/* Store "hash slot index" + 1 (NULL is a mark of uninitialized cache slot) */
- CACHE_PTR(Z_CACHE_SLOT_P(varname), (void*)(idx + 1));
+ CACHE_PTR(opline->extended_value, (void*)(idx + 1));
ZEND_VM_C_LABEL(check_indirect):
/* GLOBAL variable may be an INDIRECT pointer to CV */
if (UNEXPECTED(Z_TYPE_P(value) == IS_INDIRECT)) {
}
}
-ZEND_VM_HANDLER(122, ZEND_DEFINED, CONST, ANY)
+ZEND_VM_HANDLER(122, ZEND_DEFINED, CONST, ANY, CACHE_SLOT)
{
USE_OPLINE
zend_constant *c;
int result;
- if (EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1))))) {
+ if (EXPECTED(CACHED_PTR(opline->extended_value))) {
result = 1;
} else if ((c = zend_quick_get_constant(RT_CONSTANT(opline, opline->op1), 0)) == NULL) {
result = 0;
} else {
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)), c);
+ CACHE_PTR(opline->extended_value, c);
result = 1;
}
ZEND_VM_SMART_BRANCH(result, 0);
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RECV_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
- USE_OPLINE
- uint32_t arg_num = opline->op1.num;
-
- if (UNEXPECTED(arg_num > EX_NUM_ARGS())) {
- SAVE_OPLINE();
- zend_missing_arg_error(execute_data);
- HANDLE_EXCEPTION();
- } else if (UNEXPECTED((EX(func)->op_array.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) != 0)) {
- zval *param = _get_zval_ptr_cv_undef_BP_VAR_W(opline->result.var EXECUTE_DATA_CC);
-
- SAVE_OPLINE();
- if (UNEXPECTED(!zend_verify_arg_type(EX(func), arg_num, param, NULL, CACHE_ADDR(opline->op2.num)) || EG(exception))) {
- HANDLE_EXCEPTION();
- }
- }
-
- ZEND_VM_NEXT_OPCODE();
-}
-
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RECV_VARIADIC_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
- USE_OPLINE
- uint32_t arg_num = opline->op1.num;
- uint32_t arg_count = EX_NUM_ARGS();
- zval *params;
-
- SAVE_OPLINE();
-
- params = _get_zval_ptr_cv_undef_BP_VAR_W(opline->result.var EXECUTE_DATA_CC);
-
- if (arg_num <= arg_count) {
- zval *param;
-
- array_init_size(params, arg_count - arg_num + 1);
- zend_hash_real_init(Z_ARRVAL_P(params), 1);
- ZEND_HASH_FILL_PACKED(Z_ARRVAL_P(params)) {
- param = EX_VAR_NUM(EX(func)->op_array.last_var + EX(func)->op_array.T);
- if (UNEXPECTED((EX(func)->op_array.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) != 0)) {
- do {
- zend_verify_arg_type(EX(func), arg_num, param, NULL, CACHE_ADDR(opline->op2.num));
- if (Z_OPT_REFCOUNTED_P(param)) Z_ADDREF_P(param);
- ZEND_HASH_FILL_ADD(param);
- param++;
- } while (++arg_num <= arg_count);
- } else {
- do {
- if (Z_OPT_REFCOUNTED_P(param)) Z_ADDREF_P(param);
- ZEND_HASH_FILL_ADD(param);
- param++;
- } while (++arg_num <= arg_count);
- }
- } ZEND_HASH_FILL_END();
- } else {
- ZVAL_EMPTY_ARRAY(params);
- }
-
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
-}
-
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BEGIN_SILENCE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
zend_class_entry *trait;
SAVE_OPLINE();
- trait = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)));
+ trait = CACHED_PTR(opline->extended_value);
if (UNEXPECTED(trait == NULL)) {
trait = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)),
RT_CONSTANT(opline, opline->op2) + 1,
if (!(trait->ce_flags & ZEND_ACC_TRAIT)) {
zend_error_noreturn(E_ERROR, "%s cannot use %s - it is not a trait", ZSTR_VAL(ce->name), ZSTR_VAL(trait->name));
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), trait);
+ CACHE_PTR(opline->extended_value, trait);
}
zend_do_implement_trait(ce, trait);
zval *function_name, *func;
zend_execute_data *call;
- function_name = (zval*)RT_CONSTANT(opline, opline->op2);
- fbc = CACHED_PTR(Z_CACHE_SLOT_P(function_name));
+ fbc = CACHED_PTR(opline->result.num);
if (UNEXPECTED(fbc == NULL)) {
+ function_name = (zval*)RT_CONSTANT(opline, opline->op2);
func = zend_hash_find_ex(EG(function_table), Z_STR_P(function_name+1), 1);
if (UNEXPECTED(func == NULL)) {
SAVE_OPLINE();
if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) {
init_func_run_time_cache(&fbc->op_array);
}
- CACHE_PTR(Z_CACHE_SLOT_P(function_name), fbc);
+ CACHE_PTR(opline->result.num, fbc);
}
call = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
fbc, opline->extended_value, NULL, NULL);
zend_function *fbc;
zend_execute_data *call;
- func_name = RT_CONSTANT(opline, opline->op2) + 1;
- fbc = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)));
+ fbc = CACHED_PTR(opline->result.num);
if (UNEXPECTED(fbc == NULL)) {
+ func_name = RT_CONSTANT(opline, opline->op2) + 1;
func = zend_hash_find_ex(EG(function_table), Z_STR_P(func_name), 1);
if (func == NULL) {
func_name++;
}
}
fbc = Z_FUNC_P(func);
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), fbc);
+ CACHE_PTR(opline->result.num, fbc);
if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) {
init_func_run_time_cache(&fbc->op_array);
}
{
USE_OPLINE
- zval *fname = RT_CONSTANT(opline, opline->op2);
+ zval *fname;
zval *func;
zend_function *fbc;
zend_execute_data *call;
- fbc = CACHED_PTR(Z_CACHE_SLOT_P(fname));
+ fbc = CACHED_PTR(opline->result.num);
if (UNEXPECTED(fbc == NULL)) {
+ fname = RT_CONSTANT(opline, opline->op2);
func = zend_hash_find_ex(EG(function_table), Z_STR_P(fname), 1);
if (UNEXPECTED(func == NULL)) {
SAVE_OPLINE();
HANDLE_EXCEPTION();
}
fbc = Z_FUNC_P(func);
- CACHE_PTR(Z_CACHE_SLOT_P(fname), fbc);
+ CACHE_PTR(opline->result.num, fbc);
if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) {
init_func_run_time_cache(&fbc->op_array);
}
zval *default_value = RT_CONSTANT(opline, opline->op2);
SAVE_OPLINE();
- if (UNEXPECTED(!zend_verify_arg_type(EX(func), arg_num, param, default_value, CACHE_ADDR(Z_CACHE_SLOT_P(default_value))) || EG(exception))) {
+ if (UNEXPECTED(!zend_verify_arg_type(EX(func), arg_num, param, default_value, CACHE_ADDR(opline->extended_value)) || EG(exception))) {
HANDLE_EXCEPTION();
}
}
zend_class_entry *iface;
SAVE_OPLINE();
- iface = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)));
+ iface = CACHED_PTR(opline->extended_value);
if (UNEXPECTED(iface == NULL)) {
iface = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), RT_CONSTANT(opline, opline->op2) + 1, ZEND_FETCH_CLASS_INTERFACE);
if (UNEXPECTED(iface == NULL)) {
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), iface);
+ CACHE_PTR(opline->extended_value, iface);
}
if (UNEXPECTED((iface->ce_flags & ZEND_ACC_INTERFACE) == 0)) {
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RECV_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+ USE_OPLINE
+ uint32_t arg_num = opline->op1.num;
+
+ if (UNEXPECTED(arg_num > EX_NUM_ARGS())) {
+ SAVE_OPLINE();
+ zend_missing_arg_error(execute_data);
+ HANDLE_EXCEPTION();
+ } else if (UNEXPECTED((EX(func)->op_array.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) != 0)) {
+ zval *param = _get_zval_ptr_cv_undef_BP_VAR_W(opline->result.var EXECUTE_DATA_CC);
+
+ SAVE_OPLINE();
+ if (UNEXPECTED(!zend_verify_arg_type(EX(func), arg_num, param, NULL, CACHE_ADDR(opline->op2.num)) || EG(exception))) {
+ HANDLE_EXCEPTION();
+ }
+ }
+
+ ZEND_VM_NEXT_OPCODE();
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RECV_VARIADIC_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+ USE_OPLINE
+ uint32_t arg_num = opline->op1.num;
+ uint32_t arg_count = EX_NUM_ARGS();
+ zval *params;
+
+ SAVE_OPLINE();
+
+ params = _get_zval_ptr_cv_undef_BP_VAR_W(opline->result.var EXECUTE_DATA_CC);
+
+ if (arg_num <= arg_count) {
+ zval *param;
+
+ array_init_size(params, arg_count - arg_num + 1);
+ zend_hash_real_init(Z_ARRVAL_P(params), 1);
+ ZEND_HASH_FILL_PACKED(Z_ARRVAL_P(params)) {
+ param = EX_VAR_NUM(EX(func)->op_array.last_var + EX(func)->op_array.T);
+ if (UNEXPECTED((EX(func)->op_array.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) != 0)) {
+ do {
+ zend_verify_arg_type(EX(func), arg_num, param, NULL, CACHE_ADDR(opline->op2.num));
+ if (Z_OPT_REFCOUNTED_P(param)) Z_ADDREF_P(param);
+ ZEND_HASH_FILL_ADD(param);
+ param++;
+ } while (++arg_num <= arg_count);
+ } else {
+ do {
+ if (Z_OPT_REFCOUNTED_P(param)) Z_ADDREF_P(param);
+ ZEND_HASH_FILL_ADD(param);
+ param++;
+ } while (++arg_num <= arg_count);
+ }
+ } ZEND_HASH_FILL_END();
+ } else {
+ ZVAL_EMPTY_ARRAY(params);
+ }
+
+ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_DYNAMIC_CALL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op2));
ZEND_VM_CONTINUE();
}
- catch_ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)));
+ catch_ce = CACHED_PTR(opline->extended_value & ~ZEND_LAST_CATCH);
if (UNEXPECTED(catch_ce == NULL)) {
catch_ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), RT_CONSTANT(opline, opline->op1) + 1, ZEND_FETCH_CLASS_NO_AUTOLOAD);
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)), catch_ce);
+ CACHE_PTR(opline->extended_value & ~ZEND_LAST_CATCH, catch_ce);
}
ce = EG(exception)->ce;
if (ce != catch_ce) {
if (!catch_ce || !instanceof_function(ce, catch_ce)) {
- if (opline->extended_value == ZEND_LAST_CATCH) {
+ if (opline->extended_value & ZEND_LAST_CATCH) {
zend_rethrow_exception(execute_data);
HANDLE_EXCEPTION();
}
ZEND_VM_NEXT_OPCODE();
}
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
- USE_OPLINE
- zval *result;
- zend_function *constructor;
- zend_class_entry *ce;
- zend_execute_data *call;
-
- SAVE_OPLINE();
- if (IS_CONST == IS_CONST) {
- ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)));
- if (UNEXPECTED(ce == NULL)) {
- ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), RT_CONSTANT(opline, opline->op1) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
- if (UNEXPECTED(ce == NULL)) {
- ZEND_ASSERT(EG(exception));
- ZVAL_UNDEF(EX_VAR(opline->result.var));
- HANDLE_EXCEPTION();
- }
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)), ce);
- }
- } else if (IS_CONST == IS_UNUSED) {
- ce = zend_fetch_class(NULL, opline->op1.num);
- if (UNEXPECTED(ce == NULL)) {
- ZEND_ASSERT(EG(exception));
- ZVAL_UNDEF(EX_VAR(opline->result.var));
- HANDLE_EXCEPTION();
- }
- } else {
- ce = Z_CE_P(EX_VAR(opline->op1.var));
- }
-
- result = EX_VAR(opline->result.var);
- if (UNEXPECTED(object_init_ex(result, ce) != SUCCESS)) {
- ZVAL_UNDEF(result);
- HANDLE_EXCEPTION();
- }
-
- constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result));
- if (constructor == NULL) {
- if (UNEXPECTED(EG(exception))) {
- HANDLE_EXCEPTION();
- }
-
- /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next
- * opcode is DO_FCALL in case EXT instructions are used. */
- if (EXPECTED(opline->extended_value == 0 && (opline+1)->opcode == ZEND_DO_FCALL)) {
- ZEND_VM_NEXT_OPCODE_EX(1, 2);
- }
-
- /* Perform a dummy function call */
- call = zend_vm_stack_push_call_frame(
- ZEND_CALL_FUNCTION, (zend_function *) &zend_pass_function,
- opline->extended_value, NULL, NULL);
- } else {
- if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!constructor->op_array.run_time_cache)) {
- init_func_run_time_cache(&constructor->op_array);
- }
- /* We are not handling overloaded classes right now */
- call = zend_vm_stack_push_call_frame(
- ZEND_CALL_FUNCTION | ZEND_CALL_RELEASE_THIS | ZEND_CALL_CTOR,
- constructor,
- opline->extended_value,
- ce,
- Z_OBJ_P(result));
- Z_ADDREF_P(result);
- }
-
- call->prev_execute_data = EX(call);
- EX(call) = call;
- ZEND_VM_NEXT_OPCODE();
-}
-
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
zend_constant *c;
int result;
- if (EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1))))) {
+ if (EXPECTED(CACHED_PTR(opline->extended_value))) {
result = 1;
} else if ((c = zend_quick_get_constant(RT_CONSTANT(opline, opline->op1), 0)) == NULL) {
result = 0;
} else {
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)), c);
+ CACHE_PTR(opline->extended_value, c);
result = 1;
}
ZEND_VM_SMART_BRANCH(result, 0);
zval *varname;
zval *retval;
+ zend_string *name, *tmp_name;
+ zend_class_entry *ce;
SAVE_OPLINE();
- varname = RT_CONSTANT(opline, opline->op1);
- retval = zend_fetch_static_property_address(varname, IS_CONST, opline->op2, IS_CONST, type EXECUTE_DATA_CC OPLINE_CC);
+ do {
+ if (IS_CONST == IS_CONST) {
+ if (IS_CONST == IS_CONST && EXPECTED((ce = CACHED_PTR(opline->extended_value)) != NULL)) {
+ retval = CACHED_PTR(opline->extended_value + sizeof(void*));
+
+ /* check if static properties were destoyed */
+ if (EXPECTED(CE_STATIC_MEMBERS(ce) != NULL)) {
+
+ break;
+ }
+ } else {
+ zval *class_name = RT_CONSTANT(opline, opline->op2);
+
+ if (UNEXPECTED((ce = CACHED_PTR(opline->extended_value)) == NULL)) {
+ ce = zend_fetch_class_by_name(Z_STR_P(class_name), class_name + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
+ if (UNEXPECTED(ce == NULL)) {
+
+ retval = NULL;
+ break;
+ }
+ if (IS_CONST != IS_CONST) {
+ CACHE_PTR(opline->extended_value, ce);
+ }
+ }
+ }
+ } else {
+ if (IS_CONST == IS_UNUSED) {
+ ce = zend_fetch_class(NULL, opline->op2.num);
+ if (UNEXPECTED(ce == NULL)) {
+
+ retval = NULL;
+ break;
+ }
+ } else {
+ ce = Z_CE_P(EX_VAR(opline->op2.var));
+ }
+ if (IS_CONST == IS_CONST &&
+ EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
+ retval = CACHED_PTR(opline->extended_value + sizeof(void*));
+
+ /* check if static properties were destoyed */
+ if (EXPECTED(CE_STATIC_MEMBERS(ce) != NULL)) {
+
+ break;
+ }
+ }
+ }
+
+ varname = RT_CONSTANT(opline, opline->op1);
+ if (IS_CONST == IS_CONST) {
+ name = Z_STR_P(varname);
+ } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
+ name = Z_STR_P(varname);
+ tmp_name = NULL;
+ } else {
+ if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
+ zval_undefined_cv(EX(opline)->op1.var EXECUTE_DATA_CC);
+ }
+ name = zval_get_tmp_string(varname, &tmp_name);
+ }
+
+ retval = zend_std_get_static_property(ce, name, type == BP_VAR_IS);
+
+ if (IS_CONST != IS_CONST) {
+ zend_tmp_string_release(tmp_name);
+ }
+
+ if (IS_CONST == IS_CONST && EXPECTED(retval)) {
+ CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, retval);
+ }
+
+ } while (0);
if (UNEXPECTED(retval == NULL)) {
if (EG(exception)) {
-
ZVAL_UNDEF(EX_VAR(opline->result.var));
HANDLE_EXCEPTION();
} else {
zval *retval;
if (IS_CONST == IS_CONST) {
- cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
+ cache_slot = CACHE_ADDR(opline->extended_value);
if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
zval *retval;
if (IS_CONST == IS_CONST) {
- cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
+ cache_slot = CACHE_ADDR(opline->extended_value);
if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
}
- function_name = RT_CONSTANT(opline, opline->op2);
+ if (IS_CONST != IS_CONST) {
+ function_name = RT_CONSTANT(opline, opline->op2);
+ }
if (IS_CONST != IS_CONST &&
UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
HANDLE_EXCEPTION();
}
}
+ if (IS_CONST == IS_CONST) {
+ function_name = RT_CONSTANT(opline, opline->op2);
+ }
zend_throw_error(NULL, "Call to a member function %s() on %s", Z_STRVAL_P(function_name), zend_get_type_by_const(Z_TYPE_P(object)));
called_scope = obj->ce;
if (IS_CONST == IS_CONST &&
- EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(function_name)) == called_scope)) {
- fbc = CACHED_PTR(Z_CACHE_SLOT_P(function_name) + sizeof(void*));
+ EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
+ fbc = CACHED_PTR(opline->result.num + sizeof(void*));
} else {
zend_object *orig_obj = obj;
HANDLE_EXCEPTION();
}
+ if (IS_CONST == IS_CONST) {
+ function_name = RT_CONSTANT(opline, opline->op2);
+ }
+
/* First, locate the function. */
fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
if (UNEXPECTED(fbc == NULL)) {
EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
EXPECTED(obj == orig_obj)) {
- CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), called_scope, fbc);
+ CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
}
if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) {
init_func_run_time_cache(&fbc->op_array);
if (IS_CONST == IS_CONST) {
/* no function found. try a static method in class */
- ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)));
+ ce = CACHED_PTR(opline->result.num);
if (UNEXPECTED(ce == NULL)) {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), RT_CONSTANT(opline, opline->op1) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
HANDLE_EXCEPTION();
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)), ce);
+ if (IS_CONST != IS_CONST) {
+ CACHE_PTR(opline->result.num, ce);
+ }
}
} else if (IS_CONST == IS_UNUSED) {
ce = zend_fetch_class(NULL, opline->op1.num);
if (IS_CONST == IS_CONST &&
IS_CONST == IS_CONST &&
- EXPECTED((fbc = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)))) != NULL)) {
+ EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
/* nothing to do */
} else if (IS_CONST != IS_CONST &&
IS_CONST == IS_CONST &&
- EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2))) == ce)) {
- fbc = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)) + sizeof(void*));
+ EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
+ fbc = CACHED_PTR(opline->result.num + sizeof(void*));
} else if (IS_CONST != IS_UNUSED) {
if (IS_CONST == IS_CONST &&
EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE)))) {
- if (IS_CONST == IS_CONST) {
- CACHE_PTR(Z_CACHE_SLOT_P(function_name), fbc);
- } else {
- CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), ce, fbc);
- }
+ CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
}
if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) {
init_func_run_time_cache(&fbc->op_array);
do {
if (IS_CONST == IS_CONST) {
- if (EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2))))) {
- value = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)));
+ if (EXPECTED(CACHED_PTR(opline->extended_value + sizeof(void*)))) {
+ value = CACHED_PTR(opline->extended_value + sizeof(void*));
break;
- } else if (EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1))))) {
- ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)));
+ } else if (EXPECTED(CACHED_PTR(opline->extended_value))) {
+ ce = CACHED_PTR(opline->extended_value);
} else {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), RT_CONSTANT(opline, opline->op1) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
if (UNEXPECTED(ce == NULL)) {
ZVAL_UNDEF(EX_VAR(opline->result.var));
HANDLE_EXCEPTION();
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)), ce);
}
} else {
if (IS_CONST == IS_UNUSED) {
} else {
ce = Z_CE_P(EX_VAR(opline->op1.var));
}
- if (EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2))) == ce)) {
- value = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)) + sizeof(void*));
+ if (EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
+ value = CACHED_PTR(opline->extended_value + sizeof(void*));
break;
}
}
HANDLE_EXCEPTION();
}
}
- if (IS_CONST == IS_CONST) {
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), value);
- } else {
- CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), ce, value);
- }
+ CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, value);
} else {
zend_throw_error(NULL, "Undefined class constant '%s'", Z_STRVAL_P(RT_CONSTANT(opline, opline->op2)));
ZVAL_UNDEF(EX_VAR(opline->result.var));
SAVE_OPLINE();
- varname = RT_CONSTANT(opline, opline->op1);
-
- if (IS_CONST == IS_CONST) {
- name = Z_STR_P(varname);
- } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
- name = Z_STR_P(varname);
- tmp_name = NULL;
- } else {
- if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
- varname = GET_OP1_UNDEF_CV(varname, BP_VAR_R);
- }
- name = zval_get_tmp_string(varname, &tmp_name);
- }
-
if (IS_CONST == IS_CONST) {
- ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)));
+ ce = CACHED_PTR(opline->extended_value);
if (UNEXPECTED(ce == NULL)) {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), RT_CONSTANT(opline, opline->op2) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
- if (IS_CONST != IS_CONST) {
- zend_tmp_string_release(tmp_name);
- }
HANDLE_EXCEPTION();
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), ce);
+ /*CACHE_PTR(opline->extended_value, ce);*/
}
} else if (IS_CONST == IS_UNUSED) {
ce = zend_fetch_class(NULL, opline->op2.num);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
- if (IS_CONST != IS_CONST) {
- zend_tmp_string_release(tmp_name);
- }
HANDLE_EXCEPTION();
}
} else {
ce = Z_CE_P(EX_VAR(opline->op2.var));
}
+
+ varname = RT_CONSTANT(opline, opline->op1);
+ if (IS_CONST == IS_CONST) {
+ name = Z_STR_P(varname);
+ } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
+ name = Z_STR_P(varname);
+ tmp_name = NULL;
+ } else {
+ if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
+ varname = GET_OP1_UNDEF_CV(varname, BP_VAR_R);
+ }
+ name = zval_get_tmp_string(varname, &tmp_name);
+ }
+
zend_std_unset_static_property(ce, name);
if (IS_CONST != IS_CONST) {
zend_class_entry *ce;
SAVE_OPLINE();
- varname = RT_CONSTANT(opline, opline->op1);
if (IS_CONST == IS_CONST) {
- name = Z_STR_P(varname);
- } else {
- name = zval_get_tmp_string(varname, &tmp_name);
- }
-
- if (IS_CONST == IS_CONST) {
- if (IS_CONST == IS_CONST && EXPECTED((ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)))) != NULL)) {
- value = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)) + sizeof(void*));
+ if (IS_CONST == IS_CONST && EXPECTED((ce = CACHED_PTR(opline->extended_value & ~ZEND_ISSET)) != NULL)) {
+ value = CACHED_PTR((opline->extended_value & ~ZEND_ISSET) + sizeof(void*));
/* check if static properties were destoyed */
if (UNEXPECTED(CE_STATIC_MEMBERS(ce) == NULL)) {
}
goto is_static_prop_return;
- } else if (UNEXPECTED((ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)))) == NULL)) {
+ } else if (UNEXPECTED((ce = CACHED_PTR(opline->extended_value & ~ZEND_ISSET)) == NULL)) {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), RT_CONSTANT(opline, opline->op2) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
ZVAL_UNDEF(EX_VAR(opline->result.var));
HANDLE_EXCEPTION();
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), ce);
+ if (IS_CONST != IS_CONST) {
+ CACHE_PTR(opline->extended_value & ~ZEND_ISSET, ce);
+ }
}
} else {
if (IS_CONST == IS_UNUSED) {
ce = zend_fetch_class(NULL, opline->op2.num);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
- if (IS_CONST != IS_CONST) {
- zend_tmp_string_release(tmp_name);
- }
ZVAL_UNDEF(EX_VAR(opline->result.var));
HANDLE_EXCEPTION();
ce = Z_CE_P(EX_VAR(opline->op2.var));
}
if (IS_CONST == IS_CONST &&
- EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1))) == ce)) {
+ EXPECTED(CACHED_PTR(opline->extended_value & ~ZEND_ISSET) == ce)) {
- value = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)) + sizeof(void*));
+ value = CACHED_PTR((opline->extended_value & ~ZEND_ISSET) + sizeof(void*));
/* check if static properties were destoyed */
if (UNEXPECTED(CE_STATIC_MEMBERS(ce) == NULL)) {
}
}
+ varname = RT_CONSTANT(opline, opline->op1);
+ if (IS_CONST == IS_CONST) {
+ name = Z_STR_P(varname);
+ } else {
+ name = zval_get_tmp_string(varname, &tmp_name);
+ }
+
value = zend_std_get_static_property(ce, name, 1);
if (IS_CONST == IS_CONST && value) {
- CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)), ce, value);
+ CACHE_POLYMORPHIC_PTR(opline->extended_value & ~ZEND_ISSET, ce, value);
}
if (IS_CONST != IS_CONST) {
} else {
result =
((opline->extended_value & ZEND_ISSET) == 0) ^
- Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(offset)) : NULL));
+ Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISSET) : NULL));
}
zval *retval;
if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
- cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
+ cache_slot = CACHE_ADDR(opline->extended_value);
if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
zval *retval;
if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
- cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
+ cache_slot = CACHE_ADDR(opline->extended_value);
if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
}
- function_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+ if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
+ function_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+ }
if ((IS_TMP_VAR|IS_VAR) != IS_CONST &&
UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
HANDLE_EXCEPTION();
}
}
+ if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+ function_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+ }
zend_throw_error(NULL, "Call to a member function %s() on %s", Z_STRVAL_P(function_name), zend_get_type_by_const(Z_TYPE_P(object)));
zval_ptr_dtor_nogc(free_op2);
called_scope = obj->ce;
if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
- EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(function_name)) == called_scope)) {
- fbc = CACHED_PTR(Z_CACHE_SLOT_P(function_name) + sizeof(void*));
+ EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
+ fbc = CACHED_PTR(opline->result.num + sizeof(void*));
} else {
zend_object *orig_obj = obj;
HANDLE_EXCEPTION();
}
+ if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+ function_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+ }
+
/* First, locate the function. */
fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
if (UNEXPECTED(fbc == NULL)) {
EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
EXPECTED(obj == orig_obj)) {
- CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), called_scope, fbc);
+ CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
}
if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) {
init_func_run_time_cache(&fbc->op_array);
if (IS_CONST == IS_CONST) {
/* no function found. try a static method in class */
- ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)));
+ ce = CACHED_PTR(opline->result.num);
if (UNEXPECTED(ce == NULL)) {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), RT_CONSTANT(opline, opline->op1) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
HANDLE_EXCEPTION();
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)), ce);
+ if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
+ CACHE_PTR(opline->result.num, ce);
+ }
}
} else if (IS_CONST == IS_UNUSED) {
ce = zend_fetch_class(NULL, opline->op1.num);
if (IS_CONST == IS_CONST &&
(IS_TMP_VAR|IS_VAR) == IS_CONST &&
- EXPECTED((fbc = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)))) != NULL)) {
+ EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
/* nothing to do */
} else if (IS_CONST != IS_CONST &&
(IS_TMP_VAR|IS_VAR) == IS_CONST &&
- EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2))) == ce)) {
- fbc = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)) + sizeof(void*));
+ EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
+ fbc = CACHED_PTR(opline->result.num + sizeof(void*));
} else if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
zend_free_op free_op2;
if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE)))) {
- if (IS_CONST == IS_CONST) {
- CACHE_PTR(Z_CACHE_SLOT_P(function_name), fbc);
- } else {
- CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), ce, fbc);
- }
+ CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
}
if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) {
init_func_run_time_cache(&fbc->op_array);
} else {
result =
((opline->extended_value & ZEND_ISSET) == 0) ^
- Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(offset)) : NULL));
+ Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISSET) : NULL));
}
zval_ptr_dtor_nogc(free_op2);
zval *varname;
zval *retval;
+ zend_string *name, *tmp_name;
+ zend_class_entry *ce;
SAVE_OPLINE();
- varname = RT_CONSTANT(opline, opline->op1);
- retval = zend_fetch_static_property_address(varname, IS_CONST, opline->op2, IS_VAR, type EXECUTE_DATA_CC OPLINE_CC);
+ do {
+ if (IS_VAR == IS_CONST) {
+ if (IS_CONST == IS_CONST && EXPECTED((ce = CACHED_PTR(opline->extended_value)) != NULL)) {
+ retval = CACHED_PTR(opline->extended_value + sizeof(void*));
+
+ /* check if static properties were destoyed */
+ if (EXPECTED(CE_STATIC_MEMBERS(ce) != NULL)) {
+
+ break;
+ }
+ } else {
+ zval *class_name = RT_CONSTANT(opline, opline->op2);
+
+ if (UNEXPECTED((ce = CACHED_PTR(opline->extended_value)) == NULL)) {
+ ce = zend_fetch_class_by_name(Z_STR_P(class_name), class_name + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
+ if (UNEXPECTED(ce == NULL)) {
+
+ retval = NULL;
+ break;
+ }
+ if (IS_CONST != IS_CONST) {
+ CACHE_PTR(opline->extended_value, ce);
+ }
+ }
+ }
+ } else {
+ if (IS_VAR == IS_UNUSED) {
+ ce = zend_fetch_class(NULL, opline->op2.num);
+ if (UNEXPECTED(ce == NULL)) {
+
+ retval = NULL;
+ break;
+ }
+ } else {
+ ce = Z_CE_P(EX_VAR(opline->op2.var));
+ }
+ if (IS_CONST == IS_CONST &&
+ EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
+ retval = CACHED_PTR(opline->extended_value + sizeof(void*));
+
+ /* check if static properties were destoyed */
+ if (EXPECTED(CE_STATIC_MEMBERS(ce) != NULL)) {
+
+ break;
+ }
+ }
+ }
+
+ varname = RT_CONSTANT(opline, opline->op1);
+ if (IS_CONST == IS_CONST) {
+ name = Z_STR_P(varname);
+ } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
+ name = Z_STR_P(varname);
+ tmp_name = NULL;
+ } else {
+ if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
+ zval_undefined_cv(EX(opline)->op1.var EXECUTE_DATA_CC);
+ }
+ name = zval_get_tmp_string(varname, &tmp_name);
+ }
+
+ retval = zend_std_get_static_property(ce, name, type == BP_VAR_IS);
+
+ if (IS_CONST != IS_CONST) {
+ zend_tmp_string_release(tmp_name);
+ }
+
+ if (IS_CONST == IS_CONST && EXPECTED(retval)) {
+ CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, retval);
+ }
+
+ } while (0);
if (UNEXPECTED(retval == NULL)) {
if (EG(exception)) {
-
ZVAL_UNDEF(EX_VAR(opline->result.var));
HANDLE_EXCEPTION();
} else {
SAVE_OPLINE();
- varname = RT_CONSTANT(opline, opline->op1);
-
- if (IS_CONST == IS_CONST) {
- name = Z_STR_P(varname);
- } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
- name = Z_STR_P(varname);
- tmp_name = NULL;
- } else {
- if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
- varname = GET_OP1_UNDEF_CV(varname, BP_VAR_R);
- }
- name = zval_get_tmp_string(varname, &tmp_name);
- }
-
if (IS_VAR == IS_CONST) {
- ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)));
+ ce = CACHED_PTR(opline->extended_value);
if (UNEXPECTED(ce == NULL)) {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), RT_CONSTANT(opline, opline->op2) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
- if (IS_CONST != IS_CONST) {
- zend_tmp_string_release(tmp_name);
- }
HANDLE_EXCEPTION();
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), ce);
+ /*CACHE_PTR(opline->extended_value, ce);*/
}
} else if (IS_VAR == IS_UNUSED) {
ce = zend_fetch_class(NULL, opline->op2.num);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
- if (IS_CONST != IS_CONST) {
- zend_tmp_string_release(tmp_name);
- }
HANDLE_EXCEPTION();
}
} else {
ce = Z_CE_P(EX_VAR(opline->op2.var));
}
+
+ varname = RT_CONSTANT(opline, opline->op1);
+ if (IS_CONST == IS_CONST) {
+ name = Z_STR_P(varname);
+ } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
+ name = Z_STR_P(varname);
+ tmp_name = NULL;
+ } else {
+ if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
+ varname = GET_OP1_UNDEF_CV(varname, BP_VAR_R);
+ }
+ name = zval_get_tmp_string(varname, &tmp_name);
+ }
+
zend_std_unset_static_property(ce, name);
if (IS_CONST != IS_CONST) {
zend_class_entry *ce;
SAVE_OPLINE();
- varname = RT_CONSTANT(opline, opline->op1);
- if (IS_CONST == IS_CONST) {
- name = Z_STR_P(varname);
- } else {
- name = zval_get_tmp_string(varname, &tmp_name);
- }
-
if (IS_VAR == IS_CONST) {
- if (IS_CONST == IS_CONST && EXPECTED((ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)))) != NULL)) {
- value = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)) + sizeof(void*));
+ if (IS_CONST == IS_CONST && EXPECTED((ce = CACHED_PTR(opline->extended_value & ~ZEND_ISSET)) != NULL)) {
+ value = CACHED_PTR((opline->extended_value & ~ZEND_ISSET) + sizeof(void*));
/* check if static properties were destoyed */
if (UNEXPECTED(CE_STATIC_MEMBERS(ce) == NULL)) {
}
goto is_static_prop_return;
- } else if (UNEXPECTED((ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)))) == NULL)) {
+ } else if (UNEXPECTED((ce = CACHED_PTR(opline->extended_value & ~ZEND_ISSET)) == NULL)) {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), RT_CONSTANT(opline, opline->op2) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
ZVAL_UNDEF(EX_VAR(opline->result.var));
HANDLE_EXCEPTION();
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), ce);
+ if (IS_CONST != IS_CONST) {
+ CACHE_PTR(opline->extended_value & ~ZEND_ISSET, ce);
+ }
}
} else {
if (IS_VAR == IS_UNUSED) {
ce = zend_fetch_class(NULL, opline->op2.num);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
- if (IS_CONST != IS_CONST) {
- zend_tmp_string_release(tmp_name);
- }
ZVAL_UNDEF(EX_VAR(opline->result.var));
HANDLE_EXCEPTION();
ce = Z_CE_P(EX_VAR(opline->op2.var));
}
if (IS_CONST == IS_CONST &&
- EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1))) == ce)) {
+ EXPECTED(CACHED_PTR(opline->extended_value & ~ZEND_ISSET) == ce)) {
- value = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)) + sizeof(void*));
+ value = CACHED_PTR((opline->extended_value & ~ZEND_ISSET) + sizeof(void*));
/* check if static properties were destoyed */
if (UNEXPECTED(CE_STATIC_MEMBERS(ce) == NULL)) {
}
}
+ varname = RT_CONSTANT(opline, opline->op1);
+ if (IS_CONST == IS_CONST) {
+ name = Z_STR_P(varname);
+ } else {
+ name = zval_get_tmp_string(varname, &tmp_name);
+ }
+
value = zend_std_get_static_property(ce, name, 1);
if (IS_CONST == IS_CONST && value) {
- CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)), ce, value);
+ CACHE_POLYMORPHIC_PTR(opline->extended_value & ~ZEND_ISSET, ce, value);
}
if (IS_CONST != IS_CONST) {
zval *varname;
zval *retval;
+ zend_string *name, *tmp_name;
+ zend_class_entry *ce;
SAVE_OPLINE();
- varname = RT_CONSTANT(opline, opline->op1);
- retval = zend_fetch_static_property_address(varname, IS_CONST, opline->op2, IS_UNUSED, type EXECUTE_DATA_CC OPLINE_CC);
+ do {
+ if (IS_UNUSED == IS_CONST) {
+ if (IS_CONST == IS_CONST && EXPECTED((ce = CACHED_PTR(opline->extended_value)) != NULL)) {
+ retval = CACHED_PTR(opline->extended_value + sizeof(void*));
+
+ /* check if static properties were destoyed */
+ if (EXPECTED(CE_STATIC_MEMBERS(ce) != NULL)) {
+
+ break;
+ }
+ } else {
+ zval *class_name = RT_CONSTANT(opline, opline->op2);
+
+ if (UNEXPECTED((ce = CACHED_PTR(opline->extended_value)) == NULL)) {
+ ce = zend_fetch_class_by_name(Z_STR_P(class_name), class_name + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
+ if (UNEXPECTED(ce == NULL)) {
+
+ retval = NULL;
+ break;
+ }
+ if (IS_CONST != IS_CONST) {
+ CACHE_PTR(opline->extended_value, ce);
+ }
+ }
+ }
+ } else {
+ if (IS_UNUSED == IS_UNUSED) {
+ ce = zend_fetch_class(NULL, opline->op2.num);
+ if (UNEXPECTED(ce == NULL)) {
+
+ retval = NULL;
+ break;
+ }
+ } else {
+ ce = Z_CE_P(EX_VAR(opline->op2.var));
+ }
+ if (IS_CONST == IS_CONST &&
+ EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
+ retval = CACHED_PTR(opline->extended_value + sizeof(void*));
+
+ /* check if static properties were destoyed */
+ if (EXPECTED(CE_STATIC_MEMBERS(ce) != NULL)) {
+
+ break;
+ }
+ }
+ }
+
+ varname = RT_CONSTANT(opline, opline->op1);
+ if (IS_CONST == IS_CONST) {
+ name = Z_STR_P(varname);
+ } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
+ name = Z_STR_P(varname);
+ tmp_name = NULL;
+ } else {
+ if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
+ zval_undefined_cv(EX(opline)->op1.var EXECUTE_DATA_CC);
+ }
+ name = zval_get_tmp_string(varname, &tmp_name);
+ }
+
+ retval = zend_std_get_static_property(ce, name, type == BP_VAR_IS);
+
+ if (IS_CONST != IS_CONST) {
+ zend_tmp_string_release(tmp_name);
+ }
+
+ if (IS_CONST == IS_CONST && EXPECTED(retval)) {
+ CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, retval);
+ }
+
+ } while (0);
if (UNEXPECTED(retval == NULL)) {
if (EG(exception)) {
-
ZVAL_UNDEF(EX_VAR(opline->result.var));
HANDLE_EXCEPTION();
} else {
if (IS_CONST == IS_CONST) {
/* no function found. try a static method in class */
- ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)));
+ ce = CACHED_PTR(opline->result.num);
if (UNEXPECTED(ce == NULL)) {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), RT_CONSTANT(opline, opline->op1) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
HANDLE_EXCEPTION();
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)), ce);
+ if (IS_UNUSED != IS_CONST) {
+ CACHE_PTR(opline->result.num, ce);
+ }
}
} else if (IS_CONST == IS_UNUSED) {
ce = zend_fetch_class(NULL, opline->op1.num);
if (IS_CONST == IS_CONST &&
IS_UNUSED == IS_CONST &&
- EXPECTED((fbc = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)))) != NULL)) {
+ EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
/* nothing to do */
} else if (IS_CONST != IS_CONST &&
IS_UNUSED == IS_CONST &&
- EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2))) == ce)) {
- fbc = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)) + sizeof(void*));
+ EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
+ fbc = CACHED_PTR(opline->result.num + sizeof(void*));
} else if (IS_UNUSED != IS_UNUSED) {
if (IS_UNUSED == IS_CONST &&
EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE)))) {
- if (IS_CONST == IS_CONST) {
- CACHE_PTR(Z_CACHE_SLOT_P(function_name), fbc);
- } else {
- CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), ce, fbc);
- }
+ CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
}
if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) {
init_func_run_time_cache(&fbc->op_array);
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+ USE_OPLINE
+ zval *result;
+ zend_function *constructor;
+ zend_class_entry *ce;
+ zend_execute_data *call;
+
+ SAVE_OPLINE();
+ if (IS_CONST == IS_CONST) {
+ ce = CACHED_PTR(opline->op2.num);
+ if (UNEXPECTED(ce == NULL)) {
+ ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), RT_CONSTANT(opline, opline->op1) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
+ if (UNEXPECTED(ce == NULL)) {
+ ZEND_ASSERT(EG(exception));
+ ZVAL_UNDEF(EX_VAR(opline->result.var));
+ HANDLE_EXCEPTION();
+ }
+ CACHE_PTR(opline->op2.num, ce);
+ }
+ } else if (IS_CONST == IS_UNUSED) {
+ ce = zend_fetch_class(NULL, opline->op1.num);
+ if (UNEXPECTED(ce == NULL)) {
+ ZEND_ASSERT(EG(exception));
+ ZVAL_UNDEF(EX_VAR(opline->result.var));
+ HANDLE_EXCEPTION();
+ }
+ } else {
+ ce = Z_CE_P(EX_VAR(opline->op1.var));
+ }
+
+ result = EX_VAR(opline->result.var);
+ if (UNEXPECTED(object_init_ex(result, ce) != SUCCESS)) {
+ ZVAL_UNDEF(result);
+ HANDLE_EXCEPTION();
+ }
+
+ constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result));
+ if (constructor == NULL) {
+ if (UNEXPECTED(EG(exception))) {
+ HANDLE_EXCEPTION();
+ }
+
+ /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next
+ * opcode is DO_FCALL in case EXT instructions are used. */
+ if (EXPECTED(opline->extended_value == 0 && (opline+1)->opcode == ZEND_DO_FCALL)) {
+ ZEND_VM_NEXT_OPCODE_EX(1, 2);
+ }
+
+ /* Perform a dummy function call */
+ call = zend_vm_stack_push_call_frame(
+ ZEND_CALL_FUNCTION, (zend_function *) &zend_pass_function,
+ opline->extended_value, NULL, NULL);
+ } else {
+ if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!constructor->op_array.run_time_cache)) {
+ init_func_run_time_cache(&constructor->op_array);
+ }
+ /* We are not handling overloaded classes right now */
+ call = zend_vm_stack_push_call_frame(
+ ZEND_CALL_FUNCTION | ZEND_CALL_RELEASE_THIS | ZEND_CALL_CTOR,
+ constructor,
+ opline->extended_value,
+ ce,
+ Z_OBJ_P(result));
+ Z_ADDREF_P(result);
+ }
+
+ call->prev_execute_data = EX(call);
+ EX(call) = call;
+ ZEND_VM_NEXT_OPCODE();
+}
+
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
SAVE_OPLINE();
- varname = RT_CONSTANT(opline, opline->op1);
-
- if (IS_CONST == IS_CONST) {
- name = Z_STR_P(varname);
- } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
- name = Z_STR_P(varname);
- tmp_name = NULL;
- } else {
- if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
- varname = GET_OP1_UNDEF_CV(varname, BP_VAR_R);
- }
- name = zval_get_tmp_string(varname, &tmp_name);
- }
-
if (IS_UNUSED == IS_CONST) {
- ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)));
+ ce = CACHED_PTR(opline->extended_value);
if (UNEXPECTED(ce == NULL)) {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), RT_CONSTANT(opline, opline->op2) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
- if (IS_CONST != IS_CONST) {
- zend_tmp_string_release(tmp_name);
- }
HANDLE_EXCEPTION();
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), ce);
+ /*CACHE_PTR(opline->extended_value, ce);*/
}
} else if (IS_UNUSED == IS_UNUSED) {
ce = zend_fetch_class(NULL, opline->op2.num);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
- if (IS_CONST != IS_CONST) {
- zend_tmp_string_release(tmp_name);
- }
HANDLE_EXCEPTION();
}
} else {
ce = Z_CE_P(EX_VAR(opline->op2.var));
}
+
+ varname = RT_CONSTANT(opline, opline->op1);
+ if (IS_CONST == IS_CONST) {
+ name = Z_STR_P(varname);
+ } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
+ name = Z_STR_P(varname);
+ tmp_name = NULL;
+ } else {
+ if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
+ varname = GET_OP1_UNDEF_CV(varname, BP_VAR_R);
+ }
+ name = zval_get_tmp_string(varname, &tmp_name);
+ }
+
zend_std_unset_static_property(ce, name);
if (IS_CONST != IS_CONST) {
zend_class_entry *ce;
SAVE_OPLINE();
- varname = RT_CONSTANT(opline, opline->op1);
- if (IS_CONST == IS_CONST) {
- name = Z_STR_P(varname);
- } else {
- name = zval_get_tmp_string(varname, &tmp_name);
- }
-
if (IS_UNUSED == IS_CONST) {
- if (IS_CONST == IS_CONST && EXPECTED((ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)))) != NULL)) {
- value = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)) + sizeof(void*));
+ if (IS_CONST == IS_CONST && EXPECTED((ce = CACHED_PTR(opline->extended_value & ~ZEND_ISSET)) != NULL)) {
+ value = CACHED_PTR((opline->extended_value & ~ZEND_ISSET) + sizeof(void*));
/* check if static properties were destoyed */
if (UNEXPECTED(CE_STATIC_MEMBERS(ce) == NULL)) {
}
goto is_static_prop_return;
- } else if (UNEXPECTED((ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)))) == NULL)) {
+ } else if (UNEXPECTED((ce = CACHED_PTR(opline->extended_value & ~ZEND_ISSET)) == NULL)) {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), RT_CONSTANT(opline, opline->op2) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
ZVAL_UNDEF(EX_VAR(opline->result.var));
HANDLE_EXCEPTION();
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), ce);
+ if (IS_CONST != IS_CONST) {
+ CACHE_PTR(opline->extended_value & ~ZEND_ISSET, ce);
+ }
}
} else {
if (IS_UNUSED == IS_UNUSED) {
ce = zend_fetch_class(NULL, opline->op2.num);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
- if (IS_CONST != IS_CONST) {
- zend_tmp_string_release(tmp_name);
- }
ZVAL_UNDEF(EX_VAR(opline->result.var));
HANDLE_EXCEPTION();
ce = Z_CE_P(EX_VAR(opline->op2.var));
}
if (IS_CONST == IS_CONST &&
- EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1))) == ce)) {
+ EXPECTED(CACHED_PTR(opline->extended_value & ~ZEND_ISSET) == ce)) {
- value = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)) + sizeof(void*));
+ value = CACHED_PTR((opline->extended_value & ~ZEND_ISSET) + sizeof(void*));
/* check if static properties were destoyed */
if (UNEXPECTED(CE_STATIC_MEMBERS(ce) == NULL)) {
}
}
+ varname = RT_CONSTANT(opline, opline->op1);
+ if (IS_CONST == IS_CONST) {
+ name = Z_STR_P(varname);
+ } else {
+ name = zval_get_tmp_string(varname, &tmp_name);
+ }
+
value = zend_std_get_static_property(ce, name, 1);
if (IS_CONST == IS_CONST && value) {
- CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)), ce, value);
+ CACHE_POLYMORPHIC_PTR(opline->extended_value & ~ZEND_ISSET, ce, value);
}
if (IS_CONST != IS_CONST) {
zval *retval;
if (IS_CV == IS_CONST) {
- cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
+ cache_slot = CACHE_ADDR(opline->extended_value);
if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
zval *retval;
if (IS_CV == IS_CONST) {
- cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
+ cache_slot = CACHE_ADDR(opline->extended_value);
if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
}
- function_name = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
+ if (IS_CV != IS_CONST) {
+ function_name = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
+ }
if (IS_CV != IS_CONST &&
UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
HANDLE_EXCEPTION();
}
}
+ if (IS_CV == IS_CONST) {
+ function_name = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
+ }
zend_throw_error(NULL, "Call to a member function %s() on %s", Z_STRVAL_P(function_name), zend_get_type_by_const(Z_TYPE_P(object)));
called_scope = obj->ce;
if (IS_CV == IS_CONST &&
- EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(function_name)) == called_scope)) {
- fbc = CACHED_PTR(Z_CACHE_SLOT_P(function_name) + sizeof(void*));
+ EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
+ fbc = CACHED_PTR(opline->result.num + sizeof(void*));
} else {
zend_object *orig_obj = obj;
HANDLE_EXCEPTION();
}
+ if (IS_CV == IS_CONST) {
+ function_name = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
+ }
+
/* First, locate the function. */
fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
if (UNEXPECTED(fbc == NULL)) {
EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
EXPECTED(obj == orig_obj)) {
- CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), called_scope, fbc);
+ CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
}
if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) {
init_func_run_time_cache(&fbc->op_array);
if (IS_CONST == IS_CONST) {
/* no function found. try a static method in class */
- ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)));
+ ce = CACHED_PTR(opline->result.num);
if (UNEXPECTED(ce == NULL)) {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), RT_CONSTANT(opline, opline->op1) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
HANDLE_EXCEPTION();
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)), ce);
+ if (IS_CV != IS_CONST) {
+ CACHE_PTR(opline->result.num, ce);
+ }
}
} else if (IS_CONST == IS_UNUSED) {
ce = zend_fetch_class(NULL, opline->op1.num);
if (IS_CONST == IS_CONST &&
IS_CV == IS_CONST &&
- EXPECTED((fbc = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)))) != NULL)) {
+ EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
/* nothing to do */
} else if (IS_CONST != IS_CONST &&
IS_CV == IS_CONST &&
- EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2))) == ce)) {
- fbc = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)) + sizeof(void*));
+ EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
+ fbc = CACHED_PTR(opline->result.num + sizeof(void*));
} else if (IS_CV != IS_UNUSED) {
if (IS_CV == IS_CONST &&
EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE)))) {
- if (IS_CONST == IS_CONST) {
- CACHE_PTR(Z_CACHE_SLOT_P(function_name), fbc);
- } else {
- CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), ce, fbc);
- }
+ CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
}
if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) {
init_func_run_time_cache(&fbc->op_array);
} else {
result =
((opline->extended_value & ZEND_ISSET) == 0) ^
- Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(offset)) : NULL));
+ Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISSET) : NULL));
}
zend_free_op free_op1;
zval *varname;
zval *retval;
+ zend_string *name, *tmp_name;
+ zend_class_entry *ce;
SAVE_OPLINE();
- varname = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
- retval = zend_fetch_static_property_address(varname, (IS_TMP_VAR|IS_VAR), opline->op2, IS_CONST, type EXECUTE_DATA_CC OPLINE_CC);
+ do {
+ if (IS_CONST == IS_CONST) {
+ if ((IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED((ce = CACHED_PTR(opline->extended_value)) != NULL)) {
+ retval = CACHED_PTR(opline->extended_value + sizeof(void*));
+
+ /* check if static properties were destoyed */
+ if (EXPECTED(CE_STATIC_MEMBERS(ce) != NULL)) {
+ zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
+ break;
+ }
+ } else {
+ zval *class_name = RT_CONSTANT(opline, opline->op2);
+
+ if (UNEXPECTED((ce = CACHED_PTR(opline->extended_value)) == NULL)) {
+ ce = zend_fetch_class_by_name(Z_STR_P(class_name), class_name + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
+ if (UNEXPECTED(ce == NULL)) {
+ zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
+ retval = NULL;
+ break;
+ }
+ if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
+ CACHE_PTR(opline->extended_value, ce);
+ }
+ }
+ }
+ } else {
+ if (IS_CONST == IS_UNUSED) {
+ ce = zend_fetch_class(NULL, opline->op2.num);
+ if (UNEXPECTED(ce == NULL)) {
+ zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
+ retval = NULL;
+ break;
+ }
+ } else {
+ ce = Z_CE_P(EX_VAR(opline->op2.var));
+ }
+ if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
+ EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
+ retval = CACHED_PTR(opline->extended_value + sizeof(void*));
+
+ /* check if static properties were destoyed */
+ if (EXPECTED(CE_STATIC_MEMBERS(ce) != NULL)) {
+ zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
+ break;
+ }
+ }
+ }
+
+ varname = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+ if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+ name = Z_STR_P(varname);
+ } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
+ name = Z_STR_P(varname);
+ tmp_name = NULL;
+ } else {
+ if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
+ zval_undefined_cv(EX(opline)->op1.var EXECUTE_DATA_CC);
+ }
+ name = zval_get_tmp_string(varname, &tmp_name);
+ }
+
+ retval = zend_std_get_static_property(ce, name, type == BP_VAR_IS);
+
+ if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
+ zend_tmp_string_release(tmp_name);
+ }
+
+ if ((IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED(retval)) {
+ CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, retval);
+ }
+
+ zval_ptr_dtor_nogc(free_op1);
+ } while (0);
if (UNEXPECTED(retval == NULL)) {
if (EG(exception)) {
- zval_ptr_dtor_nogc(free_op1);
ZVAL_UNDEF(EX_VAR(opline->result.var));
HANDLE_EXCEPTION();
} else {
}
}
- zval_ptr_dtor_nogc(free_op1);
-
if (type == BP_VAR_R || type == BP_VAR_IS) {
ZVAL_COPY_UNREF(EX_VAR(opline->result.var), retval);
} else {
zval *retval;
if (IS_CONST == IS_CONST) {
- cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
+ cache_slot = CACHE_ADDR(opline->extended_value);
if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
zval *retval;
if (IS_CONST == IS_CONST) {
- cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
+ cache_slot = CACHE_ADDR(opline->extended_value);
if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
}
- function_name = RT_CONSTANT(opline, opline->op2);
+ if (IS_CONST != IS_CONST) {
+ function_name = RT_CONSTANT(opline, opline->op2);
+ }
if (IS_CONST != IS_CONST &&
UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
HANDLE_EXCEPTION();
}
}
+ if (IS_CONST == IS_CONST) {
+ function_name = RT_CONSTANT(opline, opline->op2);
+ }
zend_throw_error(NULL, "Call to a member function %s() on %s", Z_STRVAL_P(function_name), zend_get_type_by_const(Z_TYPE_P(object)));
zval_ptr_dtor_nogc(free_op1);
called_scope = obj->ce;
if (IS_CONST == IS_CONST &&
- EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(function_name)) == called_scope)) {
- fbc = CACHED_PTR(Z_CACHE_SLOT_P(function_name) + sizeof(void*));
+ EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
+ fbc = CACHED_PTR(opline->result.num + sizeof(void*));
} else {
zend_object *orig_obj = obj;
HANDLE_EXCEPTION();
}
+ if (IS_CONST == IS_CONST) {
+ function_name = RT_CONSTANT(opline, opline->op2);
+ }
+
/* First, locate the function. */
fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
if (UNEXPECTED(fbc == NULL)) {
EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
EXPECTED(obj == orig_obj)) {
- CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), called_scope, fbc);
+ CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
}
if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) {
init_func_run_time_cache(&fbc->op_array);
SAVE_OPLINE();
- varname = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
-
- if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
- name = Z_STR_P(varname);
- } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
- name = Z_STR_P(varname);
- tmp_name = NULL;
- } else {
- if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
- varname = GET_OP1_UNDEF_CV(varname, BP_VAR_R);
- }
- name = zval_get_tmp_string(varname, &tmp_name);
- }
-
if (IS_CONST == IS_CONST) {
- ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)));
+ ce = CACHED_PTR(opline->extended_value);
if (UNEXPECTED(ce == NULL)) {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), RT_CONSTANT(opline, opline->op2) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
- if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
- zend_tmp_string_release(tmp_name);
- }
- zval_ptr_dtor_nogc(free_op1);
+ zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
HANDLE_EXCEPTION();
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), ce);
+ /*CACHE_PTR(opline->extended_value, ce);*/
}
} else if (IS_CONST == IS_UNUSED) {
ce = zend_fetch_class(NULL, opline->op2.num);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
- if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
- zend_tmp_string_release(tmp_name);
- }
- zval_ptr_dtor_nogc(free_op1);
+ zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
HANDLE_EXCEPTION();
}
} else {
ce = Z_CE_P(EX_VAR(opline->op2.var));
}
+
+ varname = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+ if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+ name = Z_STR_P(varname);
+ } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
+ name = Z_STR_P(varname);
+ tmp_name = NULL;
+ } else {
+ if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
+ varname = GET_OP1_UNDEF_CV(varname, BP_VAR_R);
+ }
+ name = zval_get_tmp_string(varname, &tmp_name);
+ }
+
zend_std_unset_static_property(ce, name);
if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
zend_class_entry *ce;
SAVE_OPLINE();
- varname = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
- if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
- name = Z_STR_P(varname);
- } else {
- name = zval_get_tmp_string(varname, &tmp_name);
- }
-
if (IS_CONST == IS_CONST) {
- if ((IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED((ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)))) != NULL)) {
- value = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)) + sizeof(void*));
+ if ((IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED((ce = CACHED_PTR(opline->extended_value & ~ZEND_ISSET)) != NULL)) {
+ value = CACHED_PTR((opline->extended_value & ~ZEND_ISSET) + sizeof(void*));
/* check if static properties were destoyed */
if (UNEXPECTED(CE_STATIC_MEMBERS(ce) == NULL)) {
}
goto is_static_prop_return;
- } else if (UNEXPECTED((ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)))) == NULL)) {
+ } else if (UNEXPECTED((ce = CACHED_PTR(opline->extended_value & ~ZEND_ISSET)) == NULL)) {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), RT_CONSTANT(opline, opline->op2) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
ZVAL_UNDEF(EX_VAR(opline->result.var));
HANDLE_EXCEPTION();
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), ce);
+ if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
+ CACHE_PTR(opline->extended_value & ~ZEND_ISSET, ce);
+ }
}
} else {
if (IS_CONST == IS_UNUSED) {
ce = zend_fetch_class(NULL, opline->op2.num);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
- if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
- zend_tmp_string_release(tmp_name);
- }
- zval_ptr_dtor_nogc(free_op1);
+ zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
ZVAL_UNDEF(EX_VAR(opline->result.var));
HANDLE_EXCEPTION();
}
ce = Z_CE_P(EX_VAR(opline->op2.var));
}
if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
- EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1))) == ce)) {
+ EXPECTED(CACHED_PTR(opline->extended_value & ~ZEND_ISSET) == ce)) {
- value = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)) + sizeof(void*));
+ value = CACHED_PTR((opline->extended_value & ~ZEND_ISSET) + sizeof(void*));
/* check if static properties were destoyed */
if (UNEXPECTED(CE_STATIC_MEMBERS(ce) == NULL)) {
}
}
+ varname = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+ if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+ name = Z_STR_P(varname);
+ } else {
+ name = zval_get_tmp_string(varname, &tmp_name);
+ }
+
value = zend_std_get_static_property(ce, name, 1);
if ((IS_TMP_VAR|IS_VAR) == IS_CONST && value) {
- CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)), ce, value);
+ CACHE_POLYMORPHIC_PTR(opline->extended_value & ~ZEND_ISSET, ce, value);
}
if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
} else {
result =
((opline->extended_value & ZEND_ISSET) == 0) ^
- Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(offset)) : NULL));
+ Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISSET) : NULL));
}
zval_ptr_dtor_nogc(free_op1);
zend_class_entry *ce;
if (IS_CONST == IS_CONST) {
- ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)));
+ ce = CACHED_PTR(opline->extended_value);
if (UNEXPECTED(ce == NULL)) {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), RT_CONSTANT(opline, opline->op2) + 1, ZEND_FETCH_CLASS_NO_AUTOLOAD);
if (EXPECTED(ce)) {
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), ce);
+ CACHE_PTR(opline->extended_value, ce);
}
}
} else if (IS_CONST == IS_UNUSED) {
zval *retval;
if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
- cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
+ cache_slot = CACHE_ADDR(opline->extended_value);
if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
zval *retval;
if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
- cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
+ cache_slot = CACHE_ADDR(opline->extended_value);
if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
}
- function_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+ if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
+ function_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+ }
if ((IS_TMP_VAR|IS_VAR) != IS_CONST &&
UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
HANDLE_EXCEPTION();
}
}
+ if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+ function_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+ }
zend_throw_error(NULL, "Call to a member function %s() on %s", Z_STRVAL_P(function_name), zend_get_type_by_const(Z_TYPE_P(object)));
zval_ptr_dtor_nogc(free_op2);
zval_ptr_dtor_nogc(free_op1);
called_scope = obj->ce;
if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
- EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(function_name)) == called_scope)) {
- fbc = CACHED_PTR(Z_CACHE_SLOT_P(function_name) + sizeof(void*));
+ EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
+ fbc = CACHED_PTR(opline->result.num + sizeof(void*));
} else {
zend_object *orig_obj = obj;
HANDLE_EXCEPTION();
}
+ if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+ function_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+ }
+
/* First, locate the function. */
fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
if (UNEXPECTED(fbc == NULL)) {
EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
EXPECTED(obj == orig_obj)) {
- CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), called_scope, fbc);
+ CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
}
if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) {
init_func_run_time_cache(&fbc->op_array);
} else {
result =
((opline->extended_value & ZEND_ISSET) == 0) ^
- Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(offset)) : NULL));
+ Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISSET) : NULL));
}
zval_ptr_dtor_nogc(free_op2);
zend_free_op free_op1;
zval *varname;
zval *retval;
+ zend_string *name, *tmp_name;
+ zend_class_entry *ce;
SAVE_OPLINE();
- varname = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
- retval = zend_fetch_static_property_address(varname, (IS_TMP_VAR|IS_VAR), opline->op2, IS_VAR, type EXECUTE_DATA_CC OPLINE_CC);
+ do {
+ if (IS_VAR == IS_CONST) {
+ if ((IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED((ce = CACHED_PTR(opline->extended_value)) != NULL)) {
+ retval = CACHED_PTR(opline->extended_value + sizeof(void*));
+
+ /* check if static properties were destoyed */
+ if (EXPECTED(CE_STATIC_MEMBERS(ce) != NULL)) {
+ zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
+ break;
+ }
+ } else {
+ zval *class_name = RT_CONSTANT(opline, opline->op2);
+
+ if (UNEXPECTED((ce = CACHED_PTR(opline->extended_value)) == NULL)) {
+ ce = zend_fetch_class_by_name(Z_STR_P(class_name), class_name + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
+ if (UNEXPECTED(ce == NULL)) {
+ zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
+ retval = NULL;
+ break;
+ }
+ if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
+ CACHE_PTR(opline->extended_value, ce);
+ }
+ }
+ }
+ } else {
+ if (IS_VAR == IS_UNUSED) {
+ ce = zend_fetch_class(NULL, opline->op2.num);
+ if (UNEXPECTED(ce == NULL)) {
+ zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
+ retval = NULL;
+ break;
+ }
+ } else {
+ ce = Z_CE_P(EX_VAR(opline->op2.var));
+ }
+ if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
+ EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
+ retval = CACHED_PTR(opline->extended_value + sizeof(void*));
+
+ /* check if static properties were destoyed */
+ if (EXPECTED(CE_STATIC_MEMBERS(ce) != NULL)) {
+ zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
+ break;
+ }
+ }
+ }
+
+ varname = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+ if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+ name = Z_STR_P(varname);
+ } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
+ name = Z_STR_P(varname);
+ tmp_name = NULL;
+ } else {
+ if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
+ zval_undefined_cv(EX(opline)->op1.var EXECUTE_DATA_CC);
+ }
+ name = zval_get_tmp_string(varname, &tmp_name);
+ }
+
+ retval = zend_std_get_static_property(ce, name, type == BP_VAR_IS);
+
+ if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
+ zend_tmp_string_release(tmp_name);
+ }
+
+ if ((IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED(retval)) {
+ CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, retval);
+ }
+
+ zval_ptr_dtor_nogc(free_op1);
+ } while (0);
if (UNEXPECTED(retval == NULL)) {
if (EG(exception)) {
- zval_ptr_dtor_nogc(free_op1);
ZVAL_UNDEF(EX_VAR(opline->result.var));
HANDLE_EXCEPTION();
} else {
}
}
- zval_ptr_dtor_nogc(free_op1);
-
if (type == BP_VAR_R || type == BP_VAR_IS) {
ZVAL_COPY_UNREF(EX_VAR(opline->result.var), retval);
} else {
SAVE_OPLINE();
- varname = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
-
- if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
- name = Z_STR_P(varname);
- } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
- name = Z_STR_P(varname);
- tmp_name = NULL;
- } else {
- if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
- varname = GET_OP1_UNDEF_CV(varname, BP_VAR_R);
- }
- name = zval_get_tmp_string(varname, &tmp_name);
- }
-
if (IS_VAR == IS_CONST) {
- ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)));
+ ce = CACHED_PTR(opline->extended_value);
if (UNEXPECTED(ce == NULL)) {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), RT_CONSTANT(opline, opline->op2) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
- if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
- zend_tmp_string_release(tmp_name);
- }
- zval_ptr_dtor_nogc(free_op1);
+ zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
HANDLE_EXCEPTION();
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), ce);
+ /*CACHE_PTR(opline->extended_value, ce);*/
}
} else if (IS_VAR == IS_UNUSED) {
ce = zend_fetch_class(NULL, opline->op2.num);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
- if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
- zend_tmp_string_release(tmp_name);
- }
- zval_ptr_dtor_nogc(free_op1);
+ zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
HANDLE_EXCEPTION();
}
} else {
ce = Z_CE_P(EX_VAR(opline->op2.var));
}
+
+ varname = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+ if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+ name = Z_STR_P(varname);
+ } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
+ name = Z_STR_P(varname);
+ tmp_name = NULL;
+ } else {
+ if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
+ varname = GET_OP1_UNDEF_CV(varname, BP_VAR_R);
+ }
+ name = zval_get_tmp_string(varname, &tmp_name);
+ }
+
zend_std_unset_static_property(ce, name);
if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
zend_class_entry *ce;
SAVE_OPLINE();
- varname = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
- if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
- name = Z_STR_P(varname);
- } else {
- name = zval_get_tmp_string(varname, &tmp_name);
- }
-
if (IS_VAR == IS_CONST) {
- if ((IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED((ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)))) != NULL)) {
- value = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)) + sizeof(void*));
+ if ((IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED((ce = CACHED_PTR(opline->extended_value & ~ZEND_ISSET)) != NULL)) {
+ value = CACHED_PTR((opline->extended_value & ~ZEND_ISSET) + sizeof(void*));
/* check if static properties were destoyed */
if (UNEXPECTED(CE_STATIC_MEMBERS(ce) == NULL)) {
}
goto is_static_prop_return;
- } else if (UNEXPECTED((ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)))) == NULL)) {
+ } else if (UNEXPECTED((ce = CACHED_PTR(opline->extended_value & ~ZEND_ISSET)) == NULL)) {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), RT_CONSTANT(opline, opline->op2) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
ZVAL_UNDEF(EX_VAR(opline->result.var));
HANDLE_EXCEPTION();
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), ce);
+ if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
+ CACHE_PTR(opline->extended_value & ~ZEND_ISSET, ce);
+ }
}
} else {
if (IS_VAR == IS_UNUSED) {
ce = zend_fetch_class(NULL, opline->op2.num);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
- if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
- zend_tmp_string_release(tmp_name);
- }
- zval_ptr_dtor_nogc(free_op1);
+ zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
ZVAL_UNDEF(EX_VAR(opline->result.var));
HANDLE_EXCEPTION();
}
ce = Z_CE_P(EX_VAR(opline->op2.var));
}
if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
- EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1))) == ce)) {
+ EXPECTED(CACHED_PTR(opline->extended_value & ~ZEND_ISSET) == ce)) {
- value = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)) + sizeof(void*));
+ value = CACHED_PTR((opline->extended_value & ~ZEND_ISSET) + sizeof(void*));
/* check if static properties were destoyed */
if (UNEXPECTED(CE_STATIC_MEMBERS(ce) == NULL)) {
}
}
+ varname = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+ if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+ name = Z_STR_P(varname);
+ } else {
+ name = zval_get_tmp_string(varname, &tmp_name);
+ }
+
value = zend_std_get_static_property(ce, name, 1);
if ((IS_TMP_VAR|IS_VAR) == IS_CONST && value) {
- CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)), ce, value);
+ CACHE_POLYMORPHIC_PTR(opline->extended_value & ~ZEND_ISSET, ce, value);
}
if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
zend_class_entry *ce;
if (IS_VAR == IS_CONST) {
- ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)));
+ ce = CACHED_PTR(opline->extended_value);
if (UNEXPECTED(ce == NULL)) {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), RT_CONSTANT(opline, opline->op2) + 1, ZEND_FETCH_CLASS_NO_AUTOLOAD);
if (EXPECTED(ce)) {
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), ce);
+ CACHE_PTR(opline->extended_value, ce);
}
}
} else if (IS_VAR == IS_UNUSED) {
zend_free_op free_op1;
zval *varname;
zval *retval;
+ zend_string *name, *tmp_name;
+ zend_class_entry *ce;
SAVE_OPLINE();
- varname = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
- retval = zend_fetch_static_property_address(varname, (IS_TMP_VAR|IS_VAR), opline->op2, IS_UNUSED, type EXECUTE_DATA_CC OPLINE_CC);
+ do {
+ if (IS_UNUSED == IS_CONST) {
+ if ((IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED((ce = CACHED_PTR(opline->extended_value)) != NULL)) {
+ retval = CACHED_PTR(opline->extended_value + sizeof(void*));
+
+ /* check if static properties were destoyed */
+ if (EXPECTED(CE_STATIC_MEMBERS(ce) != NULL)) {
+ zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
+ break;
+ }
+ } else {
+ zval *class_name = RT_CONSTANT(opline, opline->op2);
+
+ if (UNEXPECTED((ce = CACHED_PTR(opline->extended_value)) == NULL)) {
+ ce = zend_fetch_class_by_name(Z_STR_P(class_name), class_name + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
+ if (UNEXPECTED(ce == NULL)) {
+ zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
+ retval = NULL;
+ break;
+ }
+ if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
+ CACHE_PTR(opline->extended_value, ce);
+ }
+ }
+ }
+ } else {
+ if (IS_UNUSED == IS_UNUSED) {
+ ce = zend_fetch_class(NULL, opline->op2.num);
+ if (UNEXPECTED(ce == NULL)) {
+ zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
+ retval = NULL;
+ break;
+ }
+ } else {
+ ce = Z_CE_P(EX_VAR(opline->op2.var));
+ }
+ if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
+ EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
+ retval = CACHED_PTR(opline->extended_value + sizeof(void*));
+
+ /* check if static properties were destoyed */
+ if (EXPECTED(CE_STATIC_MEMBERS(ce) != NULL)) {
+ zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
+ break;
+ }
+ }
+ }
+
+ varname = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+ if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+ name = Z_STR_P(varname);
+ } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
+ name = Z_STR_P(varname);
+ tmp_name = NULL;
+ } else {
+ if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
+ zval_undefined_cv(EX(opline)->op1.var EXECUTE_DATA_CC);
+ }
+ name = zval_get_tmp_string(varname, &tmp_name);
+ }
+
+ retval = zend_std_get_static_property(ce, name, type == BP_VAR_IS);
+
+ if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
+ zend_tmp_string_release(tmp_name);
+ }
+
+ if ((IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED(retval)) {
+ CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, retval);
+ }
+
+ zval_ptr_dtor_nogc(free_op1);
+ } while (0);
if (UNEXPECTED(retval == NULL)) {
if (EG(exception)) {
- zval_ptr_dtor_nogc(free_op1);
ZVAL_UNDEF(EX_VAR(opline->result.var));
HANDLE_EXCEPTION();
} else {
}
}
- zval_ptr_dtor_nogc(free_op1);
-
if (type == BP_VAR_R || type == BP_VAR_IS) {
ZVAL_COPY_UNREF(EX_VAR(opline->result.var), retval);
} else {
SAVE_OPLINE();
- varname = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
-
- if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
- name = Z_STR_P(varname);
- } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
- name = Z_STR_P(varname);
- tmp_name = NULL;
- } else {
- if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
- varname = GET_OP1_UNDEF_CV(varname, BP_VAR_R);
- }
- name = zval_get_tmp_string(varname, &tmp_name);
- }
-
if (IS_UNUSED == IS_CONST) {
- ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)));
+ ce = CACHED_PTR(opline->extended_value);
if (UNEXPECTED(ce == NULL)) {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), RT_CONSTANT(opline, opline->op2) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
- if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
- zend_tmp_string_release(tmp_name);
- }
- zval_ptr_dtor_nogc(free_op1);
+ zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
HANDLE_EXCEPTION();
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), ce);
+ /*CACHE_PTR(opline->extended_value, ce);*/
}
} else if (IS_UNUSED == IS_UNUSED) {
ce = zend_fetch_class(NULL, opline->op2.num);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
- if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
- zend_tmp_string_release(tmp_name);
- }
- zval_ptr_dtor_nogc(free_op1);
+ zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
HANDLE_EXCEPTION();
}
} else {
ce = Z_CE_P(EX_VAR(opline->op2.var));
}
+
+ varname = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+ if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+ name = Z_STR_P(varname);
+ } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
+ name = Z_STR_P(varname);
+ tmp_name = NULL;
+ } else {
+ if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
+ varname = GET_OP1_UNDEF_CV(varname, BP_VAR_R);
+ }
+ name = zval_get_tmp_string(varname, &tmp_name);
+ }
+
zend_std_unset_static_property(ce, name);
if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
zend_class_entry *ce;
SAVE_OPLINE();
- varname = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
- if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
- name = Z_STR_P(varname);
- } else {
- name = zval_get_tmp_string(varname, &tmp_name);
- }
-
if (IS_UNUSED == IS_CONST) {
- if ((IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED((ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)))) != NULL)) {
- value = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)) + sizeof(void*));
+ if ((IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED((ce = CACHED_PTR(opline->extended_value & ~ZEND_ISSET)) != NULL)) {
+ value = CACHED_PTR((opline->extended_value & ~ZEND_ISSET) + sizeof(void*));
/* check if static properties were destoyed */
if (UNEXPECTED(CE_STATIC_MEMBERS(ce) == NULL)) {
}
goto is_static_prop_return;
- } else if (UNEXPECTED((ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)))) == NULL)) {
+ } else if (UNEXPECTED((ce = CACHED_PTR(opline->extended_value & ~ZEND_ISSET)) == NULL)) {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), RT_CONSTANT(opline, opline->op2) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
ZVAL_UNDEF(EX_VAR(opline->result.var));
HANDLE_EXCEPTION();
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), ce);
+ if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
+ CACHE_PTR(opline->extended_value & ~ZEND_ISSET, ce);
+ }
}
} else {
if (IS_UNUSED == IS_UNUSED) {
ce = zend_fetch_class(NULL, opline->op2.num);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
- if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
- zend_tmp_string_release(tmp_name);
- }
- zval_ptr_dtor_nogc(free_op1);
+ zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
ZVAL_UNDEF(EX_VAR(opline->result.var));
HANDLE_EXCEPTION();
}
ce = Z_CE_P(EX_VAR(opline->op2.var));
}
if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
- EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1))) == ce)) {
+ EXPECTED(CACHED_PTR(opline->extended_value & ~ZEND_ISSET) == ce)) {
- value = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)) + sizeof(void*));
+ value = CACHED_PTR((opline->extended_value & ~ZEND_ISSET) + sizeof(void*));
/* check if static properties were destoyed */
if (UNEXPECTED(CE_STATIC_MEMBERS(ce) == NULL)) {
}
}
+ varname = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+ if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+ name = Z_STR_P(varname);
+ } else {
+ name = zval_get_tmp_string(varname, &tmp_name);
+ }
+
value = zend_std_get_static_property(ce, name, 1);
if ((IS_TMP_VAR|IS_VAR) == IS_CONST && value) {
- CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)), ce, value);
+ CACHE_POLYMORPHIC_PTR(opline->extended_value & ~ZEND_ISSET, ce, value);
}
if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
zend_class_entry *ce;
if (IS_UNUSED == IS_CONST) {
- ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)));
+ ce = CACHED_PTR(opline->extended_value);
if (UNEXPECTED(ce == NULL)) {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), RT_CONSTANT(opline, opline->op2) + 1, ZEND_FETCH_CLASS_NO_AUTOLOAD);
if (EXPECTED(ce)) {
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), ce);
+ CACHE_PTR(opline->extended_value, ce);
}
}
} else if (IS_UNUSED == IS_UNUSED) {
zval *retval;
if (IS_CV == IS_CONST) {
- cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
+ cache_slot = CACHE_ADDR(opline->extended_value);
if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
zval *retval;
if (IS_CV == IS_CONST) {
- cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
+ cache_slot = CACHE_ADDR(opline->extended_value);
if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
}
- function_name = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
+ if (IS_CV != IS_CONST) {
+ function_name = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
+ }
if (IS_CV != IS_CONST &&
UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
HANDLE_EXCEPTION();
}
}
+ if (IS_CV == IS_CONST) {
+ function_name = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
+ }
zend_throw_error(NULL, "Call to a member function %s() on %s", Z_STRVAL_P(function_name), zend_get_type_by_const(Z_TYPE_P(object)));
zval_ptr_dtor_nogc(free_op1);
called_scope = obj->ce;
if (IS_CV == IS_CONST &&
- EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(function_name)) == called_scope)) {
- fbc = CACHED_PTR(Z_CACHE_SLOT_P(function_name) + sizeof(void*));
+ EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
+ fbc = CACHED_PTR(opline->result.num + sizeof(void*));
} else {
zend_object *orig_obj = obj;
HANDLE_EXCEPTION();
}
+ if (IS_CV == IS_CONST) {
+ function_name = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
+ }
+
/* First, locate the function. */
fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
if (UNEXPECTED(fbc == NULL)) {
EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
EXPECTED(obj == orig_obj)) {
- CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), called_scope, fbc);
+ CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
}
if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) {
init_func_run_time_cache(&fbc->op_array);
} else {
result =
((opline->extended_value & ZEND_ISSET) == 0) ^
- Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(offset)) : NULL));
+ Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISSET) : NULL));
}
zval_ptr_dtor_nogc(free_op1);
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
- USE_OPLINE
- zval *result;
- zend_function *constructor;
- zend_class_entry *ce;
- zend_execute_data *call;
-
- SAVE_OPLINE();
- if (IS_VAR == IS_CONST) {
- ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)));
- if (UNEXPECTED(ce == NULL)) {
- ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), RT_CONSTANT(opline, opline->op1) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
- if (UNEXPECTED(ce == NULL)) {
- ZEND_ASSERT(EG(exception));
- ZVAL_UNDEF(EX_VAR(opline->result.var));
- HANDLE_EXCEPTION();
- }
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)), ce);
- }
- } else if (IS_VAR == IS_UNUSED) {
- ce = zend_fetch_class(NULL, opline->op1.num);
- if (UNEXPECTED(ce == NULL)) {
- ZEND_ASSERT(EG(exception));
- ZVAL_UNDEF(EX_VAR(opline->result.var));
- HANDLE_EXCEPTION();
- }
- } else {
- ce = Z_CE_P(EX_VAR(opline->op1.var));
- }
-
- result = EX_VAR(opline->result.var);
- if (UNEXPECTED(object_init_ex(result, ce) != SUCCESS)) {
- ZVAL_UNDEF(result);
- HANDLE_EXCEPTION();
- }
-
- constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result));
- if (constructor == NULL) {
- if (UNEXPECTED(EG(exception))) {
- HANDLE_EXCEPTION();
- }
-
- /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next
- * opcode is DO_FCALL in case EXT instructions are used. */
- if (EXPECTED(opline->extended_value == 0 && (opline+1)->opcode == ZEND_DO_FCALL)) {
- ZEND_VM_NEXT_OPCODE_EX(1, 2);
- }
-
- /* Perform a dummy function call */
- call = zend_vm_stack_push_call_frame(
- ZEND_CALL_FUNCTION, (zend_function *) &zend_pass_function,
- opline->extended_value, NULL, NULL);
- } else {
- if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!constructor->op_array.run_time_cache)) {
- init_func_run_time_cache(&constructor->op_array);
- }
- /* We are not handling overloaded classes right now */
- call = zend_vm_stack_push_call_frame(
- ZEND_CALL_FUNCTION | ZEND_CALL_RELEASE_THIS | ZEND_CALL_CTOR,
- constructor,
- opline->extended_value,
- ce,
- Z_OBJ_P(result));
- Z_ADDREF_P(result);
- }
-
- call->prev_execute_data = EX(call);
- EX(call) = call;
- ZEND_VM_NEXT_OPCODE();
-}
-
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CAST_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
/* 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)) {
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL))) != NULL)) {
if (UNEXPECTED(Z_ISERROR_P(zptr))) {
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_NULL(EX_VAR(opline->result.var));
}
}
} else {
- zend_assign_op_overloaded_property(object, property, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), value, binary_op, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+ zend_assign_op_overloaded_property(object, property, ((IS_CONST == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL), value, binary_op, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
}
} while (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)) {
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL))) != NULL)) {
if (UNEXPECTED(Z_ISERROR_P(zptr))) {
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_NULL(EX_VAR(opline->result.var));
}
}
} else {
- zend_pre_incdec_overloaded_property(object, property, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), inc, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+ zend_pre_incdec_overloaded_property(object, property, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), inc, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
}
} while (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)) {
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL))) != NULL)) {
if (UNEXPECTED(Z_ISERROR_P(zptr))) {
ZVAL_NULL(EX_VAR(opline->result.var));
} else {
}
}
} else {
- zend_post_incdec_overloaded_property(object, property, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), inc, EX_VAR(opline->result.var));
+ zend_post_incdec_overloaded_property(object, property, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), inc, EX_VAR(opline->result.var));
}
} while (0);
property = RT_CONSTANT(opline, opline->op2);
result = EX_VAR(opline->result.var);
- zend_fetch_property_address(result, container, IS_VAR, property, IS_CONST, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W);
+ zend_fetch_property_address(result, container, IS_VAR, property, IS_CONST, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_W);
if (IS_VAR == IS_VAR) {
FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
}
property = RT_CONSTANT(opline, opline->op2);
result = EX_VAR(opline->result.var);
- zend_fetch_property_address(result, container, IS_VAR, property, IS_CONST, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_RW);
+ zend_fetch_property_address(result, container, IS_VAR, property, IS_CONST, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW);
if (IS_VAR == IS_VAR) {
FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
property = RT_CONSTANT(opline, opline->op2);
result = EX_VAR(opline->result.var);
- zend_fetch_property_address(result, container, IS_VAR, property, IS_CONST, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_UNSET);
+ zend_fetch_property_address(result, container, IS_VAR, property, IS_CONST, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET);
if (IS_VAR == IS_VAR) {
FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
}
if (IS_CONST == IS_CONST &&
- EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
- uintptr_t prop_offset = (uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+ EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
+ uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
zend_object *zobj = Z_OBJ_P(object);
zval *property_val;
ZVAL_DEREF(value);
}
- Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL);
+ Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
}
if (IS_CONST == IS_CONST &&
- EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
- uintptr_t prop_offset = (uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+ EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
+ uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
zend_object *zobj = Z_OBJ_P(object);
zval *property_val;
ZVAL_DEREF(value);
}
- Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL);
+ Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
}
if (IS_CONST == IS_CONST &&
- EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
- uintptr_t prop_offset = (uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+ EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
+ uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
zend_object *zobj = Z_OBJ_P(object);
zval *property_val;
ZVAL_DEREF(value);
}
- Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL);
+ Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
}
if (IS_CONST == IS_CONST &&
- EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
- uintptr_t prop_offset = (uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+ EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
+ uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
zend_object *zobj = Z_OBJ_P(object);
zval *property_val;
ZVAL_DEREF(value);
}
- Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL);
+ Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
if (IS_VAR == IS_CONST) {
/* no function found. try a static method in class */
- ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)));
+ ce = CACHED_PTR(opline->result.num);
if (UNEXPECTED(ce == NULL)) {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), RT_CONSTANT(opline, opline->op1) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
HANDLE_EXCEPTION();
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)), ce);
+ if (IS_CONST != IS_CONST) {
+ CACHE_PTR(opline->result.num, ce);
+ }
}
} else if (IS_VAR == IS_UNUSED) {
ce = zend_fetch_class(NULL, opline->op1.num);
if (IS_VAR == IS_CONST &&
IS_CONST == IS_CONST &&
- EXPECTED((fbc = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)))) != NULL)) {
+ EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
/* nothing to do */
} else if (IS_VAR != IS_CONST &&
IS_CONST == IS_CONST &&
- EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2))) == ce)) {
- fbc = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)) + sizeof(void*));
+ EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
+ fbc = CACHED_PTR(opline->result.num + sizeof(void*));
} else if (IS_CONST != IS_UNUSED) {
if (IS_CONST == IS_CONST &&
EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE)))) {
- if (IS_VAR == IS_CONST) {
- CACHE_PTR(Z_CACHE_SLOT_P(function_name), fbc);
- } else {
- CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), ce, fbc);
- }
+ CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
}
if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) {
init_func_run_time_cache(&fbc->op_array);
do {
if (IS_VAR == IS_CONST) {
- if (EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2))))) {
- value = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)));
+ if (EXPECTED(CACHED_PTR(opline->extended_value + sizeof(void*)))) {
+ value = CACHED_PTR(opline->extended_value + sizeof(void*));
break;
- } else if (EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1))))) {
- ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)));
+ } else if (EXPECTED(CACHED_PTR(opline->extended_value))) {
+ ce = CACHED_PTR(opline->extended_value);
} else {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), RT_CONSTANT(opline, opline->op1) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
if (UNEXPECTED(ce == NULL)) {
ZVAL_UNDEF(EX_VAR(opline->result.var));
HANDLE_EXCEPTION();
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)), ce);
}
} else {
if (IS_VAR == IS_UNUSED) {
} else {
ce = Z_CE_P(EX_VAR(opline->op1.var));
}
- if (EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2))) == ce)) {
- value = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)) + sizeof(void*));
+ if (EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
+ value = CACHED_PTR(opline->extended_value + sizeof(void*));
break;
}
}
HANDLE_EXCEPTION();
}
}
- if (IS_VAR == IS_CONST) {
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), value);
- } else {
- CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), ce, value);
- }
+ CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, value);
} else {
zend_throw_error(NULL, "Undefined class constant '%s'", Z_STRVAL_P(RT_CONSTANT(opline, opline->op2)));
ZVAL_UNDEF(EX_VAR(opline->result.var));
}
}
if (Z_OBJ_HT_P(container)->unset_property) {
- Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(offset)) : NULL));
+ Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
} else {
zend_wrong_property_unset(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_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
+ && 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((opline+1)->extended_value) : NULL))) != NULL)) {
if (UNEXPECTED(Z_ISERROR_P(zptr))) {
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_NULL(EX_VAR(opline->result.var));
}
}
} else {
- zend_assign_op_overloaded_property(object, property, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), value, binary_op, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+ zend_assign_op_overloaded_property(object, property, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL), value, binary_op, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
}
} while (0);
/* here we are sure we are dealing with an object */
if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr)
- && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
+ && 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(opline->extended_value) : NULL))) != NULL)) {
if (UNEXPECTED(Z_ISERROR_P(zptr))) {
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_NULL(EX_VAR(opline->result.var));
}
}
} else {
- zend_pre_incdec_overloaded_property(object, property, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), inc, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+ zend_pre_incdec_overloaded_property(object, property, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), inc, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
}
} while (0);
/* here we are sure we are dealing with an object */
if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr)
- && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
+ && 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(opline->extended_value) : NULL))) != NULL)) {
if (UNEXPECTED(Z_ISERROR_P(zptr))) {
ZVAL_NULL(EX_VAR(opline->result.var));
} else {
}
}
} else {
- zend_post_incdec_overloaded_property(object, property, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), inc, EX_VAR(opline->result.var));
+ zend_post_incdec_overloaded_property(object, property, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), inc, EX_VAR(opline->result.var));
}
} while (0);
property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
result = EX_VAR(opline->result.var);
- zend_fetch_property_address(result, container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W);
+ zend_fetch_property_address(result, container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_W);
zval_ptr_dtor_nogc(free_op2);
if (IS_VAR == IS_VAR) {
FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
}
property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
result = EX_VAR(opline->result.var);
- zend_fetch_property_address(result, container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_RW);
+ zend_fetch_property_address(result, container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW);
zval_ptr_dtor_nogc(free_op2);
if (IS_VAR == IS_VAR) {
FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
result = EX_VAR(opline->result.var);
- zend_fetch_property_address(result, container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_UNSET);
+ zend_fetch_property_address(result, container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET);
zval_ptr_dtor_nogc(free_op2);
if (IS_VAR == IS_VAR) {
FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
}
if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
- EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
- uintptr_t prop_offset = (uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+ EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
+ uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
zend_object *zobj = Z_OBJ_P(object);
zval *property_val;
ZVAL_DEREF(value);
}
- Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL);
+ Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
}
if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
- EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
- uintptr_t prop_offset = (uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+ EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
+ uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
zend_object *zobj = Z_OBJ_P(object);
zval *property_val;
ZVAL_DEREF(value);
}
- Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL);
+ Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
}
if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
- EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
- uintptr_t prop_offset = (uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+ EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
+ uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
zend_object *zobj = Z_OBJ_P(object);
zval *property_val;
ZVAL_DEREF(value);
}
- Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL);
+ Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
}
if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
- EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
- uintptr_t prop_offset = (uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+ EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
+ uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
zend_object *zobj = Z_OBJ_P(object);
zval *property_val;
ZVAL_DEREF(value);
}
- Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL);
+ Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
if (IS_VAR == IS_CONST) {
/* no function found. try a static method in class */
- ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)));
+ ce = CACHED_PTR(opline->result.num);
if (UNEXPECTED(ce == NULL)) {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), RT_CONSTANT(opline, opline->op1) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
HANDLE_EXCEPTION();
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)), ce);
+ if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
+ CACHE_PTR(opline->result.num, ce);
+ }
}
} else if (IS_VAR == IS_UNUSED) {
ce = zend_fetch_class(NULL, opline->op1.num);
if (IS_VAR == IS_CONST &&
(IS_TMP_VAR|IS_VAR) == IS_CONST &&
- EXPECTED((fbc = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)))) != NULL)) {
+ EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
/* nothing to do */
} else if (IS_VAR != IS_CONST &&
(IS_TMP_VAR|IS_VAR) == IS_CONST &&
- EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2))) == ce)) {
- fbc = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)) + sizeof(void*));
+ EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
+ fbc = CACHED_PTR(opline->result.num + sizeof(void*));
} else if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
zend_free_op free_op2;
if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE)))) {
- if (IS_VAR == IS_CONST) {
- CACHE_PTR(Z_CACHE_SLOT_P(function_name), fbc);
- } else {
- CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), ce, fbc);
- }
+ CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
}
if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) {
init_func_run_time_cache(&fbc->op_array);
}
}
if (Z_OBJ_HT_P(container)->unset_property) {
- Z_OBJ_HT_P(container)->unset_property(container, offset, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(offset)) : NULL));
+ Z_OBJ_HT_P(container)->unset_property(container, offset, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
} else {
zend_wrong_property_unset(offset);
}
if (IS_VAR == IS_CONST) {
/* no function found. try a static method in class */
- ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)));
+ ce = CACHED_PTR(opline->result.num);
if (UNEXPECTED(ce == NULL)) {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), RT_CONSTANT(opline, opline->op1) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
HANDLE_EXCEPTION();
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)), ce);
+ if (IS_UNUSED != IS_CONST) {
+ CACHE_PTR(opline->result.num, ce);
+ }
}
} else if (IS_VAR == IS_UNUSED) {
ce = zend_fetch_class(NULL, opline->op1.num);
if (IS_VAR == IS_CONST &&
IS_UNUSED == IS_CONST &&
- EXPECTED((fbc = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)))) != NULL)) {
+ EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
/* nothing to do */
} else if (IS_VAR != IS_CONST &&
IS_UNUSED == IS_CONST &&
- EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2))) == ce)) {
- fbc = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)) + sizeof(void*));
+ EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
+ fbc = CACHED_PTR(opline->result.num + sizeof(void*));
} else if (IS_UNUSED != IS_UNUSED) {
if (IS_UNUSED == IS_CONST &&
EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE)))) {
- if (IS_VAR == IS_CONST) {
- CACHE_PTR(Z_CACHE_SLOT_P(function_name), fbc);
- } else {
- CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), ce, fbc);
- }
+ CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
}
if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) {
init_func_run_time_cache(&fbc->op_array);
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+ USE_OPLINE
+ zval *result;
+ zend_function *constructor;
+ zend_class_entry *ce;
+ zend_execute_data *call;
+
+ SAVE_OPLINE();
+ if (IS_VAR == IS_CONST) {
+ ce = CACHED_PTR(opline->op2.num);
+ if (UNEXPECTED(ce == NULL)) {
+ ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), RT_CONSTANT(opline, opline->op1) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
+ if (UNEXPECTED(ce == NULL)) {
+ ZEND_ASSERT(EG(exception));
+ ZVAL_UNDEF(EX_VAR(opline->result.var));
+ HANDLE_EXCEPTION();
+ }
+ CACHE_PTR(opline->op2.num, ce);
+ }
+ } else if (IS_VAR == IS_UNUSED) {
+ ce = zend_fetch_class(NULL, opline->op1.num);
+ if (UNEXPECTED(ce == NULL)) {
+ ZEND_ASSERT(EG(exception));
+ ZVAL_UNDEF(EX_VAR(opline->result.var));
+ HANDLE_EXCEPTION();
+ }
+ } else {
+ ce = Z_CE_P(EX_VAR(opline->op1.var));
+ }
+
+ result = EX_VAR(opline->result.var);
+ if (UNEXPECTED(object_init_ex(result, ce) != SUCCESS)) {
+ ZVAL_UNDEF(result);
+ HANDLE_EXCEPTION();
+ }
+
+ constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result));
+ if (constructor == NULL) {
+ if (UNEXPECTED(EG(exception))) {
+ HANDLE_EXCEPTION();
+ }
+
+ /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next
+ * opcode is DO_FCALL in case EXT instructions are used. */
+ if (EXPECTED(opline->extended_value == 0 && (opline+1)->opcode == ZEND_DO_FCALL)) {
+ ZEND_VM_NEXT_OPCODE_EX(1, 2);
+ }
+
+ /* Perform a dummy function call */
+ call = zend_vm_stack_push_call_frame(
+ ZEND_CALL_FUNCTION, (zend_function *) &zend_pass_function,
+ opline->extended_value, NULL, NULL);
+ } else {
+ if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!constructor->op_array.run_time_cache)) {
+ init_func_run_time_cache(&constructor->op_array);
+ }
+ /* We are not handling overloaded classes right now */
+ call = zend_vm_stack_push_call_frame(
+ ZEND_CALL_FUNCTION | ZEND_CALL_RELEASE_THIS | ZEND_CALL_CTOR,
+ constructor,
+ opline->extended_value,
+ ce,
+ Z_OBJ_P(result));
+ Z_ADDREF_P(result);
+ }
+
+ call->prev_execute_data = EX(call);
+ EX(call) = call;
+ ZEND_VM_NEXT_OPCODE();
+}
+
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
/* 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)) {
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL))) != NULL)) {
if (UNEXPECTED(Z_ISERROR_P(zptr))) {
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_NULL(EX_VAR(opline->result.var));
}
}
} else {
- zend_assign_op_overloaded_property(object, property, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), value, binary_op, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+ zend_assign_op_overloaded_property(object, property, ((IS_CV == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL), value, binary_op, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
}
} while (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_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL))) != NULL)) {
if (UNEXPECTED(Z_ISERROR_P(zptr))) {
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_NULL(EX_VAR(opline->result.var));
}
}
} else {
- zend_pre_incdec_overloaded_property(object, property, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), inc, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+ zend_pre_incdec_overloaded_property(object, property, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), inc, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
}
} while (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_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL))) != NULL)) {
if (UNEXPECTED(Z_ISERROR_P(zptr))) {
ZVAL_NULL(EX_VAR(opline->result.var));
} else {
}
}
} else {
- zend_post_incdec_overloaded_property(object, property, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), inc, EX_VAR(opline->result.var));
+ zend_post_incdec_overloaded_property(object, property, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), inc, EX_VAR(opline->result.var));
}
} while (0);
property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
result = EX_VAR(opline->result.var);
- zend_fetch_property_address(result, container, IS_VAR, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W);
+ zend_fetch_property_address(result, container, IS_VAR, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_W);
if (IS_VAR == IS_VAR) {
FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
}
property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
result = EX_VAR(opline->result.var);
- zend_fetch_property_address(result, container, IS_VAR, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_RW);
+ zend_fetch_property_address(result, container, IS_VAR, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW);
if (IS_VAR == IS_VAR) {
FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
result = EX_VAR(opline->result.var);
- zend_fetch_property_address(result, container, IS_VAR, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_UNSET);
+ zend_fetch_property_address(result, container, IS_VAR, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET);
if (IS_VAR == IS_VAR) {
FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
}
if (IS_CV == IS_CONST &&
- EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
- uintptr_t prop_offset = (uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+ EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
+ uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
zend_object *zobj = Z_OBJ_P(object);
zval *property_val;
ZVAL_DEREF(value);
}
- Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL);
+ Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
}
if (IS_CV == IS_CONST &&
- EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
- uintptr_t prop_offset = (uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+ EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
+ uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
zend_object *zobj = Z_OBJ_P(object);
zval *property_val;
ZVAL_DEREF(value);
}
- Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL);
+ Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
}
if (IS_CV == IS_CONST &&
- EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
- uintptr_t prop_offset = (uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+ EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
+ uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
zend_object *zobj = Z_OBJ_P(object);
zval *property_val;
ZVAL_DEREF(value);
}
- Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL);
+ Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
}
if (IS_CV == IS_CONST &&
- EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
- uintptr_t prop_offset = (uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+ EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
+ uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
zend_object *zobj = Z_OBJ_P(object);
zval *property_val;
ZVAL_DEREF(value);
}
- Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL);
+ Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
if (IS_VAR == IS_CONST) {
/* no function found. try a static method in class */
- ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)));
+ ce = CACHED_PTR(opline->result.num);
if (UNEXPECTED(ce == NULL)) {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), RT_CONSTANT(opline, opline->op1) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
HANDLE_EXCEPTION();
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)), ce);
+ if (IS_CV != IS_CONST) {
+ CACHE_PTR(opline->result.num, ce);
+ }
}
} else if (IS_VAR == IS_UNUSED) {
ce = zend_fetch_class(NULL, opline->op1.num);
if (IS_VAR == IS_CONST &&
IS_CV == IS_CONST &&
- EXPECTED((fbc = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)))) != NULL)) {
+ EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
/* nothing to do */
} else if (IS_VAR != IS_CONST &&
IS_CV == IS_CONST &&
- EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2))) == ce)) {
- fbc = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)) + sizeof(void*));
+ EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
+ fbc = CACHED_PTR(opline->result.num + sizeof(void*));
} else if (IS_CV != IS_UNUSED) {
if (IS_CV == IS_CONST &&
EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE)))) {
- if (IS_VAR == IS_CONST) {
- CACHE_PTR(Z_CACHE_SLOT_P(function_name), fbc);
- } else {
- CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), ce, fbc);
- }
+ CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
}
if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) {
init_func_run_time_cache(&fbc->op_array);
}
}
if (Z_OBJ_HT_P(container)->unset_property) {
- Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(offset)) : NULL));
+ Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
} else {
zend_wrong_property_unset(offset);
}
ZEND_VM_NEXT_OPCODE();
}
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
- USE_OPLINE
- zval *result;
- zend_function *constructor;
- zend_class_entry *ce;
- zend_execute_data *call;
-
- SAVE_OPLINE();
- if (IS_UNUSED == IS_CONST) {
- ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)));
- if (UNEXPECTED(ce == NULL)) {
- ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), RT_CONSTANT(opline, opline->op1) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
- if (UNEXPECTED(ce == NULL)) {
- ZEND_ASSERT(EG(exception));
- ZVAL_UNDEF(EX_VAR(opline->result.var));
- HANDLE_EXCEPTION();
- }
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)), ce);
- }
- } else if (IS_UNUSED == IS_UNUSED) {
- ce = zend_fetch_class(NULL, opline->op1.num);
- if (UNEXPECTED(ce == NULL)) {
- ZEND_ASSERT(EG(exception));
- ZVAL_UNDEF(EX_VAR(opline->result.var));
- HANDLE_EXCEPTION();
- }
- } else {
- ce = Z_CE_P(EX_VAR(opline->op1.var));
- }
-
- result = EX_VAR(opline->result.var);
- if (UNEXPECTED(object_init_ex(result, ce) != SUCCESS)) {
- ZVAL_UNDEF(result);
- HANDLE_EXCEPTION();
- }
-
- constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result));
- if (constructor == NULL) {
- if (UNEXPECTED(EG(exception))) {
- HANDLE_EXCEPTION();
- }
-
- /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next
- * opcode is DO_FCALL in case EXT instructions are used. */
- if (EXPECTED(opline->extended_value == 0 && (opline+1)->opcode == ZEND_DO_FCALL)) {
- ZEND_VM_NEXT_OPCODE_EX(1, 2);
- }
-
- /* Perform a dummy function call */
- call = zend_vm_stack_push_call_frame(
- ZEND_CALL_FUNCTION, (zend_function *) &zend_pass_function,
- opline->extended_value, NULL, NULL);
- } else {
- if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!constructor->op_array.run_time_cache)) {
- init_func_run_time_cache(&constructor->op_array);
- }
- /* We are not handling overloaded classes right now */
- call = zend_vm_stack_push_call_frame(
- ZEND_CALL_FUNCTION | ZEND_CALL_RELEASE_THIS | ZEND_CALL_CTOR,
- constructor,
- opline->extended_value,
- ce,
- Z_OBJ_P(result));
- Z_ADDREF_P(result);
- }
-
- call->prev_execute_data = EX(call);
- EX(call) = call;
- ZEND_VM_NEXT_OPCODE();
-}
-
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
/* 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)) {
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL))) != NULL)) {
if (UNEXPECTED(Z_ISERROR_P(zptr))) {
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_NULL(EX_VAR(opline->result.var));
}
}
} else {
- zend_assign_op_overloaded_property(object, property, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), value, binary_op, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+ zend_assign_op_overloaded_property(object, property, ((IS_CONST == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL), value, binary_op, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
}
} while (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)) {
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL))) != NULL)) {
if (UNEXPECTED(Z_ISERROR_P(zptr))) {
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_NULL(EX_VAR(opline->result.var));
}
}
} else {
- zend_pre_incdec_overloaded_property(object, property, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), inc, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+ zend_pre_incdec_overloaded_property(object, property, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), inc, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
}
} while (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)) {
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL))) != NULL)) {
if (UNEXPECTED(Z_ISERROR_P(zptr))) {
ZVAL_NULL(EX_VAR(opline->result.var));
} else {
}
}
} else {
- zend_post_incdec_overloaded_property(object, property, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), inc, EX_VAR(opline->result.var));
+ zend_post_incdec_overloaded_property(object, property, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), inc, EX_VAR(opline->result.var));
}
} while (0);
zval *retval;
if (IS_CONST == IS_CONST) {
- cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
+ cache_slot = CACHE_ADDR(opline->extended_value);
if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
property = RT_CONSTANT(opline, opline->op2);
result = EX_VAR(opline->result.var);
- zend_fetch_property_address(result, container, IS_UNUSED, property, IS_CONST, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W);
+ zend_fetch_property_address(result, container, IS_UNUSED, property, IS_CONST, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_W);
if (IS_UNUSED == IS_VAR) {
FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
}
property = RT_CONSTANT(opline, opline->op2);
result = EX_VAR(opline->result.var);
- zend_fetch_property_address(result, container, IS_UNUSED, property, IS_CONST, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_RW);
+ zend_fetch_property_address(result, container, IS_UNUSED, property, IS_CONST, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW);
if (IS_UNUSED == IS_VAR) {
FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
zval *retval;
if (IS_CONST == IS_CONST) {
- cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
+ cache_slot = CACHE_ADDR(opline->extended_value);
if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
property = RT_CONSTANT(opline, opline->op2);
result = EX_VAR(opline->result.var);
- zend_fetch_property_address(result, container, IS_UNUSED, property, IS_CONST, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_UNSET);
+ zend_fetch_property_address(result, container, IS_UNUSED, property, IS_CONST, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET);
if (IS_UNUSED == IS_VAR) {
FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
}
if (IS_CONST == IS_CONST &&
- EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
- uintptr_t prop_offset = (uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+ EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
+ uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
zend_object *zobj = Z_OBJ_P(object);
zval *property_val;
ZVAL_DEREF(value);
}
- Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL);
+ Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
}
if (IS_CONST == IS_CONST &&
- EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
- uintptr_t prop_offset = (uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+ EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
+ uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
zend_object *zobj = Z_OBJ_P(object);
zval *property_val;
ZVAL_DEREF(value);
}
- Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL);
+ Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
}
if (IS_CONST == IS_CONST &&
- EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
- uintptr_t prop_offset = (uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+ EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
+ uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
zend_object *zobj = Z_OBJ_P(object);
zval *property_val;
ZVAL_DEREF(value);
}
- Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL);
+ Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
}
if (IS_CONST == IS_CONST &&
- EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
- uintptr_t prop_offset = (uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+ EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
+ uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
zend_object *zobj = Z_OBJ_P(object);
zval *property_val;
ZVAL_DEREF(value);
}
- Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL);
+ Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
+
+ zval *class_name;
USE_OPLINE
SAVE_OPLINE();
if (IS_CONST == IS_UNUSED) {
Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->op1.num);
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
- } else {
-
- zval *class_name = RT_CONSTANT(opline, opline->op2);
+ } else if (IS_CONST == IS_CONST) {
+ zend_class_entry *ce = CACHED_PTR(opline->extended_value);
+ if (UNEXPECTED(ce == NULL)) {
+ class_name = RT_CONSTANT(opline, opline->op2);
+ ce = zend_fetch_class_by_name(Z_STR_P(class_name), class_name + 1, opline->op1.num);
+ CACHE_PTR(opline->extended_value, ce);
+ }
+ Z_CE_P(EX_VAR(opline->result.var)) = ce;
+ } else {
+ class_name = RT_CONSTANT(opline, opline->op2);
try_class_name:
- if (IS_CONST == IS_CONST) {
- zend_class_entry *ce = CACHED_PTR(Z_CACHE_SLOT_P(class_name));
-
- if (UNEXPECTED(ce == NULL)) {
- ce = zend_fetch_class_by_name(Z_STR_P(class_name), RT_CONSTANT(opline, opline->op2) + 1, opline->op1.num);
- CACHE_PTR(Z_CACHE_SLOT_P(class_name), ce);
- }
- Z_CE_P(EX_VAR(opline->result.var)) = ce;
- } else if (Z_TYPE_P(class_name) == IS_OBJECT) {
+ if (Z_TYPE_P(class_name) == IS_OBJECT) {
Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
} else if (Z_TYPE_P(class_name) == IS_STRING) {
Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->op1.num);
}
zend_throw_error(NULL, "Class name must be a valid object or a string");
}
-
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
+
+ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
}
- function_name = RT_CONSTANT(opline, opline->op2);
+ if (IS_CONST != IS_CONST) {
+ function_name = RT_CONSTANT(opline, opline->op2);
+ }
if (IS_CONST != IS_CONST &&
UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
HANDLE_EXCEPTION();
}
}
+ if (IS_CONST == IS_CONST) {
+ function_name = RT_CONSTANT(opline, opline->op2);
+ }
zend_throw_error(NULL, "Call to a member function %s() on %s", Z_STRVAL_P(function_name), zend_get_type_by_const(Z_TYPE_P(object)));
called_scope = obj->ce;
if (IS_CONST == IS_CONST &&
- EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(function_name)) == called_scope)) {
- fbc = CACHED_PTR(Z_CACHE_SLOT_P(function_name) + sizeof(void*));
+ EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
+ fbc = CACHED_PTR(opline->result.num + sizeof(void*));
} else {
zend_object *orig_obj = obj;
HANDLE_EXCEPTION();
}
+ if (IS_CONST == IS_CONST) {
+ function_name = RT_CONSTANT(opline, opline->op2);
+ }
+
/* First, locate the function. */
fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
if (UNEXPECTED(fbc == NULL)) {
EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
EXPECTED(obj == orig_obj)) {
- CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), called_scope, fbc);
+ CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
}
if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) {
init_func_run_time_cache(&fbc->op_array);
if (IS_UNUSED == IS_CONST) {
/* no function found. try a static method in class */
- ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)));
+ ce = CACHED_PTR(opline->result.num);
if (UNEXPECTED(ce == NULL)) {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), RT_CONSTANT(opline, opline->op1) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
HANDLE_EXCEPTION();
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)), ce);
+ if (IS_CONST != IS_CONST) {
+ CACHE_PTR(opline->result.num, ce);
+ }
}
} else if (IS_UNUSED == IS_UNUSED) {
ce = zend_fetch_class(NULL, opline->op1.num);
if (IS_UNUSED == IS_CONST &&
IS_CONST == IS_CONST &&
- EXPECTED((fbc = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)))) != NULL)) {
+ EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
/* nothing to do */
} else if (IS_UNUSED != IS_CONST &&
IS_CONST == IS_CONST &&
- EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2))) == ce)) {
- fbc = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)) + sizeof(void*));
+ EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
+ fbc = CACHED_PTR(opline->result.num + sizeof(void*));
} else if (IS_CONST != IS_UNUSED) {
if (IS_CONST == IS_CONST &&
EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE)))) {
- if (IS_UNUSED == IS_CONST) {
- CACHE_PTR(Z_CACHE_SLOT_P(function_name), fbc);
- } else {
- CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), ce, fbc);
- }
+ CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
}
if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) {
init_func_run_time_cache(&fbc->op_array);
USE_OPLINE
zend_constant *c;
- if (EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2))))) {
- c = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)));
+ if (EXPECTED(CACHED_PTR(opline->extended_value))) {
+ c = CACHED_PTR(opline->extended_value);
} else if ((c = zend_quick_get_constant(RT_CONSTANT(opline, opline->op2) + 1, opline->op1.num)) == NULL) {
SAVE_OPLINE();
HANDLE_EXCEPTION();
}
} else {
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), c);
+ CACHE_PTR(opline->extended_value, c);
}
ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), &c->value);
do {
if (IS_UNUSED == IS_CONST) {
- if (EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2))))) {
- value = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)));
+ if (EXPECTED(CACHED_PTR(opline->extended_value + sizeof(void*)))) {
+ value = CACHED_PTR(opline->extended_value + sizeof(void*));
break;
- } else if (EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1))))) {
- ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)));
+ } else if (EXPECTED(CACHED_PTR(opline->extended_value))) {
+ ce = CACHED_PTR(opline->extended_value);
} else {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), RT_CONSTANT(opline, opline->op1) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
if (UNEXPECTED(ce == NULL)) {
ZVAL_UNDEF(EX_VAR(opline->result.var));
HANDLE_EXCEPTION();
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)), ce);
}
} else {
if (IS_UNUSED == IS_UNUSED) {
} else {
ce = Z_CE_P(EX_VAR(opline->op1.var));
}
- if (EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2))) == ce)) {
- value = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)) + sizeof(void*));
+ if (EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
+ value = CACHED_PTR(opline->extended_value + sizeof(void*));
break;
}
}
HANDLE_EXCEPTION();
}
}
- if (IS_UNUSED == IS_CONST) {
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), value);
- } else {
- CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), ce, value);
- }
+ CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, value);
} else {
zend_throw_error(NULL, "Undefined class constant '%s'", Z_STRVAL_P(RT_CONSTANT(opline, opline->op2)));
ZVAL_UNDEF(EX_VAR(opline->result.var));
}
}
if (Z_OBJ_HT_P(container)->unset_property) {
- Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(offset)) : NULL));
+ Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
} else {
zend_wrong_property_unset(offset);
}
} else {
result =
((opline->extended_value & ZEND_ISSET) == 0) ^
- Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(offset)) : NULL));
+ Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISSET) : 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_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
+ && 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((opline+1)->extended_value) : NULL))) != NULL)) {
if (UNEXPECTED(Z_ISERROR_P(zptr))) {
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_NULL(EX_VAR(opline->result.var));
}
}
} else {
- zend_assign_op_overloaded_property(object, property, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), value, binary_op, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+ zend_assign_op_overloaded_property(object, property, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL), value, binary_op, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
}
} while (0);
/* here we are sure we are dealing with an object */
if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr)
- && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
+ && 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(opline->extended_value) : NULL))) != NULL)) {
if (UNEXPECTED(Z_ISERROR_P(zptr))) {
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_NULL(EX_VAR(opline->result.var));
}
}
} else {
- zend_pre_incdec_overloaded_property(object, property, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), inc, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+ zend_pre_incdec_overloaded_property(object, property, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), inc, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
}
} while (0);
/* here we are sure we are dealing with an object */
if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr)
- && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
+ && 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(opline->extended_value) : NULL))) != NULL)) {
if (UNEXPECTED(Z_ISERROR_P(zptr))) {
ZVAL_NULL(EX_VAR(opline->result.var));
} else {
}
}
} else {
- zend_post_incdec_overloaded_property(object, property, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), inc, EX_VAR(opline->result.var));
+ zend_post_incdec_overloaded_property(object, property, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), inc, EX_VAR(opline->result.var));
}
} while (0);
zval *retval;
if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
- cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
+ cache_slot = CACHE_ADDR(opline->extended_value);
if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
result = EX_VAR(opline->result.var);
- zend_fetch_property_address(result, container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W);
+ zend_fetch_property_address(result, container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_W);
zval_ptr_dtor_nogc(free_op2);
if (IS_UNUSED == IS_VAR) {
FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
}
property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
result = EX_VAR(opline->result.var);
- zend_fetch_property_address(result, container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_RW);
+ zend_fetch_property_address(result, container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW);
zval_ptr_dtor_nogc(free_op2);
if (IS_UNUSED == IS_VAR) {
FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
zval *retval;
if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
- cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
+ cache_slot = CACHE_ADDR(opline->extended_value);
if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
result = EX_VAR(opline->result.var);
- zend_fetch_property_address(result, container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_UNSET);
+ zend_fetch_property_address(result, container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET);
zval_ptr_dtor_nogc(free_op2);
if (IS_UNUSED == IS_VAR) {
FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
}
if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
- EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
- uintptr_t prop_offset = (uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+ EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
+ uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
zend_object *zobj = Z_OBJ_P(object);
zval *property_val;
ZVAL_DEREF(value);
}
- Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL);
+ Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
}
if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
- EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
- uintptr_t prop_offset = (uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+ EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
+ uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
zend_object *zobj = Z_OBJ_P(object);
zval *property_val;
ZVAL_DEREF(value);
}
- Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL);
+ Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
}
if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
- EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
- uintptr_t prop_offset = (uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+ EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
+ uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
zend_object *zobj = Z_OBJ_P(object);
zval *property_val;
ZVAL_DEREF(value);
}
- Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL);
+ Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
}
if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
- EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
- uintptr_t prop_offset = (uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+ EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
+ uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
zend_object *zobj = Z_OBJ_P(object);
zval *property_val;
ZVAL_DEREF(value);
}
- Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL);
+ Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
+ zend_free_op free_op2;
+ zval *class_name;
USE_OPLINE
SAVE_OPLINE();
if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->op1.num);
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
- } else {
- zend_free_op free_op2;
- zval *class_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+ } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+ zend_class_entry *ce = CACHED_PTR(opline->extended_value);
+ if (UNEXPECTED(ce == NULL)) {
+ class_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+ ce = zend_fetch_class_by_name(Z_STR_P(class_name), class_name + 1, opline->op1.num);
+ CACHE_PTR(opline->extended_value, ce);
+ }
+ Z_CE_P(EX_VAR(opline->result.var)) = ce;
+ } else {
+ class_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
try_class_name:
- if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
- zend_class_entry *ce = CACHED_PTR(Z_CACHE_SLOT_P(class_name));
-
- if (UNEXPECTED(ce == NULL)) {
- ce = zend_fetch_class_by_name(Z_STR_P(class_name), RT_CONSTANT(opline, opline->op2) + 1, opline->op1.num);
- CACHE_PTR(Z_CACHE_SLOT_P(class_name), ce);
- }
- Z_CE_P(EX_VAR(opline->result.var)) = ce;
- } else if (Z_TYPE_P(class_name) == IS_OBJECT) {
+ if (Z_TYPE_P(class_name) == IS_OBJECT) {
Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
} else if (Z_TYPE_P(class_name) == IS_STRING) {
Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->op1.num);
}
zend_throw_error(NULL, "Class name must be a valid object or a string");
}
-
- zval_ptr_dtor_nogc(free_op2);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
+
+ zval_ptr_dtor_nogc(free_op2);
+ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
}
- function_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+ if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
+ function_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+ }
if ((IS_TMP_VAR|IS_VAR) != IS_CONST &&
UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
HANDLE_EXCEPTION();
}
}
+ if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+ function_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+ }
zend_throw_error(NULL, "Call to a member function %s() on %s", Z_STRVAL_P(function_name), zend_get_type_by_const(Z_TYPE_P(object)));
zval_ptr_dtor_nogc(free_op2);
called_scope = obj->ce;
if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
- EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(function_name)) == called_scope)) {
- fbc = CACHED_PTR(Z_CACHE_SLOT_P(function_name) + sizeof(void*));
+ EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
+ fbc = CACHED_PTR(opline->result.num + sizeof(void*));
} else {
zend_object *orig_obj = obj;
HANDLE_EXCEPTION();
}
+ if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+ function_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+ }
+
/* First, locate the function. */
fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
if (UNEXPECTED(fbc == NULL)) {
EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
EXPECTED(obj == orig_obj)) {
- CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), called_scope, fbc);
+ CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
}
if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) {
init_func_run_time_cache(&fbc->op_array);
if (IS_UNUSED == IS_CONST) {
/* no function found. try a static method in class */
- ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)));
+ ce = CACHED_PTR(opline->result.num);
if (UNEXPECTED(ce == NULL)) {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), RT_CONSTANT(opline, opline->op1) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
HANDLE_EXCEPTION();
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)), ce);
+ if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
+ CACHE_PTR(opline->result.num, ce);
+ }
}
} else if (IS_UNUSED == IS_UNUSED) {
ce = zend_fetch_class(NULL, opline->op1.num);
if (IS_UNUSED == IS_CONST &&
(IS_TMP_VAR|IS_VAR) == IS_CONST &&
- EXPECTED((fbc = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)))) != NULL)) {
+ EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
/* nothing to do */
} else if (IS_UNUSED != IS_CONST &&
(IS_TMP_VAR|IS_VAR) == IS_CONST &&
- EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2))) == ce)) {
- fbc = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)) + sizeof(void*));
+ EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
+ fbc = CACHED_PTR(opline->result.num + sizeof(void*));
} else if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
zend_free_op free_op2;
if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE)))) {
- if (IS_UNUSED == IS_CONST) {
- CACHE_PTR(Z_CACHE_SLOT_P(function_name), fbc);
- } else {
- CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), ce, fbc);
- }
+ CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
}
if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) {
init_func_run_time_cache(&fbc->op_array);
}
}
if (Z_OBJ_HT_P(container)->unset_property) {
- Z_OBJ_HT_P(container)->unset_property(container, offset, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(offset)) : NULL));
+ Z_OBJ_HT_P(container)->unset_property(container, offset, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
} else {
zend_wrong_property_unset(offset);
}
} else {
result =
((opline->extended_value & ZEND_ISSET) == 0) ^
- Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(offset)) : NULL));
+ Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISSET) : NULL));
}
zval_ptr_dtor_nogc(free_op2);
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
+
+ zval *class_name;
USE_OPLINE
SAVE_OPLINE();
if (IS_UNUSED == IS_UNUSED) {
Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->op1.num);
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
- } else {
-
- zval *class_name = NULL;
+ } else if (IS_UNUSED == IS_CONST) {
+ zend_class_entry *ce = CACHED_PTR(opline->extended_value);
+ if (UNEXPECTED(ce == NULL)) {
+ class_name = NULL;
+ ce = zend_fetch_class_by_name(Z_STR_P(class_name), class_name + 1, opline->op1.num);
+ CACHE_PTR(opline->extended_value, ce);
+ }
+ Z_CE_P(EX_VAR(opline->result.var)) = ce;
+ } else {
+ class_name = NULL;
try_class_name:
- if (IS_UNUSED == IS_CONST) {
- zend_class_entry *ce = CACHED_PTR(Z_CACHE_SLOT_P(class_name));
-
- if (UNEXPECTED(ce == NULL)) {
- ce = zend_fetch_class_by_name(Z_STR_P(class_name), RT_CONSTANT(opline, opline->op2) + 1, opline->op1.num);
- CACHE_PTR(Z_CACHE_SLOT_P(class_name), ce);
- }
- Z_CE_P(EX_VAR(opline->result.var)) = ce;
- } else if (Z_TYPE_P(class_name) == IS_OBJECT) {
+ if (Z_TYPE_P(class_name) == IS_OBJECT) {
Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
} else if (Z_TYPE_P(class_name) == IS_STRING) {
Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->op1.num);
}
zend_throw_error(NULL, "Class name must be a valid object or a string");
}
-
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
+
+ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
if (IS_UNUSED == IS_CONST) {
/* no function found. try a static method in class */
- ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)));
+ ce = CACHED_PTR(opline->result.num);
if (UNEXPECTED(ce == NULL)) {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), RT_CONSTANT(opline, opline->op1) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
HANDLE_EXCEPTION();
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)), ce);
+ if (IS_UNUSED != IS_CONST) {
+ CACHE_PTR(opline->result.num, ce);
+ }
}
} else if (IS_UNUSED == IS_UNUSED) {
ce = zend_fetch_class(NULL, opline->op1.num);
if (IS_UNUSED == IS_CONST &&
IS_UNUSED == IS_CONST &&
- EXPECTED((fbc = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)))) != NULL)) {
+ EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
/* nothing to do */
} else if (IS_UNUSED != IS_CONST &&
IS_UNUSED == IS_CONST &&
- EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2))) == ce)) {
- fbc = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)) + sizeof(void*));
+ EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
+ fbc = CACHED_PTR(opline->result.num + sizeof(void*));
} else if (IS_UNUSED != IS_UNUSED) {
if (IS_UNUSED == IS_CONST &&
EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE)))) {
- if (IS_UNUSED == IS_CONST) {
- CACHE_PTR(Z_CACHE_SLOT_P(function_name), fbc);
- } else {
- CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), ce, fbc);
- }
+ CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
}
if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) {
init_func_run_time_cache(&fbc->op_array);
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+ USE_OPLINE
+ zval *result;
+ zend_function *constructor;
+ zend_class_entry *ce;
+ zend_execute_data *call;
+
+ SAVE_OPLINE();
+ if (IS_UNUSED == IS_CONST) {
+ ce = CACHED_PTR(opline->op2.num);
+ if (UNEXPECTED(ce == NULL)) {
+ ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), RT_CONSTANT(opline, opline->op1) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
+ if (UNEXPECTED(ce == NULL)) {
+ ZEND_ASSERT(EG(exception));
+ ZVAL_UNDEF(EX_VAR(opline->result.var));
+ HANDLE_EXCEPTION();
+ }
+ CACHE_PTR(opline->op2.num, ce);
+ }
+ } else if (IS_UNUSED == IS_UNUSED) {
+ ce = zend_fetch_class(NULL, opline->op1.num);
+ if (UNEXPECTED(ce == NULL)) {
+ ZEND_ASSERT(EG(exception));
+ ZVAL_UNDEF(EX_VAR(opline->result.var));
+ HANDLE_EXCEPTION();
+ }
+ } else {
+ ce = Z_CE_P(EX_VAR(opline->op1.var));
+ }
+
+ result = EX_VAR(opline->result.var);
+ if (UNEXPECTED(object_init_ex(result, ce) != SUCCESS)) {
+ ZVAL_UNDEF(result);
+ HANDLE_EXCEPTION();
+ }
+
+ constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result));
+ if (constructor == NULL) {
+ if (UNEXPECTED(EG(exception))) {
+ HANDLE_EXCEPTION();
+ }
+
+ /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next
+ * opcode is DO_FCALL in case EXT instructions are used. */
+ if (EXPECTED(opline->extended_value == 0 && (opline+1)->opcode == ZEND_DO_FCALL)) {
+ ZEND_VM_NEXT_OPCODE_EX(1, 2);
+ }
+
+ /* Perform a dummy function call */
+ call = zend_vm_stack_push_call_frame(
+ ZEND_CALL_FUNCTION, (zend_function *) &zend_pass_function,
+ opline->extended_value, NULL, NULL);
+ } else {
+ if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!constructor->op_array.run_time_cache)) {
+ init_func_run_time_cache(&constructor->op_array);
+ }
+ /* We are not handling overloaded classes right now */
+ call = zend_vm_stack_push_call_frame(
+ ZEND_CALL_FUNCTION | ZEND_CALL_RELEASE_THIS | ZEND_CALL_CTOR,
+ constructor,
+ opline->extended_value,
+ ce,
+ Z_OBJ_P(result));
+ Z_ADDREF_P(result);
+ }
+
+ call->prev_execute_data = EX(call);
+ EX(call) = call;
+ ZEND_VM_NEXT_OPCODE();
+}
+
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
/* 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)) {
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL))) != NULL)) {
if (UNEXPECTED(Z_ISERROR_P(zptr))) {
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_NULL(EX_VAR(opline->result.var));
}
}
} else {
- zend_assign_op_overloaded_property(object, property, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), value, binary_op, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+ zend_assign_op_overloaded_property(object, property, ((IS_CV == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL), value, binary_op, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
}
} while (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_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL))) != NULL)) {
if (UNEXPECTED(Z_ISERROR_P(zptr))) {
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_NULL(EX_VAR(opline->result.var));
}
}
} else {
- zend_pre_incdec_overloaded_property(object, property, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), inc, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+ zend_pre_incdec_overloaded_property(object, property, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), inc, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
}
} while (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_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL))) != NULL)) {
if (UNEXPECTED(Z_ISERROR_P(zptr))) {
ZVAL_NULL(EX_VAR(opline->result.var));
} else {
}
}
} else {
- zend_post_incdec_overloaded_property(object, property, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), inc, EX_VAR(opline->result.var));
+ zend_post_incdec_overloaded_property(object, property, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), inc, EX_VAR(opline->result.var));
}
} while (0);
zval *retval;
if (IS_CV == IS_CONST) {
- cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
+ cache_slot = CACHE_ADDR(opline->extended_value);
if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
result = EX_VAR(opline->result.var);
- zend_fetch_property_address(result, container, IS_UNUSED, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W);
+ zend_fetch_property_address(result, container, IS_UNUSED, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_W);
if (IS_UNUSED == IS_VAR) {
FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
}
property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
result = EX_VAR(opline->result.var);
- zend_fetch_property_address(result, container, IS_UNUSED, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_RW);
+ zend_fetch_property_address(result, container, IS_UNUSED, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW);
if (IS_UNUSED == IS_VAR) {
FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
zval *retval;
if (IS_CV == IS_CONST) {
- cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
+ cache_slot = CACHE_ADDR(opline->extended_value);
if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
result = EX_VAR(opline->result.var);
- zend_fetch_property_address(result, container, IS_UNUSED, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_UNSET);
+ zend_fetch_property_address(result, container, IS_UNUSED, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET);
if (IS_UNUSED == IS_VAR) {
FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
}
if (IS_CV == IS_CONST &&
- EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
- uintptr_t prop_offset = (uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+ EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
+ uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
zend_object *zobj = Z_OBJ_P(object);
zval *property_val;
ZVAL_DEREF(value);
}
- Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL);
+ Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
}
if (IS_CV == IS_CONST &&
- EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
- uintptr_t prop_offset = (uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+ EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
+ uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
zend_object *zobj = Z_OBJ_P(object);
zval *property_val;
ZVAL_DEREF(value);
}
- Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL);
+ Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
}
if (IS_CV == IS_CONST &&
- EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
- uintptr_t prop_offset = (uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+ EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
+ uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
zend_object *zobj = Z_OBJ_P(object);
zval *property_val;
ZVAL_DEREF(value);
}
- Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL);
+ Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
}
if (IS_CV == IS_CONST &&
- EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
- uintptr_t prop_offset = (uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+ EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
+ uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
zend_object *zobj = Z_OBJ_P(object);
zval *property_val;
ZVAL_DEREF(value);
}
- Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL);
+ Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
+
+ zval *class_name;
USE_OPLINE
SAVE_OPLINE();
if (IS_CV == IS_UNUSED) {
Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->op1.num);
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
- } else {
-
- zval *class_name = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
+ } else if (IS_CV == IS_CONST) {
+ zend_class_entry *ce = CACHED_PTR(opline->extended_value);
+ if (UNEXPECTED(ce == NULL)) {
+ class_name = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
+ ce = zend_fetch_class_by_name(Z_STR_P(class_name), class_name + 1, opline->op1.num);
+ CACHE_PTR(opline->extended_value, ce);
+ }
+ Z_CE_P(EX_VAR(opline->result.var)) = ce;
+ } else {
+ class_name = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
try_class_name:
- if (IS_CV == IS_CONST) {
- zend_class_entry *ce = CACHED_PTR(Z_CACHE_SLOT_P(class_name));
-
- if (UNEXPECTED(ce == NULL)) {
- ce = zend_fetch_class_by_name(Z_STR_P(class_name), RT_CONSTANT(opline, opline->op2) + 1, opline->op1.num);
- CACHE_PTR(Z_CACHE_SLOT_P(class_name), ce);
- }
- Z_CE_P(EX_VAR(opline->result.var)) = ce;
- } else if (Z_TYPE_P(class_name) == IS_OBJECT) {
+ if (Z_TYPE_P(class_name) == IS_OBJECT) {
Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
} else if (Z_TYPE_P(class_name) == IS_STRING) {
Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->op1.num);
}
zend_throw_error(NULL, "Class name must be a valid object or a string");
}
-
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
+
+ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
}
- function_name = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
+ if (IS_CV != IS_CONST) {
+ function_name = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
+ }
if (IS_CV != IS_CONST &&
UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
HANDLE_EXCEPTION();
}
}
+ if (IS_CV == IS_CONST) {
+ function_name = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
+ }
zend_throw_error(NULL, "Call to a member function %s() on %s", Z_STRVAL_P(function_name), zend_get_type_by_const(Z_TYPE_P(object)));
called_scope = obj->ce;
if (IS_CV == IS_CONST &&
- EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(function_name)) == called_scope)) {
- fbc = CACHED_PTR(Z_CACHE_SLOT_P(function_name) + sizeof(void*));
+ EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
+ fbc = CACHED_PTR(opline->result.num + sizeof(void*));
} else {
zend_object *orig_obj = obj;
HANDLE_EXCEPTION();
}
+ if (IS_CV == IS_CONST) {
+ function_name = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
+ }
+
/* First, locate the function. */
fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
if (UNEXPECTED(fbc == NULL)) {
EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
EXPECTED(obj == orig_obj)) {
- CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), called_scope, fbc);
+ CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
}
if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) {
init_func_run_time_cache(&fbc->op_array);
if (IS_UNUSED == IS_CONST) {
/* no function found. try a static method in class */
- ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)));
+ ce = CACHED_PTR(opline->result.num);
if (UNEXPECTED(ce == NULL)) {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), RT_CONSTANT(opline, opline->op1) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
HANDLE_EXCEPTION();
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)), ce);
+ if (IS_CV != IS_CONST) {
+ CACHE_PTR(opline->result.num, ce);
+ }
}
} else if (IS_UNUSED == IS_UNUSED) {
ce = zend_fetch_class(NULL, opline->op1.num);
if (IS_UNUSED == IS_CONST &&
IS_CV == IS_CONST &&
- EXPECTED((fbc = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)))) != NULL)) {
+ EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
/* nothing to do */
} else if (IS_UNUSED != IS_CONST &&
IS_CV == IS_CONST &&
- EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2))) == ce)) {
- fbc = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)) + sizeof(void*));
+ EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
+ fbc = CACHED_PTR(opline->result.num + sizeof(void*));
} else if (IS_CV != IS_UNUSED) {
if (IS_CV == IS_CONST &&
EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE)))) {
- if (IS_UNUSED == IS_CONST) {
- CACHE_PTR(Z_CACHE_SLOT_P(function_name), fbc);
- } else {
- CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), ce, fbc);
- }
+ CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
}
if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) {
init_func_run_time_cache(&fbc->op_array);
}
}
if (Z_OBJ_HT_P(container)->unset_property) {
- Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(offset)) : NULL));
+ Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
} else {
zend_wrong_property_unset(offset);
}
} else {
result =
((opline->extended_value & ZEND_ISSET) == 0) ^
- Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(offset)) : NULL));
+ Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISSET) : 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)) {
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL))) != NULL)) {
if (UNEXPECTED(Z_ISERROR_P(zptr))) {
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_NULL(EX_VAR(opline->result.var));
}
}
} else {
- zend_assign_op_overloaded_property(object, property, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), value, binary_op, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+ zend_assign_op_overloaded_property(object, property, ((IS_CONST == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL), value, binary_op, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
}
} while (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)) {
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL))) != NULL)) {
if (UNEXPECTED(Z_ISERROR_P(zptr))) {
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_NULL(EX_VAR(opline->result.var));
}
}
} else {
- zend_pre_incdec_overloaded_property(object, property, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), inc, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+ zend_pre_incdec_overloaded_property(object, property, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), inc, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
}
} while (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)) {
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL))) != NULL)) {
if (UNEXPECTED(Z_ISERROR_P(zptr))) {
ZVAL_NULL(EX_VAR(opline->result.var));
} else {
}
}
} else {
- zend_post_incdec_overloaded_property(object, property, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), inc, EX_VAR(opline->result.var));
+ zend_post_incdec_overloaded_property(object, property, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), inc, EX_VAR(opline->result.var));
}
} while (0);
zval *varname;
zval *retval;
+ zend_string *name, *tmp_name;
+ zend_class_entry *ce;
SAVE_OPLINE();
- varname = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
- retval = zend_fetch_static_property_address(varname, IS_CV, opline->op2, IS_CONST, type EXECUTE_DATA_CC OPLINE_CC);
+ do {
+ if (IS_CONST == IS_CONST) {
+ if (IS_CV == IS_CONST && EXPECTED((ce = CACHED_PTR(opline->extended_value)) != NULL)) {
+ retval = CACHED_PTR(opline->extended_value + sizeof(void*));
+
+ /* check if static properties were destoyed */
+ if (EXPECTED(CE_STATIC_MEMBERS(ce) != NULL)) {
+
+ break;
+ }
+ } else {
+ zval *class_name = RT_CONSTANT(opline, opline->op2);
+
+ if (UNEXPECTED((ce = CACHED_PTR(opline->extended_value)) == NULL)) {
+ ce = zend_fetch_class_by_name(Z_STR_P(class_name), class_name + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
+ if (UNEXPECTED(ce == NULL)) {
+
+ retval = NULL;
+ break;
+ }
+ if (IS_CV != IS_CONST) {
+ CACHE_PTR(opline->extended_value, ce);
+ }
+ }
+ }
+ } else {
+ if (IS_CONST == IS_UNUSED) {
+ ce = zend_fetch_class(NULL, opline->op2.num);
+ if (UNEXPECTED(ce == NULL)) {
+
+ retval = NULL;
+ break;
+ }
+ } else {
+ ce = Z_CE_P(EX_VAR(opline->op2.var));
+ }
+ if (IS_CV == IS_CONST &&
+ EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
+ retval = CACHED_PTR(opline->extended_value + sizeof(void*));
+
+ /* check if static properties were destoyed */
+ if (EXPECTED(CE_STATIC_MEMBERS(ce) != NULL)) {
+
+ break;
+ }
+ }
+ }
+
+ varname = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+ if (IS_CV == IS_CONST) {
+ name = Z_STR_P(varname);
+ } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
+ name = Z_STR_P(varname);
+ tmp_name = NULL;
+ } else {
+ if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
+ zval_undefined_cv(EX(opline)->op1.var EXECUTE_DATA_CC);
+ }
+ name = zval_get_tmp_string(varname, &tmp_name);
+ }
+
+ retval = zend_std_get_static_property(ce, name, type == BP_VAR_IS);
+
+ if (IS_CV != IS_CONST) {
+ zend_tmp_string_release(tmp_name);
+ }
+
+ if (IS_CV == IS_CONST && EXPECTED(retval)) {
+ CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, retval);
+ }
+
+ } while (0);
if (UNEXPECTED(retval == NULL)) {
if (EG(exception)) {
-
ZVAL_UNDEF(EX_VAR(opline->result.var));
HANDLE_EXCEPTION();
} else {
zval *retval;
if (IS_CONST == IS_CONST) {
- cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
+ cache_slot = CACHE_ADDR(opline->extended_value);
if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
property = RT_CONSTANT(opline, opline->op2);
result = EX_VAR(opline->result.var);
- zend_fetch_property_address(result, container, IS_CV, property, IS_CONST, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W);
+ zend_fetch_property_address(result, container, IS_CV, property, IS_CONST, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_W);
if (IS_CV == IS_VAR) {
FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
}
property = RT_CONSTANT(opline, opline->op2);
result = EX_VAR(opline->result.var);
- zend_fetch_property_address(result, container, IS_CV, property, IS_CONST, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_RW);
+ zend_fetch_property_address(result, container, IS_CV, property, IS_CONST, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW);
if (IS_CV == IS_VAR) {
FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
zval *retval;
if (IS_CONST == IS_CONST) {
- cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
+ cache_slot = CACHE_ADDR(opline->extended_value);
if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
property = RT_CONSTANT(opline, opline->op2);
result = EX_VAR(opline->result.var);
- zend_fetch_property_address(result, container, IS_CV, property, IS_CONST, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_UNSET);
+ zend_fetch_property_address(result, container, IS_CV, property, IS_CONST, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET);
if (IS_CV == IS_VAR) {
FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
}
if (IS_CONST == IS_CONST &&
- EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
- uintptr_t prop_offset = (uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+ EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
+ uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
zend_object *zobj = Z_OBJ_P(object);
zval *property_val;
ZVAL_DEREF(value);
}
- Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL);
+ Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
}
if (IS_CONST == IS_CONST &&
- EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
- uintptr_t prop_offset = (uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+ EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
+ uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
zend_object *zobj = Z_OBJ_P(object);
zval *property_val;
ZVAL_DEREF(value);
}
- Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL);
+ Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
}
if (IS_CONST == IS_CONST &&
- EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
- uintptr_t prop_offset = (uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+ EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
+ uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
zend_object *zobj = Z_OBJ_P(object);
zval *property_val;
ZVAL_DEREF(value);
}
- Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL);
+ Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
}
if (IS_CONST == IS_CONST &&
- EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
- uintptr_t prop_offset = (uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+ EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
+ uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
zend_object *zobj = Z_OBJ_P(object);
zval *property_val;
ZVAL_DEREF(value);
}
- Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL);
+ Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
}
- function_name = RT_CONSTANT(opline, opline->op2);
+ if (IS_CONST != IS_CONST) {
+ function_name = RT_CONSTANT(opline, opline->op2);
+ }
if (IS_CONST != IS_CONST &&
UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
HANDLE_EXCEPTION();
}
}
+ if (IS_CONST == IS_CONST) {
+ function_name = RT_CONSTANT(opline, opline->op2);
+ }
zend_throw_error(NULL, "Call to a member function %s() on %s", Z_STRVAL_P(function_name), zend_get_type_by_const(Z_TYPE_P(object)));
called_scope = obj->ce;
if (IS_CONST == IS_CONST &&
- EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(function_name)) == called_scope)) {
- fbc = CACHED_PTR(Z_CACHE_SLOT_P(function_name) + sizeof(void*));
+ EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
+ fbc = CACHED_PTR(opline->result.num + sizeof(void*));
} else {
zend_object *orig_obj = obj;
HANDLE_EXCEPTION();
}
+ if (IS_CONST == IS_CONST) {
+ function_name = RT_CONSTANT(opline, opline->op2);
+ }
+
/* First, locate the function. */
fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
if (UNEXPECTED(fbc == NULL)) {
EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
EXPECTED(obj == orig_obj)) {
- CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), called_scope, fbc);
+ CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
}
if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) {
init_func_run_time_cache(&fbc->op_array);
SAVE_OPLINE();
- varname = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
-
- if (IS_CV == IS_CONST) {
- name = Z_STR_P(varname);
- } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
- name = Z_STR_P(varname);
- tmp_name = NULL;
- } else {
- if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
- varname = GET_OP1_UNDEF_CV(varname, BP_VAR_R);
- }
- name = zval_get_tmp_string(varname, &tmp_name);
- }
-
if (IS_CONST == IS_CONST) {
- ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)));
+ ce = CACHED_PTR(opline->extended_value);
if (UNEXPECTED(ce == NULL)) {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), RT_CONSTANT(opline, opline->op2) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
- if (IS_CV != IS_CONST) {
- zend_tmp_string_release(tmp_name);
- }
HANDLE_EXCEPTION();
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), ce);
+ /*CACHE_PTR(opline->extended_value, ce);*/
}
} else if (IS_CONST == IS_UNUSED) {
ce = zend_fetch_class(NULL, opline->op2.num);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
- if (IS_CV != IS_CONST) {
- zend_tmp_string_release(tmp_name);
- }
HANDLE_EXCEPTION();
}
} else {
ce = Z_CE_P(EX_VAR(opline->op2.var));
}
+
+ varname = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+ if (IS_CV == IS_CONST) {
+ name = Z_STR_P(varname);
+ } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
+ name = Z_STR_P(varname);
+ tmp_name = NULL;
+ } else {
+ if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
+ varname = GET_OP1_UNDEF_CV(varname, BP_VAR_R);
+ }
+ name = zval_get_tmp_string(varname, &tmp_name);
+ }
+
zend_std_unset_static_property(ce, name);
if (IS_CV != IS_CONST) {
}
}
if (Z_OBJ_HT_P(container)->unset_property) {
- Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(offset)) : NULL));
+ Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
} else {
zend_wrong_property_unset(offset);
}
zend_class_entry *ce;
SAVE_OPLINE();
- varname = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
- if (IS_CV == IS_CONST) {
- name = Z_STR_P(varname);
- } else {
- name = zval_get_tmp_string(varname, &tmp_name);
- }
-
if (IS_CONST == IS_CONST) {
- if (IS_CV == IS_CONST && EXPECTED((ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)))) != NULL)) {
- value = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)) + sizeof(void*));
+ if (IS_CV == IS_CONST && EXPECTED((ce = CACHED_PTR(opline->extended_value & ~ZEND_ISSET)) != NULL)) {
+ value = CACHED_PTR((opline->extended_value & ~ZEND_ISSET) + sizeof(void*));
/* check if static properties were destoyed */
if (UNEXPECTED(CE_STATIC_MEMBERS(ce) == NULL)) {
}
goto is_static_prop_return;
- } else if (UNEXPECTED((ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)))) == NULL)) {
+ } else if (UNEXPECTED((ce = CACHED_PTR(opline->extended_value & ~ZEND_ISSET)) == NULL)) {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), RT_CONSTANT(opline, opline->op2) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
ZVAL_UNDEF(EX_VAR(opline->result.var));
HANDLE_EXCEPTION();
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), ce);
+ if (IS_CV != IS_CONST) {
+ CACHE_PTR(opline->extended_value & ~ZEND_ISSET, ce);
+ }
}
} else {
if (IS_CONST == IS_UNUSED) {
ce = zend_fetch_class(NULL, opline->op2.num);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
- if (IS_CV != IS_CONST) {
- zend_tmp_string_release(tmp_name);
- }
ZVAL_UNDEF(EX_VAR(opline->result.var));
HANDLE_EXCEPTION();
ce = Z_CE_P(EX_VAR(opline->op2.var));
}
if (IS_CV == IS_CONST &&
- EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1))) == ce)) {
+ EXPECTED(CACHED_PTR(opline->extended_value & ~ZEND_ISSET) == ce)) {
- value = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)) + sizeof(void*));
+ value = CACHED_PTR((opline->extended_value & ~ZEND_ISSET) + sizeof(void*));
/* check if static properties were destoyed */
if (UNEXPECTED(CE_STATIC_MEMBERS(ce) == NULL)) {
}
}
+ varname = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
+ if (IS_CV == IS_CONST) {
+ name = Z_STR_P(varname);
+ } else {
+ name = zval_get_tmp_string(varname, &tmp_name);
+ }
+
value = zend_std_get_static_property(ce, name, 1);
if (IS_CV == IS_CONST && value) {
- CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)), ce, value);
+ CACHE_POLYMORPHIC_PTR(opline->extended_value & ~ZEND_ISSET, ce, value);
}
if (IS_CV != IS_CONST) {
} else {
result =
((opline->extended_value & ZEND_ISSET) == 0) ^
- Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(offset)) : NULL));
+ Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISSET) : NULL));
}
zend_class_entry *ce;
if (IS_CONST == IS_CONST) {
- ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)));
+ ce = CACHED_PTR(opline->extended_value);
if (UNEXPECTED(ce == NULL)) {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), RT_CONSTANT(opline, opline->op2) + 1, ZEND_FETCH_CLASS_NO_AUTOLOAD);
if (EXPECTED(ce)) {
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), ce);
+ CACHE_PTR(opline->extended_value, ce);
}
}
} else if (IS_CONST == IS_UNUSED) {
varname = RT_CONSTANT(opline, opline->op2);
/* We store "hash slot index" + 1 (NULL is a mark of uninitialized cache slot) */
- idx = (uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(varname)) - 1;
+ idx = (uintptr_t)CACHED_PTR(opline->extended_value) - 1;
if (EXPECTED(idx < EG(symbol_table).nNumUsed * sizeof(Bucket))) {
Bucket *p = (Bucket*)((char*)EG(symbol_table).arData + idx);
value = zend_hash_add_new(&EG(symbol_table), Z_STR_P(varname), &EG(uninitialized_zval));
idx = (char*)value - (char*)EG(symbol_table).arData;
/* Store "hash slot index" + 1 (NULL is a mark of uninitialized cache slot) */
- CACHE_PTR(Z_CACHE_SLOT_P(varname), (void*)(idx + 1));
+ CACHE_PTR(opline->extended_value, (void*)(idx + 1));
} else {
idx = (char*)value - (char*)EG(symbol_table).arData;
/* Store "hash slot index" + 1 (NULL is a mark of uninitialized cache slot) */
- CACHE_PTR(Z_CACHE_SLOT_P(varname), (void*)(idx + 1));
+ CACHE_PTR(opline->extended_value, (void*)(idx + 1));
check_indirect:
/* GLOBAL variable may be an INDIRECT pointer to CV */
if (UNEXPECTED(Z_TYPE_P(value) == IS_INDIRECT)) {
/* 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)) {
+ && 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((opline+1)->extended_value) : NULL))) != NULL)) {
if (UNEXPECTED(Z_ISERROR_P(zptr))) {
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_NULL(EX_VAR(opline->result.var));
}
}
} else {
- zend_assign_op_overloaded_property(object, property, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), value, binary_op, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+ zend_assign_op_overloaded_property(object, property, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL), value, binary_op, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
}
} while (0);
/* here we are sure we are dealing with an object */
if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr)
- && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
+ && 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(opline->extended_value) : NULL))) != NULL)) {
if (UNEXPECTED(Z_ISERROR_P(zptr))) {
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_NULL(EX_VAR(opline->result.var));
}
}
} else {
- zend_pre_incdec_overloaded_property(object, property, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), inc, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+ zend_pre_incdec_overloaded_property(object, property, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), inc, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
}
} while (0);
/* here we are sure we are dealing with an object */
if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr)
- && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
+ && 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(opline->extended_value) : NULL))) != NULL)) {
if (UNEXPECTED(Z_ISERROR_P(zptr))) {
ZVAL_NULL(EX_VAR(opline->result.var));
} else {
}
}
} else {
- zend_post_incdec_overloaded_property(object, property, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), inc, EX_VAR(opline->result.var));
+ zend_post_incdec_overloaded_property(object, property, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), inc, EX_VAR(opline->result.var));
}
} while (0);
zval *retval;
if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
- cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
+ cache_slot = CACHE_ADDR(opline->extended_value);
if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
result = EX_VAR(opline->result.var);
- zend_fetch_property_address(result, container, IS_CV, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W);
+ zend_fetch_property_address(result, container, IS_CV, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_W);
zval_ptr_dtor_nogc(free_op2);
if (IS_CV == IS_VAR) {
FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
}
property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
result = EX_VAR(opline->result.var);
- zend_fetch_property_address(result, container, IS_CV, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_RW);
+ zend_fetch_property_address(result, container, IS_CV, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW);
zval_ptr_dtor_nogc(free_op2);
if (IS_CV == IS_VAR) {
FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
zval *retval;
if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
- cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
+ cache_slot = CACHE_ADDR(opline->extended_value);
if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
result = EX_VAR(opline->result.var);
- zend_fetch_property_address(result, container, IS_CV, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_UNSET);
+ zend_fetch_property_address(result, container, IS_CV, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET);
zval_ptr_dtor_nogc(free_op2);
if (IS_CV == IS_VAR) {
FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
}
if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
- EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
- uintptr_t prop_offset = (uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+ EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
+ uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
zend_object *zobj = Z_OBJ_P(object);
zval *property_val;
ZVAL_DEREF(value);
}
- Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL);
+ Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
}
if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
- EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
- uintptr_t prop_offset = (uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+ EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
+ uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
zend_object *zobj = Z_OBJ_P(object);
zval *property_val;
ZVAL_DEREF(value);
}
- Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL);
+ Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
}
if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
- EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
- uintptr_t prop_offset = (uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+ EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
+ uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
zend_object *zobj = Z_OBJ_P(object);
zval *property_val;
ZVAL_DEREF(value);
}
- Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL);
+ Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
}
if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
- EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
- uintptr_t prop_offset = (uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+ EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
+ uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
zend_object *zobj = Z_OBJ_P(object);
zval *property_val;
ZVAL_DEREF(value);
}
- Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL);
+ Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
}
- function_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+ if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
+ function_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+ }
if ((IS_TMP_VAR|IS_VAR) != IS_CONST &&
UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
HANDLE_EXCEPTION();
}
}
+ if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+ function_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+ }
zend_throw_error(NULL, "Call to a member function %s() on %s", Z_STRVAL_P(function_name), zend_get_type_by_const(Z_TYPE_P(object)));
zval_ptr_dtor_nogc(free_op2);
called_scope = obj->ce;
if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
- EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(function_name)) == called_scope)) {
- fbc = CACHED_PTR(Z_CACHE_SLOT_P(function_name) + sizeof(void*));
+ EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
+ fbc = CACHED_PTR(opline->result.num + sizeof(void*));
} else {
zend_object *orig_obj = obj;
HANDLE_EXCEPTION();
}
+ if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+ function_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+ }
+
/* First, locate the function. */
fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
if (UNEXPECTED(fbc == NULL)) {
EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
EXPECTED(obj == orig_obj)) {
- CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), called_scope, fbc);
+ CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
}
if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) {
init_func_run_time_cache(&fbc->op_array);
}
}
if (Z_OBJ_HT_P(container)->unset_property) {
- Z_OBJ_HT_P(container)->unset_property(container, offset, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(offset)) : NULL));
+ Z_OBJ_HT_P(container)->unset_property(container, offset, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
} else {
zend_wrong_property_unset(offset);
}
} else {
result =
((opline->extended_value & ZEND_ISSET) == 0) ^
- Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(offset)) : NULL));
+ Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISSET) : NULL));
}
zval_ptr_dtor_nogc(free_op2);
zval *varname;
zval *retval;
+ zend_string *name, *tmp_name;
+ zend_class_entry *ce;
SAVE_OPLINE();
- varname = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
- retval = zend_fetch_static_property_address(varname, IS_CV, opline->op2, IS_VAR, type EXECUTE_DATA_CC OPLINE_CC);
+ do {
+ if (IS_VAR == IS_CONST) {
+ if (IS_CV == IS_CONST && EXPECTED((ce = CACHED_PTR(opline->extended_value)) != NULL)) {
+ retval = CACHED_PTR(opline->extended_value + sizeof(void*));
+
+ /* check if static properties were destoyed */
+ if (EXPECTED(CE_STATIC_MEMBERS(ce) != NULL)) {
+
+ break;
+ }
+ } else {
+ zval *class_name = RT_CONSTANT(opline, opline->op2);
+
+ if (UNEXPECTED((ce = CACHED_PTR(opline->extended_value)) == NULL)) {
+ ce = zend_fetch_class_by_name(Z_STR_P(class_name), class_name + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
+ if (UNEXPECTED(ce == NULL)) {
+
+ retval = NULL;
+ break;
+ }
+ if (IS_CV != IS_CONST) {
+ CACHE_PTR(opline->extended_value, ce);
+ }
+ }
+ }
+ } else {
+ if (IS_VAR == IS_UNUSED) {
+ ce = zend_fetch_class(NULL, opline->op2.num);
+ if (UNEXPECTED(ce == NULL)) {
+
+ retval = NULL;
+ break;
+ }
+ } else {
+ ce = Z_CE_P(EX_VAR(opline->op2.var));
+ }
+ if (IS_CV == IS_CONST &&
+ EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
+ retval = CACHED_PTR(opline->extended_value + sizeof(void*));
+
+ /* check if static properties were destoyed */
+ if (EXPECTED(CE_STATIC_MEMBERS(ce) != NULL)) {
+
+ break;
+ }
+ }
+ }
+
+ varname = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+ if (IS_CV == IS_CONST) {
+ name = Z_STR_P(varname);
+ } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
+ name = Z_STR_P(varname);
+ tmp_name = NULL;
+ } else {
+ if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
+ zval_undefined_cv(EX(opline)->op1.var EXECUTE_DATA_CC);
+ }
+ name = zval_get_tmp_string(varname, &tmp_name);
+ }
+
+ retval = zend_std_get_static_property(ce, name, type == BP_VAR_IS);
+
+ if (IS_CV != IS_CONST) {
+ zend_tmp_string_release(tmp_name);
+ }
+
+ if (IS_CV == IS_CONST && EXPECTED(retval)) {
+ CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, retval);
+ }
+
+ } while (0);
if (UNEXPECTED(retval == NULL)) {
if (EG(exception)) {
-
ZVAL_UNDEF(EX_VAR(opline->result.var));
HANDLE_EXCEPTION();
} else {
SAVE_OPLINE();
- varname = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
-
- if (IS_CV == IS_CONST) {
- name = Z_STR_P(varname);
- } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
- name = Z_STR_P(varname);
- tmp_name = NULL;
- } else {
- if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
- varname = GET_OP1_UNDEF_CV(varname, BP_VAR_R);
- }
- name = zval_get_tmp_string(varname, &tmp_name);
- }
-
if (IS_VAR == IS_CONST) {
- ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)));
+ ce = CACHED_PTR(opline->extended_value);
if (UNEXPECTED(ce == NULL)) {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), RT_CONSTANT(opline, opline->op2) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
- if (IS_CV != IS_CONST) {
- zend_tmp_string_release(tmp_name);
- }
HANDLE_EXCEPTION();
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), ce);
+ /*CACHE_PTR(opline->extended_value, ce);*/
}
} else if (IS_VAR == IS_UNUSED) {
ce = zend_fetch_class(NULL, opline->op2.num);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
- if (IS_CV != IS_CONST) {
- zend_tmp_string_release(tmp_name);
- }
HANDLE_EXCEPTION();
}
} else {
ce = Z_CE_P(EX_VAR(opline->op2.var));
}
+
+ varname = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+ if (IS_CV == IS_CONST) {
+ name = Z_STR_P(varname);
+ } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
+ name = Z_STR_P(varname);
+ tmp_name = NULL;
+ } else {
+ if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
+ varname = GET_OP1_UNDEF_CV(varname, BP_VAR_R);
+ }
+ name = zval_get_tmp_string(varname, &tmp_name);
+ }
+
zend_std_unset_static_property(ce, name);
if (IS_CV != IS_CONST) {
zend_class_entry *ce;
SAVE_OPLINE();
- varname = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
- if (IS_CV == IS_CONST) {
- name = Z_STR_P(varname);
- } else {
- name = zval_get_tmp_string(varname, &tmp_name);
- }
-
if (IS_VAR == IS_CONST) {
- if (IS_CV == IS_CONST && EXPECTED((ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)))) != NULL)) {
- value = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)) + sizeof(void*));
+ if (IS_CV == IS_CONST && EXPECTED((ce = CACHED_PTR(opline->extended_value & ~ZEND_ISSET)) != NULL)) {
+ value = CACHED_PTR((opline->extended_value & ~ZEND_ISSET) + sizeof(void*));
/* check if static properties were destoyed */
if (UNEXPECTED(CE_STATIC_MEMBERS(ce) == NULL)) {
}
goto is_static_prop_return;
- } else if (UNEXPECTED((ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)))) == NULL)) {
+ } else if (UNEXPECTED((ce = CACHED_PTR(opline->extended_value & ~ZEND_ISSET)) == NULL)) {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), RT_CONSTANT(opline, opline->op2) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
ZVAL_UNDEF(EX_VAR(opline->result.var));
HANDLE_EXCEPTION();
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), ce);
+ if (IS_CV != IS_CONST) {
+ CACHE_PTR(opline->extended_value & ~ZEND_ISSET, ce);
+ }
}
} else {
if (IS_VAR == IS_UNUSED) {
ce = zend_fetch_class(NULL, opline->op2.num);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
- if (IS_CV != IS_CONST) {
- zend_tmp_string_release(tmp_name);
- }
ZVAL_UNDEF(EX_VAR(opline->result.var));
HANDLE_EXCEPTION();
ce = Z_CE_P(EX_VAR(opline->op2.var));
}
if (IS_CV == IS_CONST &&
- EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1))) == ce)) {
+ EXPECTED(CACHED_PTR(opline->extended_value & ~ZEND_ISSET) == ce)) {
- value = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)) + sizeof(void*));
+ value = CACHED_PTR((opline->extended_value & ~ZEND_ISSET) + sizeof(void*));
/* check if static properties were destoyed */
if (UNEXPECTED(CE_STATIC_MEMBERS(ce) == NULL)) {
}
}
+ varname = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
+ if (IS_CV == IS_CONST) {
+ name = Z_STR_P(varname);
+ } else {
+ name = zval_get_tmp_string(varname, &tmp_name);
+ }
+
value = zend_std_get_static_property(ce, name, 1);
if (IS_CV == IS_CONST && value) {
- CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)), ce, value);
+ CACHE_POLYMORPHIC_PTR(opline->extended_value & ~ZEND_ISSET, ce, value);
}
if (IS_CV != IS_CONST) {
zend_class_entry *ce;
if (IS_VAR == IS_CONST) {
- ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)));
+ ce = CACHED_PTR(opline->extended_value);
if (UNEXPECTED(ce == NULL)) {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), RT_CONSTANT(opline, opline->op2) + 1, ZEND_FETCH_CLASS_NO_AUTOLOAD);
if (EXPECTED(ce)) {
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), ce);
+ CACHE_PTR(opline->extended_value, ce);
}
}
} else if (IS_VAR == IS_UNUSED) {
zval *varname;
zval *retval;
+ zend_string *name, *tmp_name;
+ zend_class_entry *ce;
SAVE_OPLINE();
- varname = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
- retval = zend_fetch_static_property_address(varname, IS_CV, opline->op2, IS_UNUSED, type EXECUTE_DATA_CC OPLINE_CC);
+ do {
+ if (IS_UNUSED == IS_CONST) {
+ if (IS_CV == IS_CONST && EXPECTED((ce = CACHED_PTR(opline->extended_value)) != NULL)) {
+ retval = CACHED_PTR(opline->extended_value + sizeof(void*));
+
+ /* check if static properties were destoyed */
+ if (EXPECTED(CE_STATIC_MEMBERS(ce) != NULL)) {
+
+ break;
+ }
+ } else {
+ zval *class_name = RT_CONSTANT(opline, opline->op2);
+
+ if (UNEXPECTED((ce = CACHED_PTR(opline->extended_value)) == NULL)) {
+ ce = zend_fetch_class_by_name(Z_STR_P(class_name), class_name + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
+ if (UNEXPECTED(ce == NULL)) {
+
+ retval = NULL;
+ break;
+ }
+ if (IS_CV != IS_CONST) {
+ CACHE_PTR(opline->extended_value, ce);
+ }
+ }
+ }
+ } else {
+ if (IS_UNUSED == IS_UNUSED) {
+ ce = zend_fetch_class(NULL, opline->op2.num);
+ if (UNEXPECTED(ce == NULL)) {
+
+ retval = NULL;
+ break;
+ }
+ } else {
+ ce = Z_CE_P(EX_VAR(opline->op2.var));
+ }
+ if (IS_CV == IS_CONST &&
+ EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
+ retval = CACHED_PTR(opline->extended_value + sizeof(void*));
+
+ /* check if static properties were destoyed */
+ if (EXPECTED(CE_STATIC_MEMBERS(ce) != NULL)) {
+
+ break;
+ }
+ }
+ }
+
+ varname = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+ if (IS_CV == IS_CONST) {
+ name = Z_STR_P(varname);
+ } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
+ name = Z_STR_P(varname);
+ tmp_name = NULL;
+ } else {
+ if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
+ zval_undefined_cv(EX(opline)->op1.var EXECUTE_DATA_CC);
+ }
+ name = zval_get_tmp_string(varname, &tmp_name);
+ }
+
+ retval = zend_std_get_static_property(ce, name, type == BP_VAR_IS);
+
+ if (IS_CV != IS_CONST) {
+ zend_tmp_string_release(tmp_name);
+ }
+
+ if (IS_CV == IS_CONST && EXPECTED(retval)) {
+ CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, retval);
+ }
+
+ } while (0);
if (UNEXPECTED(retval == NULL)) {
if (EG(exception)) {
-
ZVAL_UNDEF(EX_VAR(opline->result.var));
HANDLE_EXCEPTION();
} else {
SAVE_OPLINE();
- varname = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
-
- if (IS_CV == IS_CONST) {
- name = Z_STR_P(varname);
- } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
- name = Z_STR_P(varname);
- tmp_name = NULL;
- } else {
- if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
- varname = GET_OP1_UNDEF_CV(varname, BP_VAR_R);
- }
- name = zval_get_tmp_string(varname, &tmp_name);
- }
-
if (IS_UNUSED == IS_CONST) {
- ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)));
+ ce = CACHED_PTR(opline->extended_value);
if (UNEXPECTED(ce == NULL)) {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), RT_CONSTANT(opline, opline->op2) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
- if (IS_CV != IS_CONST) {
- zend_tmp_string_release(tmp_name);
- }
HANDLE_EXCEPTION();
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), ce);
+ /*CACHE_PTR(opline->extended_value, ce);*/
}
} else if (IS_UNUSED == IS_UNUSED) {
ce = zend_fetch_class(NULL, opline->op2.num);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
- if (IS_CV != IS_CONST) {
- zend_tmp_string_release(tmp_name);
- }
HANDLE_EXCEPTION();
}
} else {
ce = Z_CE_P(EX_VAR(opline->op2.var));
}
+
+ varname = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+ if (IS_CV == IS_CONST) {
+ name = Z_STR_P(varname);
+ } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
+ name = Z_STR_P(varname);
+ tmp_name = NULL;
+ } else {
+ if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
+ varname = GET_OP1_UNDEF_CV(varname, BP_VAR_R);
+ }
+ name = zval_get_tmp_string(varname, &tmp_name);
+ }
+
zend_std_unset_static_property(ce, name);
if (IS_CV != IS_CONST) {
zend_class_entry *ce;
SAVE_OPLINE();
- varname = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
- if (IS_CV == IS_CONST) {
- name = Z_STR_P(varname);
- } else {
- name = zval_get_tmp_string(varname, &tmp_name);
- }
-
if (IS_UNUSED == IS_CONST) {
- if (IS_CV == IS_CONST && EXPECTED((ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)))) != NULL)) {
- value = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)) + sizeof(void*));
+ if (IS_CV == IS_CONST && EXPECTED((ce = CACHED_PTR(opline->extended_value & ~ZEND_ISSET)) != NULL)) {
+ value = CACHED_PTR((opline->extended_value & ~ZEND_ISSET) + sizeof(void*));
/* check if static properties were destoyed */
if (UNEXPECTED(CE_STATIC_MEMBERS(ce) == NULL)) {
}
goto is_static_prop_return;
- } else if (UNEXPECTED((ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)))) == NULL)) {
+ } else if (UNEXPECTED((ce = CACHED_PTR(opline->extended_value & ~ZEND_ISSET)) == NULL)) {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), RT_CONSTANT(opline, opline->op2) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
ZVAL_UNDEF(EX_VAR(opline->result.var));
HANDLE_EXCEPTION();
}
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), ce);
+ if (IS_CV != IS_CONST) {
+ CACHE_PTR(opline->extended_value & ~ZEND_ISSET, ce);
+ }
}
} else {
if (IS_UNUSED == IS_UNUSED) {
ce = zend_fetch_class(NULL, opline->op2.num);
if (UNEXPECTED(ce == NULL)) {
ZEND_ASSERT(EG(exception));
- if (IS_CV != IS_CONST) {
- zend_tmp_string_release(tmp_name);
- }
ZVAL_UNDEF(EX_VAR(opline->result.var));
HANDLE_EXCEPTION();
ce = Z_CE_P(EX_VAR(opline->op2.var));
}
if (IS_CV == IS_CONST &&
- EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1))) == ce)) {
+ EXPECTED(CACHED_PTR(opline->extended_value & ~ZEND_ISSET) == ce)) {
- value = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)) + sizeof(void*));
+ value = CACHED_PTR((opline->extended_value & ~ZEND_ISSET) + sizeof(void*));
/* check if static properties were destoyed */
if (UNEXPECTED(CE_STATIC_MEMBERS(ce) == NULL)) {
}
}
+ varname = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
+ if (IS_CV == IS_CONST) {
+ name = Z_STR_P(varname);
+ } else {
+ name = zval_get_tmp_string(varname, &tmp_name);
+ }
+
value = zend_std_get_static_property(ce, name, 1);
if (IS_CV == IS_CONST && value) {
- CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op1)), ce, value);
+ CACHE_POLYMORPHIC_PTR(opline->extended_value & ~ZEND_ISSET, ce, value);
}
if (IS_CV != IS_CONST) {
zend_class_entry *ce;
if (IS_UNUSED == IS_CONST) {
- ce = CACHED_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)));
+ ce = CACHED_PTR(opline->extended_value);
if (UNEXPECTED(ce == NULL)) {
ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), RT_CONSTANT(opline, opline->op2) + 1, ZEND_FETCH_CLASS_NO_AUTOLOAD);
if (EXPECTED(ce)) {
- CACHE_PTR(Z_CACHE_SLOT_P(RT_CONSTANT(opline, opline->op2)), ce);
+ CACHE_PTR(opline->extended_value, ce);
}
}
} else if (IS_UNUSED == IS_UNUSED) {
/* 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)) {
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL))) != NULL)) {
if (UNEXPECTED(Z_ISERROR_P(zptr))) {
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_NULL(EX_VAR(opline->result.var));
}
}
} else {
- zend_assign_op_overloaded_property(object, property, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), value, binary_op, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+ zend_assign_op_overloaded_property(object, property, ((IS_CV == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL), value, binary_op, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
}
} while (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_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL))) != NULL)) {
if (UNEXPECTED(Z_ISERROR_P(zptr))) {
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_NULL(EX_VAR(opline->result.var));
}
}
} else {
- zend_pre_incdec_overloaded_property(object, property, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), inc, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
+ zend_pre_incdec_overloaded_property(object, property, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), inc, (UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL));
}
} while (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_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL))) != NULL)) {
if (UNEXPECTED(Z_ISERROR_P(zptr))) {
ZVAL_NULL(EX_VAR(opline->result.var));
} else {
}
}
} else {
- zend_post_incdec_overloaded_property(object, property, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), inc, EX_VAR(opline->result.var));
+ zend_post_incdec_overloaded_property(object, property, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), inc, EX_VAR(opline->result.var));
}
} while (0);
zval *retval;
if (IS_CV == IS_CONST) {
- cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
+ cache_slot = CACHE_ADDR(opline->extended_value);
if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
result = EX_VAR(opline->result.var);
- zend_fetch_property_address(result, container, IS_CV, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W);
+ zend_fetch_property_address(result, container, IS_CV, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_W);
if (IS_CV == IS_VAR) {
FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
}
property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
result = EX_VAR(opline->result.var);
- zend_fetch_property_address(result, container, IS_CV, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_RW);
+ zend_fetch_property_address(result, container, IS_CV, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW);
if (IS_CV == IS_VAR) {
FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
zval *retval;
if (IS_CV == IS_CONST) {
- cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
+ cache_slot = CACHE_ADDR(opline->extended_value);
if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
result = EX_VAR(opline->result.var);
- zend_fetch_property_address(result, container, IS_CV, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_UNSET);
+ zend_fetch_property_address(result, container, IS_CV, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET);
if (IS_CV == IS_VAR) {
FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
}
if (IS_CV == IS_CONST &&
- EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
- uintptr_t prop_offset = (uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+ EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
+ uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
zend_object *zobj = Z_OBJ_P(object);
zval *property_val;
ZVAL_DEREF(value);
}
- Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL);
+ Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
}
if (IS_CV == IS_CONST &&
- EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
- uintptr_t prop_offset = (uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+ EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
+ uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
zend_object *zobj = Z_OBJ_P(object);
zval *property_val;
ZVAL_DEREF(value);
}
- Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL);
+ Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
}
if (IS_CV == IS_CONST &&
- EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
- uintptr_t prop_offset = (uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+ EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
+ uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
zend_object *zobj = Z_OBJ_P(object);
zval *property_val;
ZVAL_DEREF(value);
}
- Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL);
+ Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
}
if (IS_CV == IS_CONST &&
- EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
- uintptr_t prop_offset = (uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+ EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
+ uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
zend_object *zobj = Z_OBJ_P(object);
zval *property_val;
ZVAL_DEREF(value);
}
- Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL);
+ Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
ZVAL_COPY(EX_VAR(opline->result.var), value);
ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
}
- function_name = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
+ if (IS_CV != IS_CONST) {
+ function_name = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
+ }
if (IS_CV != IS_CONST &&
UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
HANDLE_EXCEPTION();
}
}
+ if (IS_CV == IS_CONST) {
+ function_name = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
+ }
zend_throw_error(NULL, "Call to a member function %s() on %s", Z_STRVAL_P(function_name), zend_get_type_by_const(Z_TYPE_P(object)));
called_scope = obj->ce;
if (IS_CV == IS_CONST &&
- EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(function_name)) == called_scope)) {
- fbc = CACHED_PTR(Z_CACHE_SLOT_P(function_name) + sizeof(void*));
+ EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
+ fbc = CACHED_PTR(opline->result.num + sizeof(void*));
} else {
zend_object *orig_obj = obj;
HANDLE_EXCEPTION();
}
+ if (IS_CV == IS_CONST) {
+ function_name = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
+ }
+
/* First, locate the function. */
fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
if (UNEXPECTED(fbc == NULL)) {
EXPECTED(fbc->type <= ZEND_USER_FUNCTION) &&
EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
EXPECTED(obj == orig_obj)) {
- CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), called_scope, fbc);
+ CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
}
if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!fbc->op_array.run_time_cache)) {
init_func_run_time_cache(&fbc->op_array);
}
}
if (Z_OBJ_HT_P(container)->unset_property) {
- Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(offset)) : NULL));
+ Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
} else {
zend_wrong_property_unset(offset);
}
} else {
result =
((opline->extended_value & ZEND_ISSET) == 0) ^
- Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(offset)) : NULL));
+ Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISSET) : NULL));
}
(void*)&&ZEND_RETURN_SPEC_VAR_LABEL,
(void*)&&ZEND_NULL_LABEL,
(void*)&&ZEND_RETURN_SPEC_CV_LABEL,
- (void*)&&ZEND_RECV_SPEC_LABEL,
+ (void*)&&ZEND_RECV_SPEC_UNUSED_LABEL,
(void*)&&ZEND_RECV_INIT_SPEC_CONST_LABEL,
(void*)&&ZEND_SEND_VAL_SPEC_CONST_LABEL,
(void*)&&ZEND_SEND_VAL_SPEC_TMPVAR_LABEL,
(void*)&&ZEND_SEND_REF_SPEC_VAR_LABEL,
(void*)&&ZEND_NULL_LABEL,
(void*)&&ZEND_SEND_REF_SPEC_CV_LABEL,
- (void*)&&ZEND_NEW_SPEC_CONST_LABEL,
+ (void*)&&ZEND_NEW_SPEC_CONST_UNUSED_LABEL,
(void*)&&ZEND_NULL_LABEL,
- (void*)&&ZEND_NEW_SPEC_VAR_LABEL,
- (void*)&&ZEND_NEW_SPEC_UNUSED_LABEL,
+ (void*)&&ZEND_NEW_SPEC_VAR_UNUSED_LABEL,
+ (void*)&&ZEND_NEW_SPEC_UNUSED_UNUSED_LABEL,
(void*)&&ZEND_NULL_LABEL,
(void*)&&ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_LABEL,
(void*)&&ZEND_FREE_SPEC_TMPVAR_LABEL,
(void*)&&ZEND_GENERATOR_RETURN_SPEC_CV_LABEL,
(void*)&&ZEND_FAST_CALL_SPEC_LABEL,
(void*)&&ZEND_FAST_RET_SPEC_LABEL,
- (void*)&&ZEND_RECV_VARIADIC_SPEC_LABEL,
+ (void*)&&ZEND_RECV_VARIADIC_SPEC_UNUSED_LABEL,
(void*)&&ZEND_SEND_UNPACK_SPEC_LABEL,
(void*)&&ZEND_POW_SPEC_CONST_CONST_LABEL,
(void*)&&ZEND_POW_SPEC_CONST_TMPVAR_LABEL,
HYBRID_CASE(ZEND_SEND_ARRAY_SPEC):
ZEND_SEND_ARRAY_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
HYBRID_BREAK();
- HYBRID_CASE(ZEND_RECV_SPEC):
- ZEND_RECV_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
- HYBRID_BREAK();
- HYBRID_CASE(ZEND_RECV_VARIADIC_SPEC):
- ZEND_RECV_VARIADIC_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
- HYBRID_BREAK();
HYBRID_CASE(ZEND_BEGIN_SILENCE_SPEC):
ZEND_BEGIN_SILENCE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
HYBRID_BREAK();
HYBRID_CASE(ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_VAR):
ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
HYBRID_BREAK();
+ HYBRID_CASE(ZEND_RECV_SPEC_UNUSED):
+ ZEND_RECV_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ HYBRID_BREAK();
+ HYBRID_CASE(ZEND_RECV_VARIADIC_SPEC_UNUSED):
+ ZEND_RECV_VARIADIC_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ HYBRID_BREAK();
HYBRID_CASE(ZEND_INIT_DYNAMIC_CALL_SPEC_CV):
ZEND_INIT_DYNAMIC_CALL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
HYBRID_BREAK();
HYBRID_CASE(ZEND_BOOL_SPEC_CONST):
ZEND_BOOL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
HYBRID_BREAK();
- HYBRID_CASE(ZEND_NEW_SPEC_CONST):
- ZEND_NEW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
- HYBRID_BREAK();
HYBRID_CASE(ZEND_CLONE_SPEC_CONST):
ZEND_CLONE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
HYBRID_BREAK();
HYBRID_CASE(ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED):
ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
HYBRID_BREAK();
+ HYBRID_CASE(ZEND_NEW_SPEC_CONST_UNUSED):
+ ZEND_NEW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ HYBRID_BREAK();
HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED):
ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
HYBRID_BREAK();
HYBRID_CASE(ZEND_SEND_USER_SPEC_VAR):
ZEND_SEND_USER_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
HYBRID_BREAK();
- HYBRID_CASE(ZEND_NEW_SPEC_VAR):
- ZEND_NEW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
- HYBRID_BREAK();
HYBRID_CASE(ZEND_CAST_SPEC_VAR):
ZEND_CAST_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
HYBRID_BREAK();
HYBRID_CASE(ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED):
ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
HYBRID_BREAK();
+ HYBRID_CASE(ZEND_NEW_SPEC_VAR_UNUSED):
+ ZEND_NEW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ HYBRID_BREAK();
HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED):
ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
HYBRID_BREAK();
HYBRID_CASE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_QUICK):
ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
HYBRID_BREAK();
- HYBRID_CASE(ZEND_NEW_SPEC_UNUSED):
- ZEND_NEW_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
- HYBRID_BREAK();
HYBRID_CASE(ZEND_CLONE_SPEC_UNUSED):
ZEND_CLONE_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
HYBRID_BREAK();
HYBRID_CASE(ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED):
ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
HYBRID_BREAK();
+ HYBRID_CASE(ZEND_NEW_SPEC_UNUSED_UNUSED):
+ ZEND_NEW_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ HYBRID_BREAK();
HYBRID_CASE(ZEND_YIELD_SPEC_UNUSED_UNUSED):
ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
HYBRID_BREAK();
ZEND_RETURN_SPEC_VAR_HANDLER,
ZEND_NULL_HANDLER,
ZEND_RETURN_SPEC_CV_HANDLER,
- ZEND_RECV_SPEC_HANDLER,
+ ZEND_RECV_SPEC_UNUSED_HANDLER,
ZEND_RECV_INIT_SPEC_CONST_HANDLER,
ZEND_SEND_VAL_SPEC_CONST_HANDLER,
ZEND_SEND_VAL_SPEC_TMPVAR_HANDLER,
ZEND_SEND_REF_SPEC_VAR_HANDLER,
ZEND_NULL_HANDLER,
ZEND_SEND_REF_SPEC_CV_HANDLER,
- ZEND_NEW_SPEC_CONST_HANDLER,
+ ZEND_NEW_SPEC_CONST_UNUSED_HANDLER,
ZEND_NULL_HANDLER,
- ZEND_NEW_SPEC_VAR_HANDLER,
- ZEND_NEW_SPEC_UNUSED_HANDLER,
+ ZEND_NEW_SPEC_VAR_UNUSED_HANDLER,
+ ZEND_NEW_SPEC_UNUSED_UNUSED_HANDLER,
ZEND_NULL_HANDLER,
ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER,
ZEND_FREE_SPEC_TMPVAR_HANDLER,
ZEND_GENERATOR_RETURN_SPEC_CV_HANDLER,
ZEND_FAST_CALL_SPEC_HANDLER,
ZEND_FAST_RET_SPEC_HANDLER,
- ZEND_RECV_VARIADIC_SPEC_HANDLER,
+ ZEND_RECV_VARIADIC_SPEC_UNUSED_HANDLER,
ZEND_SEND_UNPACK_SPEC_HANDLER,
ZEND_POW_SPEC_CONST_CONST_HANDLER,
ZEND_POW_SPEC_CONST_TMPVAR_HANDLER,