diff options
Diffstat (limited to 'Zend/zend_vm_execute.h')
| -rw-r--r-- | Zend/zend_vm_execute.h | 29068 |
1 files changed, 13834 insertions, 15234 deletions
diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 4690c3e3ae..6abc07d4e5 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -344,11 +344,6 @@ ZEND_API void execute_ex(zend_execute_data *execute_data TSRMLS_DC) original_in_execution = EG(in_execution); EG(in_execution) = 1; - if (0) { -zend_vm_enter: - execute_data = i_create_execute_data_from_op_array(EG(active_op_array), 1 TSRMLS_CC); - } - LOAD_REGS(); LOAD_OPLINE(); @@ -366,8 +361,6 @@ zend_vm_enter: EG(in_execution) = original_in_execution; return; case 2: - goto zend_vm_enter; - break; case 3: execute_data = EG(current_execute_data); break; @@ -380,120 +373,139 @@ zend_vm_enter: zend_error_noreturn(E_ERROR, "Arrived at end of main loop which shouldn't happen"); } -ZEND_API void zend_execute(zend_op_array *op_array TSRMLS_DC) +ZEND_API void zend_execute(zend_op_array *op_array, zval *return_value TSRMLS_DC) { - if (EG(exception)) { + if (EG(exception) != NULL) { return; } - zend_execute_ex(i_create_execute_data_from_op_array(op_array, 0 TSRMLS_CC) TSRMLS_CC); + zend_execute_ex(i_create_execute_data_from_op_array(op_array, return_value, EG(active_symbol_table) ? VM_FRAME_TOP_CODE : VM_FRAME_TOP_FUNCTION TSRMLS_CC) TSRMLS_CC); } static int ZEND_FASTCALL zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS) { - zend_bool nested = EX(nested); - zend_op_array *op_array = EX(op_array); + vm_frame_kind frame_kind = EX(frame_kind); EG(current_execute_data) = EX(prev_execute_data); - EG(opline_ptr) = NULL; - if (!EG(active_symbol_table)) { - i_free_compiled_variables(execute_data TSRMLS_CC); - } - - zend_vm_stack_free((char*)execute_data - (ZEND_MM_ALIGNED_SIZE(sizeof(temp_variable)) * op_array->T) TSRMLS_CC); - if ((op_array->fn_flags & ZEND_ACC_CLOSURE) && op_array->prototype) { - zval_ptr_dtor((zval**)&op_array->prototype); - } + if (frame_kind == VM_FRAME_NESTED_FUNCTION) { + i_free_compiled_variables(execute_data TSRMLS_CC); + if (UNEXPECTED(EX(symbol_table) != NULL)) { + zend_clean_and_cache_symbol_table(EX(symbol_table) TSRMLS_CC); + } + if (UNEXPECTED((EX(op_array)->fn_flags & ZEND_ACC_CLOSURE) != 0) && EX(op_array)->prototype) { + zval_ptr_dtor((zval*)EX(op_array)->prototype); + } + zend_vm_stack_free((char*)execute_data TSRMLS_CC); - if (nested) { execute_data = EG(current_execute_data); - } - if (nested) { - USE_OPLINE - - LOAD_REGS(); - LOAD_OPLINE(); - if (UNEXPECTED(opline->opcode == ZEND_INCLUDE_OR_EVAL)) { + EG(opline_ptr) = &EX(opline); + EG(active_op_array) = EX(op_array); + EG(active_symbol_table) = EX(symbol_table); - EX(function_state).function = (zend_function *) EX(op_array); - EX(function_state).arguments = NULL; + EX(function_state).function = (zend_function *) EX(op_array); + EX(function_state).arguments = NULL; - EG(opline_ptr) = &EX(opline); - EG(active_op_array) = EX(op_array); - EG(return_value_ptr_ptr) = EX(original_return_value); - destroy_op_array(op_array TSRMLS_CC); - efree(op_array); - if (UNEXPECTED(EG(exception) != NULL)) { - zend_throw_exception_internal(NULL TSRMLS_CC); - HANDLE_EXCEPTION_LEAVE(); + if (Z_OBJ(EG(This))) { + if (UNEXPECTED(EG(exception) != NULL) && EX(call)->is_ctor_call) { + if (EX(call)->is_ctor_result_used) { + Z_DELREF(EG(This)); + } + if (Z_REFCOUNT(EG(This)) == 1) { + zend_object_store_ctor_failed(Z_OBJ(EG(This)) TSRMLS_CC); + } } - - ZEND_VM_INC_OPCODE(); - ZEND_VM_LEAVE(); - } else { - EG(opline_ptr) = &EX(opline); - EG(active_op_array) = EX(op_array); - EG(return_value_ptr_ptr) = EX(original_return_value); - if (EG(active_symbol_table)) { - zend_clean_and_cache_symbol_table(EG(active_symbol_table) TSRMLS_CC); + if (!Z_DELREF(EG(This))) { + _zval_dtor_func_for_ptr(Z_COUNTED(EG(This)) ZEND_FILE_LINE_CC); + } else if (UNEXPECTED(!Z_GC_INFO(EG(This)))) { + gc_possible_root(Z_COUNTED(EG(This)) TSRMLS_CC); } - EG(active_symbol_table) = EX(symbol_table); + } + Z_OBJ(EG(This)) = EX(object); + EG(scope) = EX(scope); + EG(called_scope) = EX(called_scope); - EX(function_state).function = (zend_function *) EX(op_array); - EX(function_state).arguments = NULL; + EX(call)--; - if (EG(This)) { - if (UNEXPECTED(EG(exception) != NULL) && EX(call)->is_ctor_call) { - if (EX(call)->is_ctor_result_used) { - Z_DELREF_P(EG(This)); - } - if (Z_REFCOUNT_P(EG(This)) == 1) { - zend_object_store_ctor_failed(EG(This) TSRMLS_CC); - } - } - zval_ptr_dtor(&EG(This)); + zend_vm_stack_clear_multiple(1 TSRMLS_CC); + + if (UNEXPECTED(EG(exception) != NULL)) { + zend_op *opline = EX(opline); + zend_throw_exception_internal(NULL TSRMLS_CC); + if (RETURN_VALUE_USED(opline)) { + zval_ptr_dtor(EX_VAR(opline->result.var)); } - EG(This) = EX(current_this); - EG(scope) = EX(current_scope); - EG(called_scope) = EX(current_called_scope); + HANDLE_EXCEPTION_LEAVE(); + } - EX(call)--; + LOAD_OPLINE(); + ZEND_VM_INC_OPCODE(); + ZEND_VM_LEAVE(); + } else if (frame_kind == VM_FRAME_NESTED_CODE) { + zend_detach_symbol_table(execute_data); + destroy_op_array(EX(op_array) TSRMLS_CC); + efree(EX(op_array)); + zend_vm_stack_free((char*)execute_data TSRMLS_CC); - zend_vm_stack_clear_multiple(1 TSRMLS_CC); + execute_data = EG(current_execute_data); + zend_attach_symbol_table(execute_data); + EX(function_state).function = (zend_function *) EX(op_array); + EX(function_state).arguments = NULL; + EG(opline_ptr) = &EX(opline); + EG(active_op_array) = EX(op_array); + if (UNEXPECTED(EG(exception) != NULL)) { + zend_throw_exception_internal(NULL TSRMLS_CC); + HANDLE_EXCEPTION_LEAVE(); + } - if (UNEXPECTED(EG(exception) != NULL)) { - zend_throw_exception_internal(NULL TSRMLS_CC); - if (RETURN_VALUE_USED(opline) && EX_T(opline->result.var).var.ptr) { - zval_ptr_dtor(&EX_T(opline->result.var).var.ptr); + LOAD_OPLINE(); + ZEND_VM_INC_OPCODE(); + ZEND_VM_LEAVE(); + } else { + if (frame_kind == VM_FRAME_TOP_FUNCTION) { + i_free_compiled_variables(execute_data TSRMLS_CC); + } else /* if (frame_kind == VM_FRAME_TOP_CODE) */ { + zend_array *symbol_table = EX(symbol_table); + zend_execute_data *old_execute_data; + + zend_detach_symbol_table(execute_data); + old_execute_data = EX(prev_execute_data); + while (old_execute_data) { + if (old_execute_data->op_array) { + if (old_execute_data->symbol_table == symbol_table) { + zend_attach_symbol_table(old_execute_data); + } + break; } - HANDLE_EXCEPTION_LEAVE(); + old_execute_data = old_execute_data->prev_execute_data; } - - ZEND_VM_INC_OPCODE(); - ZEND_VM_LEAVE(); } + if ((EX(op_array)->fn_flags & ZEND_ACC_CLOSURE) && EX(op_array)->prototype) { + zval_ptr_dtor((zval*)EX(op_array)->prototype); + } + zend_vm_stack_free((char*)execute_data TSRMLS_CC); + EG(opline_ptr) = NULL; + ZEND_VM_RETURN(); } - ZEND_VM_RETURN(); } static int ZEND_FASTCALL zend_do_fcall_common_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_bool should_change_scope = 0; zend_function *fbc = EX(function_state).function; + zend_object *object; zend_uint num_args; SAVE_OPLINE(); - EX(object) = EX(call)->object; + object = EX(call)->object; if (UNEXPECTED((fbc->common.fn_flags & (ZEND_ACC_ABSTRACT|ZEND_ACC_DEPRECATED)) != 0)) { if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_ABSTRACT) != 0)) { - zend_error_noreturn(E_ERROR, "Cannot call abstract method %s::%s()", fbc->common.scope->name, fbc->common.function_name); + zend_error_noreturn(E_ERROR, "Cannot call abstract method %s::%s()", fbc->common.scope->name->val, fbc->common.function_name->val); } if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) { zend_error(E_DEPRECATED, "Function %s%s%s() is deprecated", - fbc->common.scope ? fbc->common.scope->name : "", + fbc->common.scope ? fbc->common.scope->name->val : "", fbc->common.scope ? "::" : "", - fbc->common.function_name); + fbc->common.function_name->val); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } @@ -501,158 +513,181 @@ static int ZEND_FASTCALL zend_do_fcall_common_helper_SPEC(ZEND_OPCODE_HANDLER_AR } if (fbc->common.scope && !(fbc->common.fn_flags & ZEND_ACC_STATIC) && - !EX(object)) { + !object) { if (fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { /* FIXME: output identifiers properly */ - zend_error(E_STRICT, "Non-static method %s::%s() should not be called statically", fbc->common.scope->name, fbc->common.function_name); + zend_error(E_STRICT, "Non-static method %s::%s() should not be called statically", fbc->common.scope->name->val, fbc->common.function_name->val); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } } else { /* FIXME: output identifiers properly */ /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */ - zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically", fbc->common.scope->name, fbc->common.function_name); + zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically", fbc->common.scope->name->val, fbc->common.function_name->val); } } - if (fbc->type == ZEND_USER_FUNCTION || fbc->common.scope) { - should_change_scope = 1; - EX(current_this) = EG(This); - EX(current_scope) = EG(scope); - EX(current_called_scope) = EG(called_scope); - EG(This) = EX(object); - EG(scope) = (fbc->type == ZEND_USER_FUNCTION || !EX(object)) ? fbc->common.scope : NULL; - EG(called_scope) = EX(call)->called_scope; - } - - num_args = opline->extended_value + EX(call)->num_additional_args; - if (EX(call)->num_additional_args) { + if (UNEXPECTED(EX(call)->num_additional_args != 0)) { + num_args = opline->extended_value + EX(call)->num_additional_args; EX(function_state).arguments = zend_vm_stack_push_args(num_args TSRMLS_CC); } else { + zval tmp; + + num_args = opline->extended_value; + ZVAL_LONG(&tmp, num_args); EX(function_state).arguments = zend_vm_stack_top(TSRMLS_C); - zend_vm_stack_push((void*)(zend_uintptr_t) num_args TSRMLS_CC); + zend_vm_stack_push(&tmp TSRMLS_CC); } LOAD_OPLINE(); if (fbc->type == ZEND_INTERNAL_FUNCTION) { + int should_change_scope = 0; + zval *ret; + + if (fbc->common.scope) { + should_change_scope = 1; + Z_OBJ(EG(This)) = object; +//??? EG(scope) = (object) ? NULL : fbc->common.scope; + EG(scope) = fbc->common.scope; + EG(called_scope) = EX(call)->called_scope; + } + if (fbc->common.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) { zend_uint i; - void **p = EX(function_state).arguments - num_args; + zval *p = EX(function_state).arguments - num_args; for (i = 0; i < num_args; ++i, ++p) { - zend_verify_arg_type(fbc, i + 1, (zval *) *p, 0 TSRMLS_CC); + zend_verify_arg_type(fbc, i + 1, p, 0 TSRMLS_CC); + } + if (UNEXPECTED(EG(exception) != NULL)) { + if (RETURN_VALUE_USED(opline)) { + ZVAL_UNDEF(EX_VAR(opline->result.var)); + } + if (UNEXPECTED(should_change_scope)) { + goto fcall_end_change_scope; + } else { + goto fcall_end; + } } } - if (EXPECTED(EG(exception) == NULL)) { - temp_variable *ret = &EX_T(opline->result.var); + ret = EX_VAR(opline->result.var); + ZVAL_NULL(ret); + Z_VAR_FLAGS_P(ret) = (fbc->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0 ? IS_VAR_RET_REF : 0; - MAKE_STD_ZVAL(ret->var.ptr); - ZVAL_NULL(ret->var.ptr); - ret->var.ptr_ptr = &ret->var.ptr; - ret->var.fcall_returned_reference = (fbc->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0; + if (!zend_execute_internal) { + /* saves one function call if zend_execute_internal is not used */ + fbc->internal_function.handler(num_args, ret TSRMLS_CC); + } else { + zend_execute_internal(execute_data, NULL TSRMLS_CC); + } - if (!zend_execute_internal) { - /* saves one function call if zend_execute_internal is not used */ - fbc->internal_function.handler(num_args, ret->var.ptr, &ret->var.ptr, EX(object), RETURN_VALUE_USED(opline) TSRMLS_CC); - } else { - zend_execute_internal(execute_data, NULL, RETURN_VALUE_USED(opline) TSRMLS_CC); - } + if (!RETURN_VALUE_USED(opline)) { + zval_ptr_dtor(ret); + } - if (!RETURN_VALUE_USED(opline)) { - zval_ptr_dtor(&ret->var.ptr); - } - } else if (RETURN_VALUE_USED(opline)) { - EX_T(opline->result.var).var.ptr = NULL; + if (UNEXPECTED(should_change_scope)) { + goto fcall_end_change_scope; + } else { + goto fcall_end; } } else if (fbc->type == ZEND_USER_FUNCTION) { - EX(original_return_value) = EG(return_value_ptr_ptr); + zval *return_value = NULL; + + Z_OBJ(EG(This)) = object; + EG(scope) = fbc->common.scope; + EG(called_scope) = EX(call)->called_scope; EG(active_symbol_table) = NULL; EG(active_op_array) = &fbc->op_array; - EG(return_value_ptr_ptr) = NULL; if (RETURN_VALUE_USED(opline)) { - temp_variable *ret = &EX_T(opline->result.var); + return_value = EX_VAR(opline->result.var); - ret->var.ptr = NULL; - EG(return_value_ptr_ptr) = &ret->var.ptr; - ret->var.ptr_ptr = &ret->var.ptr; - ret->var.fcall_returned_reference = (fbc->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0; + ZVAL_NULL(return_value); + Z_VAR_FLAGS_P(return_value) = (fbc->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0 ? IS_VAR_RET_REF : 0; } if (UNEXPECTED((EG(active_op_array)->fn_flags & ZEND_ACC_GENERATOR) != 0)) { if (RETURN_VALUE_USED(opline)) { - EX_T(opline->result.var).var.ptr = zend_generator_create_zval(EG(active_op_array) TSRMLS_CC); + zend_generator_create_zval(EG(active_op_array), EX_VAR(opline->result.var) TSRMLS_CC); } } else if (EXPECTED(zend_execute_ex == execute_ex)) { if (EXPECTED(EG(exception) == NULL)) { + i_create_execute_data_from_op_array(EG(active_op_array), return_value, VM_FRAME_NESTED_FUNCTION TSRMLS_CC); ZEND_VM_ENTER(); } } else { - zend_execute(EG(active_op_array) TSRMLS_CC); + zend_execute(EG(active_op_array), return_value TSRMLS_CC); } EG(opline_ptr) = &EX(opline); EG(active_op_array) = EX(op_array); - EG(return_value_ptr_ptr) = EX(original_return_value); - if (EG(active_symbol_table)) { + if (UNEXPECTED(EG(active_symbol_table) != NULL)) { zend_clean_and_cache_symbol_table(EG(active_symbol_table) TSRMLS_CC); } EG(active_symbol_table) = EX(symbol_table); } else { /* ZEND_OVERLOADED_FUNCTION */ - MAKE_STD_ZVAL(EX_T(opline->result.var).var.ptr); - ZVAL_NULL(EX_T(opline->result.var).var.ptr); + Z_OBJ(EG(This)) = object; +//??? EG(scope) = NULL; + EG(scope) = fbc->common.scope; + EG(called_scope) = EX(call)->called_scope; + + ZVAL_NULL(EX_VAR(opline->result.var)); /* Not sure what should be done here if it's a static method */ - if (EXPECTED(EX(object) != NULL)) { - Z_OBJ_HT_P(EX(object))->call_method(fbc->common.function_name, num_args, EX_T(opline->result.var).var.ptr, &EX_T(opline->result.var).var.ptr, EX(object), RETURN_VALUE_USED(opline) TSRMLS_CC); + if (EXPECTED(object != NULL)) { + object->handlers->call_method(fbc->common.function_name, object, num_args, EX_VAR(opline->result.var) TSRMLS_CC); } else { zend_error_noreturn(E_ERROR, "Cannot call overloaded function for non-object"); } if (fbc->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY) { - efree((char*)fbc->common.function_name); + STR_RELEASE(fbc->common.function_name); } efree(fbc); if (!RETURN_VALUE_USED(opline)) { - zval_ptr_dtor(&EX_T(opline->result.var).var.ptr); + zval_ptr_dtor(EX_VAR(opline->result.var)); } else { - Z_UNSET_ISREF_P(EX_T(opline->result.var).var.ptr); - Z_SET_REFCOUNT_P(EX_T(opline->result.var).var.ptr, 1); - EX_T(opline->result.var).var.fcall_returned_reference = 0; - EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; +//??? Z_UNSET_ISREF_P(EX_T(opline->result.var).var.ptr); +//??? Z_SET_REFCOUNT_P(EX_T(opline->result.var).var.ptr, 1); + Z_VAR_FLAGS_P(EX_VAR(opline->result.var)) = 0; } } - EX(function_state).function = (zend_function *) EX(op_array); - EX(function_state).arguments = NULL; - - if (should_change_scope) { - if (EG(This)) { - if (UNEXPECTED(EG(exception) != NULL) && EX(call)->is_ctor_call) { - if (EX(call)->is_ctor_result_used) { - Z_DELREF_P(EG(This)); - } - if (Z_REFCOUNT_P(EG(This)) == 1) { - zend_object_store_ctor_failed(EG(This) TSRMLS_CC); - } +fcall_end_change_scope: + if (Z_OBJ(EG(This))) { + if (UNEXPECTED(EG(exception) != NULL) && EX(call)->is_ctor_call) { + if (EX(call)->is_ctor_result_used) { + Z_DELREF(EG(This)); + } + if (Z_REFCOUNT(EG(This)) == 1) { + zend_object_store_ctor_failed(Z_OBJ(EG(This)) TSRMLS_CC); } - zval_ptr_dtor(&EG(This)); } - EG(This) = EX(current_this); - EG(scope) = EX(current_scope); - EG(called_scope) = EX(current_called_scope); + if (!Z_DELREF(EG(This))) { + EX(function_state).function = (zend_function *) EX(op_array); + EX(function_state).arguments = NULL; + _zval_dtor_func_for_ptr(Z_COUNTED(EG(This)) ZEND_FILE_LINE_CC); + } else if (UNEXPECTED(!Z_GC_INFO(EG(This)))) { + gc_possible_root(Z_COUNTED(EG(This)) TSRMLS_CC); + } } + Z_OBJ(EG(This)) = EX(object); + EG(scope) = EX(scope); + EG(called_scope) = EX(called_scope); +fcall_end: + EX(function_state).function = (zend_function *) EX(op_array); + EX(function_state).arguments = NULL; EX(call)--; zend_vm_stack_clear_multiple(1 TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { zend_throw_exception_internal(NULL TSRMLS_CC); - if (RETURN_VALUE_USED(opline) && EX_T(opline->result.var).var.ptr) { - zval_ptr_dtor(&EX_T(opline->result.var).var.ptr); + if (RETURN_VALUE_USED(opline)) { + zval_ptr_dtor(EX_VAR(opline->result.var)); } HANDLE_EXCEPTION(); } @@ -664,9 +699,6 @@ static int ZEND_FASTCALL ZEND_JMP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE -#if DEBUG_ZEND>=2 - printf("Jumping to %d\n", opline->op1.opline_num); -#endif ZEND_VM_SET_OPCODE(opline->op1.jmp_addr); ZEND_VM_CONTINUE(); } @@ -674,15 +706,10 @@ static int ZEND_FASTCALL ZEND_JMP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) static int ZEND_FASTCALL ZEND_INIT_STRING_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *tmp = &EX_T(opline->result.var).tmp_var; + zval *tmp = EX_VAR(opline->result.var); SAVE_OPLINE(); - tmp->value.str.val = emalloc(1); - tmp->value.str.val[0] = 0; - tmp->value.str.len = 0; - Z_SET_REFCOUNT_P(tmp, 1); - tmp->type = IS_STRING; - Z_UNSET_ISREF_P(tmp); + ZVAL_EMPTY_STRING(tmp); /*CHECK_EXCEPTION();*/ ZEND_VM_NEXT_OPCODE(); } @@ -695,8 +722,8 @@ static int ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER(ZEND_OPCODE_HANDLER static int ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - /* The generator object is stored in return_value_ptr_ptr */ - zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr); + /* The generator object is stored in EX(return_value) */ + zend_generator *generator = (zend_generator *) EX(return_value); /* Close the generator to free up resources */ zend_generator_close(generator, 1 TSRMLS_CC); @@ -716,44 +743,38 @@ static int ZEND_FASTCALL ZEND_SEND_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS args = get_zval_ptr(opline->op1_type, &opline->op1, execute_data, &free_op1, BP_VAR_R); arg_num = opline->op2.num + EX(call)->num_additional_args + 1; +send_again: switch (Z_TYPE_P(args)) { case IS_ARRAY: { HashTable *ht = Z_ARRVAL_P(args); - HashPosition pos; - zval **arg_ptr, *arg; + zval *arg, *top; + zend_string *name; ZEND_VM_STACK_GROW_IF_NEEDED(zend_hash_num_elements(ht)); - for (zend_hash_internal_pointer_reset_ex(ht, &pos); - zend_hash_get_current_data_ex(ht, (void **) &arg_ptr, &pos) == SUCCESS; - zend_hash_move_forward_ex(ht, &pos), ++arg_num - ) { - char *name; - zend_uint name_len; - zend_ulong index; - - if (zend_hash_get_current_key_ex(ht, &name, &name_len, &index, 0, &pos) == HASH_KEY_IS_STRING) { + ZEND_HASH_FOREACH_STR_KEY_VAL(ht, name, arg) { + if (name) { zend_error(E_RECOVERABLE_ERROR, "Cannot unpack array with string keys"); FREE_OP(free_op1); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } + top = zend_vm_stack_top_inc(TSRMLS_C); if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->fbc, arg_num)) { - SEPARATE_ZVAL_TO_MAKE_IS_REF(arg_ptr); - arg = *arg_ptr; + SEPARATE_ZVAL_TO_MAKE_IS_REF(arg); Z_ADDREF_P(arg); - } else if (Z_ISREF_PP(arg_ptr)) { - ALLOC_ZVAL(arg); - MAKE_COPY_ZVAL(arg_ptr, arg); + ZVAL_COPY_VALUE(top, arg); + } else if (Z_ISREF_P(arg)) { + ZVAL_DUP(top, Z_REFVAL_P(arg)); } else { - arg = *arg_ptr; - Z_ADDREF_P(arg); + ZVAL_COPY(top, arg); } - zend_vm_stack_push(arg TSRMLS_CC); EX(call)->num_additional_args++; - } + arg_num++; + } ZEND_HASH_FOREACH_END(); + break; } case IS_OBJECT: { @@ -770,7 +791,7 @@ static int ZEND_FASTCALL ZEND_SEND_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS FREE_OP(free_op1); if (!EG(exception)) { zend_throw_exception_ex( - NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name + NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name->val ); } HANDLE_EXCEPTION(); @@ -784,13 +805,13 @@ static int ZEND_FASTCALL ZEND_SEND_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS } for (; iter->funcs->valid(iter TSRMLS_CC) == SUCCESS; ++arg_num) { - zval **arg_ptr, *arg; + zval *arg; if (UNEXPECTED(EG(exception) != NULL)) { goto unpack_iter_dtor; } - iter->funcs->get_current_data(iter, &arg_ptr TSRMLS_CC); + arg = iter->funcs->get_current_data(iter TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { goto unpack_iter_dtor; } @@ -816,18 +837,16 @@ static int ZEND_FASTCALL ZEND_SEND_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS zend_error( E_WARNING, "Cannot pass by-reference argument %d of %s%s%s()" " by unpacking a Traversable, passing by-value instead", arg_num, - EX(call)->fbc->common.scope ? EX(call)->fbc->common.scope->name : "", + EX(call)->fbc->common.scope ? EX(call)->fbc->common.scope->name->val : "", EX(call)->fbc->common.scope ? "::" : "", - EX(call)->fbc->common.function_name + EX(call)->fbc->common.function_name->val ); } - if (Z_ISREF_PP(arg_ptr)) { - ALLOC_ZVAL(arg); - MAKE_COPY_ZVAL(arg_ptr, arg); + if (Z_ISREF_P(arg)) { + ZVAL_DUP(arg, Z_REFVAL_P(arg)); } else { - arg = *arg_ptr; - Z_ADDREF_P(arg); + if (Z_REFCOUNTED_P(arg)) Z_ADDREF_P(arg); } ZEND_VM_STACK_GROW_IF_NEEDED(1); @@ -841,9 +860,13 @@ static int ZEND_FASTCALL ZEND_SEND_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS } unpack_iter_dtor: - iter->funcs->dtor(iter TSRMLS_CC); + zend_iterator_dtor(iter TSRMLS_CC); break; } + case IS_REFERENCE: + args = Z_REFVAL_P(args); + goto send_again; + break; default: zend_error(E_WARNING, "Only arrays and Traversables can be unpacked"); } @@ -857,37 +880,22 @@ static int ZEND_FASTCALL ZEND_RECV_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_uint arg_num = opline->op1.num; - zval **param = zend_vm_stack_get_arg(arg_num TSRMLS_CC); + zval *arguments = EX(prev_execute_data)->function_state.arguments; + zend_uint arg_count = Z_LVAL_P(arguments); SAVE_OPLINE(); - if (UNEXPECTED(param == NULL)) { - if (zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, NULL, opline->extended_value TSRMLS_CC)) { - const char *space; - const char *class_name; - zend_execute_data *ptr; - - if (EG(active_op_array)->scope) { - class_name = EG(active_op_array)->scope->name; - space = "::"; - } else { - class_name = space = ""; - } - ptr = EX(prev_execute_data); - - if(ptr && ptr->op_array) { - zend_error(E_WARNING, "Missing argument %u for %s%s%s(), called in %s on line %d and defined", opline->op1.num, class_name, space, get_active_function_name(TSRMLS_C), ptr->op_array->filename, ptr->opline->lineno); - } else { - zend_error(E_WARNING, "Missing argument %u for %s%s%s()", opline->op1.num, class_name, space, get_active_function_name(TSRMLS_C)); - } - } + if (UNEXPECTED(arg_num > arg_count)) { + zend_verify_missing_arg(execute_data, arg_num TSRMLS_CC); } else { - zval **var_ptr; + zval *var_ptr; + zval *param = arguments - arg_count + arg_num - 1; - zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, *param, opline->extended_value TSRMLS_CC); - var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->result.var TSRMLS_CC); - Z_DELREF_PP(var_ptr); - *var_ptr = *param; - Z_ADDREF_PP(var_ptr); + if (UNEXPECTED((EX(op_array)->fn_flags & ZEND_ACC_HAS_TYPE_HINTS) != 0)) { + zend_verify_arg_type((zend_function *) EX(op_array), arg_num, param, opline->extended_value TSRMLS_CC); + } + var_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->result.var TSRMLS_CC); + if (UNEXPECTED(Z_REFCOUNTED_P(var_ptr))) Z_DELREF_P(var_ptr); + ZVAL_COPY(var_ptr, param); } CHECK_EXCEPTION(); @@ -898,29 +906,36 @@ static int ZEND_FASTCALL ZEND_RECV_VARIADIC_SPEC_HANDLER(ZEND_OPCODE_HANDLER_AR { USE_OPLINE zend_uint arg_num = opline->op1.num; - zend_uint arg_count = zend_vm_stack_get_args_count(TSRMLS_C); - zval **var_ptr, *params; + zval *arguments = EX(prev_execute_data)->function_state.arguments; + zend_uint arg_count = Z_LVAL_P(arguments); + zval *params; SAVE_OPLINE(); - var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->result.var TSRMLS_CC); - Z_DELREF_PP(var_ptr); - MAKE_STD_ZVAL(params); - *var_ptr = params; + params = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->result.var TSRMLS_CC); + if (UNEXPECTED(Z_REFCOUNTED_P(params))) Z_DELREF_P(params); if (arg_num <= arg_count) { + zval *param = arguments - arg_count + arg_num - 1; array_init_size(params, arg_count - arg_num + 1); + if (UNEXPECTED((EX(op_array)->fn_flags & ZEND_ACC_HAS_TYPE_HINTS) != 0)) { + do { + zend_verify_arg_type((zend_function *) EX(op_array), arg_num, param, opline->extended_value TSRMLS_CC); + zend_hash_next_index_insert(Z_ARRVAL_P(params), param); + if (Z_REFCOUNTED_P(param)) Z_ADDREF_P(param); + param++; + } while (++arg_num <= arg_count); + } else { + do { + zend_hash_next_index_insert(Z_ARRVAL_P(params), param); + if (Z_REFCOUNTED_P(param)) Z_ADDREF_P(param); + param++; + } while (++arg_num <= arg_count); + } } else { array_init(params); } - for (; arg_num <= arg_count; ++arg_num) { - zval **param = zend_vm_stack_get_arg(arg_num TSRMLS_CC); - zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, *param, opline->extended_value TSRMLS_CC); - zend_hash_next_index_insert(Z_ARRVAL_P(params), param, sizeof(zval *), NULL); - Z_ADDREF_PP(param); - } - CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -928,28 +943,25 @@ static int ZEND_FASTCALL ZEND_RECV_VARIADIC_SPEC_HANDLER(ZEND_OPCODE_HANDLER_AR static int ZEND_FASTCALL ZEND_NEW_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *object_zval; + zval object_zval; zend_function *constructor; SAVE_OPLINE(); - if (UNEXPECTED((EX_T(opline->op1.var).class_entry->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)) != 0)) { - if (EX_T(opline->op1.var).class_entry->ce_flags & ZEND_ACC_INTERFACE) { - zend_error_noreturn(E_ERROR, "Cannot instantiate interface %s", EX_T(opline->op1.var).class_entry->name); - } else if ((EX_T(opline->op1.var).class_entry->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) { - zend_error_noreturn(E_ERROR, "Cannot instantiate trait %s", EX_T(opline->op1.var).class_entry->name); + if (UNEXPECTED((Z_CE_P(EX_VAR(opline->op1.var))->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)) != 0)) { + if (Z_CE_P(EX_VAR(opline->op1.var))->ce_flags & ZEND_ACC_INTERFACE) { + zend_error_noreturn(E_ERROR, "Cannot instantiate interface %s", Z_CE_P(EX_VAR(opline->op1.var))->name->val); + } else if ((Z_CE_P(EX_VAR(opline->op1.var))->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) { + zend_error_noreturn(E_ERROR, "Cannot instantiate trait %s", Z_CE_P(EX_VAR(opline->op1.var))->name->val); } else { - zend_error_noreturn(E_ERROR, "Cannot instantiate abstract class %s", EX_T(opline->op1.var).class_entry->name); + zend_error_noreturn(E_ERROR, "Cannot instantiate abstract class %s", Z_CE_P(EX_VAR(opline->op1.var))->name->val); } } - ALLOC_ZVAL(object_zval); - object_init_ex(object_zval, EX_T(opline->op1.var).class_entry); - INIT_PZVAL(object_zval); - - constructor = Z_OBJ_HT_P(object_zval)->get_constructor(object_zval TSRMLS_CC); + object_init_ex(&object_zval, Z_CE_P(EX_VAR(opline->op1.var))); + constructor = Z_OBJ_HT(object_zval)->get_constructor(Z_OBJ(object_zval) TSRMLS_CC); if (constructor == NULL) { if (RETURN_VALUE_USED(opline)) { - AI_SET_PTR(&EX_T(opline->result.var), object_zval); + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), &object_zval); } else { zval_ptr_dtor(&object_zval); } @@ -958,14 +970,13 @@ static int ZEND_FASTCALL ZEND_NEW_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) call_slot *call = EX(call_slots) + opline->extended_value; if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(object_zval); - AI_SET_PTR(&EX_T(opline->result.var), object_zval); + ZVAL_COPY(EX_VAR(opline->result.var), &object_zval); } /* We are not handling overloaded classes right now */ call->fbc = constructor; - call->object = object_zval; - call->called_scope = EX_T(opline->op1.var).class_entry; + call->object = Z_OBJ(object_zval); + call->called_scope = Z_CE_P(EX_VAR(opline->op1.var)); call->num_additional_args = 0; call->is_ctor_call = 1; call->is_ctor_result_used = RETURN_VALUE_USED(opline); @@ -981,17 +992,19 @@ static int ZEND_FASTCALL ZEND_BEGIN_SILENCE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_AR USE_OPLINE SAVE_OPLINE(); - Z_LVAL(EX_T(opline->result.var).tmp_var) = EG(error_reporting); - Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_LONG; /* shouldn't be necessary */ - if (EX(old_error_reporting) == NULL) { - EX(old_error_reporting) = &EX_T(opline->result.var).tmp_var; + ZVAL_LONG(EX_VAR(opline->result.var), EG(error_reporting)); + if (Z_TYPE(EX(old_error_reporting)) == IS_UNDEF) { + ZVAL_LONG(&EX(old_error_reporting), EG(error_reporting)); } if (EG(error_reporting)) { do { EG(error_reporting) = 0; if (!EG(error_reporting_ini_entry)) { - if (UNEXPECTED(zend_hash_find(EG(ini_directives), "error_reporting", sizeof("error_reporting"), (void **) &EG(error_reporting_ini_entry)) == FAILURE)) { + zend_ini_entry *p = zend_hash_str_find_ptr(EG(ini_directives), "error_reporting", sizeof("error_reporting")-1); + if (p) { + EG(error_reporting_ini_entry) = p; + } else { break; } } @@ -1000,7 +1013,7 @@ static int ZEND_FASTCALL ZEND_BEGIN_SILENCE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_AR ALLOC_HASHTABLE(EG(modified_ini_directives)); zend_hash_init(EG(modified_ini_directives), 8, NULL, NULL, 0); } - if (EXPECTED(zend_hash_add(EG(modified_ini_directives), "error_reporting", sizeof("error_reporting"), &EG(error_reporting_ini_entry), sizeof(zend_ini_entry*), NULL) == SUCCESS)) { + if (EXPECTED(zend_hash_str_add_ptr(EG(modified_ini_directives), "error_reporting", sizeof("error_reporting")-1, EG(error_reporting_ini_entry)) != NULL)) { EG(error_reporting_ini_entry)->orig_value = EG(error_reporting_ini_entry)->value; EG(error_reporting_ini_entry)->orig_value_length = EG(error_reporting_ini_entry)->value_length; EG(error_reporting_ini_entry)->orig_modifiable = EG(error_reporting_ini_entry)->modifiable; @@ -1020,7 +1033,7 @@ static int ZEND_FASTCALL ZEND_BEGIN_SILENCE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_AR static int ZEND_FASTCALL ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { SAVE_OPLINE(); - zend_error_noreturn(E_ERROR, "Cannot call abstract method %s::%s()", EG(scope)->name, EX(op_array)->function_name); + zend_error_noreturn(E_ERROR, "Cannot call abstract method %s::%s()", EG(scope)->name->val, EX(op_array)->function_name->val); ZEND_VM_NEXT_OPCODE(); /* Never reached */ } @@ -1059,7 +1072,7 @@ static int ZEND_FASTCALL ZEND_DECLARE_CLASS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_AR USE_OPLINE SAVE_OPLINE(); - EX_T(opline->result.var).class_entry = do_bind_class(EX(op_array), opline, EG(class_table), 0 TSRMLS_CC); + Z_CE_P(EX_VAR(opline->result.var)) = do_bind_class(EX(op_array), opline, EG(class_table), 0 TSRMLS_CC); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -1069,7 +1082,7 @@ static int ZEND_FASTCALL ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER(ZEND_OPCODE_ USE_OPLINE SAVE_OPLINE(); - EX_T(opline->result.var).class_entry = do_bind_inherited_class(EX(op_array), opline, EG(class_table), EX_T(opline->extended_value).class_entry, 0 TSRMLS_CC); + Z_CE_P(EX_VAR(opline->result.var)) = do_bind_inherited_class(EX(op_array), opline, EG(class_table), Z_CE_P(EX_VAR(opline->extended_value)), 0 TSRMLS_CC); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -1077,13 +1090,13 @@ static int ZEND_FASTCALL ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER(ZEND_OPCODE_ static int ZEND_FASTCALL ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_class_entry **pce, **pce_orig; + zval *zce, *orig_zce; SAVE_OPLINE(); - if (zend_hash_quick_find(EG(class_table), Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv)+1, Z_HASH_P(opline->op2.zv), (void**)&pce) == FAILURE || - (zend_hash_quick_find(EG(class_table), Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), Z_HASH_P(opline->op1.zv), (void**)&pce_orig) == SUCCESS && - *pce != *pce_orig)) { - do_bind_inherited_class(EX(op_array), opline, EG(class_table), EX_T(opline->extended_value).class_entry, 0 TSRMLS_CC); + if ((zce = zend_hash_find(EG(class_table), Z_STR_P(opline->op2.zv))) == NULL || + ((orig_zce = zend_hash_find(EG(class_table), Z_STR_P(opline->op1.zv))) != NULL && + Z_CE_P(zce) != Z_CE_P(orig_zce))) { + do_bind_inherited_class(EX(op_array), opline, EG(class_table), Z_CE_P(EX_VAR(opline->extended_value)), 0 TSRMLS_CC); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -1127,25 +1140,24 @@ static int ZEND_FASTCALL ZEND_NOP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) static int ZEND_FASTCALL ZEND_ADD_TRAIT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_class_entry *ce = EX_T(opline->op1.var).class_entry; + zend_class_entry *ce = Z_CE_P(EX_VAR(opline->op1.var)); zend_class_entry *trait; SAVE_OPLINE(); - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - trait = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + trait = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else { - trait = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), - Z_STRLEN_P(opline->op2.zv), - opline->op2.literal + 1, + trait = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), + opline->op2.zv + 1, opline->extended_value TSRMLS_CC); if (UNEXPECTED(trait == NULL)) { CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } if (!((trait->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT)) { - zend_error_noreturn(E_ERROR, "%s cannot use %s - it is not a trait", ce->name, trait->name); + zend_error_noreturn(E_ERROR, "%s cannot use %s - it is not a trait", ce->name->val, trait->name->val); } - CACHE_PTR(opline->op2.literal->cache_slot, trait); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), trait); } zend_do_implement_trait(ce, trait TSRMLS_CC); @@ -1157,7 +1169,7 @@ static int ZEND_FASTCALL ZEND_ADD_TRAIT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) static int ZEND_FASTCALL ZEND_BIND_TRAITS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_class_entry *ce = EX_T(opline->op1.var).class_entry; + zend_class_entry *ce = Z_CE_P(EX_VAR(opline->op1.var)); SAVE_OPLINE(); zend_do_bind_traits(ce TSRMLS_CC); @@ -1170,7 +1182,7 @@ static int ZEND_FASTCALL ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER zend_uint op_num = EG(opline_before_exception)-EG(active_op_array)->opcodes; int i; zend_uint catch_op_num = 0, finally_op_num = 0, finally_op_end = 0; - void **stack_frame; + zval *stack_frame; /* Figure out where the next stack frame (which maybe contains pushed * arguments that have to be dtor'ed) starts */ @@ -1180,7 +1192,7 @@ static int ZEND_FASTCALL ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER * arguments pushed to the stack that have to be dtor'ed. */ while (zend_vm_stack_top(TSRMLS_C) != stack_frame) { zval *stack_zval_p = zend_vm_stack_pop(TSRMLS_C); - zval_ptr_dtor(&stack_zval_p); + zval_ptr_dtor(stack_zval_p); } for (i=0; i<EG(active_op_array)->last_try_catch; i++) { @@ -1206,13 +1218,13 @@ static int ZEND_FASTCALL ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER if (call->object) { if (call->is_ctor_call) { if (call->is_ctor_result_used) { - Z_DELREF_P(call->object); + GC_REFCOUNT(call->object)--; } - if (Z_REFCOUNT_P(call->object) == 1) { + if (GC_REFCOUNT(call->object) == 1) { zend_object_store_ctor_failed(call->object TSRMLS_CC); } } - zval_ptr_dtor(&call->object); + OBJ_RELEASE(call->object); } call--; } while (call >= EX(call_slots)); @@ -1233,12 +1245,12 @@ static int ZEND_FASTCALL ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER switch (brk_opline->opcode) { case ZEND_SWITCH_FREE: if (!(brk_opline->extended_value & EXT_TYPE_FREE_ON_RETURN)) { - zval_ptr_dtor(&EX_T(brk_opline->op1.var).var.ptr); + zval_ptr_dtor(EX_VAR(brk_opline->op1.var)); } break; case ZEND_FREE: if (!(brk_opline->extended_value & EXT_TYPE_FREE_ON_RETURN)) { - zendi_zval_dtor(EX_T(brk_opline->op1.var).tmp_var); + zval_dtor(EX_VAR(brk_opline->op1.var)); } break; } @@ -1247,16 +1259,18 @@ static int ZEND_FASTCALL ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER } /* restore previous error_reporting value */ - if (!EG(error_reporting) && EX(old_error_reporting) != NULL && Z_LVAL_P(EX(old_error_reporting)) != 0) { + if (!EG(error_reporting) && Z_TYPE(EX(old_error_reporting)) != IS_UNDEF && Z_LVAL(EX(old_error_reporting)) != 0) { zval restored_error_reporting; + zend_string *key; - Z_TYPE(restored_error_reporting) = IS_LONG; - Z_LVAL(restored_error_reporting) = Z_LVAL_P(EX(old_error_reporting)); + ZVAL_LONG(&restored_error_reporting, Z_LVAL(EX(old_error_reporting))); convert_to_string(&restored_error_reporting); - zend_alter_ini_entry_ex("error_reporting", sizeof("error_reporting"), Z_STRVAL(restored_error_reporting), Z_STRLEN(restored_error_reporting), ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME, 1 TSRMLS_CC); - zendi_zval_dtor(restored_error_reporting); + key = STR_INIT("error_reporting", sizeof("error_reporting")-1, 0); + zend_alter_ini_entry_ex(key, Z_STRVAL(restored_error_reporting), Z_STRLEN(restored_error_reporting), ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME, 1 TSRMLS_CC); + STR_FREE(key); + zval_dtor(&restored_error_reporting); } - EX(old_error_reporting) = NULL; + ZVAL_UNDEF(&EX(old_error_reporting)); if (finally_op_num && (!catch_op_num || catch_op_num >= finally_op_num)) { if (EX(delayed_exception)) { @@ -1295,7 +1309,7 @@ static int ZEND_FASTCALL ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER(ZEND_OPCODE_HA USE_OPLINE SAVE_OPLINE(); - zend_verify_abstract_class(EX_T(opline->op1.var).class_entry TSRMLS_CC); + zend_verify_abstract_class(Z_CE_P(EX_VAR(opline->op1.var)) TSRMLS_CC); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -1333,7 +1347,7 @@ static int ZEND_FASTCALL ZEND_DISCARD_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLE { if (EX(delayed_exception) != NULL) { /* discard the previously thrown exception */ - zval_ptr_dtor(&EX(delayed_exception)); + OBJ_RELEASE(EX(delayed_exception)); EX(delayed_exception) = NULL; } @@ -1392,7 +1406,7 @@ static int ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLE zend_exception_save(TSRMLS_C); } if (IS_CONST == IS_UNUSED) { - EX_T(opline->result.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC); + Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->extended_value TSRMLS_CC); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } else { @@ -1400,16 +1414,16 @@ static int ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLE zval *class_name = opline->op2.zv; if (IS_CONST == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - EX_T(opline->result.var).class_entry = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(class_name))) { + Z_CE_P(EX_VAR(opline->result.var)) = CACHED_PTR(Z_CACHE_SLOT_P(class_name)); } else { - EX_T(opline->result.var).class_entry = zend_fetch_class_by_name(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->op2.literal + 1, opline->extended_value TSRMLS_CC); - CACHE_PTR(opline->op2.literal->cache_slot, EX_T(opline->result.var).class_entry); + Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class_by_name(Z_STR_P(class_name), opline->op2.zv + 1, opline->extended_value TSRMLS_CC); + CACHE_PTR(Z_CACHE_SLOT_P(class_name), Z_CE_P(EX_VAR(opline->result.var))); } } else if (Z_TYPE_P(class_name) == IS_OBJECT) { - EX_T(opline->result.var).class_entry = Z_OBJCE_P(class_name); + Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name); } else if (Z_TYPE_P(class_name) == IS_STRING) { - EX_T(opline->result.var).class_entry = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->extended_value TSRMLS_CC); + Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->extended_value TSRMLS_CC); } else { if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); @@ -1425,18 +1439,19 @@ static int ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLE static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *function_name; + zval *function_name_ptr, *function_name, *func; call_slot *call = EX(call_slots) + opline->result.num; if (IS_CONST == IS_CONST) { - function_name = (zval*)(opline->op2.literal+1); - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - call->fbc = CACHED_PTR(opline->op2.literal->cache_slot); - } else if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL_P(function_name), Z_STRLEN_P(function_name)+1, Z_HASH_P(function_name), (void **) &call->fbc) == FAILURE)) { + function_name_ptr = function_name = (zval*)(opline->op2.zv+1); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + } else if (UNEXPECTED((func = zend_hash_find(EG(function_table), Z_STR_P(function_name))) == NULL)) { SAVE_OPLINE(); zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv)); } else { - CACHE_PTR(opline->op2.literal->cache_slot, call->fbc); + call->fbc = Z_FUNC_P(func); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->fbc); } call->object = NULL; @@ -1448,27 +1463,27 @@ static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE /*CHECK_EXCEPTION();*/ ZEND_VM_NEXT_OPCODE(); } else { - char *function_name_strval, *lcname; - int function_name_strlen; + zend_string *lcname; SAVE_OPLINE(); - function_name = opline->op2.zv; + function_name_ptr = function_name = opline->op2.zv; + ZVAL_DEREF(function_name); if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { - function_name_strval = Z_STRVAL_P(function_name); - function_name_strlen = Z_STRLEN_P(function_name); - if (function_name_strval[0] == '\\') { - function_name_strlen -= 1; - lcname = zend_str_tolower_dup(function_name_strval + 1, function_name_strlen); + if (Z_STRVAL_P(function_name)[0] == '\\') { + lcname = STR_ALLOC(Z_STRLEN_P(function_name) - 1, 0); + zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name) + 1, Z_STRLEN_P(function_name) - 1); } else { - lcname = zend_str_tolower_dup(function_name_strval, function_name_strlen); + lcname = STR_ALLOC(Z_STRLEN_P(function_name), 0); + zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name), Z_STRLEN_P(function_name)); } - if (UNEXPECTED(zend_hash_find(EG(function_table), lcname, function_name_strlen+1, (void **) &call->fbc) == FAILURE)) { - zend_error_noreturn(E_ERROR, "Call to undefined function %s()", function_name_strval); + if (UNEXPECTED((func = zend_hash_find(EG(function_table), lcname)) == NULL)) { + zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(function_name)); } - efree(lcname); + STR_FREE(lcname); + call->fbc = Z_FUNC_P(func); call->object = NULL; call->called_scope = NULL; call->num_additional_args = 0; @@ -1482,12 +1497,12 @@ static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE Z_OBJ_HANDLER_P(function_name, get_closure) && Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &call->called_scope, &call->fbc, &call->object TSRMLS_CC) == SUCCESS) { if (call->object) { - Z_ADDREF_P(call->object); + GC_REFCOUNT(call->object)++; } if (IS_CONST == IS_VAR && 0 && Z_REFCOUNT_P(function_name) == 1 && call->fbc->common.fn_flags & ZEND_ACC_CLOSURE) { /* Delay closure destruction until its invocation */ - call->fbc->common.prototype = (zend_function*)function_name; + call->fbc->common.prototype = (zend_function*)function_name_ptr; } else { } @@ -1501,67 +1516,56 @@ static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE } else if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) && zend_hash_num_elements(Z_ARRVAL_P(function_name)) == 2) { - zend_class_entry *ce; - zval **method = NULL; - zval **obj = NULL; + zval *obj; + zval *method; - zend_hash_index_find(Z_ARRVAL_P(function_name), 0, (void **) &obj); - zend_hash_index_find(Z_ARRVAL_P(function_name), 1, (void **) &method); + obj = zend_hash_index_find(Z_ARRVAL_P(function_name), 0); + method = zend_hash_index_find(Z_ARRVAL_P(function_name), 1); if (!obj || !method) { zend_error_noreturn(E_ERROR, "Array callback has to contain indices 0 and 1"); } - if (Z_TYPE_PP(obj) != IS_STRING && Z_TYPE_PP(obj) != IS_OBJECT) { + if (Z_TYPE_P(obj) != IS_STRING && Z_TYPE_P(obj) != IS_OBJECT) { zend_error_noreturn(E_ERROR, "First array member is not a valid class name or object"); } - if (Z_TYPE_PP(method) != IS_STRING) { + if (Z_TYPE_P(method) != IS_STRING) { zend_error_noreturn(E_ERROR, "Second array member is not a valid method"); } - if (Z_TYPE_PP(obj) == IS_STRING) { - ce = zend_fetch_class_by_name(Z_STRVAL_PP(obj), Z_STRLEN_PP(obj), NULL, 0 TSRMLS_CC); - if (UNEXPECTED(ce == NULL)) { + if (Z_TYPE_P(obj) == IS_STRING) { + call->object = NULL; + call->called_scope = zend_fetch_class_by_name(Z_STR_P(obj), NULL, 0 TSRMLS_CC); + if (UNEXPECTED(call->called_scope == NULL)) { CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - call->called_scope = ce; - call->object = NULL; - if (ce->get_static_method) { - call->fbc = ce->get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method) TSRMLS_CC); + if (call->called_scope->get_static_method) { + call->fbc = call->called_scope->get_static_method(call->called_scope, Z_STR_P(method) TSRMLS_CC); } else { - call->fbc = zend_std_get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC); + call->fbc = zend_std_get_static_method(call->called_scope, Z_STR_P(method), NULL TSRMLS_CC); + } + if (UNEXPECTED(call->fbc == NULL)) { + zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", call->called_scope->name->val, Z_STRVAL_P(method)); } } else { - call->object = *obj; - ce = call->called_scope = Z_OBJCE_PP(obj); + call->called_scope = Z_OBJCE_P(obj); + call->object = Z_OBJ_P(obj); - call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC); + call->fbc = Z_OBJ_HT_P(obj)->get_method(&call->object, Z_STR_P(method), NULL TSRMLS_CC); if (UNEXPECTED(call->fbc == NULL)) { - zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_PP(method)); + zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(method)); } if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) { call->object = NULL; } else { - if (!PZVAL_IS_REF(call->object)) { - Z_ADDREF_P(call->object); /* For $this pointer */ - } else { - zval *this_ptr; - ALLOC_ZVAL(this_ptr); - INIT_PZVAL_COPY(this_ptr, call->object); - zval_copy_ctor(this_ptr); - call->object = this_ptr; - } + GC_REFCOUNT(call->object)++; /* For $this pointer */ } } - if (UNEXPECTED(call->fbc == NULL)) { - zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, Z_STRVAL_PP(method)); - } - call->num_additional_args = 0; call->is_ctor_call = 0; EX(call) = call; @@ -1582,61 +1586,65 @@ static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE static int ZEND_FASTCALL ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_literal *func_name; + zval *func_name; + zval *func; call_slot *call = EX(call_slots) + opline->result.num; - func_name = opline->op2.literal + 1; - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - call->fbc = CACHED_PTR(opline->op2.literal->cache_slot); - } else if (zend_hash_quick_find(EG(function_table), Z_STRVAL(func_name->constant), Z_STRLEN(func_name->constant)+1, func_name->hash_value, (void **) &call->fbc)==FAILURE) { + func_name = opline->op2.zv + 1; + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + } else if ((func = zend_hash_find(EG(function_table), Z_STR_P(func_name))) == NULL) { func_name++; - if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL(func_name->constant), Z_STRLEN(func_name->constant)+1, func_name->hash_value, (void **) &call->fbc)==FAILURE)) { + if (UNEXPECTED((func = zend_hash_find(EG(function_table), Z_STR_P(func_name))) == NULL)) { SAVE_OPLINE(); zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv)); } else { - CACHE_PTR(opline->op2.literal->cache_slot, call->fbc); + call->fbc = Z_FUNC_P(func); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->fbc); } } else { - CACHE_PTR(opline->op2.literal->cache_slot, call->fbc); + call->fbc = Z_FUNC_P(func); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->fbc); } call->object = NULL; call->called_scope = NULL; call->num_additional_args = 0; call->is_ctor_call = 0; - EX(call) = call; + ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_RECV_INIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *assignment_value; zend_uint arg_num = opline->op1.num; - zval **param = zend_vm_stack_get_arg(arg_num TSRMLS_CC); - zval **var_ptr; + zval *arguments = EX(prev_execute_data)->function_state.arguments; + zend_uint arg_count = Z_LVAL_P(arguments); + zval *var_ptr; SAVE_OPLINE(); - if (param == NULL) { - ALLOC_ZVAL(assignment_value); - *assignment_value = *opline->op2.zv; - if (IS_CONSTANT_TYPE(Z_TYPE_P(assignment_value))) { - Z_SET_REFCOUNT_P(assignment_value, 1); - zval_update_constant(&assignment_value, 0 TSRMLS_CC); + var_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->result.var TSRMLS_CC); + if (UNEXPECTED(Z_REFCOUNTED_P(var_ptr))) Z_DELREF_P(var_ptr); + if (arg_num > arg_count) { + ZVAL_COPY_VALUE(var_ptr, opline->op2.zv); + if (Z_OPT_CONSTANT_P(var_ptr)) { + zval_update_constant(var_ptr, 0 TSRMLS_CC); } else { - zval_copy_ctor(assignment_value); + /* IS_CONST can't be IS_OBJECT, IS_RESOURCE or IS_REFERENCE */ + if (UNEXPECTED(Z_OPT_COPYABLE_P(var_ptr))) { + _zval_copy_ctor_func(var_ptr ZEND_FILE_LINE_CC); + } } - INIT_PZVAL(assignment_value); } else { - assignment_value = *param; - Z_ADDREF_P(assignment_value); + zval *param = arguments - arg_count + arg_num - 1; + ZVAL_COPY(var_ptr, param); } - zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, assignment_value, opline->extended_value TSRMLS_CC); - var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->result.var TSRMLS_CC); - zval_ptr_dtor(var_ptr); - *var_ptr = assignment_value; + if (UNEXPECTED((EX(op_array)->fn_flags & ZEND_ACC_HAS_TYPE_HINTS) != 0)) { + zend_verify_arg_type((zend_function *) EX(op_array), arg_num, var_ptr, opline->extended_value TSRMLS_CC); + } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -1679,12 +1687,12 @@ static int ZEND_FASTCALL ZEND_GOTO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) switch (brk_opline->opcode) { case ZEND_SWITCH_FREE: if (!(brk_opline->extended_value & EXT_TYPE_FREE_ON_RETURN)) { - zval_ptr_dtor(&EX_T(brk_opline->op1.var).var.ptr); + zval_ptr_dtor(EX_VAR(brk_opline->op1.var)); } break; case ZEND_FREE: if (!(brk_opline->extended_value & EXT_TYPE_FREE_ON_RETURN)) { - zendi_zval_dtor(EX_T(brk_opline->op1.var).tmp_var); + zval_dtor(EX_VAR(brk_opline->op1.var)); } break; } @@ -1694,23 +1702,23 @@ static int ZEND_FASTCALL ZEND_GOTO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) static int ZEND_FASTCALL ZEND_ADD_INTERFACE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_class_entry *ce = EX_T(opline->op1.var).class_entry; + zend_class_entry *ce = Z_CE_P(EX_VAR(opline->op1.var)); zend_class_entry *iface; SAVE_OPLINE(); - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - iface = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + iface = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else { - iface = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, opline->extended_value TSRMLS_CC); + iface = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, opline->extended_value TSRMLS_CC); if (UNEXPECTED(iface == NULL)) { CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(opline->op2.literal->cache_slot, iface); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), iface); } if (UNEXPECTED((iface->ce_flags & ZEND_ACC_INTERFACE) == 0)) { - zend_error_noreturn(E_ERROR, "%s cannot implement %s - it is not an interface", ce->name, iface->name); + zend_error_noreturn(E_ERROR, "%s cannot implement %s - it is not an interface", ce->name->val, iface->name->val); } zend_do_implement_interface(ce, iface TSRMLS_CC); @@ -1727,7 +1735,7 @@ static int ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ zend_exception_save(TSRMLS_C); } if (IS_TMP_VAR == IS_UNUSED) { - EX_T(opline->result.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC); + Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->extended_value TSRMLS_CC); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } else { @@ -1735,16 +1743,16 @@ static int ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ zval *class_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); if (IS_TMP_VAR == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - EX_T(opline->result.var).class_entry = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(class_name))) { + Z_CE_P(EX_VAR(opline->result.var)) = CACHED_PTR(Z_CACHE_SLOT_P(class_name)); } else { - EX_T(opline->result.var).class_entry = zend_fetch_class_by_name(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->op2.literal + 1, opline->extended_value TSRMLS_CC); - CACHE_PTR(opline->op2.literal->cache_slot, EX_T(opline->result.var).class_entry); + Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class_by_name(Z_STR_P(class_name), opline->op2.zv + 1, opline->extended_value TSRMLS_CC); + CACHE_PTR(Z_CACHE_SLOT_P(class_name), Z_CE_P(EX_VAR(opline->result.var))); } } else if (Z_TYPE_P(class_name) == IS_OBJECT) { - EX_T(opline->result.var).class_entry = Z_OBJCE_P(class_name); + Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name); } else if (Z_TYPE_P(class_name) == IS_STRING) { - EX_T(opline->result.var).class_entry = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->extended_value TSRMLS_CC); + Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->extended_value TSRMLS_CC); } else { if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); @@ -1761,18 +1769,19 @@ static int ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *function_name; + zval *function_name_ptr, *function_name, *func; call_slot *call = EX(call_slots) + opline->result.num; if (IS_TMP_VAR == IS_CONST) { - function_name = (zval*)(opline->op2.literal+1); - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - call->fbc = CACHED_PTR(opline->op2.literal->cache_slot); - } else if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL_P(function_name), Z_STRLEN_P(function_name)+1, Z_HASH_P(function_name), (void **) &call->fbc) == FAILURE)) { + function_name_ptr = function_name = (zval*)(opline->op2.zv+1); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + } else if (UNEXPECTED((func = zend_hash_find(EG(function_table), Z_STR_P(function_name))) == NULL)) { SAVE_OPLINE(); zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv)); } else { - CACHE_PTR(opline->op2.literal->cache_slot, call->fbc); + call->fbc = Z_FUNC_P(func); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->fbc); } call->object = NULL; @@ -1784,28 +1793,28 @@ static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER(ZEND_OPCODE_H /*CHECK_EXCEPTION();*/ ZEND_VM_NEXT_OPCODE(); } else { - char *function_name_strval, *lcname; - int function_name_strlen; + zend_string *lcname; zend_free_op free_op2; SAVE_OPLINE(); - function_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + function_name_ptr = function_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + ZVAL_DEREF(function_name); if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { - function_name_strval = Z_STRVAL_P(function_name); - function_name_strlen = Z_STRLEN_P(function_name); - if (function_name_strval[0] == '\\') { - function_name_strlen -= 1; - lcname = zend_str_tolower_dup(function_name_strval + 1, function_name_strlen); + if (Z_STRVAL_P(function_name)[0] == '\\') { + lcname = STR_ALLOC(Z_STRLEN_P(function_name) - 1, 0); + zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name) + 1, Z_STRLEN_P(function_name) - 1); } else { - lcname = zend_str_tolower_dup(function_name_strval, function_name_strlen); + lcname = STR_ALLOC(Z_STRLEN_P(function_name), 0); + zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name), Z_STRLEN_P(function_name)); } - if (UNEXPECTED(zend_hash_find(EG(function_table), lcname, function_name_strlen+1, (void **) &call->fbc) == FAILURE)) { - zend_error_noreturn(E_ERROR, "Call to undefined function %s()", function_name_strval); + if (UNEXPECTED((func = zend_hash_find(EG(function_table), lcname)) == NULL)) { + zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(function_name)); } - efree(lcname); + STR_FREE(lcname); zval_dtor(free_op2.var); + call->fbc = Z_FUNC_P(func); call->object = NULL; call->called_scope = NULL; call->num_additional_args = 0; @@ -1819,12 +1828,12 @@ static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER(ZEND_OPCODE_H Z_OBJ_HANDLER_P(function_name, get_closure) && Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &call->called_scope, &call->fbc, &call->object TSRMLS_CC) == SUCCESS) { if (call->object) { - Z_ADDREF_P(call->object); + GC_REFCOUNT(call->object)++; } if (IS_TMP_VAR == IS_VAR && 1 && Z_REFCOUNT_P(function_name) == 1 && call->fbc->common.fn_flags & ZEND_ACC_CLOSURE) { /* Delay closure destruction until its invocation */ - call->fbc->common.prototype = (zend_function*)function_name; + call->fbc->common.prototype = (zend_function*)function_name_ptr; } else { zval_dtor(free_op2.var); } @@ -1838,67 +1847,56 @@ static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER(ZEND_OPCODE_H } else if (IS_TMP_VAR != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) && zend_hash_num_elements(Z_ARRVAL_P(function_name)) == 2) { - zend_class_entry *ce; - zval **method = NULL; - zval **obj = NULL; + zval *obj; + zval *method; - zend_hash_index_find(Z_ARRVAL_P(function_name), 0, (void **) &obj); - zend_hash_index_find(Z_ARRVAL_P(function_name), 1, (void **) &method); + obj = zend_hash_index_find(Z_ARRVAL_P(function_name), 0); + method = zend_hash_index_find(Z_ARRVAL_P(function_name), 1); if (!obj || !method) { zend_error_noreturn(E_ERROR, "Array callback has to contain indices 0 and 1"); } - if (Z_TYPE_PP(obj) != IS_STRING && Z_TYPE_PP(obj) != IS_OBJECT) { + if (Z_TYPE_P(obj) != IS_STRING && Z_TYPE_P(obj) != IS_OBJECT) { zend_error_noreturn(E_ERROR, "First array member is not a valid class name or object"); } - if (Z_TYPE_PP(method) != IS_STRING) { + if (Z_TYPE_P(method) != IS_STRING) { zend_error_noreturn(E_ERROR, "Second array member is not a valid method"); } - if (Z_TYPE_PP(obj) == IS_STRING) { - ce = zend_fetch_class_by_name(Z_STRVAL_PP(obj), Z_STRLEN_PP(obj), NULL, 0 TSRMLS_CC); - if (UNEXPECTED(ce == NULL)) { + if (Z_TYPE_P(obj) == IS_STRING) { + call->object = NULL; + call->called_scope = zend_fetch_class_by_name(Z_STR_P(obj), NULL, 0 TSRMLS_CC); + if (UNEXPECTED(call->called_scope == NULL)) { CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - call->called_scope = ce; - call->object = NULL; - if (ce->get_static_method) { - call->fbc = ce->get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method) TSRMLS_CC); + if (call->called_scope->get_static_method) { + call->fbc = call->called_scope->get_static_method(call->called_scope, Z_STR_P(method) TSRMLS_CC); } else { - call->fbc = zend_std_get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC); + call->fbc = zend_std_get_static_method(call->called_scope, Z_STR_P(method), NULL TSRMLS_CC); + } + if (UNEXPECTED(call->fbc == NULL)) { + zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", call->called_scope->name->val, Z_STRVAL_P(method)); } } else { - call->object = *obj; - ce = call->called_scope = Z_OBJCE_PP(obj); + call->called_scope = Z_OBJCE_P(obj); + call->object = Z_OBJ_P(obj); - call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC); + call->fbc = Z_OBJ_HT_P(obj)->get_method(&call->object, Z_STR_P(method), NULL TSRMLS_CC); if (UNEXPECTED(call->fbc == NULL)) { - zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_PP(method)); + zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(method)); } if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) { call->object = NULL; } else { - if (!PZVAL_IS_REF(call->object)) { - Z_ADDREF_P(call->object); /* For $this pointer */ - } else { - zval *this_ptr; - ALLOC_ZVAL(this_ptr); - INIT_PZVAL_COPY(this_ptr, call->object); - zval_copy_ctor(this_ptr); - call->object = this_ptr; - } + GC_REFCOUNT(call->object)++; /* For $this pointer */ } } - if (UNEXPECTED(call->fbc == NULL)) { - zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, Z_STRVAL_PP(method)); - } - call->num_additional_args = 0; call->is_ctor_call = 0; EX(call) = call; @@ -1926,24 +1924,24 @@ static int ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ zend_exception_save(TSRMLS_C); } if (IS_VAR == IS_UNUSED) { - EX_T(opline->result.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC); + Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->extended_value TSRMLS_CC); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } else { zend_free_op free_op2; - zval *class_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + zval *class_name = _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); if (IS_VAR == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - EX_T(opline->result.var).class_entry = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(class_name))) { + Z_CE_P(EX_VAR(opline->result.var)) = CACHED_PTR(Z_CACHE_SLOT_P(class_name)); } else { - EX_T(opline->result.var).class_entry = zend_fetch_class_by_name(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->op2.literal + 1, opline->extended_value TSRMLS_CC); - CACHE_PTR(opline->op2.literal->cache_slot, EX_T(opline->result.var).class_entry); + Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class_by_name(Z_STR_P(class_name), opline->op2.zv + 1, opline->extended_value TSRMLS_CC); + CACHE_PTR(Z_CACHE_SLOT_P(class_name), Z_CE_P(EX_VAR(opline->result.var))); } } else if (Z_TYPE_P(class_name) == IS_OBJECT) { - EX_T(opline->result.var).class_entry = Z_OBJCE_P(class_name); + Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name); } else if (Z_TYPE_P(class_name) == IS_STRING) { - EX_T(opline->result.var).class_entry = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->extended_value TSRMLS_CC); + Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->extended_value TSRMLS_CC); } else { if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); @@ -1951,7 +1949,7 @@ static int ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ zend_error_noreturn(E_ERROR, "Class name must be a valid object or a string"); } - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -1960,18 +1958,19 @@ static int ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *function_name; + zval *function_name_ptr, *function_name, *func; call_slot *call = EX(call_slots) + opline->result.num; if (IS_VAR == IS_CONST) { - function_name = (zval*)(opline->op2.literal+1); - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - call->fbc = CACHED_PTR(opline->op2.literal->cache_slot); - } else if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL_P(function_name), Z_STRLEN_P(function_name)+1, Z_HASH_P(function_name), (void **) &call->fbc) == FAILURE)) { + function_name_ptr = function_name = (zval*)(opline->op2.zv+1); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + } else if (UNEXPECTED((func = zend_hash_find(EG(function_table), Z_STR_P(function_name))) == NULL)) { SAVE_OPLINE(); zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv)); } else { - CACHE_PTR(opline->op2.literal->cache_slot, call->fbc); + call->fbc = Z_FUNC_P(func); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->fbc); } call->object = NULL; @@ -1983,28 +1982,28 @@ static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER(ZEND_OPCODE_H /*CHECK_EXCEPTION();*/ ZEND_VM_NEXT_OPCODE(); } else { - char *function_name_strval, *lcname; - int function_name_strlen; + zend_string *lcname; zend_free_op free_op2; SAVE_OPLINE(); - function_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + function_name_ptr = function_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + ZVAL_DEREF(function_name); if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { - function_name_strval = Z_STRVAL_P(function_name); - function_name_strlen = Z_STRLEN_P(function_name); - if (function_name_strval[0] == '\\') { - function_name_strlen -= 1; - lcname = zend_str_tolower_dup(function_name_strval + 1, function_name_strlen); + if (Z_STRVAL_P(function_name)[0] == '\\') { + lcname = STR_ALLOC(Z_STRLEN_P(function_name) - 1, 0); + zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name) + 1, Z_STRLEN_P(function_name) - 1); } else { - lcname = zend_str_tolower_dup(function_name_strval, function_name_strlen); + lcname = STR_ALLOC(Z_STRLEN_P(function_name), 0); + zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name), Z_STRLEN_P(function_name)); } - if (UNEXPECTED(zend_hash_find(EG(function_table), lcname, function_name_strlen+1, (void **) &call->fbc) == FAILURE)) { - zend_error_noreturn(E_ERROR, "Call to undefined function %s()", function_name_strval); + if (UNEXPECTED((func = zend_hash_find(EG(function_table), lcname)) == NULL)) { + zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(function_name)); } - efree(lcname); - zval_ptr_dtor_nogc(&free_op2.var); + STR_FREE(lcname); + zval_ptr_dtor_nogc(free_op2.var); + call->fbc = Z_FUNC_P(func); call->object = NULL; call->called_scope = NULL; call->num_additional_args = 0; @@ -2018,14 +2017,14 @@ static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER(ZEND_OPCODE_H Z_OBJ_HANDLER_P(function_name, get_closure) && Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &call->called_scope, &call->fbc, &call->object TSRMLS_CC) == SUCCESS) { if (call->object) { - Z_ADDREF_P(call->object); + GC_REFCOUNT(call->object)++; } if (IS_VAR == IS_VAR && (free_op2.var != NULL) && Z_REFCOUNT_P(function_name) == 1 && call->fbc->common.fn_flags & ZEND_ACC_CLOSURE) { /* Delay closure destruction until its invocation */ - call->fbc->common.prototype = (zend_function*)function_name; + call->fbc->common.prototype = (zend_function*)function_name_ptr; } else { - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); } call->num_additional_args = 0; @@ -2037,72 +2036,61 @@ static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER(ZEND_OPCODE_H } else if (IS_VAR != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) && zend_hash_num_elements(Z_ARRVAL_P(function_name)) == 2) { - zend_class_entry *ce; - zval **method = NULL; - zval **obj = NULL; + zval *obj; + zval *method; - zend_hash_index_find(Z_ARRVAL_P(function_name), 0, (void **) &obj); - zend_hash_index_find(Z_ARRVAL_P(function_name), 1, (void **) &method); + obj = zend_hash_index_find(Z_ARRVAL_P(function_name), 0); + method = zend_hash_index_find(Z_ARRVAL_P(function_name), 1); if (!obj || !method) { zend_error_noreturn(E_ERROR, "Array callback has to contain indices 0 and 1"); } - if (Z_TYPE_PP(obj) != IS_STRING && Z_TYPE_PP(obj) != IS_OBJECT) { + if (Z_TYPE_P(obj) != IS_STRING && Z_TYPE_P(obj) != IS_OBJECT) { zend_error_noreturn(E_ERROR, "First array member is not a valid class name or object"); } - if (Z_TYPE_PP(method) != IS_STRING) { + if (Z_TYPE_P(method) != IS_STRING) { zend_error_noreturn(E_ERROR, "Second array member is not a valid method"); } - if (Z_TYPE_PP(obj) == IS_STRING) { - ce = zend_fetch_class_by_name(Z_STRVAL_PP(obj), Z_STRLEN_PP(obj), NULL, 0 TSRMLS_CC); - if (UNEXPECTED(ce == NULL)) { + if (Z_TYPE_P(obj) == IS_STRING) { + call->object = NULL; + call->called_scope = zend_fetch_class_by_name(Z_STR_P(obj), NULL, 0 TSRMLS_CC); + if (UNEXPECTED(call->called_scope == NULL)) { CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - call->called_scope = ce; - call->object = NULL; - if (ce->get_static_method) { - call->fbc = ce->get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method) TSRMLS_CC); + if (call->called_scope->get_static_method) { + call->fbc = call->called_scope->get_static_method(call->called_scope, Z_STR_P(method) TSRMLS_CC); } else { - call->fbc = zend_std_get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC); + call->fbc = zend_std_get_static_method(call->called_scope, Z_STR_P(method), NULL TSRMLS_CC); + } + if (UNEXPECTED(call->fbc == NULL)) { + zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", call->called_scope->name->val, Z_STRVAL_P(method)); } } else { - call->object = *obj; - ce = call->called_scope = Z_OBJCE_PP(obj); + call->called_scope = Z_OBJCE_P(obj); + call->object = Z_OBJ_P(obj); - call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC); + call->fbc = Z_OBJ_HT_P(obj)->get_method(&call->object, Z_STR_P(method), NULL TSRMLS_CC); if (UNEXPECTED(call->fbc == NULL)) { - zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_PP(method)); + zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(method)); } if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) { call->object = NULL; } else { - if (!PZVAL_IS_REF(call->object)) { - Z_ADDREF_P(call->object); /* For $this pointer */ - } else { - zval *this_ptr; - ALLOC_ZVAL(this_ptr); - INIT_PZVAL_COPY(this_ptr, call->object); - zval_copy_ctor(this_ptr); - call->object = this_ptr; - } + GC_REFCOUNT(call->object)++; /* For $this pointer */ } } - if (UNEXPECTED(call->fbc == NULL)) { - zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, Z_STRVAL_PP(method)); - } - call->num_additional_args = 0; call->is_ctor_call = 0; EX(call) = call; - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } else { @@ -2125,7 +2113,7 @@ static int ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDL zend_exception_save(TSRMLS_C); } if (IS_UNUSED == IS_UNUSED) { - EX_T(opline->result.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC); + Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->extended_value TSRMLS_CC); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } else { @@ -2133,16 +2121,16 @@ static int ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDL zval *class_name = NULL; if (IS_UNUSED == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - EX_T(opline->result.var).class_entry = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(class_name))) { + Z_CE_P(EX_VAR(opline->result.var)) = CACHED_PTR(Z_CACHE_SLOT_P(class_name)); } else { - EX_T(opline->result.var).class_entry = zend_fetch_class_by_name(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->op2.literal + 1, opline->extended_value TSRMLS_CC); - CACHE_PTR(opline->op2.literal->cache_slot, EX_T(opline->result.var).class_entry); + Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class_by_name(Z_STR_P(class_name), opline->op2.zv + 1, opline->extended_value TSRMLS_CC); + CACHE_PTR(Z_CACHE_SLOT_P(class_name), Z_CE_P(EX_VAR(opline->result.var))); } } else if (Z_TYPE_P(class_name) == IS_OBJECT) { - EX_T(opline->result.var).class_entry = Z_OBJCE_P(class_name); + Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name); } else if (Z_TYPE_P(class_name) == IS_STRING) { - EX_T(opline->result.var).class_entry = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->extended_value TSRMLS_CC); + Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->extended_value TSRMLS_CC); } else { if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); @@ -2164,24 +2152,24 @@ static int ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_A zend_exception_save(TSRMLS_C); } if (IS_CV == IS_UNUSED) { - EX_T(opline->result.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC); + Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->extended_value TSRMLS_CC); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } else { - zval *class_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); + zval *class_name = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); if (IS_CV == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - EX_T(opline->result.var).class_entry = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(class_name))) { + Z_CE_P(EX_VAR(opline->result.var)) = CACHED_PTR(Z_CACHE_SLOT_P(class_name)); } else { - EX_T(opline->result.var).class_entry = zend_fetch_class_by_name(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->op2.literal + 1, opline->extended_value TSRMLS_CC); - CACHE_PTR(opline->op2.literal->cache_slot, EX_T(opline->result.var).class_entry); + Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class_by_name(Z_STR_P(class_name), opline->op2.zv + 1, opline->extended_value TSRMLS_CC); + CACHE_PTR(Z_CACHE_SLOT_P(class_name), Z_CE_P(EX_VAR(opline->result.var))); } } else if (Z_TYPE_P(class_name) == IS_OBJECT) { - EX_T(opline->result.var).class_entry = Z_OBJCE_P(class_name); + Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name); } else if (Z_TYPE_P(class_name) == IS_STRING) { - EX_T(opline->result.var).class_entry = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->extended_value TSRMLS_CC); + Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->extended_value TSRMLS_CC); } else { if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); @@ -2197,18 +2185,19 @@ static int ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_A static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *function_name; + zval *function_name_ptr, *function_name, *func; call_slot *call = EX(call_slots) + opline->result.num; if (IS_CV == IS_CONST) { - function_name = (zval*)(opline->op2.literal+1); - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - call->fbc = CACHED_PTR(opline->op2.literal->cache_slot); - } else if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL_P(function_name), Z_STRLEN_P(function_name)+1, Z_HASH_P(function_name), (void **) &call->fbc) == FAILURE)) { + function_name_ptr = function_name = (zval*)(opline->op2.zv+1); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + } else if (UNEXPECTED((func = zend_hash_find(EG(function_table), Z_STR_P(function_name))) == NULL)) { SAVE_OPLINE(); zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv)); } else { - CACHE_PTR(opline->op2.literal->cache_slot, call->fbc); + call->fbc = Z_FUNC_P(func); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->fbc); } call->object = NULL; @@ -2220,27 +2209,27 @@ static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HA /*CHECK_EXCEPTION();*/ ZEND_VM_NEXT_OPCODE(); } else { - char *function_name_strval, *lcname; - int function_name_strlen; + zend_string *lcname; SAVE_OPLINE(); - function_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); + function_name_ptr = function_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); + ZVAL_DEREF(function_name); if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { - function_name_strval = Z_STRVAL_P(function_name); - function_name_strlen = Z_STRLEN_P(function_name); - if (function_name_strval[0] == '\\') { - function_name_strlen -= 1; - lcname = zend_str_tolower_dup(function_name_strval + 1, function_name_strlen); + if (Z_STRVAL_P(function_name)[0] == '\\') { + lcname = STR_ALLOC(Z_STRLEN_P(function_name) - 1, 0); + zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name) + 1, Z_STRLEN_P(function_name) - 1); } else { - lcname = zend_str_tolower_dup(function_name_strval, function_name_strlen); + lcname = STR_ALLOC(Z_STRLEN_P(function_name), 0); + zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name), Z_STRLEN_P(function_name)); } - if (UNEXPECTED(zend_hash_find(EG(function_table), lcname, function_name_strlen+1, (void **) &call->fbc) == FAILURE)) { - zend_error_noreturn(E_ERROR, "Call to undefined function %s()", function_name_strval); + if (UNEXPECTED((func = zend_hash_find(EG(function_table), lcname)) == NULL)) { + zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(function_name)); } - efree(lcname); + STR_FREE(lcname); + call->fbc = Z_FUNC_P(func); call->object = NULL; call->called_scope = NULL; call->num_additional_args = 0; @@ -2254,12 +2243,12 @@ static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HA Z_OBJ_HANDLER_P(function_name, get_closure) && Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &call->called_scope, &call->fbc, &call->object TSRMLS_CC) == SUCCESS) { if (call->object) { - Z_ADDREF_P(call->object); + GC_REFCOUNT(call->object)++; } if (IS_CV == IS_VAR && 0 && Z_REFCOUNT_P(function_name) == 1 && call->fbc->common.fn_flags & ZEND_ACC_CLOSURE) { /* Delay closure destruction until its invocation */ - call->fbc->common.prototype = (zend_function*)function_name; + call->fbc->common.prototype = (zend_function*)function_name_ptr; } else { } @@ -2273,67 +2262,56 @@ static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HA } else if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) && zend_hash_num_elements(Z_ARRVAL_P(function_name)) == 2) { - zend_class_entry *ce; - zval **method = NULL; - zval **obj = NULL; + zval *obj; + zval *method; - zend_hash_index_find(Z_ARRVAL_P(function_name), 0, (void **) &obj); - zend_hash_index_find(Z_ARRVAL_P(function_name), 1, (void **) &method); + obj = zend_hash_index_find(Z_ARRVAL_P(function_name), 0); + method = zend_hash_index_find(Z_ARRVAL_P(function_name), 1); if (!obj || !method) { zend_error_noreturn(E_ERROR, "Array callback has to contain indices 0 and 1"); } - if (Z_TYPE_PP(obj) != IS_STRING && Z_TYPE_PP(obj) != IS_OBJECT) { + if (Z_TYPE_P(obj) != IS_STRING && Z_TYPE_P(obj) != IS_OBJECT) { zend_error_noreturn(E_ERROR, "First array member is not a valid class name or object"); } - if (Z_TYPE_PP(method) != IS_STRING) { + if (Z_TYPE_P(method) != IS_STRING) { zend_error_noreturn(E_ERROR, "Second array member is not a valid method"); } - if (Z_TYPE_PP(obj) == IS_STRING) { - ce = zend_fetch_class_by_name(Z_STRVAL_PP(obj), Z_STRLEN_PP(obj), NULL, 0 TSRMLS_CC); - if (UNEXPECTED(ce == NULL)) { + if (Z_TYPE_P(obj) == IS_STRING) { + call->object = NULL; + call->called_scope = zend_fetch_class_by_name(Z_STR_P(obj), NULL, 0 TSRMLS_CC); + if (UNEXPECTED(call->called_scope == NULL)) { CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - call->called_scope = ce; - call->object = NULL; - if (ce->get_static_method) { - call->fbc = ce->get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method) TSRMLS_CC); + if (call->called_scope->get_static_method) { + call->fbc = call->called_scope->get_static_method(call->called_scope, Z_STR_P(method) TSRMLS_CC); } else { - call->fbc = zend_std_get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC); + call->fbc = zend_std_get_static_method(call->called_scope, Z_STR_P(method), NULL TSRMLS_CC); + } + if (UNEXPECTED(call->fbc == NULL)) { + zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", call->called_scope->name->val, Z_STRVAL_P(method)); } } else { - call->object = *obj; - ce = call->called_scope = Z_OBJCE_PP(obj); + call->called_scope = Z_OBJCE_P(obj); + call->object = Z_OBJ_P(obj); - call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC); + call->fbc = Z_OBJ_HT_P(obj)->get_method(&call->object, Z_STR_P(method), NULL TSRMLS_CC); if (UNEXPECTED(call->fbc == NULL)) { - zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_PP(method)); + zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(method)); } if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) { call->object = NULL; } else { - if (!PZVAL_IS_REF(call->object)) { - Z_ADDREF_P(call->object); /* For $this pointer */ - } else { - zval *this_ptr; - ALLOC_ZVAL(this_ptr); - INIT_PZVAL_COPY(this_ptr, call->object); - zval_copy_ctor(this_ptr); - call->object = this_ptr; - } + GC_REFCOUNT(call->object)++; /* For $this pointer */ } } - if (UNEXPECTED(call->fbc == NULL)) { - zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, Z_STRVAL_PP(method)); - } - call->num_additional_args = 0; call->is_ctor_call = 0; EX(call) = call; @@ -2357,7 +2335,7 @@ static int ZEND_FASTCALL ZEND_BW_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG SAVE_OPLINE(); - bitwise_not_function(&EX_T(opline->result.var).tmp_var, + bitwise_not_function(EX_VAR(opline->result.var), opline->op1.zv TSRMLS_CC); CHECK_EXCEPTION(); @@ -2370,7 +2348,7 @@ static int ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A SAVE_OPLINE(); - boolean_not_function(&EX_T(opline->result.var).tmp_var, + boolean_not_function(EX_VAR(opline->result.var), opline->op1.zv TSRMLS_CC); CHECK_EXCEPTION(); @@ -2386,10 +2364,7 @@ static int ZEND_FASTCALL ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) SAVE_OPLINE(); z = opline->op1.zv; - if (IS_CONST == IS_TMP_VAR && Z_TYPE_P(z) == IS_OBJECT) { - INIT_PZVAL(z); - } - zend_print_variable(z); + zend_print_variable(z TSRMLS_CC); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -2399,7 +2374,7 @@ static int ZEND_FASTCALL ZEND_PRINT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS { USE_OPLINE - ZVAL_LONG(&EX_T(opline->result.var).tmp_var, 1); + ZVAL_LONG(EX_VAR(opline->result.var), 1); return ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } @@ -2408,29 +2383,30 @@ static int ZEND_FASTCALL ZEND_JMPZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) USE_OPLINE zval *val; - int ret; SAVE_OPLINE(); val = opline->op1.zv; - if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { - ret = Z_LVAL_P(val); - } else { - ret = i_zend_is_true(val TSRMLS_CC); - - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); + if (IS_CONST == IS_TMP_VAR) { + if (Z_TYPE_P(val) == IS_TRUE) { + ZEND_VM_SET_OPCODE(opline + 1); + ZEND_VM_CONTINUE(); + } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { + ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); + ZEND_VM_CONTINUE(); } } - if (!ret) { -#if DEBUG_ZEND>=2 - printf("Conditional jmp to %d\n", opline->op2.opline_num); -#endif - ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); - ZEND_VM_CONTINUE(); + + if (i_zend_is_true(val TSRMLS_CC)) { + opline++; + } else { + opline = opline->op2.jmp_addr; } - ZEND_VM_NEXT_OPCODE(); + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } + ZEND_VM_JMP(opline); } static int ZEND_FASTCALL ZEND_JMPNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -2438,29 +2414,30 @@ static int ZEND_FASTCALL ZEND_JMPNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS USE_OPLINE zval *val; - int ret; SAVE_OPLINE(); val = opline->op1.zv; - if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { - ret = Z_LVAL_P(val); - } else { - ret = i_zend_is_true(val TSRMLS_CC); - - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); + if (IS_CONST == IS_TMP_VAR) { + if (Z_TYPE_P(val) == IS_TRUE) { + ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); + ZEND_VM_CONTINUE(); + } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { + ZEND_VM_SET_OPCODE(opline + 1); + ZEND_VM_CONTINUE(); } } - if (ret) { -#if DEBUG_ZEND>=2 - printf("Conditional jmp to %d\n", opline->op2.opline_num); -#endif - ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); - ZEND_VM_CONTINUE(); + + if (i_zend_is_true(val TSRMLS_CC)) { + opline = opline->op2.jmp_addr; + } else { + opline++; } - ZEND_VM_NEXT_OPCODE(); + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } + ZEND_VM_JMP(opline); } static int ZEND_FASTCALL ZEND_JMPZNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -2468,33 +2445,30 @@ static int ZEND_FASTCALL ZEND_JMPZNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG USE_OPLINE zval *val; - int retval; SAVE_OPLINE(); val = opline->op1.zv; - if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { - retval = Z_LVAL_P(val); - } else { - retval = i_zend_is_true(val TSRMLS_CC); - - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); + if (IS_CONST == IS_TMP_VAR) { + if (EXPECTED(Z_TYPE_P(val) == IS_TRUE)) { + ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value); + ZEND_VM_CONTINUE(); + } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { + ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); + ZEND_VM_CONTINUE(); } } - if (EXPECTED(retval != 0)) { -#if DEBUG_ZEND>=2 - printf("Conditional jmp on true to %d\n", opline->extended_value); -#endif - ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]); - ZEND_VM_CONTINUE(); /* CHECK_ME */ + + if (i_zend_is_true(val TSRMLS_CC)) { + opline = (zend_op*)(((char*)opline) + opline->extended_value); } else { -#if DEBUG_ZEND>=2 - printf("Conditional jmp on false to %d\n", opline->op2.opline_num); -#endif - ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->op2.opline_num]); - ZEND_VM_CONTINUE(); /* CHECK_ME */ + opline = opline->op2.jmp_addr; + } + + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); } + ZEND_VM_JMP(opline); } static int ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -2502,30 +2476,34 @@ static int ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR USE_OPLINE zval *val; - int retval; SAVE_OPLINE(); val = opline->op1.zv; - if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { - retval = Z_LVAL_P(val); - } else { - retval = i_zend_is_true(val TSRMLS_CC); - - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); + if (IS_CONST == IS_TMP_VAR) { + if (Z_TYPE_P(val) == IS_TRUE) { + ZVAL_TRUE(EX_VAR(opline->result.var)); + ZEND_VM_SET_OPCODE(opline + 1); + ZEND_VM_CONTINUE(); + } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { + ZVAL_FALSE(EX_VAR(opline->result.var)); + ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); + ZEND_VM_CONTINUE(); } } - Z_LVAL(EX_T(opline->result.var).tmp_var) = retval; - Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; - if (!retval) { -#if DEBUG_ZEND>=2 - printf("Conditional jmp to %d\n", opline->op2.opline_num); -#endif - ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); - ZEND_VM_CONTINUE(); + + if (i_zend_is_true(val TSRMLS_CC)) { + ZVAL_TRUE(EX_VAR(opline->result.var)); + opline++; + } else { + ZVAL_FALSE(EX_VAR(opline->result.var)); + opline = opline->op2.jmp_addr; } - ZEND_VM_NEXT_OPCODE(); + + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } + ZEND_VM_JMP(opline); } static int ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -2533,30 +2511,33 @@ static int ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A USE_OPLINE zval *val; - int retval; SAVE_OPLINE(); val = opline->op1.zv; - if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { - retval = Z_LVAL_P(val); - } else { - retval = i_zend_is_true(val TSRMLS_CC); - - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); + if (IS_CONST == IS_TMP_VAR) { + if (Z_TYPE_P(val) == IS_TRUE) { + ZVAL_TRUE(EX_VAR(opline->result.var)); + ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); + ZEND_VM_CONTINUE(); + } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { + ZVAL_FALSE(EX_VAR(opline->result.var)); + ZEND_VM_SET_OPCODE(opline + 1); + ZEND_VM_CONTINUE(); } } - Z_LVAL(EX_T(opline->result.var).tmp_var) = retval; - Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; - if (retval) { -#if DEBUG_ZEND>=2 - printf("Conditional jmp to %d\n", opline->op2.opline_num); -#endif - ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); - ZEND_VM_CONTINUE(); + if (i_zend_is_true(val TSRMLS_CC)) { + ZVAL_TRUE(EX_VAR(opline->result.var)); + opline = opline->op2.jmp_addr; + } else { + ZVAL_FALSE(EX_VAR(opline->result.var)); + opline++; } - ZEND_VM_NEXT_OPCODE(); + + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } + ZEND_VM_JMP(opline); } static int ZEND_FASTCALL ZEND_DO_FCALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -2564,15 +2545,17 @@ static int ZEND_FASTCALL ZEND_DO_FCALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A USE_OPLINE zval *fname = opline->op1.zv; + zval *func; call_slot *call = EX(call_slots) + opline->op2.num; - if (CACHED_PTR(opline->op1.literal->cache_slot)) { - EX(function_state).function = CACHED_PTR(opline->op1.literal->cache_slot); - } else if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL_P(fname), Z_STRLEN_P(fname)+1, Z_HASH_P(fname), (void **) &EX(function_state).function)==FAILURE)) { + if (CACHED_PTR(Z_CACHE_SLOT_P(fname))) { + EX(function_state).function = CACHED_PTR(Z_CACHE_SLOT_P(fname)); + } else if (UNEXPECTED((func = zend_hash_find(EG(function_table), Z_STR_P(fname))) == NULL)) { SAVE_OPLINE(); - zend_error_noreturn(E_ERROR, "Call to undefined function %s()", fname->value.str.val); + zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(fname)); } else { - CACHE_PTR(opline->op1.literal->cache_slot, EX(function_state).function); + EX(function_state).function = Z_FUNC_P(func); + CACHE_PTR(Z_CACHE_SLOT_P(fname), EX(function_state).function); } call->fbc = EX(function_state).function; @@ -2594,34 +2577,21 @@ static int ZEND_FASTCALL ZEND_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG SAVE_OPLINE(); retval_ptr = opline->op1.zv; - if (!EG(return_value_ptr_ptr)) { + if (!EX(return_value)) { } else { - if (IS_CONST == IS_CONST || - IS_CONST == IS_TMP_VAR || - PZVAL_IS_REF(retval_ptr)) { - zval *ret; - - ALLOC_ZVAL(ret); - INIT_PZVAL_COPY(ret, retval_ptr); + if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) { + ZVAL_COPY_VALUE(EX(return_value), retval_ptr); if (IS_CONST != IS_TMP_VAR) { - zval_copy_ctor(ret); + zval_opt_copy_ctor(EX(return_value)); } - *EG(return_value_ptr_ptr) = ret; + } else if (Z_ISREF_P(retval_ptr)) { + ZVAL_DUP(EX(return_value), Z_REFVAL_P(retval_ptr)); - } else if ((IS_CONST == IS_CV || IS_CONST == IS_VAR) && - retval_ptr == &EG(uninitialized_zval)) { - zval *ret; - - if (IS_CONST == IS_VAR) { - Z_DELREF_P(retval_ptr); - } - ALLOC_INIT_ZVAL(ret); - *EG(return_value_ptr_ptr) = ret; } else { - *EG(return_value_ptr_ptr) = retval_ptr; + ZVAL_COPY_VALUE(EX(return_value), retval_ptr); if (IS_CONST == IS_CV) { - Z_ADDREF_P(retval_ptr); + if (Z_OPT_REFCOUNTED_P(retval_ptr)) Z_ADDREF_P(retval_ptr); } } } @@ -2632,7 +2602,6 @@ static int ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER(ZEND_OPCODE_HAND { USE_OPLINE zval *retval_ptr; - zval **retval_ptr_ptr; SAVE_OPLINE(); @@ -2644,55 +2613,41 @@ static int ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER(ZEND_OPCODE_HAND zend_error(E_NOTICE, "Only variable references should be returned by reference"); retval_ptr = opline->op1.zv; - if (!EG(return_value_ptr_ptr)) { + if (!EX(return_value)) { if (IS_CONST == IS_TMP_VAR) { } } else if (!0) { /* Not a temp var */ - zval *ret; - - ALLOC_ZVAL(ret); - INIT_PZVAL_COPY(ret, retval_ptr); - zval_copy_ctor(ret); - *EG(return_value_ptr_ptr) = ret; + ZVAL_DUP(EX(return_value), retval_ptr); } else { - zval *ret; - - ALLOC_ZVAL(ret); - INIT_PZVAL_COPY(ret, retval_ptr); - *EG(return_value_ptr_ptr) = ret; + ZVAL_COPY_VALUE(EX(return_value), retval_ptr); } break; } - retval_ptr_ptr = NULL; + retval_ptr = NULL; - if (IS_CONST == IS_VAR && UNEXPECTED(retval_ptr_ptr == NULL)) { + if (IS_CONST == IS_VAR && UNEXPECTED(Z_TYPE_P(retval_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference"); } - if (IS_CONST == IS_VAR && !Z_ISREF_PP(retval_ptr_ptr)) { + if (IS_CONST == IS_VAR && !Z_ISREF_P(retval_ptr)) { if (opline->extended_value == ZEND_RETURNS_FUNCTION && - EX_T(opline->op1.var).var.fcall_returned_reference) { - } else if (EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) { + (Z_VAR_FLAGS_P(retval_ptr) & IS_VAR_RET_REF)) { + } else { zend_error(E_NOTICE, "Only variable references should be returned by reference"); - if (EG(return_value_ptr_ptr)) { - zval *ret; - - ALLOC_ZVAL(ret); - INIT_PZVAL_COPY(ret, *retval_ptr_ptr); - zval_copy_ctor(ret); - *EG(return_value_ptr_ptr) = ret; + if (EX(return_value)) { + zval tmp; + ZVAL_DUP(&tmp, retval_ptr); + ZVAL_NEW_REF(EX(return_value), &tmp); } break; } } - if (EG(return_value_ptr_ptr)) { - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr); - Z_ADDREF_PP(retval_ptr_ptr); - - *EG(return_value_ptr_ptr) = *retval_ptr_ptr; + if (EX(return_value)) { + SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); + ZVAL_COPY(EX(return_value), retval_ptr); } } while (0); @@ -2703,7 +2658,7 @@ static int ZEND_FASTCALL ZEND_THROW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS { USE_OPLINE zval *value; - zval *exception; + zval exception; SAVE_OPLINE(); @@ -2717,14 +2672,14 @@ static int ZEND_FASTCALL ZEND_THROW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS } zend_exception_save(TSRMLS_C); - /* Not sure if a complete copy is what we want here */ - ALLOC_ZVAL(exception); - INIT_PZVAL_COPY(exception, value); - if (!0) { - zval_copy_ctor(exception); + if (IS_CONST == IS_CONST) { + ZVAL_DUP(&exception, value); + value = &exception; + } else if (IS_CONST != IS_TMP_VAR) { + if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value); } - zend_throw_exception_object(exception TSRMLS_CC); + zend_throw_exception_object(value TSRMLS_CC); zend_exception_restore(TSRMLS_C); HANDLE_EXCEPTION(); @@ -2733,6 +2688,8 @@ static int ZEND_FASTCALL ZEND_THROW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS static int ZEND_FASTCALL ZEND_SEND_VAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE + zval *value, *top; + SAVE_OPLINE(); if (opline->extended_value == ZEND_DO_FCALL_BY_NAME) { @@ -2741,22 +2698,12 @@ static int ZEND_FASTCALL ZEND_SEND_VAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A } } - { - zval *valptr; - zval *value; - - - value = opline->op1.zv; - - ALLOC_ZVAL(valptr); - INIT_PZVAL_COPY(valptr, value); - if (!0) { - zval_copy_ctor(valptr); - } - zend_vm_stack_push(valptr TSRMLS_CC); - + value = opline->op1.zv; + top = zend_vm_stack_top_inc(TSRMLS_C); + ZVAL_COPY_VALUE(top, value); + if (IS_CONST == IS_CONST) { + zval_opt_copy_ctor(top); } - CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -2764,7 +2711,7 @@ static int ZEND_FASTCALL ZEND_BOOL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *retval = &EX_T(opline->result.var).tmp_var; + zval *retval = EX_VAR(opline->result.var); SAVE_OPLINE(); /* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */ @@ -2799,7 +2746,7 @@ static int ZEND_FASTCALL ZEND_CLONE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS clone_call = Z_OBJ_HT_P(obj)->clone_obj; if (UNEXPECTED(clone_call == NULL)) { if (ce) { - zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name); + zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name->val); } else { zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object"); } @@ -2810,29 +2757,21 @@ static int ZEND_FASTCALL ZEND_CLONE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS /* Ensure that if we're calling a private function, we're allowed to do so. */ if (UNEXPECTED(ce != EG(scope))) { - zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : ""); + zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name->val, EG(scope) ? EG(scope)->name->val : ""); } } else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) { /* Ensure that if we're calling a protected function, we're allowed to do so. */ if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), EG(scope)))) { - zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : ""); + zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name->val, EG(scope) ? EG(scope)->name->val : ""); } } } if (EXPECTED(EG(exception) == NULL)) { - zval *retval; - - ALLOC_ZVAL(retval); - Z_OBJVAL_P(retval) = clone_call(obj TSRMLS_CC); - Z_TYPE_P(retval) = IS_OBJECT; - Z_SET_REFCOUNT_P(retval, 1); - Z_SET_ISREF_P(retval); + ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(obj TSRMLS_CC)); if (!RETURN_VALUE_USED(opline) || UNEXPECTED(EG(exception) != NULL)) { - zval_ptr_dtor(&retval); - } else { - EX_T(opline->result.var).var.ptr = retval; + zval_ptr_dtor(EX_VAR(opline->result.var)); } } @@ -2845,54 +2784,71 @@ static int ZEND_FASTCALL ZEND_CAST_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) USE_OPLINE zval *expr; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); expr = opline->op1.zv; - if (opline->extended_value != IS_STRING) { - ZVAL_COPY_VALUE(result, expr); - if (!0) { - zendi_zval_copy_ctor(*result); - } - } switch (opline->extended_value) { case IS_NULL: - convert_to_null(result); + /* This code is taken from convert_to_null. However, it does not seems very useful, + * because a conversion to null always results in the same value. This could only + * be relevant if a cast_object handler for IS_NULL has some kind of side-effect. */ +#if 0 + if (IS_CONST == IS_VAR || IS_CONST == IS_CV) { + ZVAL_DEREF(expr); + } + if (Z_TYPE_P(expr) == IS_OBJECT && Z_OBJ_HT_P(expr)->cast_object) { + if (Z_OBJ_HT_P(expr)->cast_object(expr, result, IS_NULL TSRMLS_CC) == SUCCESS) { + break; + } + } +#endif + + ZVAL_NULL(result); break; - case IS_BOOL: - convert_to_boolean(result); + case _IS_BOOL: + ZVAL_BOOL(result, zend_is_true(expr TSRMLS_CC)); break; case IS_LONG: - convert_to_long(result); + ZVAL_LONG(result, zval_get_long(expr)); break; case IS_DOUBLE: - convert_to_double(result); + ZVAL_DOUBLE(result, zval_get_double(expr)); break; - case IS_STRING: { - zval var_copy; - int use_copy; + case IS_STRING: + ZVAL_STR(result, zval_get_string(expr)); + break; + default: + /* If value is already of correct type, return it directly */ + if (Z_TYPE_P(expr) == opline->extended_value) { + ZVAL_COPY_VALUE(result, expr); + if (IS_CONST == IS_CONST) { + zval_opt_copy_ctor(result); + } else if (IS_CONST == IS_CV) { + if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr); + } - zend_make_printable_zval(expr, &var_copy, &use_copy); - if (use_copy) { - ZVAL_COPY_VALUE(result, &var_copy); - if (0) { + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); + } - } + if (IS_CONST == IS_VAR || IS_CONST == IS_CV) { + ZVAL_DEREF(expr); + } + ZVAL_COPY_VALUE(result, expr); + if (!0) { + zval_opt_copy_ctor(result); + } + + if (opline->extended_value == IS_ARRAY) { + convert_to_array(result); } else { - ZVAL_COPY_VALUE(result, expr); - if (!0) { - zendi_zval_copy_ctor(*result); - } + convert_to_object(result); } - break; - } - case IS_ARRAY: - convert_to_array(result); - break; - case IS_OBJECT: - convert_to_object(result); - break; + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } CHECK_EXCEPTION(); @@ -2905,18 +2861,17 @@ static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HA zend_op_array *new_op_array=NULL; zval *inc_filename; - zval *tmp_inc_filename = NULL; + zval tmp_inc_filename; zend_bool failure_retval=0; SAVE_OPLINE(); inc_filename = opline->op1.zv; - if (inc_filename->type!=IS_STRING) { - MAKE_STD_ZVAL(tmp_inc_filename); - ZVAL_COPY_VALUE(tmp_inc_filename, inc_filename); - zval_copy_ctor(tmp_inc_filename); - convert_to_string(tmp_inc_filename); - inc_filename = tmp_inc_filename; + ZVAL_UNDEF(&tmp_inc_filename); + if (Z_TYPE_P(inc_filename) != IS_STRING) { + ZVAL_DUP(&tmp_inc_filename, inc_filename); + convert_to_string(&tmp_inc_filename); + inc_filename = &tmp_inc_filename; } if (opline->extended_value != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRLEN_P(inc_filename)) { @@ -2934,7 +2889,7 @@ static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HA resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename) TSRMLS_CC); if (resolved_path) { - failure_retval = zend_hash_exists(&EG(included_files), resolved_path, strlen(resolved_path)+1); + failure_retval = zend_hash_str_exists(&EG(included_files), resolved_path, strlen(resolved_path)); } else { resolved_path = Z_STRVAL_P(inc_filename); } @@ -2947,7 +2902,7 @@ static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HA file_handle.opened_path = estrdup(resolved_path); } - if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1)==SUCCESS) { + if (zend_hash_str_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path))) { new_op_array = zend_compile_file(&file_handle, (opline->extended_value==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) TSRMLS_CC); zend_destroy_file_handle(&file_handle TSRMLS_CC); } else { @@ -2980,40 +2935,37 @@ static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HA EMPTY_SWITCH_DEFAULT_CASE() } } - if (tmp_inc_filename) { + if (Z_TYPE(tmp_inc_filename) != IS_UNDEF) { zval_ptr_dtor(&tmp_inc_filename); } if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } else if (EXPECTED(new_op_array != NULL)) { - EX(original_return_value) = EG(return_value_ptr_ptr); + zval *return_value = NULL; + EG(active_op_array) = new_op_array; if (RETURN_VALUE_USED(opline)) { - EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; - EG(return_value_ptr_ptr) = EX_T(opline->result.var).var.ptr_ptr; - } else { - EG(return_value_ptr_ptr) = NULL; + return_value = EX_VAR(opline->result.var); } EX(function_state).function = (zend_function *) new_op_array; - EX(object) = NULL; if (!EG(active_symbol_table)) { zend_rebuild_symbol_table(TSRMLS_C); } if (EXPECTED(zend_execute_ex == execute_ex)) { + i_create_execute_data_from_op_array(new_op_array, return_value, VM_FRAME_NESTED_CODE TSRMLS_CC); ZEND_VM_ENTER(); } else { - zend_execute(new_op_array TSRMLS_CC); + zend_execute(new_op_array, return_value TSRMLS_CC); } EX(function_state).function = (zend_function *) EX(op_array); EG(opline_ptr) = &EX(opline); EG(active_op_array) = EX(op_array); - EG(return_value_ptr_ptr) = EX(original_return_value); destroy_op_array(new_op_array TSRMLS_CC); efree(new_op_array); if (UNEXPECTED(EG(exception) != NULL)) { @@ -3022,12 +2974,7 @@ static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HA } } else if (RETURN_VALUE_USED(opline)) { - zval *retval; - - ALLOC_ZVAL(retval); - ZVAL_BOOL(retval, failure_retval); - INIT_PZVAL(retval); - EX_T(opline->result.var).var.ptr = retval; + ZVAL_BOOL(EX_VAR(opline->result.var), failure_retval); } ZEND_VM_NEXT_OPCODE(); } @@ -3036,7 +2983,7 @@ static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A { USE_OPLINE - zval *array_ptr, **array_ptr_ptr; + zval *array_ptr, *array_ref, iterator; HashTable *fe_ht; zend_object_iterator *iter = NULL; zend_class_entry *ce = NULL; @@ -3046,71 +2993,79 @@ static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A if ((IS_CONST == IS_CV || IS_CONST == IS_VAR) && (opline->extended_value & ZEND_FE_RESET_VARIABLE)) { - array_ptr_ptr = NULL; - if (array_ptr_ptr == NULL || array_ptr_ptr == &EG(uninitialized_zval_ptr)) { - MAKE_STD_ZVAL(array_ptr); - ZVAL_NULL(array_ptr); - } else if (Z_TYPE_PP(array_ptr_ptr) == IS_OBJECT) { - if(Z_OBJ_HT_PP(array_ptr_ptr)->get_class_entry == NULL) { + array_ptr = array_ref = NULL; + ZVAL_DEREF(array_ptr); + if (Z_TYPE_P(array_ptr) == IS_ARRAY) { + if (!Z_ISREF_P(array_ref)) { + SEPARATE_ZVAL(array_ptr); + array_ref = array_ptr; + if (opline->extended_value & ZEND_FE_FETCH_BYREF) { + ZVAL_NEW_REF(array_ptr, array_ptr); + array_ref = array_ptr; + array_ptr = Z_REFVAL_P(array_ptr); + } + } + if (Z_REFCOUNTED_P(array_ref)) Z_ADDREF_P(array_ref); + } else if (Z_TYPE_P(array_ptr) == IS_OBJECT) { + if(Z_OBJ_HT_P(array_ptr)->get_class_entry == NULL) { zend_error(E_WARNING, "foreach() cannot iterate over objects without PHP class"); ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num); } - ce = Z_OBJCE_PP(array_ptr_ptr); + ce = Z_OBJCE_P(array_ptr); if (!ce || ce->get_iterator == NULL) { - SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr); - Z_ADDREF_PP(array_ptr_ptr); - } - array_ptr = *array_ptr_ptr; - } else { - if (Z_TYPE_PP(array_ptr_ptr) == IS_ARRAY) { - SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr); - if (opline->extended_value & ZEND_FE_FETCH_BYREF) { - Z_SET_ISREF_PP(array_ptr_ptr); + if (!Z_ISREF_P(array_ref)) { + SEPARATE_ZVAL(array_ptr); } + Z_ADDREF_P(array_ptr); } - array_ptr = *array_ptr_ptr; - Z_ADDREF_P(array_ptr); + array_ref = array_ptr; + } else { + if (Z_REFCOUNTED_P(array_ref)) Z_ADDREF_P(array_ref); } } else { - array_ptr = opline->op1.zv; + array_ptr = array_ref = opline->op1.zv; + ZVAL_DEREF(array_ptr); if (0) { /* IS_TMP_VAR */ - zval *tmp; + zval tmp; - ALLOC_ZVAL(tmp); - INIT_PZVAL_COPY(tmp, array_ptr); - array_ptr = tmp; + ZVAL_COPY_VALUE(&tmp, array_ptr); + array_ptr = &tmp; if (Z_TYPE_P(array_ptr) == IS_OBJECT) { ce = Z_OBJCE_P(array_ptr); if (ce && ce->get_iterator) { - Z_DELREF_P(array_ptr); + Z_DELREF_P(array_ref); } } } else if (Z_TYPE_P(array_ptr) == IS_OBJECT) { ce = Z_OBJCE_P(array_ptr); if (!ce || !ce->get_iterator) { if (IS_CONST == IS_CV) { - Z_ADDREF_P(array_ptr); + Z_ADDREF_P(array_ref); } } - } else if (IS_CONST == IS_CONST || - (IS_CONST == IS_CV && - !Z_ISREF_P(array_ptr) && - Z_REFCOUNT_P(array_ptr) > 1) || - (IS_CONST == IS_VAR && - !Z_ISREF_P(array_ptr) && - Z_REFCOUNT_P(array_ptr) > 2)) { - zval *tmp; + } else if (Z_REFCOUNTED_P(array_ref)) { + if (IS_CONST == IS_CONST || + (IS_CONST == IS_CV && + !Z_ISREF_P(array_ref) && + Z_REFCOUNT_P(array_ref) > 1) || + (IS_CONST == IS_VAR && + !Z_ISREF_P(array_ref) && + Z_REFCOUNT_P(array_ref) > 2)) { + zval tmp; - if (IS_CONST == IS_VAR) { - Z_DELREF_P(array_ptr); + if (IS_CONST == IS_VAR) { + Z_DELREF_P(array_ref); + } + ZVAL_DUP(&tmp, array_ref); + array_ptr = array_ref = &tmp; + } else if (IS_CONST == IS_CV) { + if (Z_ISREF_P(array_ref) && Z_REFCOUNT_P(array_ref) == 1) { + ZVAL_UNREF(array_ref); + array_ptr = array_ref; + } + Z_ADDREF_P(array_ref); } - ALLOC_ZVAL(tmp); - INIT_PZVAL_COPY(tmp, array_ptr); - zval_copy_ctor(tmp); - array_ptr = tmp; - } else if (IS_CONST == IS_CV) { - Z_ADDREF_P(array_ptr); } } @@ -3121,27 +3076,28 @@ static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A } if (iter && EXPECTED(EG(exception) == NULL)) { - array_ptr = zend_iterator_wrap(iter TSRMLS_CC); + ZVAL_OBJ(&iterator, &iter->std); + array_ptr = array_ref = &iterator; } else { if (IS_CONST == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) { } if (!EG(exception)) { - zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name); + zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name->val); } zend_throw_exception_internal(NULL TSRMLS_CC); HANDLE_EXCEPTION(); } } - EX_T(opline->result.var).fe.ptr = array_ptr; + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref); if (iter) { iter->index = 0; if (iter->funcs->rewind) { iter->funcs->rewind(iter TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { - zval_ptr_dtor(&array_ptr); + zval_ptr_dtor(array_ref); if (IS_CONST == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) { } @@ -3150,7 +3106,7 @@ static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A } is_empty = iter->funcs->valid(iter TSRMLS_CC) != SUCCESS; if (UNEXPECTED(EG(exception) != NULL)) { - zval_ptr_dtor(&array_ptr); + zval_ptr_dtor(array_ref); if (IS_CONST == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) { } @@ -3160,24 +3116,23 @@ static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A } else if ((fe_ht = HASH_OF(array_ptr)) != NULL) { zend_hash_internal_pointer_reset(fe_ht); if (ce) { - zend_object *zobj = zend_objects_get_address(array_ptr TSRMLS_CC); + zend_object *zobj = Z_OBJ_P(array_ptr); while (zend_hash_has_more_elements(fe_ht) == SUCCESS) { - char *str_key; - uint str_key_len; + zend_string *str_key; ulong int_key; zend_uchar key_type; - key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL); + key_type = zend_hash_get_current_key(fe_ht, &str_key, &int_key, 0); if (key_type != HASH_KEY_NON_EXISTENT && (key_type == HASH_KEY_IS_LONG || - zend_check_property_access(zobj, str_key, str_key_len-1 TSRMLS_CC) == SUCCESS)) { + zend_check_property_access(zobj, str_key TSRMLS_CC) == SUCCESS)) { break; } zend_hash_move_forward(fe_ht); } } is_empty = zend_hash_has_more_elements(fe_ht) != SUCCESS; - zend_hash_get_pointer(fe_ht, &EX_T(opline->result.var).fe.fe_pos); + zend_hash_get_pointer(fe_ht, (HashPointer*)EX_VAR((opline+2)->op1.var)); } else { zend_error(E_WARNING, "Invalid argument supplied for foreach()"); is_empty = 1; @@ -3207,7 +3162,7 @@ static int ZEND_FASTCALL ZEND_EXIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) if (Z_TYPE_P(ptr) == IS_LONG) { EG(exit_status) = Z_LVAL_P(ptr); } else { - zend_print_variable(ptr); + zend_print_variable(ptr TSRMLS_CC); } } @@ -3226,14 +3181,11 @@ static int ZEND_FASTCALL ZEND_JMP_SET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR value = opline->op1.zv; if (i_zend_is_true(value TSRMLS_CC)) { - ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value); + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value); if (!0) { - zendi_zval_copy_ctor(EX_T(opline->result.var).tmp_var); + zval_opt_copy_ctor(EX_VAR(opline->result.var)); } -#if DEBUG_ZEND>=2 - printf("Conditional jmp to %d\n", opline->op2.opline_num); -#endif ZEND_VM_JMP(opline->op2.jmp_addr); } @@ -3245,29 +3197,21 @@ static int ZEND_FASTCALL ZEND_JMP_SET_VAR_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLE { USE_OPLINE - zval *value, *ret; + zval *value; SAVE_OPLINE(); value = opline->op1.zv; if (i_zend_is_true(value TSRMLS_CC)) { if (IS_CONST == IS_VAR || IS_CONST == IS_CV) { - Z_ADDREF_P(value); - EX_T(opline->result.var).var.ptr = value; - EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; - } else { - ALLOC_ZVAL(ret); - INIT_PZVAL_COPY(ret, value); - EX_T(opline->result.var).var.ptr = ret; - EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; + ZVAL_COPY(EX_VAR(opline->result.var), value); + } else { + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value); if (!0) { - zval_copy_ctor(EX_T(opline->result.var).var.ptr); + zval_opt_copy_ctor(EX_VAR(opline->result.var)); } } -#if DEBUG_ZEND>=2 - printf("Conditional jmp to %d\n", opline->op2.opline_num); -#endif ZEND_VM_JMP(opline->op2.jmp_addr); } @@ -3284,9 +3228,9 @@ static int ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ SAVE_OPLINE(); value = opline->op1.zv; - ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value); + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value); if (!0) { - zval_copy_ctor(&EX_T(opline->result.var).tmp_var); + zval_opt_copy_ctor(EX_VAR(opline->result.var)); } CHECK_EXCEPTION(); @@ -3297,22 +3241,17 @@ static int ZEND_FASTCALL ZEND_QM_ASSIGN_VAR_SPEC_CONST_HANDLER(ZEND_OPCODE_HAND { USE_OPLINE - zval *value, *ret; + zval *value; SAVE_OPLINE(); value = opline->op1.zv; if (IS_CONST == IS_VAR || IS_CONST == IS_CV) { - Z_ADDREF_P(value); - EX_T(opline->result.var).var.ptr = value; - EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; - } else { - ALLOC_ZVAL(ret); - INIT_PZVAL_COPY(ret, value); - EX_T(opline->result.var).var.ptr = ret; - EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; + ZVAL_COPY(EX_VAR(opline->result.var), value); + } else { + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value); if (!0) { - zval_copy_ctor(EX_T(opline->result.var).var.ptr); + zval_opt_copy_ctor(EX_VAR(opline->result.var)); } } @@ -3326,7 +3265,7 @@ static int ZEND_FASTCALL ZEND_ADD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ SAVE_OPLINE(); - fast_add_function(&EX_T(opline->result.var).tmp_var, + fast_add_function(EX_VAR(opline->result.var), opline->op1.zv, opline->op2.zv TSRMLS_CC); @@ -3341,7 +3280,7 @@ static int ZEND_FASTCALL ZEND_SUB_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ SAVE_OPLINE(); - fast_sub_function(&EX_T(opline->result.var).tmp_var, + fast_sub_function(EX_VAR(opline->result.var), opline->op1.zv, opline->op2.zv TSRMLS_CC); @@ -3356,7 +3295,7 @@ static int ZEND_FASTCALL ZEND_MUL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ SAVE_OPLINE(); - fast_mul_function(&EX_T(opline->result.var).tmp_var, + fast_mul_function(EX_VAR(opline->result.var), opline->op1.zv, opline->op2.zv TSRMLS_CC); @@ -3371,7 +3310,7 @@ static int ZEND_FASTCALL ZEND_DIV_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ SAVE_OPLINE(); - fast_div_function(&EX_T(opline->result.var).tmp_var, + fast_div_function(EX_VAR(opline->result.var), opline->op1.zv, opline->op2.zv TSRMLS_CC); @@ -3386,7 +3325,7 @@ static int ZEND_FASTCALL ZEND_MOD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ SAVE_OPLINE(); - fast_mod_function(&EX_T(opline->result.var).tmp_var, + fast_mod_function(EX_VAR(opline->result.var), opline->op1.zv, opline->op2.zv TSRMLS_CC); @@ -3401,7 +3340,7 @@ static int ZEND_FASTCALL ZEND_SL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_A SAVE_OPLINE(); - shift_left_function(&EX_T(opline->result.var).tmp_var, + shift_left_function(EX_VAR(opline->result.var), opline->op1.zv, opline->op2.zv TSRMLS_CC); @@ -3416,7 +3355,7 @@ static int ZEND_FASTCALL ZEND_SR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_A SAVE_OPLINE(); - shift_right_function(&EX_T(opline->result.var).tmp_var, + shift_right_function(EX_VAR(opline->result.var), opline->op1.zv, opline->op2.zv TSRMLS_CC); @@ -3431,7 +3370,7 @@ static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDL SAVE_OPLINE(); - concat_function(&EX_T(opline->result.var).tmp_var, + concat_function(EX_VAR(opline->result.var), opline->op1.zv, opline->op2.zv TSRMLS_CC); @@ -3446,7 +3385,7 @@ static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE SAVE_OPLINE(); - is_identical_function(&EX_T(opline->result.var).tmp_var, + fast_is_identical_function(EX_VAR(opline->result.var), opline->op1.zv, opline->op2.zv TSRMLS_CC); @@ -3459,13 +3398,12 @@ static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OP { USE_OPLINE - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - is_identical_function(result, + fast_is_not_identical_function(result, opline->op1.zv, opline->op2.zv TSRMLS_CC); - Z_LVAL_P(result) = !Z_LVAL_P(result); CHECK_EXCEPTION(); @@ -3476,12 +3414,12 @@ static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HAN { USE_OPLINE - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_equal_function(result, + fast_equal_function(result, opline->op1.zv, - opline->op2.zv TSRMLS_CC)); + opline->op2.zv TSRMLS_CC); CHECK_EXCEPTION(); @@ -3492,12 +3430,12 @@ static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE { USE_OPLINE - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_not_equal_function(result, + fast_not_equal_function(result, opline->op1.zv, - opline->op2.zv TSRMLS_CC)); + opline->op2.zv TSRMLS_CC); CHECK_EXCEPTION(); @@ -3508,12 +3446,12 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_H { USE_OPLINE - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_is_smaller_function(result, + fast_is_smaller_function(result, opline->op1.zv, - opline->op2.zv TSRMLS_CC)); + opline->op2.zv TSRMLS_CC); CHECK_EXCEPTION(); @@ -3524,12 +3462,12 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND { USE_OPLINE - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, + fast_is_smaller_or_equal_function(result, opline->op1.zv, - opline->op2.zv TSRMLS_CC)); + opline->op2.zv TSRMLS_CC); CHECK_EXCEPTION(); @@ -3542,7 +3480,7 @@ static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLE SAVE_OPLINE(); - bitwise_or_function(&EX_T(opline->result.var).tmp_var, + bitwise_or_function(EX_VAR(opline->result.var), opline->op1.zv, opline->op2.zv TSRMLS_CC); @@ -3557,7 +3495,7 @@ static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDL SAVE_OPLINE(); - bitwise_and_function(&EX_T(opline->result.var).tmp_var, + bitwise_and_function(EX_VAR(opline->result.var), opline->op1.zv, opline->op2.zv TSRMLS_CC); @@ -3572,7 +3510,7 @@ static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDL SAVE_OPLINE(); - bitwise_xor_function(&EX_T(opline->result.var).tmp_var, + bitwise_xor_function(EX_VAR(opline->result.var), opline->op1.zv, opline->op2.zv TSRMLS_CC); @@ -3587,7 +3525,7 @@ static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HAN SAVE_OPLINE(); - boolean_xor_function(&EX_T(opline->result.var).tmp_var, + boolean_xor_function(EX_VAR(opline->result.var), opline->op1.zv, opline->op2.zv TSRMLS_CC); @@ -3599,21 +3537,18 @@ static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HAN static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_CONST(int type, ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_free_op free_op1; + zval *varname; - zval **retval; + zval *retval; zval tmp_varname; HashTable *target_symbol_table; - ulong hash_value; SAVE_OPLINE(); varname = opline->op1.zv; + ZVAL_UNDEF(&tmp_varname); if (IS_CONST != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) { - ZVAL_COPY_VALUE(&tmp_varname, varname); - zval_copy_ctor(&tmp_varname); - Z_SET_REFCOUNT(tmp_varname, 1); - Z_UNSET_ISREF(tmp_varname); + ZVAL_DUP_DEREF(&tmp_varname, varname); convert_to_string(&tmp_varname); varname = &tmp_varname; } @@ -3622,105 +3557,88 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_CONST(int type zend_class_entry *ce; if (IS_CONST == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { - if (IS_CONST != IS_CONST && varname == &tmp_varname) { + if (IS_CONST != IS_CONST) { zval_dtor(&tmp_varname); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(opline->op2.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); } } else { - ce = EX_T(opline->op2.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op2.var)); } - retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); + retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC); } else { target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); -/* - if (!target_symbol_table) { - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); - } -*/ - if (IS_CONST == IS_CONST) { - hash_value = Z_HASH_P(varname); - } else { - hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname)); - } - - if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) { + retval = zend_hash_find(target_symbol_table, Z_STR_P(varname)); + if (retval == NULL) { switch (type) { case BP_VAR_R: case BP_VAR_UNSET: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); /* break missing intentionally */ case BP_VAR_IS: - retval = &EG(uninitialized_zval_ptr); + retval = EX_VAR(opline->result.var); + ZVAL_NULL(retval); break; case BP_VAR_RW: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); /* break missing intentionally */ case BP_VAR_W: - Z_ADDREF_P(&EG(uninitialized_zval)); - zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval); + retval = zend_hash_update(target_symbol_table, Z_STR_P(varname), &EG(uninitialized_zval)); break; EMPTY_SWITCH_DEFAULT_CASE() } - } - switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) { - case ZEND_FETCH_GLOBAL: - if (IS_CONST != IS_TMP_VAR) { - + /* GLOBAL or $$name variable may be an INDIRECT pointer to CV */ + } else if (Z_TYPE_P(retval) == IS_INDIRECT) { + retval = Z_INDIRECT_P(retval); + if (Z_TYPE_P(retval) == IS_UNDEF) { + switch (type) { + case BP_VAR_R: + case BP_VAR_UNSET: + zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); + /* break missing intentionally */ + case BP_VAR_IS: + retval = EX_VAR(opline->result.var); + ZVAL_NULL(retval); + break; + case BP_VAR_RW: + zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); + /* break missing intentionally */ + case BP_VAR_W: + ZVAL_NULL(retval); + break; + EMPTY_SWITCH_DEFAULT_CASE() } - break; - case ZEND_FETCH_LOCAL: + } + } + if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC) { + zval_update_constant(retval, 1 TSRMLS_CC); + } else if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) != ZEND_FETCH_GLOBAL_LOCK) { - break; - case ZEND_FETCH_STATIC: - zval_update_constant(retval, 1 TSRMLS_CC); - break; - case ZEND_FETCH_GLOBAL_LOCK: - if (IS_CONST == IS_VAR && !free_op1.var) { - PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); - } - break; } } - - if (IS_CONST != IS_CONST && varname == &tmp_varname) { + if (IS_CONST != IS_CONST) { zval_dtor(&tmp_varname); } - if (opline->extended_value & ZEND_FETCH_MAKE_REF) { - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval); - } - PZVAL_LOCK(*retval); - switch (type) { - case BP_VAR_R: - case BP_VAR_IS: - EX_T(opline->result.var).var.ptr = *retval; - break; - case BP_VAR_UNSET: { - zend_free_op free_res; - PZVAL_UNLOCK(*retval, &free_res); - if (retval != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(retval); - } - PZVAL_LOCK(*retval); - FREE_OP_VAR_PTR(free_res); + ZEND_ASSERT(retval != NULL); + if (type == BP_VAR_R || type == BP_VAR_IS) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); + } else { + if (/*type == BP_VAR_W &&*/ (opline->extended_value & ZEND_FETCH_MAKE_REF)) { + SEPARATE_ZVAL_TO_MAKE_IS_REF(retval); } - /* break missing intentionally */ - default: - EX_T(opline->result.var).var.ptr_ptr = retval; - break; + ZVAL_INDIRECT(EX_VAR(opline->result.var), retval); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -3745,7 +3663,11 @@ static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_OPCO { USE_OPLINE - return zend_fetch_var_address_helper_SPEC_CONST_CONST(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { + return zend_fetch_var_address_helper_SPEC_CONST_CONST(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else { + return zend_fetch_var_address_helper_SPEC_CONST_CONST(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -3766,7 +3688,7 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_ SAVE_OPLINE(); container = opline->op1.zv; - zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); if (IS_CONST != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) { @@ -3785,14 +3707,12 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_TMP_VAR_SPEC_CONST_CONST_HANDLER(ZEND_O container = opline->op1.zv; if (UNEXPECTED(Z_TYPE_P(container) != IS_ARRAY)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } else { - zval *value = *zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC); + zval *value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC); - PZVAL_LOCK(value); - EX_T(opline->result.var).var.ptr = value; + ZVAL_COPY(EX_VAR(opline->result.var), value); } CHECK_EXCEPTION(); @@ -3810,21 +3730,21 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER( if (IS_CONST == IS_CONST) { /* no function found. try a static method in class */ - if (CACHED_PTR(opline->op1.literal->cache_slot)) { - ce = CACHED_PTR(opline->op1.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } if (UNEXPECTED(ce == NULL)) { zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv)); } - CACHE_PTR(opline->op1.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce); } call->called_scope = ce; } else { - ce = EX_T(opline->op1.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op1.var)); if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) { call->called_scope = EG(called_scope); @@ -3835,51 +3755,40 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER( if (IS_CONST == IS_CONST && IS_CONST == IS_CONST && - CACHED_PTR(opline->op2.literal->cache_slot)) { - call->fbc = CACHED_PTR(opline->op2.literal->cache_slot); + CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else if (IS_CONST != IS_CONST && IS_CONST == IS_CONST && - (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) { + (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce))) { /* do nothing */ } else if (IS_CONST != IS_UNUSED) { - char *function_name_strval = NULL; - int function_name_strlen = 0; - if (IS_CONST == IS_CONST) { - function_name_strval = Z_STRVAL_P(opline->op2.zv); - function_name_strlen = Z_STRLEN_P(opline->op2.zv); - } else { - function_name = opline->op2.zv; - + function_name = opline->op2.zv; + if (IS_CONST != IS_CONST) { if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } zend_error_noreturn(E_ERROR, "Function name must be a string"); - } else { - function_name_strval = Z_STRVAL_P(function_name); - function_name_strlen = Z_STRLEN_P(function_name); } } - if (function_name_strval) { - if (ce->get_static_method) { - call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC); + if (ce->get_static_method) { + call->fbc = ce->get_static_method(ce, Z_STR_P(function_name) TSRMLS_CC); + } else { + call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); + } + if (UNEXPECTED(call->fbc == NULL)) { + zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name)); + } + if (IS_CONST == IS_CONST && + EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) && + EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) { + if (IS_CONST == IS_CONST) { + CACHE_PTR(Z_CACHE_SLOT_P(function_name), call->fbc); } else { - call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); - } - if (UNEXPECTED(call->fbc == NULL)) { - zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval); - } - if (IS_CONST == IS_CONST && - EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) && - EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) { - if (IS_CONST == IS_CONST) { - CACHE_PTR(opline->op2.literal->cache_slot, call->fbc); - } else { - CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc); - } + CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), ce, call->fbc); } } if (IS_CONST != IS_CONST) { @@ -3889,8 +3798,8 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER( if (UNEXPECTED(ce->constructor == NULL)) { zend_error_noreturn(E_ERROR, "Cannot call constructor"); } - if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { - zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name); + if (Z_OBJ(EG(This)) && Z_OBJCE(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { + zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name->val); } call->fbc = ce->constructor; } @@ -3898,21 +3807,21 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER( if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) { call->object = NULL; } else { - if (EG(This) && - Z_OBJ_HT_P(EG(This))->get_class_entry && - !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) { + if (Z_OBJ(EG(This)) && + Z_OBJ_HT(EG(This))->get_class_entry && + !instanceof_function(Z_OBJCE(EG(This)), ce TSRMLS_CC)) { /* We are calling method of the other (incompatible) class, but passing $this. This is done for compatibility with php-4. */ if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { - zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name); + zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val); } else { /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */ - zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name); + zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val); } } - if ((call->object = EG(This))) { - Z_ADDREF_P(call->object); - call->called_scope = Z_OBJCE_P(call->object); + call->object = Z_OBJ(EG(This)); + if (call->object) { + GC_REFCOUNT(call->object)++; } } @@ -3928,11 +3837,12 @@ static int ZEND_FASTCALL ZEND_CASE_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER { USE_OPLINE + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - is_equal_function(&EX_T(opline->result.var).tmp_var, - opline->op1.zv, - opline->op2.zv TSRMLS_CC); + fast_equal_function(result, + opline->op1.zv, + opline->op2.zv TSRMLS_CC); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -3947,9 +3857,9 @@ static int ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCO zend_constant *c; zval *retval; - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - c = CACHED_PTR(opline->op2.literal->cache_slot); - } else if ((c = zend_quick_get_constant(opline->op2.literal + 1, opline->extended_value TSRMLS_CC)) == NULL) { + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + c = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + } else if ((c = zend_quick_get_constant(opline->op2.zv + 1, opline->extended_value TSRMLS_CC)) == NULL) { if ((opline->extended_value & IS_CONSTANT_UNQUALIFIED) != 0) { char *actual = (char *)zend_memrchr(Z_STRVAL_P(opline->op2.zv), '\\', Z_STRLEN_P(opline->op2.zv)); if(!actual) { @@ -3959,52 +3869,52 @@ static int ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCO } /* non-qualified constant - allow text substitution */ zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'", actual, actual); - ZVAL_STRINGL(&EX_T(opline->result.var).tmp_var, actual, Z_STRLEN_P(opline->op2.zv)-(actual - Z_STRVAL_P(opline->op2.zv)), 1); + ZVAL_STRINGL(EX_VAR(opline->result.var), actual, Z_STRLEN_P(opline->op2.zv)-(actual - Z_STRVAL_P(opline->op2.zv))); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } else { zend_error_noreturn(E_ERROR, "Undefined constant '%s'", Z_STRVAL_P(opline->op2.zv)); } } else { - CACHE_PTR(opline->op2.literal->cache_slot, c); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), c); } - retval = &EX_T(opline->result.var).tmp_var; - ZVAL_COPY_VALUE(retval, &c->value); - zval_copy_ctor(retval); + retval = EX_VAR(opline->result.var); + ZVAL_DUP(retval, &c->value); } else { /* class constant */ zend_class_entry *ce; - zval **value; + zval *value; if (IS_CONST == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - value = CACHED_PTR(opline->op2.literal->cache_slot); - ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value); - zval_copy_ctor(&EX_T(opline->result.var).tmp_var); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + value = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + ZVAL_DUP(EX_VAR(opline->result.var), value); goto constant_fetch_end; - } else if (CACHED_PTR(opline->op1.literal->cache_slot)) { - ce = CACHED_PTR(opline->op1.literal->cache_slot); + } else if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } if (UNEXPECTED(ce == NULL)) { zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv)); } - CACHE_PTR(opline->op1.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce); } } else { - ce = EX_T(opline->op1.var).class_entry; - if ((value = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce)) != NULL) { - ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value); - zval_copy_ctor(&EX_T(opline->result.var).tmp_var); + ce = Z_CE_P(EX_VAR(opline->op1.var)); + if ((value = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce)) != NULL) { + ZVAL_DUP(EX_VAR(opline->result.var), value); goto constant_fetch_end; } } - if (EXPECTED(zend_hash_quick_find(&ce->constants_table, Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv)+1, Z_HASH_P(opline->op2.zv), (void **) &value) == SUCCESS)) { - if (IS_CONSTANT_TYPE(Z_TYPE_PP(value))) { + if (EXPECTED((value = zend_hash_find(&ce->constants_table, Z_STR_P(opline->op2.zv))) != NULL)) { + if (Z_ISREF_P(value)) { + value = Z_REFVAL_P(value); + } + if (Z_CONSTANT_P(value)) { zend_class_entry *old_scope = EG(scope); EG(scope) = ce; @@ -4012,23 +3922,20 @@ static int ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCO EG(scope) = old_scope; } if (IS_CONST == IS_CONST) { - CACHE_PTR(opline->op2.literal->cache_slot, value); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), value); } else { - CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, value); + CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce, value); } - ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value); - zval_copy_ctor(&EX_T(opline->result.var).tmp_var); + ZVAL_DUP(EX_VAR(opline->result.var), value); } else if (Z_STRLEN_P(opline->op2.zv) == sizeof("class")-1 && memcmp(Z_STRVAL_P(opline->op2.zv), "class", sizeof("class") - 1) == 0) { /* "class" is assigned as a case-sensitive keyword from zend_do_resolve_class_name */ - ZVAL_STRINGL(&EX_T(opline->result.var).tmp_var, ce->name, ce->name_length, 1); + ZVAL_STR(EX_VAR(opline->result.var), ce->name); + STR_ADDREF(ce->name); } else { zend_error_noreturn(E_ERROR, "Undefined class constant '%s'", Z_STRVAL_P(opline->op2.zv)); } } constant_fetch_end: - if (Z_TYPE(EX_T(opline->result.var).tmp_var) == IS_ARRAY) { - zend_error_noreturn(E_ERROR, "Arrays are not allowed in constants at run-time"); - } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -4037,35 +3944,31 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_O { USE_OPLINE - zval *expr_ptr; + zval *expr_ptr, new_expr; SAVE_OPLINE(); - if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) { - zval **expr_ptr_ptr = NULL; - - if (IS_CONST == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) { + if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && + (opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) { + expr_ptr = NULL; + if (IS_CONST == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets"); } - SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); - expr_ptr = *expr_ptr_ptr; + SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr); Z_ADDREF_P(expr_ptr); + } else { - expr_ptr=opline->op1.zv; + expr_ptr = opline->op1.zv; if (0) { /* temporary variable */ - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - } else if (IS_CONST == IS_CONST || PZVAL_IS_REF(expr_ptr)) { - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - zendi_zval_copy_ctor(*expr_ptr); + ZVAL_COPY_VALUE(&new_expr, expr_ptr); + expr_ptr = &new_expr; + } else if (IS_CONST == IS_CONST) { + ZVAL_DUP(&new_expr, expr_ptr); + expr_ptr = &new_expr; + } else if (Z_ISREF_P(expr_ptr)) { + ZVAL_DUP(&new_expr, Z_REFVAL_P(expr_ptr)); + expr_ptr = &new_expr; - } else if (IS_CONST == IS_CV) { + } else if (IS_CONST == IS_CV && Z_REFCOUNTED_P(expr_ptr)) { Z_ADDREF_P(expr_ptr); } } @@ -4073,42 +3976,49 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_O if (IS_CONST != IS_UNUSED) { zval *offset = opline->op2.zv; + zend_string *str; ulong hval; +add_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: hval = zend_dval_to_lval(Z_DVAL_P(offset)); goto num_index; case IS_LONG: - case IS_BOOL: hval = Z_LVAL_P(offset); num_index: - zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL); + zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); break; case IS_STRING: - if (IS_CONST == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); + str = Z_STR_P(offset); + if (IS_CONST != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index); } - zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL); +str_index: + zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); break; case IS_NULL: - zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); + str = STR_EMPTY_ALLOC(); + goto str_index; + case IS_FALSE: + hval = 0; + goto num_index; + case IS_TRUE: + hval = 1; + goto num_index; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto add_again; break; default: zend_error(E_WARNING, "Illegal offset type"); - zval_ptr_dtor(&expr_ptr); + zval_ptr_dtor(expr_ptr); /* do nothing */ break; } } else { - zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL); - } - if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) { - + zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -4116,9 +4026,26 @@ num_index: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { + zval *array; + zend_uint size; USE_OPLINE - array_init(&EX_T(opline->result.var).tmp_var); + array = EX_VAR(opline->result.var); + if (IS_CONST != IS_UNUSED) { + size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; + } else { + size = 0; + } + ZVAL_NEW_ARR(array); + zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); + + if (IS_CONST != IS_UNUSED) { + /* Explicitly initialize array as not-packed if flag is set */ + if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) { + zend_hash_real_init(Z_ARRVAL_P(array), 0); + } + } + if (IS_CONST == IS_UNUSED) { ZEND_VM_NEXT_OPCODE(); #if 0 || IS_CONST != IS_UNUSED @@ -4134,20 +4061,15 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HA zval tmp, *varname; HashTable *target_symbol_table; + zend_bool tmp_is_dup = 0; SAVE_OPLINE(); if (IS_CONST == IS_CV && IS_CONST == IS_UNUSED && (opline->extended_value & ZEND_QUICK_SET)) { - if (EG(active_symbol_table)) { - zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); - - zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC); - EX_CV(opline->op1.var) = NULL; - } else if (EX_CV(opline->op1.var)) { - zval_ptr_dtor(EX_CV(opline->op1.var)); - EX_CV(opline->op1.var) = NULL; - } + ZVAL_COPY_VALUE(&tmp, EX_VAR(opline->op1.var)); + ZVAL_UNDEF(EX_VAR(opline->op1.var)); + zval_ptr_dtor(&tmp); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -4155,27 +4077,28 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HA varname = opline->op1.zv; if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { - ZVAL_COPY_VALUE(&tmp, varname); - zval_copy_ctor(&tmp); + ZVAL_DUP(&tmp, varname); convert_to_string(&tmp); varname = &tmp; + tmp_is_dup = 1; } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) { - Z_ADDREF_P(varname); + ZVAL_COPY(&tmp, varname); + varname = &tmp; } if (IS_CONST != IS_UNUSED) { zend_class_entry *ce; if (IS_CONST == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { - if (IS_CONST != IS_CONST && varname == &tmp) { + if (IS_CONST != IS_CONST && tmp_is_dup) { zval_dtor(&tmp); } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) { - zval_ptr_dtor(&varname); + zval_ptr_dtor(&tmp); } HANDLE_EXCEPTION(); @@ -4183,23 +4106,21 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HA if (UNEXPECTED(ce == NULL)) { zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv)); } - CACHE_PTR(opline->op2.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); } } else { - ce = EX_T(opline->op2.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op2.var)); } - zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); + zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC); } else { - ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1); - target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); - zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC); + zend_hash_del_ind(target_symbol_table, Z_STR_P(varname)); } - if (IS_CONST != IS_CONST && varname == &tmp) { + if (IS_CONST != IS_CONST && tmp_is_dup) { zval_dtor(&tmp); } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) { - zval_ptr_dtor(&varname); + zval_ptr_dtor(&tmp); } CHECK_EXCEPTION(); @@ -4209,21 +4130,16 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HA static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval **value; + zval *value; zend_bool isset = 1; SAVE_OPLINE(); if (IS_CONST == IS_CV && IS_CONST == IS_UNUSED && (opline->extended_value & ZEND_QUICK_SET)) { - if (EX_CV(opline->op1.var)) { - value = EX_CV(opline->op1.var); - } else if (EG(active_symbol_table)) { - zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); - - if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) { - isset = 0; - } + if (Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_UNDEF) { + value = EX_VAR(opline->op1.var); + ZVAL_DEREF(value); } else { isset = 0; } @@ -4233,8 +4149,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_CONST_HANDLER(ZEND_O zval tmp, *varname = opline->op1.zv; if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { - ZVAL_COPY_VALUE(&tmp, varname); - zval_copy_ctor(&tmp); + ZVAL_DUP(&tmp, varname); convert_to_string(&tmp); varname = &tmp; } @@ -4243,26 +4158,26 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_CONST_HANDLER(ZEND_O zend_class_entry *ce; if (IS_CONST == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(opline->op2.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); } } else { - ce = EX_T(opline->op2.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op2.var)); } - value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); + value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC); if (!value) { isset = 0; } } else { target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); - if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) { + if ((value = zend_hash_find(target_symbol_table, Z_STR_P(varname))) == NULL) { isset = 0; } } @@ -4274,16 +4189,16 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_CONST_HANDLER(ZEND_O } if (opline->extended_value & ZEND_ISSET) { - if (isset && Z_TYPE_PP(value) != IS_NULL) { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); + if (isset && Z_TYPE_P(value) != IS_NULL) { + ZVAL_BOOL(EX_VAR(opline->result.var), 1); } else { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); + ZVAL_BOOL(EX_VAR(opline->result.var), 0); } } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { - if (!isset || !i_zend_is_true(*value TSRMLS_CC)) { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); + if (!isset || !i_zend_is_true(value TSRMLS_CC)) { + ZVAL_BOOL(EX_VAR(opline->result.var), 1); } else { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); + ZVAL_BOOL(EX_VAR(opline->result.var), 0); } } @@ -4303,21 +4218,20 @@ static int ZEND_FASTCALL ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER(ZEND_OPCOD name = opline->op1.zv; val = opline->op2.zv; - if (IS_CONSTANT_TYPE(Z_TYPE_P(val))) { - zval tmp; - zval *tmp_ptr = &tmp; - - ZVAL_COPY_VALUE(&tmp, val); - INIT_PZVAL(&tmp); - zval_update_constant(&tmp_ptr, 0 TSRMLS_CC); - c.value = *tmp_ptr; + ZVAL_COPY_VALUE(&c.value, val); + if (Z_OPT_CONSTANT(c.value)) { + if (Z_TYPE_P(val) == IS_CONSTANT_ARRAY) { + zval_opt_copy_ctor(&c.value); + } + zval_update_constant(&c.value, 0 TSRMLS_CC); } else { - INIT_PZVAL_COPY(&c.value, val); - zval_copy_ctor(&c.value); + /* IS_CONST can't be IS_OBJECT, IS_RESOURCE or IS_REFERENCE */ + if (UNEXPECTED(Z_OPT_COPYABLE(c.value))) { + _zval_copy_ctor_func(&c.value ZEND_FILE_LINE_CC); + } } c.flags = CONST_CS; /* non persistent, case sensetive */ - c.name = str_strndup(Z_STRVAL_P(name), Z_STRLEN_P(name)); - c.name_len = Z_STRLEN_P(name)+1; + c.name = STR_DUP(Z_STR_P(name), 0); c.module_number = PHP_USER_CONSTANT; if (zend_register_constant(&c TSRMLS_CC) == FAILURE) { @@ -4332,22 +4246,18 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLE { USE_OPLINE - /* The generator object is stored in return_value_ptr_ptr */ - zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr); + /* The generator object is stored in EX(return_value) */ + zend_generator *generator = (zend_generator *) EX(return_value); if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) { zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator"); } /* Destroy the previously yielded value */ - if (generator->value) { - zval_ptr_dtor(&generator->value); - } + zval_ptr_dtor(&generator->value); /* Destroy the previously yielded key */ - if (generator->key) { - zval_ptr_dtor(&generator->key); - } + zval_ptr_dtor(&generator->key); /* Set the new yielded value */ if (IS_CONST != IS_UNUSED) { @@ -4357,74 +4267,58 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLE /* Constants and temporary variables aren't yieldable by reference, * but we still allow them with a notice. */ if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) { - zval *value, *copy; + zval *value; zend_error(E_NOTICE, "Only variable references should be yielded by reference"); value = opline->op1.zv; - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); + ZVAL_COPY_VALUE(&generator->value, value); + if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1); /* Temporary variables don't need ctor copying */ if (!0) { - zval_copy_ctor(copy); + zval_copy_ctor(&generator->value); } - - generator->value = copy; } else { - zval **value_ptr = NULL; + zval *value_ptr = NULL; - if (IS_CONST == IS_VAR && UNEXPECTED(value_ptr == NULL)) { + if (IS_CONST == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference"); } /* If a function call result is yielded and the function did * not return by reference we throw a notice. */ - if (IS_CONST == IS_VAR && !Z_ISREF_PP(value_ptr) + if (IS_CONST == IS_VAR && !Z_ISREF_P(value_ptr) && !(opline->extended_value == ZEND_RETURNS_FUNCTION - && EX_T(opline->op1.var).var.fcall_returned_reference) - && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) { + && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); - - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } else { SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr); - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } + ZVAL_COPY(&generator->value, value_ptr); } } else { zval *value = opline->op1.zv; /* Consts, temporary variables and references need copying */ - if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR - || PZVAL_IS_REF(value) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); - - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } - - generator->value = copy; + if (IS_CONST == IS_CONST) { + ZVAL_DUP(&generator->value, value); + } else if (IS_CONST == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->value, value); + } else if (Z_ISREF_P(value)) { + ZVAL_DUP(&generator->value, Z_REFVAL_P(value)); } else { if (IS_CONST == IS_CV) { - Z_ADDREF_P(value); + if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value); } - generator->value = value; + ZVAL_COPY_VALUE(&generator->value, value); } } } else { /* If no value was specified yield null */ - Z_ADDREF(EG(uninitialized_zval)); - generator->value = &EG(uninitialized_zval); + ZVAL_NULL(&generator->value); } /* Set the new yielded key */ @@ -4433,45 +4327,36 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLE zval *key = opline->op2.zv; /* Consts, temporary variables and references need copying */ - if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR - || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, key); - - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } + if (IS_CONST == IS_CONST) { + ZVAL_DUP(&generator->key, key); + } else if (IS_CONST == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->key, key); + } else if (Z_ISREF_P(key)) { + ZVAL_DUP(&generator->key, Z_REFVAL_P(key)); - generator->key = copy; } else { - Z_ADDREF_P(key); - generator->key = key; + if (IS_CONST == IS_CV) { + if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key); + } + ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE_P(generator->key) == IS_LONG - && Z_LVAL_P(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_LONG + && Z_LVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL_P(generator->key); + generator->largest_used_integer_key = Z_LVAL(generator->key); } - } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - - ALLOC_INIT_ZVAL(generator->key); - ZVAL_LONG(generator->key, generator->largest_used_integer_key); + ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ - generator->send_target = &EX_T(opline->result.var).var.ptr; - Z_ADDREF(EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + generator->send_target = EX_VAR(opline->result.var); + ZVAL_NULL(generator->send_target); } else { generator->send_target = NULL; } @@ -4493,7 +4378,7 @@ static int ZEND_FASTCALL ZEND_POW_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ SAVE_OPLINE(); - pow_function(&EX_T(opline->result.var).tmp_var, + pow_function(EX_VAR(opline->result.var), opline->op1.zv, opline->op2.zv TSRMLS_CC); @@ -4508,7 +4393,7 @@ static int ZEND_FASTCALL ZEND_ADD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR zend_free_op free_op2; SAVE_OPLINE(); - fast_add_function(&EX_T(opline->result.var).tmp_var, + fast_add_function(EX_VAR(opline->result.var), opline->op1.zv, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); @@ -4523,7 +4408,7 @@ static int ZEND_FASTCALL ZEND_SUB_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR zend_free_op free_op2; SAVE_OPLINE(); - fast_sub_function(&EX_T(opline->result.var).tmp_var, + fast_sub_function(EX_VAR(opline->result.var), opline->op1.zv, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); @@ -4538,7 +4423,7 @@ static int ZEND_FASTCALL ZEND_MUL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR zend_free_op free_op2; SAVE_OPLINE(); - fast_mul_function(&EX_T(opline->result.var).tmp_var, + fast_mul_function(EX_VAR(opline->result.var), opline->op1.zv, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); @@ -4553,7 +4438,7 @@ static int ZEND_FASTCALL ZEND_DIV_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR zend_free_op free_op2; SAVE_OPLINE(); - fast_div_function(&EX_T(opline->result.var).tmp_var, + fast_div_function(EX_VAR(opline->result.var), opline->op1.zv, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); @@ -4568,7 +4453,7 @@ static int ZEND_FASTCALL ZEND_MOD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR zend_free_op free_op2; SAVE_OPLINE(); - fast_mod_function(&EX_T(opline->result.var).tmp_var, + fast_mod_function(EX_VAR(opline->result.var), opline->op1.zv, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); @@ -4583,7 +4468,7 @@ static int ZEND_FASTCALL ZEND_SL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG zend_free_op free_op2; SAVE_OPLINE(); - shift_left_function(&EX_T(opline->result.var).tmp_var, + shift_left_function(EX_VAR(opline->result.var), opline->op1.zv, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); @@ -4598,7 +4483,7 @@ static int ZEND_FASTCALL ZEND_SR_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG zend_free_op free_op2; SAVE_OPLINE(); - shift_right_function(&EX_T(opline->result.var).tmp_var, + shift_right_function(EX_VAR(opline->result.var), opline->op1.zv, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); @@ -4613,7 +4498,7 @@ static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER zend_free_op free_op2; SAVE_OPLINE(); - concat_function(&EX_T(opline->result.var).tmp_var, + concat_function(EX_VAR(opline->result.var), opline->op1.zv, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); @@ -4628,7 +4513,7 @@ static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_H zend_free_op free_op2; SAVE_OPLINE(); - is_identical_function(&EX_T(opline->result.var).tmp_var, + fast_is_identical_function(EX_VAR(opline->result.var), opline->op1.zv, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); @@ -4641,13 +4526,12 @@ static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCO { USE_OPLINE zend_free_op free_op2; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - is_identical_function(result, + fast_is_not_identical_function(result, opline->op1.zv, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - Z_LVAL_P(result) = !Z_LVAL_P(result); zval_dtor(free_op2.var); CHECK_EXCEPTION(); @@ -4658,12 +4542,12 @@ static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDL { USE_OPLINE zend_free_op free_op2; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_equal_function(result, + fast_equal_function(result, opline->op1.zv, - _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op2.var); CHECK_EXCEPTION(); @@ -4674,12 +4558,12 @@ static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_H { USE_OPLINE zend_free_op free_op2; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_not_equal_function(result, + fast_not_equal_function(result, opline->op1.zv, - _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op2.var); CHECK_EXCEPTION(); @@ -4690,12 +4574,12 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HAN { USE_OPLINE zend_free_op free_op2; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_is_smaller_function(result, + fast_is_smaller_function(result, opline->op1.zv, - _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op2.var); CHECK_EXCEPTION(); @@ -4706,12 +4590,12 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMP_HANDLER(ZEND_O { USE_OPLINE zend_free_op free_op2; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, + fast_is_smaller_or_equal_function(result, opline->op1.zv, - _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op2.var); CHECK_EXCEPTION(); @@ -4724,7 +4608,7 @@ static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ zend_free_op free_op2; SAVE_OPLINE(); - bitwise_or_function(&EX_T(opline->result.var).tmp_var, + bitwise_or_function(EX_VAR(opline->result.var), opline->op1.zv, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); @@ -4739,7 +4623,7 @@ static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER zend_free_op free_op2; SAVE_OPLINE(); - bitwise_and_function(&EX_T(opline->result.var).tmp_var, + bitwise_and_function(EX_VAR(opline->result.var), opline->op1.zv, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); @@ -4754,7 +4638,7 @@ static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER zend_free_op free_op2; SAVE_OPLINE(); - bitwise_xor_function(&EX_T(opline->result.var).tmp_var, + bitwise_xor_function(EX_VAR(opline->result.var), opline->op1.zv, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); @@ -4769,7 +4653,7 @@ static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDL zend_free_op free_op2; SAVE_OPLINE(); - boolean_xor_function(&EX_T(opline->result.var).tmp_var, + boolean_xor_function(EX_VAR(opline->result.var), opline->op1.zv, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); @@ -4786,7 +4670,7 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HA SAVE_OPLINE(); container = opline->op1.zv; - zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC); zval_dtor(free_op2.var); if (IS_CONST != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) { @@ -4806,21 +4690,21 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMP_HANDLER(ZE if (IS_CONST == IS_CONST) { /* no function found. try a static method in class */ - if (CACHED_PTR(opline->op1.literal->cache_slot)) { - ce = CACHED_PTR(opline->op1.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } if (UNEXPECTED(ce == NULL)) { zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv)); } - CACHE_PTR(opline->op1.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce); } call->called_scope = ce; } else { - ce = EX_T(opline->op1.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op1.var)); if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) { call->called_scope = EG(called_scope); @@ -4831,51 +4715,40 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMP_HANDLER(ZE if (IS_CONST == IS_CONST && IS_TMP_VAR == IS_CONST && - CACHED_PTR(opline->op2.literal->cache_slot)) { - call->fbc = CACHED_PTR(opline->op2.literal->cache_slot); + CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else if (IS_CONST != IS_CONST && IS_TMP_VAR == IS_CONST && - (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) { + (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce))) { /* do nothing */ } else if (IS_TMP_VAR != IS_UNUSED) { - char *function_name_strval = NULL; - int function_name_strlen = 0; zend_free_op free_op2; - if (IS_TMP_VAR == IS_CONST) { - function_name_strval = Z_STRVAL_P(opline->op2.zv); - function_name_strlen = Z_STRLEN_P(opline->op2.zv); - } else { - function_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - + function_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + if (IS_TMP_VAR != IS_CONST) { if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } zend_error_noreturn(E_ERROR, "Function name must be a string"); - } else { - function_name_strval = Z_STRVAL_P(function_name); - function_name_strlen = Z_STRLEN_P(function_name); } } - if (function_name_strval) { - if (ce->get_static_method) { - call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC); + if (ce->get_static_method) { + call->fbc = ce->get_static_method(ce, Z_STR_P(function_name) TSRMLS_CC); + } else { + call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); + } + if (UNEXPECTED(call->fbc == NULL)) { + zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name)); + } + if (IS_TMP_VAR == IS_CONST && + EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) && + EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) { + if (IS_CONST == IS_CONST) { + CACHE_PTR(Z_CACHE_SLOT_P(function_name), call->fbc); } else { - call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); - } - if (UNEXPECTED(call->fbc == NULL)) { - zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval); - } - if (IS_TMP_VAR == IS_CONST && - EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) && - EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) { - if (IS_CONST == IS_CONST) { - CACHE_PTR(opline->op2.literal->cache_slot, call->fbc); - } else { - CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc); - } + CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), ce, call->fbc); } } if (IS_TMP_VAR != IS_CONST) { @@ -4885,8 +4758,8 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMP_HANDLER(ZE if (UNEXPECTED(ce->constructor == NULL)) { zend_error_noreturn(E_ERROR, "Cannot call constructor"); } - if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { - zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name); + if (Z_OBJ(EG(This)) && Z_OBJCE(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { + zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name->val); } call->fbc = ce->constructor; } @@ -4894,21 +4767,21 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMP_HANDLER(ZE if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) { call->object = NULL; } else { - if (EG(This) && - Z_OBJ_HT_P(EG(This))->get_class_entry && - !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) { + if (Z_OBJ(EG(This)) && + Z_OBJ_HT(EG(This))->get_class_entry && + !instanceof_function(Z_OBJCE(EG(This)), ce TSRMLS_CC)) { /* We are calling method of the other (incompatible) class, but passing $this. This is done for compatibility with php-4. */ if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { - zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name); + zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val); } else { /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */ - zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name); + zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val); } } - if ((call->object = EG(This))) { - Z_ADDREF_P(call->object); - call->called_scope = Z_OBJCE_P(call->object); + call->object = Z_OBJ(EG(This)); + if (call->object) { + GC_REFCOUNT(call->object)++; } } @@ -4924,11 +4797,12 @@ static int ZEND_FASTCALL ZEND_CASE_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_A { USE_OPLINE zend_free_op free_op2; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - is_equal_function(&EX_T(opline->result.var).tmp_var, - opline->op1.zv, - _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + fast_equal_function(result, + opline->op1.zv, + _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op2.var); CHECK_EXCEPTION(); @@ -4939,35 +4813,31 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_HANDLER(ZEND_OPC { USE_OPLINE - zval *expr_ptr; + zval *expr_ptr, new_expr; SAVE_OPLINE(); - if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) { - zval **expr_ptr_ptr = NULL; - - if (IS_CONST == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) { + if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && + (opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) { + expr_ptr = NULL; + if (IS_CONST == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets"); } - SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); - expr_ptr = *expr_ptr_ptr; + SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr); Z_ADDREF_P(expr_ptr); + } else { - expr_ptr=opline->op1.zv; + expr_ptr = opline->op1.zv; if (0) { /* temporary variable */ - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - } else if (IS_CONST == IS_CONST || PZVAL_IS_REF(expr_ptr)) { - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - zendi_zval_copy_ctor(*expr_ptr); + ZVAL_COPY_VALUE(&new_expr, expr_ptr); + expr_ptr = &new_expr; + } else if (IS_CONST == IS_CONST) { + ZVAL_DUP(&new_expr, expr_ptr); + expr_ptr = &new_expr; + } else if (Z_ISREF_P(expr_ptr)) { + ZVAL_DUP(&new_expr, Z_REFVAL_P(expr_ptr)); + expr_ptr = &new_expr; - } else if (IS_CONST == IS_CV) { + } else if (IS_CONST == IS_CV && Z_REFCOUNTED_P(expr_ptr)) { Z_ADDREF_P(expr_ptr); } } @@ -4975,42 +4845,49 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_HANDLER(ZEND_OPC if (IS_TMP_VAR != IS_UNUSED) { zend_free_op free_op2; zval *offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + zend_string *str; ulong hval; +add_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: hval = zend_dval_to_lval(Z_DVAL_P(offset)); goto num_index; case IS_LONG: - case IS_BOOL: hval = Z_LVAL_P(offset); num_index: - zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL); + zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); break; case IS_STRING: - if (IS_TMP_VAR == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); + str = Z_STR_P(offset); + if (IS_TMP_VAR != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index); } - zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL); +str_index: + zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); break; case IS_NULL: - zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); + str = STR_EMPTY_ALLOC(); + goto str_index; + case IS_FALSE: + hval = 0; + goto num_index; + case IS_TRUE: + hval = 1; + goto num_index; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto add_again; break; default: zend_error(E_WARNING, "Illegal offset type"); - zval_ptr_dtor(&expr_ptr); + zval_ptr_dtor(expr_ptr); /* do nothing */ break; } zval_dtor(free_op2.var); } else { - zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL); - } - if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) { - + zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -5018,9 +4895,26 @@ num_index: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { + zval *array; + zend_uint size; USE_OPLINE - array_init(&EX_T(opline->result.var).tmp_var); + array = EX_VAR(opline->result.var); + if (IS_CONST != IS_UNUSED) { + size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; + } else { + size = 0; + } + ZVAL_NEW_ARR(array); + zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); + + if (IS_CONST != IS_UNUSED) { + /* Explicitly initialize array as not-packed if flag is set */ + if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) { + zend_hash_real_init(Z_ARRVAL_P(array), 0); + } + } + if (IS_CONST == IS_UNUSED) { ZEND_VM_NEXT_OPCODE(); #if 0 || IS_CONST != IS_UNUSED @@ -5034,22 +4928,18 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ { USE_OPLINE - /* The generator object is stored in return_value_ptr_ptr */ - zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr); + /* The generator object is stored in EX(return_value) */ + zend_generator *generator = (zend_generator *) EX(return_value); if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) { zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator"); } /* Destroy the previously yielded value */ - if (generator->value) { - zval_ptr_dtor(&generator->value); - } + zval_ptr_dtor(&generator->value); /* Destroy the previously yielded key */ - if (generator->key) { - zval_ptr_dtor(&generator->key); - } + zval_ptr_dtor(&generator->key); /* Set the new yielded value */ if (IS_CONST != IS_UNUSED) { @@ -5059,74 +4949,58 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ /* Constants and temporary variables aren't yieldable by reference, * but we still allow them with a notice. */ if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) { - zval *value, *copy; + zval *value; zend_error(E_NOTICE, "Only variable references should be yielded by reference"); value = opline->op1.zv; - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); + ZVAL_COPY_VALUE(&generator->value, value); + if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1); /* Temporary variables don't need ctor copying */ if (!0) { - zval_copy_ctor(copy); + zval_copy_ctor(&generator->value); } - - generator->value = copy; } else { - zval **value_ptr = NULL; + zval *value_ptr = NULL; - if (IS_CONST == IS_VAR && UNEXPECTED(value_ptr == NULL)) { + if (IS_CONST == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference"); } /* If a function call result is yielded and the function did * not return by reference we throw a notice. */ - if (IS_CONST == IS_VAR && !Z_ISREF_PP(value_ptr) + if (IS_CONST == IS_VAR && !Z_ISREF_P(value_ptr) && !(opline->extended_value == ZEND_RETURNS_FUNCTION - && EX_T(opline->op1.var).var.fcall_returned_reference) - && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) { + && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); - - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } else { SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr); - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } + ZVAL_COPY(&generator->value, value_ptr); } } else { zval *value = opline->op1.zv; /* Consts, temporary variables and references need copying */ - if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR - || PZVAL_IS_REF(value) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); - - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } - - generator->value = copy; + if (IS_CONST == IS_CONST) { + ZVAL_DUP(&generator->value, value); + } else if (IS_CONST == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->value, value); + } else if (Z_ISREF_P(value)) { + ZVAL_DUP(&generator->value, Z_REFVAL_P(value)); } else { if (IS_CONST == IS_CV) { - Z_ADDREF_P(value); + if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value); } - generator->value = value; + ZVAL_COPY_VALUE(&generator->value, value); } } } else { /* If no value was specified yield null */ - Z_ADDREF(EG(uninitialized_zval)); - generator->value = &EG(uninitialized_zval); + ZVAL_NULL(&generator->value); } /* Set the new yielded key */ @@ -5135,45 +5009,36 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); /* Consts, temporary variables and references need copying */ - if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR - || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, key); - - /* Temporary variables don't need ctor copying */ - if (!1) { - zval_copy_ctor(copy); - } + if (IS_TMP_VAR == IS_CONST) { + ZVAL_DUP(&generator->key, key); + } else if (IS_TMP_VAR == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->key, key); + } else if (Z_ISREF_P(key)) { + ZVAL_DUP(&generator->key, Z_REFVAL_P(key)); - generator->key = copy; } else { - Z_ADDREF_P(key); - generator->key = key; + if (IS_TMP_VAR == IS_CV) { + if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key); + } + ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE_P(generator->key) == IS_LONG - && Z_LVAL_P(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_LONG + && Z_LVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL_P(generator->key); + generator->largest_used_integer_key = Z_LVAL(generator->key); } - } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - - ALLOC_INIT_ZVAL(generator->key); - ZVAL_LONG(generator->key, generator->largest_used_integer_key); + ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ - generator->send_target = &EX_T(opline->result.var).var.ptr; - Z_ADDREF(EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + generator->send_target = EX_VAR(opline->result.var); + ZVAL_NULL(generator->send_target); } else { generator->send_target = NULL; } @@ -5195,7 +5060,7 @@ static int ZEND_FASTCALL ZEND_POW_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR zend_free_op free_op2; SAVE_OPLINE(); - pow_function(&EX_T(opline->result.var).tmp_var, + pow_function(EX_VAR(opline->result.var), opline->op1.zv, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); @@ -5210,11 +5075,11 @@ static int ZEND_FASTCALL ZEND_ADD_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR zend_free_op free_op2; SAVE_OPLINE(); - fast_add_function(&EX_T(opline->result.var).tmp_var, + fast_add_function(EX_VAR(opline->result.var), opline->op1.zv, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -5225,11 +5090,11 @@ static int ZEND_FASTCALL ZEND_SUB_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR zend_free_op free_op2; SAVE_OPLINE(); - fast_sub_function(&EX_T(opline->result.var).tmp_var, + fast_sub_function(EX_VAR(opline->result.var), opline->op1.zv, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -5240,11 +5105,11 @@ static int ZEND_FASTCALL ZEND_MUL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR zend_free_op free_op2; SAVE_OPLINE(); - fast_mul_function(&EX_T(opline->result.var).tmp_var, + fast_mul_function(EX_VAR(opline->result.var), opline->op1.zv, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -5255,11 +5120,11 @@ static int ZEND_FASTCALL ZEND_DIV_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR zend_free_op free_op2; SAVE_OPLINE(); - fast_div_function(&EX_T(opline->result.var).tmp_var, + fast_div_function(EX_VAR(opline->result.var), opline->op1.zv, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -5270,11 +5135,11 @@ static int ZEND_FASTCALL ZEND_MOD_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR zend_free_op free_op2; SAVE_OPLINE(); - fast_mod_function(&EX_T(opline->result.var).tmp_var, + fast_mod_function(EX_VAR(opline->result.var), opline->op1.zv, - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -5285,11 +5150,11 @@ static int ZEND_FASTCALL ZEND_SL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG zend_free_op free_op2; SAVE_OPLINE(); - shift_left_function(&EX_T(opline->result.var).tmp_var, + shift_left_function(EX_VAR(opline->result.var), opline->op1.zv, - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -5300,11 +5165,11 @@ static int ZEND_FASTCALL ZEND_SR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG zend_free_op free_op2; SAVE_OPLINE(); - shift_right_function(&EX_T(opline->result.var).tmp_var, + shift_right_function(EX_VAR(opline->result.var), opline->op1.zv, - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -5315,11 +5180,11 @@ static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER zend_free_op free_op2; SAVE_OPLINE(); - concat_function(&EX_T(opline->result.var).tmp_var, + concat_function(EX_VAR(opline->result.var), opline->op1.zv, - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -5330,11 +5195,11 @@ static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_H zend_free_op free_op2; SAVE_OPLINE(); - is_identical_function(&EX_T(opline->result.var).tmp_var, + fast_is_identical_function(EX_VAR(opline->result.var), opline->op1.zv, - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -5343,15 +5208,14 @@ static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCO { USE_OPLINE zend_free_op free_op2; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - is_identical_function(result, + fast_is_not_identical_function(result, opline->op1.zv, - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - Z_LVAL_P(result) = !Z_LVAL_P(result); + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -5360,14 +5224,14 @@ static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDL { USE_OPLINE zend_free_op free_op2; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_equal_function(result, + fast_equal_function(result, opline->op1.zv, - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -5376,14 +5240,14 @@ static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_H { USE_OPLINE zend_free_op free_op2; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_not_equal_function(result, + fast_not_equal_function(result, opline->op1.zv, - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -5392,14 +5256,14 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HAN { USE_OPLINE zend_free_op free_op2; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_is_smaller_function(result, + fast_is_smaller_function(result, opline->op1.zv, - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -5408,14 +5272,14 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_VAR_HANDLER(ZEND_O { USE_OPLINE zend_free_op free_op2; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, + fast_is_smaller_or_equal_function(result, opline->op1.zv, - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -5426,11 +5290,11 @@ static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ zend_free_op free_op2; SAVE_OPLINE(); - bitwise_or_function(&EX_T(opline->result.var).tmp_var, + bitwise_or_function(EX_VAR(opline->result.var), opline->op1.zv, - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -5441,11 +5305,11 @@ static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER zend_free_op free_op2; SAVE_OPLINE(); - bitwise_and_function(&EX_T(opline->result.var).tmp_var, + bitwise_and_function(EX_VAR(opline->result.var), opline->op1.zv, - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -5456,11 +5320,11 @@ static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER zend_free_op free_op2; SAVE_OPLINE(); - bitwise_xor_function(&EX_T(opline->result.var).tmp_var, + bitwise_xor_function(EX_VAR(opline->result.var), opline->op1.zv, - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -5471,11 +5335,11 @@ static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDL zend_free_op free_op2; SAVE_OPLINE(); - boolean_xor_function(&EX_T(opline->result.var).tmp_var, + boolean_xor_function(EX_VAR(opline->result.var), opline->op1.zv, - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -5483,21 +5347,18 @@ static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDL static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_VAR(int type, ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_free_op free_op1; + zval *varname; - zval **retval; + zval *retval; zval tmp_varname; HashTable *target_symbol_table; - ulong hash_value; SAVE_OPLINE(); varname = opline->op1.zv; + ZVAL_UNDEF(&tmp_varname); if (IS_CONST != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) { - ZVAL_COPY_VALUE(&tmp_varname, varname); - zval_copy_ctor(&tmp_varname); - Z_SET_REFCOUNT(tmp_varname, 1); - Z_UNSET_ISREF(tmp_varname); + ZVAL_DUP_DEREF(&tmp_varname, varname); convert_to_string(&tmp_varname); varname = &tmp_varname; } @@ -5506,105 +5367,88 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_VAR(int type, zend_class_entry *ce; if (IS_VAR == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { - if (IS_CONST != IS_CONST && varname == &tmp_varname) { + if (IS_CONST != IS_CONST) { zval_dtor(&tmp_varname); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(opline->op2.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); } } else { - ce = EX_T(opline->op2.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op2.var)); } - retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); + retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC); } else { target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); -/* - if (!target_symbol_table) { - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); - } -*/ - if (IS_CONST == IS_CONST) { - hash_value = Z_HASH_P(varname); - } else { - hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname)); - } - - if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) { + retval = zend_hash_find(target_symbol_table, Z_STR_P(varname)); + if (retval == NULL) { switch (type) { case BP_VAR_R: case BP_VAR_UNSET: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); /* break missing intentionally */ case BP_VAR_IS: - retval = &EG(uninitialized_zval_ptr); + retval = EX_VAR(opline->result.var); + ZVAL_NULL(retval); break; case BP_VAR_RW: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); /* break missing intentionally */ case BP_VAR_W: - Z_ADDREF_P(&EG(uninitialized_zval)); - zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval); + retval = zend_hash_update(target_symbol_table, Z_STR_P(varname), &EG(uninitialized_zval)); break; EMPTY_SWITCH_DEFAULT_CASE() } - } - switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) { - case ZEND_FETCH_GLOBAL: - if (IS_CONST != IS_TMP_VAR) { - + /* GLOBAL or $$name variable may be an INDIRECT pointer to CV */ + } else if (Z_TYPE_P(retval) == IS_INDIRECT) { + retval = Z_INDIRECT_P(retval); + if (Z_TYPE_P(retval) == IS_UNDEF) { + switch (type) { + case BP_VAR_R: + case BP_VAR_UNSET: + zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); + /* break missing intentionally */ + case BP_VAR_IS: + retval = EX_VAR(opline->result.var); + ZVAL_NULL(retval); + break; + case BP_VAR_RW: + zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); + /* break missing intentionally */ + case BP_VAR_W: + ZVAL_NULL(retval); + break; + EMPTY_SWITCH_DEFAULT_CASE() } - break; - case ZEND_FETCH_LOCAL: + } + } + if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC) { + zval_update_constant(retval, 1 TSRMLS_CC); + } else if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) != ZEND_FETCH_GLOBAL_LOCK) { - break; - case ZEND_FETCH_STATIC: - zval_update_constant(retval, 1 TSRMLS_CC); - break; - case ZEND_FETCH_GLOBAL_LOCK: - if (IS_CONST == IS_VAR && !free_op1.var) { - PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); - } - break; } } - - if (IS_CONST != IS_CONST && varname == &tmp_varname) { + if (IS_CONST != IS_CONST) { zval_dtor(&tmp_varname); } - if (opline->extended_value & ZEND_FETCH_MAKE_REF) { - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval); - } - PZVAL_LOCK(*retval); - switch (type) { - case BP_VAR_R: - case BP_VAR_IS: - EX_T(opline->result.var).var.ptr = *retval; - break; - case BP_VAR_UNSET: { - zend_free_op free_res; - PZVAL_UNLOCK(*retval, &free_res); - if (retval != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(retval); - } - PZVAL_LOCK(*retval); - FREE_OP_VAR_PTR(free_res); + ZEND_ASSERT(retval != NULL); + if (type == BP_VAR_R || type == BP_VAR_IS) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); + } else { + if (/*type == BP_VAR_W &&*/ (opline->extended_value & ZEND_FETCH_MAKE_REF)) { + SEPARATE_ZVAL_TO_MAKE_IS_REF(retval); } - /* break missing intentionally */ - default: - EX_T(opline->result.var).var.ptr_ptr = retval; - break; + ZVAL_INDIRECT(EX_VAR(opline->result.var), retval); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -5629,7 +5473,11 @@ static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE { USE_OPLINE - return zend_fetch_var_address_helper_SPEC_CONST_VAR(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { + return zend_fetch_var_address_helper_SPEC_CONST_VAR(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else { + return zend_fetch_var_address_helper_SPEC_CONST_VAR(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -5650,8 +5498,8 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HA SAVE_OPLINE(); container = opline->op1.zv; - zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC); + zval_ptr_dtor_nogc(free_op2.var); if (IS_CONST != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) { } @@ -5670,21 +5518,21 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_VAR_HANDLER(ZE if (IS_CONST == IS_CONST) { /* no function found. try a static method in class */ - if (CACHED_PTR(opline->op1.literal->cache_slot)) { - ce = CACHED_PTR(opline->op1.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } if (UNEXPECTED(ce == NULL)) { zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv)); } - CACHE_PTR(opline->op1.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce); } call->called_scope = ce; } else { - ce = EX_T(opline->op1.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op1.var)); if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) { call->called_scope = EG(called_scope); @@ -5695,62 +5543,51 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_VAR_HANDLER(ZE if (IS_CONST == IS_CONST && IS_VAR == IS_CONST && - CACHED_PTR(opline->op2.literal->cache_slot)) { - call->fbc = CACHED_PTR(opline->op2.literal->cache_slot); + CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else if (IS_CONST != IS_CONST && IS_VAR == IS_CONST && - (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) { + (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce))) { /* do nothing */ } else if (IS_VAR != IS_UNUSED) { - char *function_name_strval = NULL; - int function_name_strlen = 0; zend_free_op free_op2; - if (IS_VAR == IS_CONST) { - function_name_strval = Z_STRVAL_P(opline->op2.zv); - function_name_strlen = Z_STRLEN_P(opline->op2.zv); - } else { - function_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - + function_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + if (IS_VAR != IS_CONST) { if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } zend_error_noreturn(E_ERROR, "Function name must be a string"); - } else { - function_name_strval = Z_STRVAL_P(function_name); - function_name_strlen = Z_STRLEN_P(function_name); } } - if (function_name_strval) { - if (ce->get_static_method) { - call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC); + if (ce->get_static_method) { + call->fbc = ce->get_static_method(ce, Z_STR_P(function_name) TSRMLS_CC); + } else { + call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_VAR == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); + } + if (UNEXPECTED(call->fbc == NULL)) { + zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name)); + } + if (IS_VAR == IS_CONST && + EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) && + EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) { + if (IS_CONST == IS_CONST) { + CACHE_PTR(Z_CACHE_SLOT_P(function_name), call->fbc); } else { - call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); - } - if (UNEXPECTED(call->fbc == NULL)) { - zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval); - } - if (IS_VAR == IS_CONST && - EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) && - EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) { - if (IS_CONST == IS_CONST) { - CACHE_PTR(opline->op2.literal->cache_slot, call->fbc); - } else { - CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc); - } + CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), ce, call->fbc); } } if (IS_VAR != IS_CONST) { - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); } } else { if (UNEXPECTED(ce->constructor == NULL)) { zend_error_noreturn(E_ERROR, "Cannot call constructor"); } - if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { - zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name); + if (Z_OBJ(EG(This)) && Z_OBJCE(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { + zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name->val); } call->fbc = ce->constructor; } @@ -5758,21 +5595,21 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_VAR_HANDLER(ZE if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) { call->object = NULL; } else { - if (EG(This) && - Z_OBJ_HT_P(EG(This))->get_class_entry && - !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) { + if (Z_OBJ(EG(This)) && + Z_OBJ_HT(EG(This))->get_class_entry && + !instanceof_function(Z_OBJCE(EG(This)), ce TSRMLS_CC)) { /* We are calling method of the other (incompatible) class, but passing $this. This is done for compatibility with php-4. */ if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { - zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name); + zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val); } else { /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */ - zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name); + zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val); } } - if ((call->object = EG(This))) { - Z_ADDREF_P(call->object); - call->called_scope = Z_OBJCE_P(call->object); + call->object = Z_OBJ(EG(This)); + if (call->object) { + GC_REFCOUNT(call->object)++; } } @@ -5788,13 +5625,14 @@ static int ZEND_FASTCALL ZEND_CASE_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_A { USE_OPLINE zend_free_op free_op2; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - is_equal_function(&EX_T(opline->result.var).tmp_var, - opline->op1.zv, - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + fast_equal_function(result, + opline->op1.zv, + _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -5803,35 +5641,31 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_VAR_HANDLER(ZEND_OPC { USE_OPLINE - zval *expr_ptr; + zval *expr_ptr, new_expr; SAVE_OPLINE(); - if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) { - zval **expr_ptr_ptr = NULL; - - if (IS_CONST == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) { + if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && + (opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) { + expr_ptr = NULL; + if (IS_CONST == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets"); } - SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); - expr_ptr = *expr_ptr_ptr; + SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr); Z_ADDREF_P(expr_ptr); + } else { - expr_ptr=opline->op1.zv; + expr_ptr = opline->op1.zv; if (0) { /* temporary variable */ - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - } else if (IS_CONST == IS_CONST || PZVAL_IS_REF(expr_ptr)) { - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - zendi_zval_copy_ctor(*expr_ptr); + ZVAL_COPY_VALUE(&new_expr, expr_ptr); + expr_ptr = &new_expr; + } else if (IS_CONST == IS_CONST) { + ZVAL_DUP(&new_expr, expr_ptr); + expr_ptr = &new_expr; + } else if (Z_ISREF_P(expr_ptr)) { + ZVAL_DUP(&new_expr, Z_REFVAL_P(expr_ptr)); + expr_ptr = &new_expr; - } else if (IS_CONST == IS_CV) { + } else if (IS_CONST == IS_CV && Z_REFCOUNTED_P(expr_ptr)) { Z_ADDREF_P(expr_ptr); } } @@ -5839,42 +5673,49 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_VAR_HANDLER(ZEND_OPC if (IS_VAR != IS_UNUSED) { zend_free_op free_op2; zval *offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + zend_string *str; ulong hval; +add_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: hval = zend_dval_to_lval(Z_DVAL_P(offset)); goto num_index; case IS_LONG: - case IS_BOOL: hval = Z_LVAL_P(offset); num_index: - zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL); + zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); break; case IS_STRING: - if (IS_VAR == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); + str = Z_STR_P(offset); + if (IS_VAR != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index); } - zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL); +str_index: + zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); break; case IS_NULL: - zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); + str = STR_EMPTY_ALLOC(); + goto str_index; + case IS_FALSE: + hval = 0; + goto num_index; + case IS_TRUE: + hval = 1; + goto num_index; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto add_again; break; default: zend_error(E_WARNING, "Illegal offset type"); - zval_ptr_dtor(&expr_ptr); + zval_ptr_dtor(expr_ptr); /* do nothing */ break; } - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); } else { - zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL); - } - if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) { - + zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -5882,9 +5723,26 @@ num_index: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { + zval *array; + zend_uint size; USE_OPLINE - array_init(&EX_T(opline->result.var).tmp_var); + array = EX_VAR(opline->result.var); + if (IS_CONST != IS_UNUSED) { + size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; + } else { + size = 0; + } + ZVAL_NEW_ARR(array); + zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); + + if (IS_CONST != IS_UNUSED) { + /* Explicitly initialize array as not-packed if flag is set */ + if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) { + zend_hash_real_init(Z_ARRVAL_P(array), 0); + } + } + if (IS_CONST == IS_UNUSED) { ZEND_VM_NEXT_OPCODE(); #if 0 || IS_CONST != IS_UNUSED @@ -5900,20 +5758,15 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HAND zval tmp, *varname; HashTable *target_symbol_table; + zend_bool tmp_is_dup = 0; SAVE_OPLINE(); if (IS_CONST == IS_CV && IS_VAR == IS_UNUSED && (opline->extended_value & ZEND_QUICK_SET)) { - if (EG(active_symbol_table)) { - zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); - - zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC); - EX_CV(opline->op1.var) = NULL; - } else if (EX_CV(opline->op1.var)) { - zval_ptr_dtor(EX_CV(opline->op1.var)); - EX_CV(opline->op1.var) = NULL; - } + ZVAL_COPY_VALUE(&tmp, EX_VAR(opline->op1.var)); + ZVAL_UNDEF(EX_VAR(opline->op1.var)); + zval_ptr_dtor(&tmp); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -5921,27 +5774,28 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HAND varname = opline->op1.zv; if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { - ZVAL_COPY_VALUE(&tmp, varname); - zval_copy_ctor(&tmp); + ZVAL_DUP(&tmp, varname); convert_to_string(&tmp); varname = &tmp; + tmp_is_dup = 1; } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) { - Z_ADDREF_P(varname); + ZVAL_COPY(&tmp, varname); + varname = &tmp; } if (IS_VAR != IS_UNUSED) { zend_class_entry *ce; if (IS_VAR == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { - if (IS_CONST != IS_CONST && varname == &tmp) { + if (IS_CONST != IS_CONST && tmp_is_dup) { zval_dtor(&tmp); } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) { - zval_ptr_dtor(&varname); + zval_ptr_dtor(&tmp); } HANDLE_EXCEPTION(); @@ -5949,23 +5803,21 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HAND if (UNEXPECTED(ce == NULL)) { zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv)); } - CACHE_PTR(opline->op2.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); } } else { - ce = EX_T(opline->op2.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op2.var)); } - zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); + zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC); } else { - ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1); - target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); - zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC); + zend_hash_del_ind(target_symbol_table, Z_STR_P(varname)); } - if (IS_CONST != IS_CONST && varname == &tmp) { + if (IS_CONST != IS_CONST && tmp_is_dup) { zval_dtor(&tmp); } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) { - zval_ptr_dtor(&varname); + zval_ptr_dtor(&tmp); } CHECK_EXCEPTION(); @@ -5975,21 +5827,16 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HAND static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval **value; + zval *value; zend_bool isset = 1; SAVE_OPLINE(); if (IS_CONST == IS_CV && IS_VAR == IS_UNUSED && (opline->extended_value & ZEND_QUICK_SET)) { - if (EX_CV(opline->op1.var)) { - value = EX_CV(opline->op1.var); - } else if (EG(active_symbol_table)) { - zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); - - if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) { - isset = 0; - } + if (Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_UNDEF) { + value = EX_VAR(opline->op1.var); + ZVAL_DEREF(value); } else { isset = 0; } @@ -5999,8 +5846,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPC zval tmp, *varname = opline->op1.zv; if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { - ZVAL_COPY_VALUE(&tmp, varname); - zval_copy_ctor(&tmp); + ZVAL_DUP(&tmp, varname); convert_to_string(&tmp); varname = &tmp; } @@ -6009,26 +5855,26 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPC zend_class_entry *ce; if (IS_VAR == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(opline->op2.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); } } else { - ce = EX_T(opline->op2.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op2.var)); } - value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); + value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC); if (!value) { isset = 0; } } else { target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); - if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) { + if ((value = zend_hash_find(target_symbol_table, Z_STR_P(varname))) == NULL) { isset = 0; } } @@ -6040,16 +5886,16 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPC } if (opline->extended_value & ZEND_ISSET) { - if (isset && Z_TYPE_PP(value) != IS_NULL) { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); + if (isset && Z_TYPE_P(value) != IS_NULL) { + ZVAL_BOOL(EX_VAR(opline->result.var), 1); } else { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); + ZVAL_BOOL(EX_VAR(opline->result.var), 0); } } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { - if (!isset || !i_zend_is_true(*value TSRMLS_CC)) { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); + if (!isset || !i_zend_is_true(value TSRMLS_CC)) { + ZVAL_BOOL(EX_VAR(opline->result.var), 1); } else { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); + ZVAL_BOOL(EX_VAR(opline->result.var), 0); } } @@ -6061,22 +5907,18 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ { USE_OPLINE - /* The generator object is stored in return_value_ptr_ptr */ - zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr); + /* The generator object is stored in EX(return_value) */ + zend_generator *generator = (zend_generator *) EX(return_value); if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) { zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator"); } /* Destroy the previously yielded value */ - if (generator->value) { - zval_ptr_dtor(&generator->value); - } + zval_ptr_dtor(&generator->value); /* Destroy the previously yielded key */ - if (generator->key) { - zval_ptr_dtor(&generator->key); - } + zval_ptr_dtor(&generator->key); /* Set the new yielded value */ if (IS_CONST != IS_UNUSED) { @@ -6086,74 +5928,58 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ /* Constants and temporary variables aren't yieldable by reference, * but we still allow them with a notice. */ if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) { - zval *value, *copy; + zval *value; zend_error(E_NOTICE, "Only variable references should be yielded by reference"); value = opline->op1.zv; - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); + ZVAL_COPY_VALUE(&generator->value, value); + if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1); /* Temporary variables don't need ctor copying */ if (!0) { - zval_copy_ctor(copy); + zval_copy_ctor(&generator->value); } - - generator->value = copy; } else { - zval **value_ptr = NULL; + zval *value_ptr = NULL; - if (IS_CONST == IS_VAR && UNEXPECTED(value_ptr == NULL)) { + if (IS_CONST == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference"); } /* If a function call result is yielded and the function did * not return by reference we throw a notice. */ - if (IS_CONST == IS_VAR && !Z_ISREF_PP(value_ptr) + if (IS_CONST == IS_VAR && !Z_ISREF_P(value_ptr) && !(opline->extended_value == ZEND_RETURNS_FUNCTION - && EX_T(opline->op1.var).var.fcall_returned_reference) - && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) { + && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); - - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } else { SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr); - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } + ZVAL_COPY(&generator->value, value_ptr); } } else { zval *value = opline->op1.zv; /* Consts, temporary variables and references need copying */ - if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR - || PZVAL_IS_REF(value) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); - - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } - - generator->value = copy; + if (IS_CONST == IS_CONST) { + ZVAL_DUP(&generator->value, value); + } else if (IS_CONST == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->value, value); + } else if (Z_ISREF_P(value)) { + ZVAL_DUP(&generator->value, Z_REFVAL_P(value)); } else { if (IS_CONST == IS_CV) { - Z_ADDREF_P(value); + if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value); } - generator->value = value; + ZVAL_COPY_VALUE(&generator->value, value); } } } else { /* If no value was specified yield null */ - Z_ADDREF(EG(uninitialized_zval)); - generator->value = &EG(uninitialized_zval); + ZVAL_NULL(&generator->value); } /* Set the new yielded key */ @@ -6162,46 +5988,36 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); /* Consts, temporary variables and references need copying */ - if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR - || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, key); - - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } - - generator->key = copy; + if (IS_VAR == IS_CONST) { + ZVAL_DUP(&generator->key, key); + } else if (IS_VAR == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->key, key); + } else if (Z_ISREF_P(key)) { + ZVAL_DUP(&generator->key, Z_REFVAL_P(key)); + zval_ptr_dtor_nogc(free_op2.var); } else { - Z_ADDREF_P(key); - generator->key = key; + if (IS_VAR == IS_CV) { + if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key); + } + ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE_P(generator->key) == IS_LONG - && Z_LVAL_P(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_LONG + && Z_LVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL_P(generator->key); + generator->largest_used_integer_key = Z_LVAL(generator->key); } - - zval_ptr_dtor_nogc(&free_op2.var); } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - - ALLOC_INIT_ZVAL(generator->key); - ZVAL_LONG(generator->key, generator->largest_used_integer_key); + ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ - generator->send_target = &EX_T(opline->result.var).var.ptr; - Z_ADDREF(EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + generator->send_target = EX_VAR(opline->result.var); + ZVAL_NULL(generator->send_target); } else { generator->send_target = NULL; } @@ -6223,11 +6039,11 @@ static int ZEND_FASTCALL ZEND_POW_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR zend_free_op free_op2; SAVE_OPLINE(); - pow_function(&EX_T(opline->result.var).tmp_var, + pow_function(EX_VAR(opline->result.var), opline->op1.zv, - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -6235,21 +6051,18 @@ static int ZEND_FASTCALL ZEND_POW_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_UNUSED(int type, ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_free_op free_op1; + zval *varname; - zval **retval; + zval *retval; zval tmp_varname; HashTable *target_symbol_table; - ulong hash_value; SAVE_OPLINE(); varname = opline->op1.zv; + ZVAL_UNDEF(&tmp_varname); if (IS_CONST != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) { - ZVAL_COPY_VALUE(&tmp_varname, varname); - zval_copy_ctor(&tmp_varname); - Z_SET_REFCOUNT(tmp_varname, 1); - Z_UNSET_ISREF(tmp_varname); + ZVAL_DUP_DEREF(&tmp_varname, varname); convert_to_string(&tmp_varname); varname = &tmp_varname; } @@ -6258,105 +6071,88 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_UNUSED(int typ zend_class_entry *ce; if (IS_UNUSED == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { - if (IS_CONST != IS_CONST && varname == &tmp_varname) { + if (IS_CONST != IS_CONST) { zval_dtor(&tmp_varname); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(opline->op2.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); } } else { - ce = EX_T(opline->op2.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op2.var)); } - retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); + retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC); } else { target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); -/* - if (!target_symbol_table) { - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); - } -*/ - if (IS_CONST == IS_CONST) { - hash_value = Z_HASH_P(varname); - } else { - hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname)); - } - - if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) { + retval = zend_hash_find(target_symbol_table, Z_STR_P(varname)); + if (retval == NULL) { switch (type) { case BP_VAR_R: case BP_VAR_UNSET: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); /* break missing intentionally */ case BP_VAR_IS: - retval = &EG(uninitialized_zval_ptr); + retval = EX_VAR(opline->result.var); + ZVAL_NULL(retval); break; case BP_VAR_RW: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); /* break missing intentionally */ case BP_VAR_W: - Z_ADDREF_P(&EG(uninitialized_zval)); - zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval); + retval = zend_hash_update(target_symbol_table, Z_STR_P(varname), &EG(uninitialized_zval)); break; EMPTY_SWITCH_DEFAULT_CASE() } - } - switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) { - case ZEND_FETCH_GLOBAL: - if (IS_CONST != IS_TMP_VAR) { - + /* GLOBAL or $$name variable may be an INDIRECT pointer to CV */ + } else if (Z_TYPE_P(retval) == IS_INDIRECT) { + retval = Z_INDIRECT_P(retval); + if (Z_TYPE_P(retval) == IS_UNDEF) { + switch (type) { + case BP_VAR_R: + case BP_VAR_UNSET: + zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); + /* break missing intentionally */ + case BP_VAR_IS: + retval = EX_VAR(opline->result.var); + ZVAL_NULL(retval); + break; + case BP_VAR_RW: + zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); + /* break missing intentionally */ + case BP_VAR_W: + ZVAL_NULL(retval); + break; + EMPTY_SWITCH_DEFAULT_CASE() } - break; - case ZEND_FETCH_LOCAL: + } + } + if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC) { + zval_update_constant(retval, 1 TSRMLS_CC); + } else if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) != ZEND_FETCH_GLOBAL_LOCK) { - break; - case ZEND_FETCH_STATIC: - zval_update_constant(retval, 1 TSRMLS_CC); - break; - case ZEND_FETCH_GLOBAL_LOCK: - if (IS_CONST == IS_VAR && !free_op1.var) { - PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); - } - break; } } - - if (IS_CONST != IS_CONST && varname == &tmp_varname) { + if (IS_CONST != IS_CONST) { zval_dtor(&tmp_varname); } - if (opline->extended_value & ZEND_FETCH_MAKE_REF) { - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval); - } - PZVAL_LOCK(*retval); - switch (type) { - case BP_VAR_R: - case BP_VAR_IS: - EX_T(opline->result.var).var.ptr = *retval; - break; - case BP_VAR_UNSET: { - zend_free_op free_res; - PZVAL_UNLOCK(*retval, &free_res); - if (retval != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(retval); - } - PZVAL_LOCK(*retval); - FREE_OP_VAR_PTR(free_res); + ZEND_ASSERT(retval != NULL); + if (type == BP_VAR_R || type == BP_VAR_IS) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); + } else { + if (/*type == BP_VAR_W &&*/ (opline->extended_value & ZEND_FETCH_MAKE_REF)) { + SEPARATE_ZVAL_TO_MAKE_IS_REF(retval); } - /* break missing intentionally */ - default: - EX_T(opline->result.var).var.ptr_ptr = retval; - break; + ZVAL_INDIRECT(EX_VAR(opline->result.var), retval); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -6381,7 +6177,11 @@ static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND_OPC { USE_OPLINE - return zend_fetch_var_address_helper_SPEC_CONST_UNUSED(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { + return zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else { + return zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -6405,21 +6205,21 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER if (IS_CONST == IS_CONST) { /* no function found. try a static method in class */ - if (CACHED_PTR(opline->op1.literal->cache_slot)) { - ce = CACHED_PTR(opline->op1.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } if (UNEXPECTED(ce == NULL)) { zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv)); } - CACHE_PTR(opline->op1.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce); } call->called_scope = ce; } else { - ce = EX_T(opline->op1.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op1.var)); if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) { call->called_scope = EG(called_scope); @@ -6430,51 +6230,40 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER if (IS_CONST == IS_CONST && IS_UNUSED == IS_CONST && - CACHED_PTR(opline->op2.literal->cache_slot)) { - call->fbc = CACHED_PTR(opline->op2.literal->cache_slot); + CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else if (IS_CONST != IS_CONST && IS_UNUSED == IS_CONST && - (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) { + (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce))) { /* do nothing */ } else if (IS_UNUSED != IS_UNUSED) { - char *function_name_strval = NULL; - int function_name_strlen = 0; - if (IS_UNUSED == IS_CONST) { - function_name_strval = Z_STRVAL_P(opline->op2.zv); - function_name_strlen = Z_STRLEN_P(opline->op2.zv); - } else { - function_name = NULL; - + function_name = NULL; + if (IS_UNUSED != IS_CONST) { if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } zend_error_noreturn(E_ERROR, "Function name must be a string"); - } else { - function_name_strval = Z_STRVAL_P(function_name); - function_name_strlen = Z_STRLEN_P(function_name); } } - if (function_name_strval) { - if (ce->get_static_method) { - call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC); + if (ce->get_static_method) { + call->fbc = ce->get_static_method(ce, Z_STR_P(function_name) TSRMLS_CC); + } else { + call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_UNUSED == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); + } + if (UNEXPECTED(call->fbc == NULL)) { + zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name)); + } + if (IS_UNUSED == IS_CONST && + EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) && + EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) { + if (IS_CONST == IS_CONST) { + CACHE_PTR(Z_CACHE_SLOT_P(function_name), call->fbc); } else { - call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_UNUSED == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); - } - if (UNEXPECTED(call->fbc == NULL)) { - zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval); - } - if (IS_UNUSED == IS_CONST && - EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) && - EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) { - if (IS_CONST == IS_CONST) { - CACHE_PTR(opline->op2.literal->cache_slot, call->fbc); - } else { - CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc); - } + CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), ce, call->fbc); } } if (IS_UNUSED != IS_CONST) { @@ -6484,8 +6273,8 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER if (UNEXPECTED(ce->constructor == NULL)) { zend_error_noreturn(E_ERROR, "Cannot call constructor"); } - if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { - zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name); + if (Z_OBJ(EG(This)) && Z_OBJCE(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { + zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name->val); } call->fbc = ce->constructor; } @@ -6493,21 +6282,21 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) { call->object = NULL; } else { - if (EG(This) && - Z_OBJ_HT_P(EG(This))->get_class_entry && - !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) { + if (Z_OBJ(EG(This)) && + Z_OBJ_HT(EG(This))->get_class_entry && + !instanceof_function(Z_OBJCE(EG(This)), ce TSRMLS_CC)) { /* We are calling method of the other (incompatible) class, but passing $this. This is done for compatibility with php-4. */ if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { - zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name); + zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val); } else { /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */ - zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name); + zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val); } } - if ((call->object = EG(This))) { - Z_ADDREF_P(call->object); - call->called_scope = Z_OBJCE_P(call->object); + call->object = Z_OBJ(EG(This)); + if (call->object) { + GC_REFCOUNT(call->object)++; } } @@ -6523,35 +6312,31 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_ { USE_OPLINE - zval *expr_ptr; + zval *expr_ptr, new_expr; SAVE_OPLINE(); - if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) { - zval **expr_ptr_ptr = NULL; - - if (IS_CONST == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) { + if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && + (opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) { + expr_ptr = NULL; + if (IS_CONST == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets"); } - SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); - expr_ptr = *expr_ptr_ptr; + SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr); Z_ADDREF_P(expr_ptr); + } else { - expr_ptr=opline->op1.zv; + expr_ptr = opline->op1.zv; if (0) { /* temporary variable */ - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - } else if (IS_CONST == IS_CONST || PZVAL_IS_REF(expr_ptr)) { - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - zendi_zval_copy_ctor(*expr_ptr); + ZVAL_COPY_VALUE(&new_expr, expr_ptr); + expr_ptr = &new_expr; + } else if (IS_CONST == IS_CONST) { + ZVAL_DUP(&new_expr, expr_ptr); + expr_ptr = &new_expr; + } else if (Z_ISREF_P(expr_ptr)) { + ZVAL_DUP(&new_expr, Z_REFVAL_P(expr_ptr)); + expr_ptr = &new_expr; - } else if (IS_CONST == IS_CV) { + } else if (IS_CONST == IS_CV && Z_REFCOUNTED_P(expr_ptr)) { Z_ADDREF_P(expr_ptr); } } @@ -6559,42 +6344,49 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_ if (IS_UNUSED != IS_UNUSED) { zval *offset = NULL; + zend_string *str; ulong hval; +add_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: hval = zend_dval_to_lval(Z_DVAL_P(offset)); goto num_index; case IS_LONG: - case IS_BOOL: hval = Z_LVAL_P(offset); num_index: - zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL); + zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); break; case IS_STRING: - if (IS_UNUSED == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); + str = Z_STR_P(offset); + if (IS_UNUSED != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index); } - zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL); +str_index: + zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); break; case IS_NULL: - zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); + str = STR_EMPTY_ALLOC(); + goto str_index; + case IS_FALSE: + hval = 0; + goto num_index; + case IS_TRUE: + hval = 1; + goto num_index; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto add_again; break; default: zend_error(E_WARNING, "Illegal offset type"); - zval_ptr_dtor(&expr_ptr); + zval_ptr_dtor(expr_ptr); /* do nothing */ break; } } else { - zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL); - } - if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) { - + zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -6602,9 +6394,26 @@ num_index: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { + zval *array; + zend_uint size; USE_OPLINE - array_init(&EX_T(opline->result.var).tmp_var); + array = EX_VAR(opline->result.var); + if (IS_CONST != IS_UNUSED) { + size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; + } else { + size = 0; + } + ZVAL_NEW_ARR(array); + zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); + + if (IS_CONST != IS_UNUSED) { + /* Explicitly initialize array as not-packed if flag is set */ + if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) { + zend_hash_real_init(Z_ARRVAL_P(array), 0); + } + } + if (IS_CONST == IS_UNUSED) { ZEND_VM_NEXT_OPCODE(); #if 0 || IS_CONST != IS_UNUSED @@ -6620,20 +6429,15 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_H zval tmp, *varname; HashTable *target_symbol_table; + zend_bool tmp_is_dup = 0; SAVE_OPLINE(); if (IS_CONST == IS_CV && IS_UNUSED == IS_UNUSED && (opline->extended_value & ZEND_QUICK_SET)) { - if (EG(active_symbol_table)) { - zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); - - zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC); - EX_CV(opline->op1.var) = NULL; - } else if (EX_CV(opline->op1.var)) { - zval_ptr_dtor(EX_CV(opline->op1.var)); - EX_CV(opline->op1.var) = NULL; - } + ZVAL_COPY_VALUE(&tmp, EX_VAR(opline->op1.var)); + ZVAL_UNDEF(EX_VAR(opline->op1.var)); + zval_ptr_dtor(&tmp); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -6641,27 +6445,28 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_H varname = opline->op1.zv; if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { - ZVAL_COPY_VALUE(&tmp, varname); - zval_copy_ctor(&tmp); + ZVAL_DUP(&tmp, varname); convert_to_string(&tmp); varname = &tmp; + tmp_is_dup = 1; } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) { - Z_ADDREF_P(varname); + ZVAL_COPY(&tmp, varname); + varname = &tmp; } if (IS_UNUSED != IS_UNUSED) { zend_class_entry *ce; if (IS_UNUSED == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { - if (IS_CONST != IS_CONST && varname == &tmp) { + if (IS_CONST != IS_CONST && tmp_is_dup) { zval_dtor(&tmp); } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) { - zval_ptr_dtor(&varname); + zval_ptr_dtor(&tmp); } HANDLE_EXCEPTION(); @@ -6669,23 +6474,21 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_H if (UNEXPECTED(ce == NULL)) { zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv)); } - CACHE_PTR(opline->op2.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); } } else { - ce = EX_T(opline->op2.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op2.var)); } - zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); + zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC); } else { - ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1); - target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); - zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC); + zend_hash_del_ind(target_symbol_table, Z_STR_P(varname)); } - if (IS_CONST != IS_CONST && varname == &tmp) { + if (IS_CONST != IS_CONST && tmp_is_dup) { zval_dtor(&tmp); } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) { - zval_ptr_dtor(&varname); + zval_ptr_dtor(&tmp); } CHECK_EXCEPTION(); @@ -6695,21 +6498,16 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_H static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval **value; + zval *value; zend_bool isset = 1; SAVE_OPLINE(); if (IS_CONST == IS_CV && IS_UNUSED == IS_UNUSED && (opline->extended_value & ZEND_QUICK_SET)) { - if (EX_CV(opline->op1.var)) { - value = EX_CV(opline->op1.var); - } else if (EG(active_symbol_table)) { - zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); - - if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) { - isset = 0; - } + if (Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_UNDEF) { + value = EX_VAR(opline->op1.var); + ZVAL_DEREF(value); } else { isset = 0; } @@ -6719,8 +6517,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_ zval tmp, *varname = opline->op1.zv; if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { - ZVAL_COPY_VALUE(&tmp, varname); - zval_copy_ctor(&tmp); + ZVAL_DUP(&tmp, varname); convert_to_string(&tmp); varname = &tmp; } @@ -6729,26 +6526,26 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_ zend_class_entry *ce; if (IS_UNUSED == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(opline->op2.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); } } else { - ce = EX_T(opline->op2.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op2.var)); } - value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); + value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC); if (!value) { isset = 0; } } else { target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); - if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) { + if ((value = zend_hash_find(target_symbol_table, Z_STR_P(varname))) == NULL) { isset = 0; } } @@ -6760,16 +6557,16 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_ } if (opline->extended_value & ZEND_ISSET) { - if (isset && Z_TYPE_PP(value) != IS_NULL) { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); + if (isset && Z_TYPE_P(value) != IS_NULL) { + ZVAL_BOOL(EX_VAR(opline->result.var), 1); } else { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); + ZVAL_BOOL(EX_VAR(opline->result.var), 0); } } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { - if (!isset || !i_zend_is_true(*value TSRMLS_CC)) { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); + if (!isset || !i_zend_is_true(value TSRMLS_CC)) { + ZVAL_BOOL(EX_VAR(opline->result.var), 1); } else { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); + ZVAL_BOOL(EX_VAR(opline->result.var), 0); } } @@ -6780,16 +6577,16 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_ static int ZEND_FASTCALL ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_function *op_array; + zval *zfunc; SAVE_OPLINE(); - if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), Z_HASH_P(opline->op1.zv), (void *) &op_array) == FAILURE) || - UNEXPECTED(op_array->type != ZEND_USER_FUNCTION)) { + if (UNEXPECTED((zfunc = zend_hash_find(EG(function_table), Z_STR_P(opline->op1.zv))) == NULL) || + UNEXPECTED(Z_FUNC_P(zfunc)->type != ZEND_USER_FUNCTION)) { zend_error_noreturn(E_ERROR, "Base lambda function for closure not found"); } - zend_create_closure(&EX_T(opline->result.var).tmp_var, (zend_function *) op_array, EG(scope), EG(This) TSRMLS_CC); + zend_create_closure(EX_VAR(opline->result.var), Z_FUNC_P(zfunc), EG(scope), Z_OBJ(EG(This)) ? &EG(This) : NULL TSRMLS_CC); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -6799,22 +6596,18 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDL { USE_OPLINE - /* The generator object is stored in return_value_ptr_ptr */ - zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr); + /* The generator object is stored in EX(return_value) */ + zend_generator *generator = (zend_generator *) EX(return_value); if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) { zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator"); } /* Destroy the previously yielded value */ - if (generator->value) { - zval_ptr_dtor(&generator->value); - } + zval_ptr_dtor(&generator->value); /* Destroy the previously yielded key */ - if (generator->key) { - zval_ptr_dtor(&generator->key); - } + zval_ptr_dtor(&generator->key); /* Set the new yielded value */ if (IS_CONST != IS_UNUSED) { @@ -6824,74 +6617,58 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDL /* Constants and temporary variables aren't yieldable by reference, * but we still allow them with a notice. */ if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) { - zval *value, *copy; + zval *value; zend_error(E_NOTICE, "Only variable references should be yielded by reference"); value = opline->op1.zv; - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); + ZVAL_COPY_VALUE(&generator->value, value); + if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1); /* Temporary variables don't need ctor copying */ if (!0) { - zval_copy_ctor(copy); + zval_copy_ctor(&generator->value); } - - generator->value = copy; } else { - zval **value_ptr = NULL; + zval *value_ptr = NULL; - if (IS_CONST == IS_VAR && UNEXPECTED(value_ptr == NULL)) { + if (IS_CONST == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference"); } /* If a function call result is yielded and the function did * not return by reference we throw a notice. */ - if (IS_CONST == IS_VAR && !Z_ISREF_PP(value_ptr) + if (IS_CONST == IS_VAR && !Z_ISREF_P(value_ptr) && !(opline->extended_value == ZEND_RETURNS_FUNCTION - && EX_T(opline->op1.var).var.fcall_returned_reference) - && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) { + && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); - - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } else { SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr); - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } + ZVAL_COPY(&generator->value, value_ptr); } } else { zval *value = opline->op1.zv; /* Consts, temporary variables and references need copying */ - if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR - || PZVAL_IS_REF(value) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); - - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } - - generator->value = copy; + if (IS_CONST == IS_CONST) { + ZVAL_DUP(&generator->value, value); + } else if (IS_CONST == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->value, value); + } else if (Z_ISREF_P(value)) { + ZVAL_DUP(&generator->value, Z_REFVAL_P(value)); } else { if (IS_CONST == IS_CV) { - Z_ADDREF_P(value); + if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value); } - generator->value = value; + ZVAL_COPY_VALUE(&generator->value, value); } } } else { /* If no value was specified yield null */ - Z_ADDREF(EG(uninitialized_zval)); - generator->value = &EG(uninitialized_zval); + ZVAL_NULL(&generator->value); } /* Set the new yielded key */ @@ -6900,45 +6677,36 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDL zval *key = NULL; /* Consts, temporary variables and references need copying */ - if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR - || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, key); - - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } + if (IS_UNUSED == IS_CONST) { + ZVAL_DUP(&generator->key, key); + } else if (IS_UNUSED == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->key, key); + } else if (Z_ISREF_P(key)) { + ZVAL_DUP(&generator->key, Z_REFVAL_P(key)); - generator->key = copy; } else { - Z_ADDREF_P(key); - generator->key = key; + if (IS_UNUSED == IS_CV) { + if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key); + } + ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE_P(generator->key) == IS_LONG - && Z_LVAL_P(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_LONG + && Z_LVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL_P(generator->key); + generator->largest_used_integer_key = Z_LVAL(generator->key); } - } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - - ALLOC_INIT_ZVAL(generator->key); - ZVAL_LONG(generator->key, generator->largest_used_integer_key); + ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ - generator->send_target = &EX_T(opline->result.var).var.ptr; - Z_ADDREF(EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + generator->send_target = EX_VAR(opline->result.var); + ZVAL_NULL(generator->send_target); } else { generator->send_target = NULL; } @@ -6960,7 +6728,7 @@ static int ZEND_FASTCALL ZEND_ADD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG SAVE_OPLINE(); - fast_add_function(&EX_T(opline->result.var).tmp_var, + fast_add_function(EX_VAR(opline->result.var), opline->op1.zv, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); @@ -6975,7 +6743,7 @@ static int ZEND_FASTCALL ZEND_SUB_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG SAVE_OPLINE(); - fast_sub_function(&EX_T(opline->result.var).tmp_var, + fast_sub_function(EX_VAR(opline->result.var), opline->op1.zv, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); @@ -6990,7 +6758,7 @@ static int ZEND_FASTCALL ZEND_MUL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG SAVE_OPLINE(); - fast_mul_function(&EX_T(opline->result.var).tmp_var, + fast_mul_function(EX_VAR(opline->result.var), opline->op1.zv, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); @@ -7005,7 +6773,7 @@ static int ZEND_FASTCALL ZEND_DIV_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG SAVE_OPLINE(); - fast_div_function(&EX_T(opline->result.var).tmp_var, + fast_div_function(EX_VAR(opline->result.var), opline->op1.zv, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); @@ -7020,9 +6788,9 @@ static int ZEND_FASTCALL ZEND_MOD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG SAVE_OPLINE(); - fast_mod_function(&EX_T(opline->result.var).tmp_var, + fast_mod_function(EX_VAR(opline->result.var), opline->op1.zv, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); CHECK_EXCEPTION(); @@ -7035,9 +6803,9 @@ static int ZEND_FASTCALL ZEND_SL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS SAVE_OPLINE(); - shift_left_function(&EX_T(opline->result.var).tmp_var, + shift_left_function(EX_VAR(opline->result.var), opline->op1.zv, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); CHECK_EXCEPTION(); @@ -7050,9 +6818,9 @@ static int ZEND_FASTCALL ZEND_SR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS SAVE_OPLINE(); - shift_right_function(&EX_T(opline->result.var).tmp_var, + shift_right_function(EX_VAR(opline->result.var), opline->op1.zv, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); CHECK_EXCEPTION(); @@ -7065,9 +6833,9 @@ static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ SAVE_OPLINE(); - concat_function(&EX_T(opline->result.var).tmp_var, + concat_function(EX_VAR(opline->result.var), opline->op1.zv, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); CHECK_EXCEPTION(); @@ -7080,9 +6848,9 @@ static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HA SAVE_OPLINE(); - is_identical_function(&EX_T(opline->result.var).tmp_var, + fast_is_identical_function(EX_VAR(opline->result.var), opline->op1.zv, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); CHECK_EXCEPTION(); @@ -7093,13 +6861,12 @@ static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CV_HANDLER(ZEND_OPCOD { USE_OPLINE - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - is_identical_function(result, + fast_is_not_identical_function(result, opline->op1.zv, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); - Z_LVAL_P(result) = !Z_LVAL_P(result); + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); CHECK_EXCEPTION(); @@ -7110,12 +6877,12 @@ static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLE { USE_OPLINE - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_equal_function(result, + fast_equal_function(result, opline->op1.zv, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); CHECK_EXCEPTION(); @@ -7126,12 +6893,12 @@ static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HA { USE_OPLINE - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_not_equal_function(result, + fast_not_equal_function(result, opline->op1.zv, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); CHECK_EXCEPTION(); @@ -7142,12 +6909,12 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HAND { USE_OPLINE - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_is_smaller_function(result, + fast_is_smaller_function(result, opline->op1.zv, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); CHECK_EXCEPTION(); @@ -7158,12 +6925,12 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OP { USE_OPLINE - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, + fast_is_smaller_or_equal_function(result, opline->op1.zv, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); CHECK_EXCEPTION(); @@ -7176,9 +6943,9 @@ static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_A SAVE_OPLINE(); - bitwise_or_function(&EX_T(opline->result.var).tmp_var, + bitwise_or_function(EX_VAR(opline->result.var), opline->op1.zv, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); CHECK_EXCEPTION(); @@ -7191,9 +6958,9 @@ static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ SAVE_OPLINE(); - bitwise_and_function(&EX_T(opline->result.var).tmp_var, + bitwise_and_function(EX_VAR(opline->result.var), opline->op1.zv, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); CHECK_EXCEPTION(); @@ -7206,9 +6973,9 @@ static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ SAVE_OPLINE(); - bitwise_xor_function(&EX_T(opline->result.var).tmp_var, + bitwise_xor_function(EX_VAR(opline->result.var), opline->op1.zv, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); CHECK_EXCEPTION(); @@ -7221,9 +6988,9 @@ static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLE SAVE_OPLINE(); - boolean_xor_function(&EX_T(opline->result.var).tmp_var, + boolean_xor_function(EX_VAR(opline->result.var), opline->op1.zv, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); CHECK_EXCEPTION(); @@ -7238,7 +7005,7 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HAN SAVE_OPLINE(); container = opline->op1.zv; - zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC); if (IS_CONST != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) { @@ -7258,21 +7025,21 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEN if (IS_CONST == IS_CONST) { /* no function found. try a static method in class */ - if (CACHED_PTR(opline->op1.literal->cache_slot)) { - ce = CACHED_PTR(opline->op1.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } if (UNEXPECTED(ce == NULL)) { zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv)); } - CACHE_PTR(opline->op1.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce); } call->called_scope = ce; } else { - ce = EX_T(opline->op1.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op1.var)); if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) { call->called_scope = EG(called_scope); @@ -7283,51 +7050,40 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEN if (IS_CONST == IS_CONST && IS_CV == IS_CONST && - CACHED_PTR(opline->op2.literal->cache_slot)) { - call->fbc = CACHED_PTR(opline->op2.literal->cache_slot); + CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else if (IS_CONST != IS_CONST && IS_CV == IS_CONST && - (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) { + (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce))) { /* do nothing */ } else if (IS_CV != IS_UNUSED) { - char *function_name_strval = NULL; - int function_name_strlen = 0; - - if (IS_CV == IS_CONST) { - function_name_strval = Z_STRVAL_P(opline->op2.zv); - function_name_strlen = Z_STRLEN_P(opline->op2.zv); - } else { - function_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); + function_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); + if (IS_CV != IS_CONST) { if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } zend_error_noreturn(E_ERROR, "Function name must be a string"); - } else { - function_name_strval = Z_STRVAL_P(function_name); - function_name_strlen = Z_STRLEN_P(function_name); } } - if (function_name_strval) { - if (ce->get_static_method) { - call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC); + if (ce->get_static_method) { + call->fbc = ce->get_static_method(ce, Z_STR_P(function_name) TSRMLS_CC); + } else { + call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); + } + if (UNEXPECTED(call->fbc == NULL)) { + zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name)); + } + if (IS_CV == IS_CONST && + EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) && + EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) { + if (IS_CONST == IS_CONST) { + CACHE_PTR(Z_CACHE_SLOT_P(function_name), call->fbc); } else { - call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); - } - if (UNEXPECTED(call->fbc == NULL)) { - zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval); - } - if (IS_CV == IS_CONST && - EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) && - EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) { - if (IS_CONST == IS_CONST) { - CACHE_PTR(opline->op2.literal->cache_slot, call->fbc); - } else { - CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc); - } + CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), ce, call->fbc); } } if (IS_CV != IS_CONST) { @@ -7337,8 +7093,8 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEN if (UNEXPECTED(ce->constructor == NULL)) { zend_error_noreturn(E_ERROR, "Cannot call constructor"); } - if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { - zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name); + if (Z_OBJ(EG(This)) && Z_OBJCE(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { + zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name->val); } call->fbc = ce->constructor; } @@ -7346,21 +7102,21 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEN if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) { call->object = NULL; } else { - if (EG(This) && - Z_OBJ_HT_P(EG(This))->get_class_entry && - !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) { + if (Z_OBJ(EG(This)) && + Z_OBJ_HT(EG(This))->get_class_entry && + !instanceof_function(Z_OBJCE(EG(This)), ce TSRMLS_CC)) { /* We are calling method of the other (incompatible) class, but passing $this. This is done for compatibility with php-4. */ if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { - zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name); + zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val); } else { /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */ - zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name); + zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val); } } - if ((call->object = EG(This))) { - Z_ADDREF_P(call->object); - call->called_scope = Z_OBJCE_P(call->object); + call->object = Z_OBJ(EG(This)); + if (call->object) { + GC_REFCOUNT(call->object)++; } } @@ -7376,7 +7132,7 @@ static int ZEND_FASTCALL ZEND_CATCH_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_A { USE_OPLINE zend_class_entry *ce, *catch_ce; - zval *exception; + zend_object *exception; SAVE_OPLINE(); /* Check whether an exception has been thrown, if not, jump over code */ @@ -7385,14 +7141,14 @@ static int ZEND_FASTCALL ZEND_CATCH_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_A ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]); ZEND_VM_CONTINUE(); /* CHECK_ME */ } - if (CACHED_PTR(opline->op1.literal->cache_slot)) { - catch_ce = CACHED_PTR(opline->op1.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) { + catch_ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv)); } else { - catch_ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC); + catch_ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC); - CACHE_PTR(opline->op1.literal->cache_slot, catch_ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), catch_ce); } - ce = Z_OBJCE_P(EG(exception)); + ce = zend_get_class_entry(EG(exception) TSRMLS_CC); #ifdef HAVE_DTRACE if (DTRACE_EXCEPTION_CAUGHT_ENABLED()) { @@ -7412,19 +7168,12 @@ static int ZEND_FASTCALL ZEND_CATCH_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_A } exception = EG(exception); - if (!EG(active_symbol_table)) { - if (EX_CV(opline->op2.var)) { - zval_ptr_dtor(EX_CV(opline->op2.var)); - } - EX_CV(opline->op2.var) = (zval**)EX_CV_NUM(execute_data, EX(op_array)->last_var + opline->op2.var); - *EX_CV(opline->op2.var) = EG(exception); - } else { - zend_compiled_variable *cv = &CV_DEF_OF(opline->op2.var); - zend_hash_quick_update(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, - &EG(exception), sizeof(zval *), (void**)&EX_CV(opline->op2.var)); + if (Z_REFCOUNTED_P(EX_VAR(opline->op2.var))) { + zval_ptr_dtor(EX_VAR(opline->op2.var)); } + ZVAL_OBJ(EX_VAR(opline->op2.var), EG(exception)); if (UNEXPECTED(EG(exception) != exception)) { - Z_ADDREF_P(EG(exception)); + GC_REFCOUNT(EG(exception))++; HANDLE_EXCEPTION(); } else { EG(exception) = NULL; @@ -7436,11 +7185,12 @@ static int ZEND_FASTCALL ZEND_CASE_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_AR { USE_OPLINE + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - is_equal_function(&EX_T(opline->result.var).tmp_var, - opline->op1.zv, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + fast_equal_function(result, + opline->op1.zv, + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -7450,35 +7200,31 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCO { USE_OPLINE - zval *expr_ptr; + zval *expr_ptr, new_expr; SAVE_OPLINE(); - if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) { - zval **expr_ptr_ptr = NULL; - - if (IS_CONST == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) { + if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && + (opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) { + expr_ptr = NULL; + if (IS_CONST == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets"); } - SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); - expr_ptr = *expr_ptr_ptr; + SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr); Z_ADDREF_P(expr_ptr); + } else { - expr_ptr=opline->op1.zv; + expr_ptr = opline->op1.zv; if (0) { /* temporary variable */ - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - } else if (IS_CONST == IS_CONST || PZVAL_IS_REF(expr_ptr)) { - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - zendi_zval_copy_ctor(*expr_ptr); + ZVAL_COPY_VALUE(&new_expr, expr_ptr); + expr_ptr = &new_expr; + } else if (IS_CONST == IS_CONST) { + ZVAL_DUP(&new_expr, expr_ptr); + expr_ptr = &new_expr; + } else if (Z_ISREF_P(expr_ptr)) { + ZVAL_DUP(&new_expr, Z_REFVAL_P(expr_ptr)); + expr_ptr = &new_expr; - } else if (IS_CONST == IS_CV) { + } else if (IS_CONST == IS_CV && Z_REFCOUNTED_P(expr_ptr)) { Z_ADDREF_P(expr_ptr); } } @@ -7486,42 +7232,49 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCO if (IS_CV != IS_UNUSED) { zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); + zend_string *str; ulong hval; +add_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: hval = zend_dval_to_lval(Z_DVAL_P(offset)); goto num_index; case IS_LONG: - case IS_BOOL: hval = Z_LVAL_P(offset); num_index: - zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL); + zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); break; case IS_STRING: - if (IS_CV == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); + str = Z_STR_P(offset); + if (IS_CV != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index); } - zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL); +str_index: + zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); break; case IS_NULL: - zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); + str = STR_EMPTY_ALLOC(); + goto str_index; + case IS_FALSE: + hval = 0; + goto num_index; + case IS_TRUE: + hval = 1; + goto num_index; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto add_again; break; default: zend_error(E_WARNING, "Illegal offset type"); - zval_ptr_dtor(&expr_ptr); + zval_ptr_dtor(expr_ptr); /* do nothing */ break; } } else { - zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL); - } - if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) { - + zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -7529,9 +7282,26 @@ num_index: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { + zval *array; + zend_uint size; USE_OPLINE - array_init(&EX_T(opline->result.var).tmp_var); + array = EX_VAR(opline->result.var); + if (IS_CONST != IS_UNUSED) { + size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; + } else { + size = 0; + } + ZVAL_NEW_ARR(array); + zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); + + if (IS_CONST != IS_UNUSED) { + /* Explicitly initialize array as not-packed if flag is set */ + if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) { + zend_hash_real_init(Z_ARRVAL_P(array), 0); + } + } + if (IS_CONST == IS_UNUSED) { ZEND_VM_NEXT_OPCODE(); #if 0 || IS_CONST != IS_UNUSED @@ -7545,22 +7315,18 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_A { USE_OPLINE - /* The generator object is stored in return_value_ptr_ptr */ - zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr); + /* The generator object is stored in EX(return_value) */ + zend_generator *generator = (zend_generator *) EX(return_value); if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) { zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator"); } /* Destroy the previously yielded value */ - if (generator->value) { - zval_ptr_dtor(&generator->value); - } + zval_ptr_dtor(&generator->value); /* Destroy the previously yielded key */ - if (generator->key) { - zval_ptr_dtor(&generator->key); - } + zval_ptr_dtor(&generator->key); /* Set the new yielded value */ if (IS_CONST != IS_UNUSED) { @@ -7570,74 +7336,58 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_A /* Constants and temporary variables aren't yieldable by reference, * but we still allow them with a notice. */ if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) { - zval *value, *copy; + zval *value; zend_error(E_NOTICE, "Only variable references should be yielded by reference"); value = opline->op1.zv; - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); + ZVAL_COPY_VALUE(&generator->value, value); + if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1); /* Temporary variables don't need ctor copying */ if (!0) { - zval_copy_ctor(copy); + zval_copy_ctor(&generator->value); } - - generator->value = copy; } else { - zval **value_ptr = NULL; + zval *value_ptr = NULL; - if (IS_CONST == IS_VAR && UNEXPECTED(value_ptr == NULL)) { + if (IS_CONST == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference"); } /* If a function call result is yielded and the function did * not return by reference we throw a notice. */ - if (IS_CONST == IS_VAR && !Z_ISREF_PP(value_ptr) + if (IS_CONST == IS_VAR && !Z_ISREF_P(value_ptr) && !(opline->extended_value == ZEND_RETURNS_FUNCTION - && EX_T(opline->op1.var).var.fcall_returned_reference) - && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) { + && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); - - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } else { SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr); - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } + ZVAL_COPY(&generator->value, value_ptr); } } else { zval *value = opline->op1.zv; /* Consts, temporary variables and references need copying */ - if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR - || PZVAL_IS_REF(value) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); - - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } - - generator->value = copy; + if (IS_CONST == IS_CONST) { + ZVAL_DUP(&generator->value, value); + } else if (IS_CONST == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->value, value); + } else if (Z_ISREF_P(value)) { + ZVAL_DUP(&generator->value, Z_REFVAL_P(value)); } else { if (IS_CONST == IS_CV) { - Z_ADDREF_P(value); + if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value); } - generator->value = value; + ZVAL_COPY_VALUE(&generator->value, value); } } } else { /* If no value was specified yield null */ - Z_ADDREF(EG(uninitialized_zval)); - generator->value = &EG(uninitialized_zval); + ZVAL_NULL(&generator->value); } /* Set the new yielded key */ @@ -7646,45 +7396,36 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_A zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); /* Consts, temporary variables and references need copying */ - if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR - || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, key); - - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } + if (IS_CV == IS_CONST) { + ZVAL_DUP(&generator->key, key); + } else if (IS_CV == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->key, key); + } else if (Z_ISREF_P(key)) { + ZVAL_DUP(&generator->key, Z_REFVAL_P(key)); - generator->key = copy; } else { - Z_ADDREF_P(key); - generator->key = key; + if (IS_CV == IS_CV) { + if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key); + } + ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE_P(generator->key) == IS_LONG - && Z_LVAL_P(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_LONG + && Z_LVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL_P(generator->key); + generator->largest_used_integer_key = Z_LVAL(generator->key); } - } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - - ALLOC_INIT_ZVAL(generator->key); - ZVAL_LONG(generator->key, generator->largest_used_integer_key); + ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ - generator->send_target = &EX_T(opline->result.var).var.ptr; - Z_ADDREF(EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + generator->send_target = EX_VAR(opline->result.var); + ZVAL_NULL(generator->send_target); } else { generator->send_target = NULL; } @@ -7706,9 +7447,9 @@ static int ZEND_FASTCALL ZEND_POW_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG SAVE_OPLINE(); - pow_function(&EX_T(opline->result.var).tmp_var, + pow_function(EX_VAR(opline->result.var), opline->op1.zv, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); CHECK_EXCEPTION(); @@ -7721,7 +7462,7 @@ static int ZEND_FASTCALL ZEND_BW_NOT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op1; SAVE_OPLINE(); - bitwise_not_function(&EX_T(opline->result.var).tmp_var, + bitwise_not_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); CHECK_EXCEPTION(); @@ -7734,7 +7475,7 @@ static int ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG zend_free_op free_op1; SAVE_OPLINE(); - boolean_not_function(&EX_T(opline->result.var).tmp_var, + boolean_not_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); CHECK_EXCEPTION(); @@ -7750,10 +7491,7 @@ static int ZEND_FASTCALL ZEND_ECHO_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) SAVE_OPLINE(); z = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_TMP_VAR == IS_TMP_VAR && Z_TYPE_P(z) == IS_OBJECT) { - INIT_PZVAL(z); - } - zend_print_variable(z); + zend_print_variable(z TSRMLS_CC); zval_dtor(free_op1.var); CHECK_EXCEPTION(); @@ -7764,7 +7502,7 @@ static int ZEND_FASTCALL ZEND_PRINT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - ZVAL_LONG(&EX_T(opline->result.var).tmp_var, 1); + ZVAL_LONG(EX_VAR(opline->result.var), 1); return ZEND_ECHO_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } @@ -7773,29 +7511,30 @@ static int ZEND_FASTCALL ZEND_JMPZ_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) USE_OPLINE zend_free_op free_op1; zval *val; - int ret; SAVE_OPLINE(); val = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { - ret = Z_LVAL_P(val); - } else { - ret = i_zend_is_true(val TSRMLS_CC); - zval_dtor(free_op1.var); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); + if (IS_TMP_VAR == IS_TMP_VAR) { + if (Z_TYPE_P(val) == IS_TRUE) { + ZEND_VM_SET_OPCODE(opline + 1); + ZEND_VM_CONTINUE(); + } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { + ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); + ZEND_VM_CONTINUE(); } } - if (!ret) { -#if DEBUG_ZEND>=2 - printf("Conditional jmp to %d\n", opline->op2.opline_num); -#endif - ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); - ZEND_VM_CONTINUE(); - } - ZEND_VM_NEXT_OPCODE(); + if (i_zend_is_true(val TSRMLS_CC)) { + opline++; + } else { + opline = opline->op2.jmp_addr; + } + zval_dtor(free_op1.var); + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } + ZEND_VM_JMP(opline); } static int ZEND_FASTCALL ZEND_JMPNZ_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -7803,29 +7542,30 @@ static int ZEND_FASTCALL ZEND_JMPNZ_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) USE_OPLINE zend_free_op free_op1; zval *val; - int ret; SAVE_OPLINE(); val = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { - ret = Z_LVAL_P(val); - } else { - ret = i_zend_is_true(val TSRMLS_CC); - zval_dtor(free_op1.var); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); + if (IS_TMP_VAR == IS_TMP_VAR) { + if (Z_TYPE_P(val) == IS_TRUE) { + ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); + ZEND_VM_CONTINUE(); + } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { + ZEND_VM_SET_OPCODE(opline + 1); + ZEND_VM_CONTINUE(); } } - if (ret) { -#if DEBUG_ZEND>=2 - printf("Conditional jmp to %d\n", opline->op2.opline_num); -#endif - ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); - ZEND_VM_CONTINUE(); - } - ZEND_VM_NEXT_OPCODE(); + if (i_zend_is_true(val TSRMLS_CC)) { + opline = opline->op2.jmp_addr; + } else { + opline++; + } + zval_dtor(free_op1.var); + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } + ZEND_VM_JMP(opline); } static int ZEND_FASTCALL ZEND_JMPZNZ_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -7833,33 +7573,30 @@ static int ZEND_FASTCALL ZEND_JMPZNZ_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) USE_OPLINE zend_free_op free_op1; zval *val; - int retval; SAVE_OPLINE(); val = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { - retval = Z_LVAL_P(val); - } else { - retval = i_zend_is_true(val TSRMLS_CC); - zval_dtor(free_op1.var); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); + if (IS_TMP_VAR == IS_TMP_VAR) { + if (EXPECTED(Z_TYPE_P(val) == IS_TRUE)) { + ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value); + ZEND_VM_CONTINUE(); + } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { + ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); + ZEND_VM_CONTINUE(); } } - if (EXPECTED(retval != 0)) { -#if DEBUG_ZEND>=2 - printf("Conditional jmp on true to %d\n", opline->extended_value); -#endif - ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]); - ZEND_VM_CONTINUE(); /* CHECK_ME */ + + if (i_zend_is_true(val TSRMLS_CC)) { + opline = (zend_op*)(((char*)opline) + opline->extended_value); } else { -#if DEBUG_ZEND>=2 - printf("Conditional jmp on false to %d\n", opline->op2.opline_num); -#endif - ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->op2.opline_num]); - ZEND_VM_CONTINUE(); /* CHECK_ME */ + opline = opline->op2.jmp_addr; + } + zval_dtor(free_op1.var); + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); } + ZEND_VM_JMP(opline); } static int ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -7867,30 +7604,34 @@ static int ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS USE_OPLINE zend_free_op free_op1; zval *val; - int retval; SAVE_OPLINE(); val = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { - retval = Z_LVAL_P(val); - } else { - retval = i_zend_is_true(val TSRMLS_CC); - zval_dtor(free_op1.var); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); + if (IS_TMP_VAR == IS_TMP_VAR) { + if (Z_TYPE_P(val) == IS_TRUE) { + ZVAL_TRUE(EX_VAR(opline->result.var)); + ZEND_VM_SET_OPCODE(opline + 1); + ZEND_VM_CONTINUE(); + } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { + ZVAL_FALSE(EX_VAR(opline->result.var)); + ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); + ZEND_VM_CONTINUE(); } } - Z_LVAL(EX_T(opline->result.var).tmp_var) = retval; - Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; - if (!retval) { -#if DEBUG_ZEND>=2 - printf("Conditional jmp to %d\n", opline->op2.opline_num); -#endif - ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); - ZEND_VM_CONTINUE(); + + if (i_zend_is_true(val TSRMLS_CC)) { + ZVAL_TRUE(EX_VAR(opline->result.var)); + opline++; + } else { + ZVAL_FALSE(EX_VAR(opline->result.var)); + opline = opline->op2.jmp_addr; } - ZEND_VM_NEXT_OPCODE(); + zval_dtor(free_op1.var); + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } + ZEND_VM_JMP(opline); } static int ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -7898,30 +7639,33 @@ static int ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG USE_OPLINE zend_free_op free_op1; zval *val; - int retval; SAVE_OPLINE(); val = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { - retval = Z_LVAL_P(val); - } else { - retval = i_zend_is_true(val TSRMLS_CC); - zval_dtor(free_op1.var); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); + if (IS_TMP_VAR == IS_TMP_VAR) { + if (Z_TYPE_P(val) == IS_TRUE) { + ZVAL_TRUE(EX_VAR(opline->result.var)); + ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); + ZEND_VM_CONTINUE(); + } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { + ZVAL_FALSE(EX_VAR(opline->result.var)); + ZEND_VM_SET_OPCODE(opline + 1); + ZEND_VM_CONTINUE(); } } - Z_LVAL(EX_T(opline->result.var).tmp_var) = retval; - Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; - if (retval) { -#if DEBUG_ZEND>=2 - printf("Conditional jmp to %d\n", opline->op2.opline_num); -#endif - ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); - ZEND_VM_CONTINUE(); + if (i_zend_is_true(val TSRMLS_CC)) { + ZVAL_TRUE(EX_VAR(opline->result.var)); + opline = opline->op2.jmp_addr; + } else { + ZVAL_FALSE(EX_VAR(opline->result.var)); + opline++; } - ZEND_VM_NEXT_OPCODE(); + zval_dtor(free_op1.var); + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } + ZEND_VM_JMP(opline); } static int ZEND_FASTCALL ZEND_FREE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -7930,9 +7674,9 @@ static int ZEND_FASTCALL ZEND_FREE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) SAVE_OPLINE(); if (IS_TMP_VAR == IS_TMP_VAR) { - zendi_zval_dtor(EX_T(opline->op1.var).tmp_var); + zval_dtor(EX_VAR(opline->op1.var)); } else { - zval_ptr_dtor(&EX_T(opline->op1.var).var.ptr); + zval_ptr_dtor(EX_VAR(opline->op1.var)); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -7947,34 +7691,21 @@ static int ZEND_FASTCALL ZEND_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) SAVE_OPLINE(); retval_ptr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (!EG(return_value_ptr_ptr)) { + if (!EX(return_value)) { zval_dtor(free_op1.var); } else { - if (IS_TMP_VAR == IS_CONST || - IS_TMP_VAR == IS_TMP_VAR || - PZVAL_IS_REF(retval_ptr)) { - zval *ret; - - ALLOC_ZVAL(ret); - INIT_PZVAL_COPY(ret, retval_ptr); + if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) { + ZVAL_COPY_VALUE(EX(return_value), retval_ptr); if (IS_TMP_VAR != IS_TMP_VAR) { - zval_copy_ctor(ret); + zval_opt_copy_ctor(EX(return_value)); } - *EG(return_value_ptr_ptr) = ret; - - } else if ((IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) && - retval_ptr == &EG(uninitialized_zval)) { - zval *ret; + } else if (Z_ISREF_P(retval_ptr)) { + ZVAL_DUP(EX(return_value), Z_REFVAL_P(retval_ptr)); - if (IS_TMP_VAR == IS_VAR) { - Z_DELREF_P(retval_ptr); - } - ALLOC_INIT_ZVAL(ret); - *EG(return_value_ptr_ptr) = ret; } else { - *EG(return_value_ptr_ptr) = retval_ptr; + ZVAL_COPY_VALUE(EX(return_value), retval_ptr); if (IS_TMP_VAR == IS_CV) { - Z_ADDREF_P(retval_ptr); + if (Z_OPT_REFCOUNTED_P(retval_ptr)) Z_ADDREF_P(retval_ptr); } } } @@ -7985,7 +7716,6 @@ static int ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLE { USE_OPLINE zval *retval_ptr; - zval **retval_ptr_ptr; zend_free_op free_op1; SAVE_OPLINE(); @@ -7997,55 +7727,41 @@ static int ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLE zend_error(E_NOTICE, "Only variable references should be returned by reference"); retval_ptr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (!EG(return_value_ptr_ptr)) { + if (!EX(return_value)) { if (IS_TMP_VAR == IS_TMP_VAR) { zval_dtor(free_op1.var); } } else if (!1) { /* Not a temp var */ - zval *ret; - - ALLOC_ZVAL(ret); - INIT_PZVAL_COPY(ret, retval_ptr); - zval_copy_ctor(ret); - *EG(return_value_ptr_ptr) = ret; + ZVAL_DUP(EX(return_value), retval_ptr); } else { - zval *ret; - - ALLOC_ZVAL(ret); - INIT_PZVAL_COPY(ret, retval_ptr); - *EG(return_value_ptr_ptr) = ret; + ZVAL_COPY_VALUE(EX(return_value), retval_ptr); } break; } - retval_ptr_ptr = NULL; + retval_ptr = NULL; - if (IS_TMP_VAR == IS_VAR && UNEXPECTED(retval_ptr_ptr == NULL)) { + if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(retval_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference"); } - if (IS_TMP_VAR == IS_VAR && !Z_ISREF_PP(retval_ptr_ptr)) { + if (IS_TMP_VAR == IS_VAR && !Z_ISREF_P(retval_ptr)) { if (opline->extended_value == ZEND_RETURNS_FUNCTION && - EX_T(opline->op1.var).var.fcall_returned_reference) { - } else if (EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) { + (Z_VAR_FLAGS_P(retval_ptr) & IS_VAR_RET_REF)) { + } else { zend_error(E_NOTICE, "Only variable references should be returned by reference"); - if (EG(return_value_ptr_ptr)) { - zval *ret; - - ALLOC_ZVAL(ret); - INIT_PZVAL_COPY(ret, *retval_ptr_ptr); - zval_copy_ctor(ret); - *EG(return_value_ptr_ptr) = ret; + if (EX(return_value)) { + zval tmp; + ZVAL_DUP(&tmp, retval_ptr); + ZVAL_NEW_REF(EX(return_value), &tmp); } break; } } - if (EG(return_value_ptr_ptr)) { - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr); - Z_ADDREF_PP(retval_ptr_ptr); - - *EG(return_value_ptr_ptr) = *retval_ptr_ptr; + if (EX(return_value)) { + SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); + ZVAL_COPY(EX(return_value), retval_ptr); } } while (0); @@ -8056,7 +7772,7 @@ static int ZEND_FASTCALL ZEND_THROW_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *value; - zval *exception; + zval exception; zend_free_op free_op1; SAVE_OPLINE(); @@ -8070,14 +7786,14 @@ static int ZEND_FASTCALL ZEND_THROW_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) } zend_exception_save(TSRMLS_C); - /* Not sure if a complete copy is what we want here */ - ALLOC_ZVAL(exception); - INIT_PZVAL_COPY(exception, value); - if (!1) { - zval_copy_ctor(exception); + if (IS_TMP_VAR == IS_CONST) { + ZVAL_DUP(&exception, value); + value = &exception; + } else if (IS_TMP_VAR != IS_TMP_VAR) { + if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value); } - zend_throw_exception_object(exception TSRMLS_CC); + zend_throw_exception_object(value TSRMLS_CC); zend_exception_restore(TSRMLS_C); HANDLE_EXCEPTION(); @@ -8086,6 +7802,8 @@ static int ZEND_FASTCALL ZEND_THROW_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) static int ZEND_FASTCALL ZEND_SEND_VAL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE + zval *value, *top; + zend_free_op free_op1; SAVE_OPLINE(); if (opline->extended_value == ZEND_DO_FCALL_BY_NAME) { @@ -8094,22 +7812,12 @@ static int ZEND_FASTCALL ZEND_SEND_VAL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG } } - { - zval *valptr; - zval *value; - zend_free_op free_op1; - - value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - - ALLOC_ZVAL(valptr); - INIT_PZVAL_COPY(valptr, value); - if (!1) { - zval_copy_ctor(valptr); - } - zend_vm_stack_push(valptr TSRMLS_CC); - + value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + top = zend_vm_stack_top_inc(TSRMLS_C); + ZVAL_COPY_VALUE(top, value); + if (IS_TMP_VAR == IS_CONST) { + zval_opt_copy_ctor(top); } - CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -8117,7 +7825,7 @@ static int ZEND_FASTCALL ZEND_BOOL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_free_op free_op1; - zval *retval = &EX_T(opline->result.var).tmp_var; + zval *retval = EX_VAR(opline->result.var); SAVE_OPLINE(); /* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */ @@ -8153,7 +7861,7 @@ static int ZEND_FASTCALL ZEND_CLONE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) clone_call = Z_OBJ_HT_P(obj)->clone_obj; if (UNEXPECTED(clone_call == NULL)) { if (ce) { - zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name); + zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name->val); } else { zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object"); } @@ -8164,29 +7872,21 @@ static int ZEND_FASTCALL ZEND_CLONE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) /* Ensure that if we're calling a private function, we're allowed to do so. */ if (UNEXPECTED(ce != EG(scope))) { - zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : ""); + zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name->val, EG(scope) ? EG(scope)->name->val : ""); } } else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) { /* Ensure that if we're calling a protected function, we're allowed to do so. */ if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), EG(scope)))) { - zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : ""); + zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name->val, EG(scope) ? EG(scope)->name->val : ""); } } } if (EXPECTED(EG(exception) == NULL)) { - zval *retval; - - ALLOC_ZVAL(retval); - Z_OBJVAL_P(retval) = clone_call(obj TSRMLS_CC); - Z_TYPE_P(retval) = IS_OBJECT; - Z_SET_REFCOUNT_P(retval, 1); - Z_SET_ISREF_P(retval); + ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(obj TSRMLS_CC)); if (!RETURN_VALUE_USED(opline) || UNEXPECTED(EG(exception) != NULL)) { - zval_ptr_dtor(&retval); - } else { - EX_T(opline->result.var).var.ptr = retval; + zval_ptr_dtor(EX_VAR(opline->result.var)); } } @@ -8199,56 +7899,73 @@ static int ZEND_FASTCALL ZEND_CAST_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) USE_OPLINE zend_free_op free_op1; zval *expr; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); expr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (opline->extended_value != IS_STRING) { - ZVAL_COPY_VALUE(result, expr); - if (!1) { - zendi_zval_copy_ctor(*result); - } - } switch (opline->extended_value) { case IS_NULL: - convert_to_null(result); + /* This code is taken from convert_to_null. However, it does not seems very useful, + * because a conversion to null always results in the same value. This could only + * be relevant if a cast_object handler for IS_NULL has some kind of side-effect. */ +#if 0 + if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) { + ZVAL_DEREF(expr); + } + if (Z_TYPE_P(expr) == IS_OBJECT && Z_OBJ_HT_P(expr)->cast_object) { + if (Z_OBJ_HT_P(expr)->cast_object(expr, result, IS_NULL TSRMLS_CC) == SUCCESS) { + break; + } + } +#endif + + ZVAL_NULL(result); break; - case IS_BOOL: - convert_to_boolean(result); + case _IS_BOOL: + ZVAL_BOOL(result, zend_is_true(expr TSRMLS_CC)); break; case IS_LONG: - convert_to_long(result); + ZVAL_LONG(result, zval_get_long(expr)); break; case IS_DOUBLE: - convert_to_double(result); + ZVAL_DOUBLE(result, zval_get_double(expr)); break; - case IS_STRING: { - zval var_copy; - int use_copy; - - zend_make_printable_zval(expr, &var_copy, &use_copy); - if (use_copy) { - ZVAL_COPY_VALUE(result, &var_copy); - if (1) { - zval_dtor(free_op1.var); - } - } else { + case IS_STRING: + ZVAL_STR(result, zval_get_string(expr)); + break; + default: + /* If value is already of correct type, return it directly */ + if (Z_TYPE_P(expr) == opline->extended_value) { ZVAL_COPY_VALUE(result, expr); - if (!1) { - zendi_zval_copy_ctor(*result); + if (IS_TMP_VAR == IS_CONST) { + zval_opt_copy_ctor(result); + } else if (IS_TMP_VAR == IS_CV) { + if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr); } + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); + } + + if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) { + ZVAL_DEREF(expr); + } + ZVAL_COPY_VALUE(result, expr); + if (!1) { + zval_opt_copy_ctor(result); } - break; - } - case IS_ARRAY: - convert_to_array(result); - break; - case IS_OBJECT: - convert_to_object(result); - break; - } + if (opline->extended_value == IS_ARRAY) { + convert_to_array(result); + } else { + convert_to_object(result); + } + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); + } + zval_dtor(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -8259,18 +7976,17 @@ static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER(ZEND_OPCODE_HAND zend_op_array *new_op_array=NULL; zend_free_op free_op1; zval *inc_filename; - zval *tmp_inc_filename = NULL; + zval tmp_inc_filename; zend_bool failure_retval=0; SAVE_OPLINE(); inc_filename = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (inc_filename->type!=IS_STRING) { - MAKE_STD_ZVAL(tmp_inc_filename); - ZVAL_COPY_VALUE(tmp_inc_filename, inc_filename); - zval_copy_ctor(tmp_inc_filename); - convert_to_string(tmp_inc_filename); - inc_filename = tmp_inc_filename; + ZVAL_UNDEF(&tmp_inc_filename); + if (Z_TYPE_P(inc_filename) != IS_STRING) { + ZVAL_DUP(&tmp_inc_filename, inc_filename); + convert_to_string(&tmp_inc_filename); + inc_filename = &tmp_inc_filename; } if (opline->extended_value != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRLEN_P(inc_filename)) { @@ -8288,7 +8004,7 @@ static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER(ZEND_OPCODE_HAND resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename) TSRMLS_CC); if (resolved_path) { - failure_retval = zend_hash_exists(&EG(included_files), resolved_path, strlen(resolved_path)+1); + failure_retval = zend_hash_str_exists(&EG(included_files), resolved_path, strlen(resolved_path)); } else { resolved_path = Z_STRVAL_P(inc_filename); } @@ -8301,7 +8017,7 @@ static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER(ZEND_OPCODE_HAND file_handle.opened_path = estrdup(resolved_path); } - if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1)==SUCCESS) { + if (zend_hash_str_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path))) { new_op_array = zend_compile_file(&file_handle, (opline->extended_value==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) TSRMLS_CC); zend_destroy_file_handle(&file_handle TSRMLS_CC); } else { @@ -8334,40 +8050,37 @@ static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER(ZEND_OPCODE_HAND EMPTY_SWITCH_DEFAULT_CASE() } } - if (tmp_inc_filename) { + if (Z_TYPE(tmp_inc_filename) != IS_UNDEF) { zval_ptr_dtor(&tmp_inc_filename); } zval_dtor(free_op1.var); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } else if (EXPECTED(new_op_array != NULL)) { - EX(original_return_value) = EG(return_value_ptr_ptr); + zval *return_value = NULL; + EG(active_op_array) = new_op_array; if (RETURN_VALUE_USED(opline)) { - EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; - EG(return_value_ptr_ptr) = EX_T(opline->result.var).var.ptr_ptr; - } else { - EG(return_value_ptr_ptr) = NULL; + return_value = EX_VAR(opline->result.var); } EX(function_state).function = (zend_function *) new_op_array; - EX(object) = NULL; if (!EG(active_symbol_table)) { zend_rebuild_symbol_table(TSRMLS_C); } if (EXPECTED(zend_execute_ex == execute_ex)) { + i_create_execute_data_from_op_array(new_op_array, return_value, VM_FRAME_NESTED_CODE TSRMLS_CC); ZEND_VM_ENTER(); } else { - zend_execute(new_op_array TSRMLS_CC); + zend_execute(new_op_array, return_value TSRMLS_CC); } EX(function_state).function = (zend_function *) EX(op_array); EG(opline_ptr) = &EX(opline); EG(active_op_array) = EX(op_array); - EG(return_value_ptr_ptr) = EX(original_return_value); destroy_op_array(new_op_array TSRMLS_CC); efree(new_op_array); if (UNEXPECTED(EG(exception) != NULL)) { @@ -8376,12 +8089,7 @@ static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER(ZEND_OPCODE_HAND } } else if (RETURN_VALUE_USED(opline)) { - zval *retval; - - ALLOC_ZVAL(retval); - ZVAL_BOOL(retval, failure_retval); - INIT_PZVAL(retval); - EX_T(opline->result.var).var.ptr = retval; + ZVAL_BOOL(EX_VAR(opline->result.var), failure_retval); } ZEND_VM_NEXT_OPCODE(); } @@ -8390,7 +8098,7 @@ static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG { USE_OPLINE zend_free_op free_op1; - zval *array_ptr, **array_ptr_ptr; + zval *array_ptr, *array_ref, iterator; HashTable *fe_ht; zend_object_iterator *iter = NULL; zend_class_entry *ce = NULL; @@ -8400,71 +8108,79 @@ static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG if ((IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) && (opline->extended_value & ZEND_FE_RESET_VARIABLE)) { - array_ptr_ptr = NULL; - if (array_ptr_ptr == NULL || array_ptr_ptr == &EG(uninitialized_zval_ptr)) { - MAKE_STD_ZVAL(array_ptr); - ZVAL_NULL(array_ptr); - } else if (Z_TYPE_PP(array_ptr_ptr) == IS_OBJECT) { - if(Z_OBJ_HT_PP(array_ptr_ptr)->get_class_entry == NULL) { + array_ptr = array_ref = NULL; + ZVAL_DEREF(array_ptr); + if (Z_TYPE_P(array_ptr) == IS_ARRAY) { + if (!Z_ISREF_P(array_ref)) { + SEPARATE_ZVAL(array_ptr); + array_ref = array_ptr; + if (opline->extended_value & ZEND_FE_FETCH_BYREF) { + ZVAL_NEW_REF(array_ptr, array_ptr); + array_ref = array_ptr; + array_ptr = Z_REFVAL_P(array_ptr); + } + } + if (Z_REFCOUNTED_P(array_ref)) Z_ADDREF_P(array_ref); + } else if (Z_TYPE_P(array_ptr) == IS_OBJECT) { + if(Z_OBJ_HT_P(array_ptr)->get_class_entry == NULL) { zend_error(E_WARNING, "foreach() cannot iterate over objects without PHP class"); ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num); } - ce = Z_OBJCE_PP(array_ptr_ptr); + ce = Z_OBJCE_P(array_ptr); if (!ce || ce->get_iterator == NULL) { - SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr); - Z_ADDREF_PP(array_ptr_ptr); - } - array_ptr = *array_ptr_ptr; - } else { - if (Z_TYPE_PP(array_ptr_ptr) == IS_ARRAY) { - SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr); - if (opline->extended_value & ZEND_FE_FETCH_BYREF) { - Z_SET_ISREF_PP(array_ptr_ptr); + if (!Z_ISREF_P(array_ref)) { + SEPARATE_ZVAL(array_ptr); } + Z_ADDREF_P(array_ptr); } - array_ptr = *array_ptr_ptr; - Z_ADDREF_P(array_ptr); + array_ref = array_ptr; + } else { + if (Z_REFCOUNTED_P(array_ref)) Z_ADDREF_P(array_ref); } } else { - array_ptr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + array_ptr = array_ref = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + ZVAL_DEREF(array_ptr); if (1) { /* IS_TMP_VAR */ - zval *tmp; + zval tmp; - ALLOC_ZVAL(tmp); - INIT_PZVAL_COPY(tmp, array_ptr); - array_ptr = tmp; + ZVAL_COPY_VALUE(&tmp, array_ptr); + array_ptr = &tmp; if (Z_TYPE_P(array_ptr) == IS_OBJECT) { ce = Z_OBJCE_P(array_ptr); if (ce && ce->get_iterator) { - Z_DELREF_P(array_ptr); + Z_DELREF_P(array_ref); } } } else if (Z_TYPE_P(array_ptr) == IS_OBJECT) { ce = Z_OBJCE_P(array_ptr); if (!ce || !ce->get_iterator) { if (IS_TMP_VAR == IS_CV) { - Z_ADDREF_P(array_ptr); + Z_ADDREF_P(array_ref); } } - } else if (IS_TMP_VAR == IS_CONST || - (IS_TMP_VAR == IS_CV && - !Z_ISREF_P(array_ptr) && - Z_REFCOUNT_P(array_ptr) > 1) || - (IS_TMP_VAR == IS_VAR && - !Z_ISREF_P(array_ptr) && - Z_REFCOUNT_P(array_ptr) > 2)) { - zval *tmp; + } else if (Z_REFCOUNTED_P(array_ref)) { + if (IS_TMP_VAR == IS_CONST || + (IS_TMP_VAR == IS_CV && + !Z_ISREF_P(array_ref) && + Z_REFCOUNT_P(array_ref) > 1) || + (IS_TMP_VAR == IS_VAR && + !Z_ISREF_P(array_ref) && + Z_REFCOUNT_P(array_ref) > 2)) { + zval tmp; - if (IS_TMP_VAR == IS_VAR) { - Z_DELREF_P(array_ptr); + if (IS_TMP_VAR == IS_VAR) { + Z_DELREF_P(array_ref); + } + ZVAL_DUP(&tmp, array_ref); + array_ptr = array_ref = &tmp; + } else if (IS_TMP_VAR == IS_CV) { + if (Z_ISREF_P(array_ref) && Z_REFCOUNT_P(array_ref) == 1) { + ZVAL_UNREF(array_ref); + array_ptr = array_ref; + } + Z_ADDREF_P(array_ref); } - ALLOC_ZVAL(tmp); - INIT_PZVAL_COPY(tmp, array_ptr); - zval_copy_ctor(tmp); - array_ptr = tmp; - } else if (IS_TMP_VAR == IS_CV) { - Z_ADDREF_P(array_ptr); } } @@ -8475,27 +8191,28 @@ static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG } if (iter && EXPECTED(EG(exception) == NULL)) { - array_ptr = zend_iterator_wrap(iter TSRMLS_CC); + ZVAL_OBJ(&iterator, &iter->std); + array_ptr = array_ref = &iterator; } else { if (IS_TMP_VAR == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) { } if (!EG(exception)) { - zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name); + zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name->val); } zend_throw_exception_internal(NULL TSRMLS_CC); HANDLE_EXCEPTION(); } } - EX_T(opline->result.var).fe.ptr = array_ptr; + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref); if (iter) { iter->index = 0; if (iter->funcs->rewind) { iter->funcs->rewind(iter TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { - zval_ptr_dtor(&array_ptr); + zval_ptr_dtor(array_ref); if (IS_TMP_VAR == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) { } @@ -8504,7 +8221,7 @@ static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG } is_empty = iter->funcs->valid(iter TSRMLS_CC) != SUCCESS; if (UNEXPECTED(EG(exception) != NULL)) { - zval_ptr_dtor(&array_ptr); + zval_ptr_dtor(array_ref); if (IS_TMP_VAR == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) { } @@ -8514,24 +8231,23 @@ static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG } else if ((fe_ht = HASH_OF(array_ptr)) != NULL) { zend_hash_internal_pointer_reset(fe_ht); if (ce) { - zend_object *zobj = zend_objects_get_address(array_ptr TSRMLS_CC); + zend_object *zobj = Z_OBJ_P(array_ptr); while (zend_hash_has_more_elements(fe_ht) == SUCCESS) { - char *str_key; - uint str_key_len; + zend_string *str_key; ulong int_key; zend_uchar key_type; - key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL); + key_type = zend_hash_get_current_key(fe_ht, &str_key, &int_key, 0); if (key_type != HASH_KEY_NON_EXISTENT && (key_type == HASH_KEY_IS_LONG || - zend_check_property_access(zobj, str_key, str_key_len-1 TSRMLS_CC) == SUCCESS)) { + zend_check_property_access(zobj, str_key TSRMLS_CC) == SUCCESS)) { break; } zend_hash_move_forward(fe_ht); } } is_empty = zend_hash_has_more_elements(fe_ht) != SUCCESS; - zend_hash_get_pointer(fe_ht, &EX_T(opline->result.var).fe.fe_pos); + zend_hash_get_pointer(fe_ht, (HashPointer*)EX_VAR((opline+2)->op1.var)); } else { zend_error(E_WARNING, "Invalid argument supplied for foreach()"); is_empty = 1; @@ -8561,7 +8277,7 @@ static int ZEND_FASTCALL ZEND_EXIT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) if (Z_TYPE_P(ptr) == IS_LONG) { EG(exit_status) = Z_LVAL_P(ptr); } else { - zend_print_variable(ptr); + zend_print_variable(ptr TSRMLS_CC); } zval_dtor(free_op1.var); } @@ -8576,9 +8292,8 @@ static int ZEND_FASTCALL ZEND_END_SILENCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ zval restored_error_reporting; SAVE_OPLINE(); - if (!EG(error_reporting) && Z_LVAL(EX_T(opline->op1.var).tmp_var) != 0) { - Z_TYPE(restored_error_reporting) = IS_LONG; - Z_LVAL(restored_error_reporting) = Z_LVAL(EX_T(opline->op1.var).tmp_var); + if (!EG(error_reporting) && Z_LVAL_P(EX_VAR(opline->op1.var)) != 0) { + ZVAL_LONG(&restored_error_reporting, Z_LVAL_P(EX_VAR(opline->op1.var))); EG(error_reporting) = Z_LVAL(restored_error_reporting); convert_to_string(&restored_error_reporting); if (EXPECTED(EG(error_reporting_ini_entry) != NULL)) { @@ -8586,15 +8301,14 @@ static int ZEND_FASTCALL ZEND_END_SILENCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ EG(error_reporting_ini_entry)->value != EG(error_reporting_ini_entry)->orig_value)) { efree(EG(error_reporting_ini_entry)->value); } - EG(error_reporting_ini_entry)->value = Z_STRVAL(restored_error_reporting); + EG(error_reporting_ini_entry)->value = estrndup(Z_STRVAL(restored_error_reporting), Z_STRLEN(restored_error_reporting)); EG(error_reporting_ini_entry)->value_length = Z_STRLEN(restored_error_reporting); - } else { - zendi_zval_dtor(restored_error_reporting); } + zval_dtor(&restored_error_reporting); } - if (EX(old_error_reporting) == &EX_T(opline->op1.var).tmp_var) { - EX(old_error_reporting) = NULL; - } +//??? if (EX(old_error_reporting) == EX_VAR(opline->op1.var)) { +//??? EX(old_error_reporting) = NULL; +//??? } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -8609,14 +8323,11 @@ static int ZEND_FASTCALL ZEND_JMP_SET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (i_zend_is_true(value TSRMLS_CC)) { - ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value); + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value); if (!1) { - zendi_zval_copy_ctor(EX_T(opline->result.var).tmp_var); + zval_opt_copy_ctor(EX_VAR(opline->result.var)); } -#if DEBUG_ZEND>=2 - printf("Conditional jmp to %d\n", opline->op2.opline_num); -#endif ZEND_VM_JMP(opline->op2.jmp_addr); } @@ -8629,29 +8340,21 @@ static int ZEND_FASTCALL ZEND_JMP_SET_VAR_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ { USE_OPLINE zend_free_op free_op1; - zval *value, *ret; + zval *value; SAVE_OPLINE(); value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (i_zend_is_true(value TSRMLS_CC)) { if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) { - Z_ADDREF_P(value); - EX_T(opline->result.var).var.ptr = value; - EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; - } else { - ALLOC_ZVAL(ret); - INIT_PZVAL_COPY(ret, value); - EX_T(opline->result.var).var.ptr = ret; - EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; + ZVAL_COPY(EX_VAR(opline->result.var), value); + } else { + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value); if (!1) { - zval_copy_ctor(EX_T(opline->result.var).var.ptr); + zval_opt_copy_ctor(EX_VAR(opline->result.var)); } } -#if DEBUG_ZEND>=2 - printf("Conditional jmp to %d\n", opline->op2.opline_num); -#endif ZEND_VM_JMP(opline->op2.jmp_addr); } @@ -8669,9 +8372,9 @@ static int ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR SAVE_OPLINE(); value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value); + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value); if (!1) { - zval_copy_ctor(&EX_T(opline->result.var).tmp_var); + zval_opt_copy_ctor(EX_VAR(opline->result.var)); } CHECK_EXCEPTION(); @@ -8682,22 +8385,17 @@ static int ZEND_FASTCALL ZEND_QM_ASSIGN_VAR_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLE { USE_OPLINE zend_free_op free_op1; - zval *value, *ret; + zval *value; SAVE_OPLINE(); value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) { - Z_ADDREF_P(value); - EX_T(opline->result.var).var.ptr = value; - EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; - } else { - ALLOC_ZVAL(ret); - INIT_PZVAL_COPY(ret, value); - EX_T(opline->result.var).var.ptr = ret; - EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; + ZVAL_COPY(EX_VAR(opline->result.var), value); + } else { + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value); if (!1) { - zval_copy_ctor(EX_T(opline->result.var).var.ptr); + zval_opt_copy_ctor(EX_VAR(opline->result.var)); } } @@ -8716,11 +8414,11 @@ static int ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_A expr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (Z_TYPE_P(expr) == IS_OBJECT && Z_OBJ_HT_P(expr)->get_class_entry) { - result = instanceof_function(Z_OBJCE_P(expr), EX_T(opline->op2.var).class_entry TSRMLS_CC); + result = instanceof_function(Z_OBJCE_P(expr), Z_CE_P(EX_VAR(opline->op2.var)) TSRMLS_CC); } else { result = 0; } - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, result); + ZVAL_BOOL(EX_VAR(opline->result.var), result); zval_dtor(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -8732,7 +8430,7 @@ static int ZEND_FASTCALL ZEND_ADD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR zend_free_op free_op1; SAVE_OPLINE(); - fast_add_function(&EX_T(opline->result.var).tmp_var, + fast_add_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), opline->op2.zv TSRMLS_CC); zval_dtor(free_op1.var); @@ -8747,7 +8445,7 @@ static int ZEND_FASTCALL ZEND_SUB_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR zend_free_op free_op1; SAVE_OPLINE(); - fast_sub_function(&EX_T(opline->result.var).tmp_var, + fast_sub_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), opline->op2.zv TSRMLS_CC); zval_dtor(free_op1.var); @@ -8762,7 +8460,7 @@ static int ZEND_FASTCALL ZEND_MUL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR zend_free_op free_op1; SAVE_OPLINE(); - fast_mul_function(&EX_T(opline->result.var).tmp_var, + fast_mul_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), opline->op2.zv TSRMLS_CC); zval_dtor(free_op1.var); @@ -8777,7 +8475,7 @@ static int ZEND_FASTCALL ZEND_DIV_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR zend_free_op free_op1; SAVE_OPLINE(); - fast_div_function(&EX_T(opline->result.var).tmp_var, + fast_div_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), opline->op2.zv TSRMLS_CC); zval_dtor(free_op1.var); @@ -8792,7 +8490,7 @@ static int ZEND_FASTCALL ZEND_MOD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR zend_free_op free_op1; SAVE_OPLINE(); - fast_mod_function(&EX_T(opline->result.var).tmp_var, + fast_mod_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), opline->op2.zv TSRMLS_CC); zval_dtor(free_op1.var); @@ -8807,7 +8505,7 @@ static int ZEND_FASTCALL ZEND_SL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG zend_free_op free_op1; SAVE_OPLINE(); - shift_left_function(&EX_T(opline->result.var).tmp_var, + shift_left_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), opline->op2.zv TSRMLS_CC); zval_dtor(free_op1.var); @@ -8822,7 +8520,7 @@ static int ZEND_FASTCALL ZEND_SR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG zend_free_op free_op1; SAVE_OPLINE(); - shift_right_function(&EX_T(opline->result.var).tmp_var, + shift_right_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), opline->op2.zv TSRMLS_CC); zval_dtor(free_op1.var); @@ -8837,7 +8535,7 @@ static int ZEND_FASTCALL ZEND_CONCAT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER zend_free_op free_op1; SAVE_OPLINE(); - concat_function(&EX_T(opline->result.var).tmp_var, + concat_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), opline->op2.zv TSRMLS_CC); zval_dtor(free_op1.var); @@ -8852,7 +8550,7 @@ static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_H zend_free_op free_op1; SAVE_OPLINE(); - is_identical_function(&EX_T(opline->result.var).tmp_var, + fast_is_identical_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), opline->op2.zv TSRMLS_CC); zval_dtor(free_op1.var); @@ -8865,13 +8563,12 @@ static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCO { USE_OPLINE zend_free_op free_op1; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - is_identical_function(result, + fast_is_not_identical_function(result, _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), opline->op2.zv TSRMLS_CC); - Z_LVAL_P(result) = !Z_LVAL_P(result); zval_dtor(free_op1.var); CHECK_EXCEPTION(); @@ -8882,12 +8579,12 @@ static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDL { USE_OPLINE zend_free_op free_op1; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_equal_function(result, + fast_equal_function(result, _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - opline->op2.zv TSRMLS_CC)); + opline->op2.zv TSRMLS_CC); zval_dtor(free_op1.var); CHECK_EXCEPTION(); @@ -8898,12 +8595,12 @@ static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_H { USE_OPLINE zend_free_op free_op1; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_not_equal_function(result, + fast_not_equal_function(result, _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - opline->op2.zv TSRMLS_CC)); + opline->op2.zv TSRMLS_CC); zval_dtor(free_op1.var); CHECK_EXCEPTION(); @@ -8914,12 +8611,12 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HAN { USE_OPLINE zend_free_op free_op1; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_is_smaller_function(result, + fast_is_smaller_function(result, _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - opline->op2.zv TSRMLS_CC)); + opline->op2.zv TSRMLS_CC); zval_dtor(free_op1.var); CHECK_EXCEPTION(); @@ -8930,12 +8627,12 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_CONST_HANDLER(ZEND_O { USE_OPLINE zend_free_op free_op1; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, + fast_is_smaller_or_equal_function(result, _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - opline->op2.zv TSRMLS_CC)); + opline->op2.zv TSRMLS_CC); zval_dtor(free_op1.var); CHECK_EXCEPTION(); @@ -8948,7 +8645,7 @@ static int ZEND_FASTCALL ZEND_BW_OR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ zend_free_op free_op1; SAVE_OPLINE(); - bitwise_or_function(&EX_T(opline->result.var).tmp_var, + bitwise_or_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), opline->op2.zv TSRMLS_CC); zval_dtor(free_op1.var); @@ -8963,7 +8660,7 @@ static int ZEND_FASTCALL ZEND_BW_AND_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER zend_free_op free_op1; SAVE_OPLINE(); - bitwise_and_function(&EX_T(opline->result.var).tmp_var, + bitwise_and_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), opline->op2.zv TSRMLS_CC); zval_dtor(free_op1.var); @@ -8978,7 +8675,7 @@ static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER zend_free_op free_op1; SAVE_OPLINE(); - bitwise_xor_function(&EX_T(opline->result.var).tmp_var, + bitwise_xor_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), opline->op2.zv TSRMLS_CC); zval_dtor(free_op1.var); @@ -8993,7 +8690,7 @@ static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDL zend_free_op free_op1; SAVE_OPLINE(); - boolean_xor_function(&EX_T(opline->result.var).tmp_var, + boolean_xor_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), opline->op2.zv TSRMLS_CC); zval_dtor(free_op1.var); @@ -9007,19 +8704,16 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_CONST(int type, USE_OPLINE zend_free_op free_op1; zval *varname; - zval **retval; + zval *retval; zval tmp_varname; HashTable *target_symbol_table; - ulong hash_value; SAVE_OPLINE(); varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + ZVAL_UNDEF(&tmp_varname); if (IS_TMP_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) { - ZVAL_COPY_VALUE(&tmp_varname, varname); - zval_copy_ctor(&tmp_varname); - Z_SET_REFCOUNT(tmp_varname, 1); - Z_UNSET_ISREF(tmp_varname); + ZVAL_DUP_DEREF(&tmp_varname, varname); convert_to_string(&tmp_varname); varname = &tmp_varname; } @@ -9028,105 +8722,88 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_CONST(int type, zend_class_entry *ce; if (IS_CONST == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { - if (IS_TMP_VAR != IS_CONST && varname == &tmp_varname) { + if (IS_TMP_VAR != IS_CONST) { zval_dtor(&tmp_varname); } zval_dtor(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(opline->op2.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); } } else { - ce = EX_T(opline->op2.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op2.var)); } - retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); + retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC); zval_dtor(free_op1.var); } else { target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); -/* - if (!target_symbol_table) { - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); - } -*/ - if (IS_TMP_VAR == IS_CONST) { - hash_value = Z_HASH_P(varname); - } else { - hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname)); - } - - if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) { + retval = zend_hash_find(target_symbol_table, Z_STR_P(varname)); + if (retval == NULL) { switch (type) { case BP_VAR_R: case BP_VAR_UNSET: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); /* break missing intentionally */ case BP_VAR_IS: - retval = &EG(uninitialized_zval_ptr); + retval = EX_VAR(opline->result.var); + ZVAL_NULL(retval); break; case BP_VAR_RW: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); /* break missing intentionally */ case BP_VAR_W: - Z_ADDREF_P(&EG(uninitialized_zval)); - zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval); + retval = zend_hash_update(target_symbol_table, Z_STR_P(varname), &EG(uninitialized_zval)); break; EMPTY_SWITCH_DEFAULT_CASE() } - } - switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) { - case ZEND_FETCH_GLOBAL: - if (IS_TMP_VAR != IS_TMP_VAR) { - zval_dtor(free_op1.var); - } - break; - case ZEND_FETCH_LOCAL: - zval_dtor(free_op1.var); - break; - case ZEND_FETCH_STATIC: - zval_update_constant(retval, 1 TSRMLS_CC); - break; - case ZEND_FETCH_GLOBAL_LOCK: - if (IS_TMP_VAR == IS_VAR && !free_op1.var) { - PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); + /* GLOBAL or $$name variable may be an INDIRECT pointer to CV */ + } else if (Z_TYPE_P(retval) == IS_INDIRECT) { + retval = Z_INDIRECT_P(retval); + if (Z_TYPE_P(retval) == IS_UNDEF) { + switch (type) { + case BP_VAR_R: + case BP_VAR_UNSET: + zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); + /* break missing intentionally */ + case BP_VAR_IS: + retval = EX_VAR(opline->result.var); + ZVAL_NULL(retval); + break; + case BP_VAR_RW: + zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); + /* break missing intentionally */ + case BP_VAR_W: + ZVAL_NULL(retval); + break; + EMPTY_SWITCH_DEFAULT_CASE() } - break; + } + } + if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC) { + zval_update_constant(retval, 1 TSRMLS_CC); + } else if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) != ZEND_FETCH_GLOBAL_LOCK) { + zval_dtor(free_op1.var); } } - - if (IS_TMP_VAR != IS_CONST && varname == &tmp_varname) { + if (IS_TMP_VAR != IS_CONST) { zval_dtor(&tmp_varname); } - if (opline->extended_value & ZEND_FETCH_MAKE_REF) { - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval); - } - PZVAL_LOCK(*retval); - switch (type) { - case BP_VAR_R: - case BP_VAR_IS: - EX_T(opline->result.var).var.ptr = *retval; - break; - case BP_VAR_UNSET: { - zend_free_op free_res; - PZVAL_UNLOCK(*retval, &free_res); - if (retval != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(retval); - } - PZVAL_LOCK(*retval); - FREE_OP_VAR_PTR(free_res); + ZEND_ASSERT(retval != NULL); + if (type == BP_VAR_R || type == BP_VAR_IS) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); + } else { + if (/*type == BP_VAR_W &&*/ (opline->extended_value & ZEND_FETCH_MAKE_REF)) { + SEPARATE_ZVAL_TO_MAKE_IS_REF(retval); } - /* break missing intentionally */ - default: - EX_T(opline->result.var).var.ptr_ptr = retval; - break; + ZVAL_INDIRECT(EX_VAR(opline->result.var), retval); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -9151,7 +8828,11 @@ static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE { USE_OPLINE - return zend_fetch_var_address_helper_SPEC_TMP_CONST(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { + return zend_fetch_var_address_helper_SPEC_TMP_CONST(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else { + return zend_fetch_var_address_helper_SPEC_TMP_CONST(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -9172,7 +8853,7 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HA SAVE_OPLINE(); container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); if (IS_TMP_VAR != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) { zval_dtor(free_op1.var); @@ -9191,14 +8872,12 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_TMP_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPC container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (UNEXPECTED(Z_TYPE_P(container) != IS_ARRAY)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } else { - zval *value = *zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC); + zval *value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC); - PZVAL_LOCK(value); - EX_T(opline->result.var).var.ptr = value; + ZVAL_COPY(EX_VAR(opline->result.var), value); } CHECK_EXCEPTION(); @@ -9208,17 +8887,13 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_TMP_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPC static int ZEND_FASTCALL ZEND_ADD_CHAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *str = &EX_T(opline->result.var).tmp_var; + zval *str = EX_VAR(opline->result.var); SAVE_OPLINE(); if (IS_TMP_VAR == IS_UNUSED) { /* Initialize for erealloc in add_char_to_string */ - Z_STRVAL_P(str) = NULL; - Z_STRLEN_P(str) = 0; - Z_TYPE_P(str) = IS_STRING; - - INIT_PZVAL(str); + ZVAL_EMPTY_STRING(str); } add_char_to_string(str, str, opline->op2.zv); @@ -9231,17 +8906,13 @@ static int ZEND_FASTCALL ZEND_ADD_CHAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDL static int ZEND_FASTCALL ZEND_ADD_STRING_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *str = &EX_T(opline->result.var).tmp_var; + zval *str = EX_VAR(opline->result.var); SAVE_OPLINE(); if (IS_TMP_VAR == IS_UNUSED) { /* Initialize for erealloc in add_string_to_string */ - Z_STRVAL_P(str) = NULL; - Z_STRLEN_P(str) = 0; - Z_TYPE_P(str) = IS_STRING; - - INIT_PZVAL(str); + ZVAL_EMPTY_STRING(str); } add_string_to_string(str, str, opline->op2.zv); @@ -9255,10 +8926,9 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMP_CONST_HANDLER(ZEND_OPCO { USE_OPLINE zval *function_name; - char *function_name_strval; - int function_name_strlen; zend_free_op free_op1; call_slot *call = EX(call_slots) + opline->result.num; + zval *object; SAVE_OPLINE(); @@ -9272,33 +8942,30 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMP_CONST_HANDLER(ZEND_OPCO zend_error_noreturn(E_ERROR, "Method name must be a string"); } - function_name_strval = Z_STRVAL_P(function_name); - function_name_strlen = Z_STRLEN_P(function_name); + object = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL; - call->object = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - - if (EXPECTED(call->object != NULL) && - EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) { - call->called_scope = Z_OBJCE_P(call->object); + if (EXPECTED(call->object != NULL)) { + call->called_scope = zend_get_class_entry(call->object TSRMLS_CC); if (IS_CONST != IS_CONST || - (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) { - zval *object = call->object; + (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope)) == NULL) { + zend_object *object = call->object; - if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) { + if (UNEXPECTED(object->handlers->get_method == NULL)) { zend_error_noreturn(E_ERROR, "Object does not support method calls"); } /* First, locate the function. */ - call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); + call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); if (UNEXPECTED(call->fbc == NULL)) { - zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval); + zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name)); } if (IS_CONST == IS_CONST && EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) && EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) && EXPECTED(call->object == object)) { - CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc); + CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope, call->fbc); } } } else { @@ -9306,21 +8973,13 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMP_CONST_HANDLER(ZEND_OPCO HANDLE_EXCEPTION(); } - zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval); + zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", Z_STRVAL_P(function_name)); } if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) { call->object = NULL; } else { - if (!PZVAL_IS_REF(call->object)) { - Z_ADDREF_P(call->object); /* For $this pointer */ - } else { - zval *this_ptr; - ALLOC_ZVAL(this_ptr); - INIT_PZVAL_COPY(this_ptr, call->object); - zval_copy_ctor(this_ptr); - call->object = this_ptr; - } + GC_REFCOUNT(call->object)++; /* For $this pointer */ } call->num_additional_args = 0; @@ -9336,11 +8995,12 @@ static int ZEND_FASTCALL ZEND_CASE_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_A { USE_OPLINE zend_free_op free_op1; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - is_equal_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - opline->op2.zv TSRMLS_CC); + fast_equal_function(result, + _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + opline->op2.zv TSRMLS_CC); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -9350,35 +9010,31 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPC { USE_OPLINE zend_free_op free_op1; - zval *expr_ptr; + zval *expr_ptr, new_expr; SAVE_OPLINE(); - if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) { - zval **expr_ptr_ptr = NULL; - - if (IS_TMP_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) { + if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && + (opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) { + expr_ptr = NULL; + if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets"); } - SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); - expr_ptr = *expr_ptr_ptr; + SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr); Z_ADDREF_P(expr_ptr); + } else { - expr_ptr=_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + expr_ptr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (1) { /* temporary variable */ - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - } else if (IS_TMP_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) { - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - zendi_zval_copy_ctor(*expr_ptr); + ZVAL_COPY_VALUE(&new_expr, expr_ptr); + expr_ptr = &new_expr; + } else if (IS_TMP_VAR == IS_CONST) { + ZVAL_DUP(&new_expr, expr_ptr); + expr_ptr = &new_expr; + } else if (Z_ISREF_P(expr_ptr)) { + ZVAL_DUP(&new_expr, Z_REFVAL_P(expr_ptr)); + expr_ptr = &new_expr; - } else if (IS_TMP_VAR == IS_CV) { + } else if (IS_TMP_VAR == IS_CV && Z_REFCOUNTED_P(expr_ptr)) { Z_ADDREF_P(expr_ptr); } } @@ -9386,42 +9042,49 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPC if (IS_CONST != IS_UNUSED) { zval *offset = opline->op2.zv; + zend_string *str; ulong hval; +add_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: hval = zend_dval_to_lval(Z_DVAL_P(offset)); goto num_index; case IS_LONG: - case IS_BOOL: hval = Z_LVAL_P(offset); num_index: - zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL); + zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); break; case IS_STRING: - if (IS_CONST == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); + str = Z_STR_P(offset); + if (IS_CONST != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index); } - zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL); +str_index: + zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); break; case IS_NULL: - zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); + str = STR_EMPTY_ALLOC(); + goto str_index; + case IS_FALSE: + hval = 0; + goto num_index; + case IS_TRUE: + hval = 1; + goto num_index; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto add_again; break; default: zend_error(E_WARNING, "Illegal offset type"); - zval_ptr_dtor(&expr_ptr); + zval_ptr_dtor(expr_ptr); /* do nothing */ break; } } else { - zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL); - } - if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) { - + zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -9429,9 +9092,26 @@ num_index: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { + zval *array; + zend_uint size; USE_OPLINE - array_init(&EX_T(opline->result.var).tmp_var); + array = EX_VAR(opline->result.var); + if (IS_TMP_VAR != IS_UNUSED) { + size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; + } else { + size = 0; + } + ZVAL_NEW_ARR(array); + zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); + + if (IS_TMP_VAR != IS_UNUSED) { + /* Explicitly initialize array as not-packed if flag is set */ + if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) { + zend_hash_real_init(Z_ARRVAL_P(array), 0); + } + } + if (IS_TMP_VAR == IS_UNUSED) { ZEND_VM_NEXT_OPCODE(); #if 0 || IS_TMP_VAR != IS_UNUSED @@ -9447,20 +9127,15 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HAND zval tmp, *varname; HashTable *target_symbol_table; zend_free_op free_op1; + zend_bool tmp_is_dup = 0; SAVE_OPLINE(); if (IS_TMP_VAR == IS_CV && IS_CONST == IS_UNUSED && (opline->extended_value & ZEND_QUICK_SET)) { - if (EG(active_symbol_table)) { - zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); - - zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC); - EX_CV(opline->op1.var) = NULL; - } else if (EX_CV(opline->op1.var)) { - zval_ptr_dtor(EX_CV(opline->op1.var)); - EX_CV(opline->op1.var) = NULL; - } + ZVAL_COPY_VALUE(&tmp, EX_VAR(opline->op1.var)); + ZVAL_UNDEF(EX_VAR(opline->op1.var)); + zval_ptr_dtor(&tmp); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -9468,27 +9143,28 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HAND varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { - ZVAL_COPY_VALUE(&tmp, varname); - zval_copy_ctor(&tmp); + ZVAL_DUP(&tmp, varname); convert_to_string(&tmp); varname = &tmp; + tmp_is_dup = 1; } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) { - Z_ADDREF_P(varname); + ZVAL_COPY(&tmp, varname); + varname = &tmp; } if (IS_CONST != IS_UNUSED) { zend_class_entry *ce; if (IS_CONST == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { - if (IS_TMP_VAR != IS_CONST && varname == &tmp) { + if (IS_TMP_VAR != IS_CONST && tmp_is_dup) { zval_dtor(&tmp); } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) { - zval_ptr_dtor(&varname); + zval_ptr_dtor(&tmp); } zval_dtor(free_op1.var); HANDLE_EXCEPTION(); @@ -9496,23 +9172,21 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HAND if (UNEXPECTED(ce == NULL)) { zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv)); } - CACHE_PTR(opline->op2.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); } } else { - ce = EX_T(opline->op2.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op2.var)); } - zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); + zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC); } else { - ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1); - target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); - zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC); + zend_hash_del_ind(target_symbol_table, Z_STR_P(varname)); } - if (IS_TMP_VAR != IS_CONST && varname == &tmp) { + if (IS_TMP_VAR != IS_CONST && tmp_is_dup) { zval_dtor(&tmp); } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) { - zval_ptr_dtor(&varname); + zval_ptr_dtor(&tmp); } zval_dtor(free_op1.var); CHECK_EXCEPTION(); @@ -9522,21 +9196,16 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HAND static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval **value; + zval *value; zend_bool isset = 1; SAVE_OPLINE(); if (IS_TMP_VAR == IS_CV && IS_CONST == IS_UNUSED && (opline->extended_value & ZEND_QUICK_SET)) { - if (EX_CV(opline->op1.var)) { - value = EX_CV(opline->op1.var); - } else if (EG(active_symbol_table)) { - zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); - - if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) { - isset = 0; - } + if (Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_UNDEF) { + value = EX_VAR(opline->op1.var); + ZVAL_DEREF(value); } else { isset = 0; } @@ -9546,8 +9215,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPC zval tmp, *varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { - ZVAL_COPY_VALUE(&tmp, varname); - zval_copy_ctor(&tmp); + ZVAL_DUP(&tmp, varname); convert_to_string(&tmp); varname = &tmp; } @@ -9556,26 +9224,26 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPC zend_class_entry *ce; if (IS_CONST == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(opline->op2.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); } } else { - ce = EX_T(opline->op2.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op2.var)); } - value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); + value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC); if (!value) { isset = 0; } } else { target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); - if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) { + if ((value = zend_hash_find(target_symbol_table, Z_STR_P(varname))) == NULL) { isset = 0; } } @@ -9587,16 +9255,16 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPC } if (opline->extended_value & ZEND_ISSET) { - if (isset && Z_TYPE_PP(value) != IS_NULL) { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); + if (isset && Z_TYPE_P(value) != IS_NULL) { + ZVAL_BOOL(EX_VAR(opline->result.var), 1); } else { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); + ZVAL_BOOL(EX_VAR(opline->result.var), 0); } } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { - if (!isset || !i_zend_is_true(*value TSRMLS_CC)) { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); + if (!isset || !i_zend_is_true(value TSRMLS_CC)) { + ZVAL_BOOL(EX_VAR(opline->result.var), 1); } else { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); + ZVAL_BOOL(EX_VAR(opline->result.var), 0); } } @@ -9608,22 +9276,18 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ { USE_OPLINE - /* The generator object is stored in return_value_ptr_ptr */ - zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr); + /* The generator object is stored in EX(return_value) */ + zend_generator *generator = (zend_generator *) EX(return_value); if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) { zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator"); } /* Destroy the previously yielded value */ - if (generator->value) { - zval_ptr_dtor(&generator->value); - } + zval_ptr_dtor(&generator->value); /* Destroy the previously yielded key */ - if (generator->key) { - zval_ptr_dtor(&generator->key); - } + zval_ptr_dtor(&generator->key); /* Set the new yielded value */ if (IS_TMP_VAR != IS_UNUSED) { @@ -9633,74 +9297,58 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ /* Constants and temporary variables aren't yieldable by reference, * but we still allow them with a notice. */ if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) { - zval *value, *copy; + zval *value; zend_error(E_NOTICE, "Only variable references should be yielded by reference"); value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); + ZVAL_COPY_VALUE(&generator->value, value); + if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1); /* Temporary variables don't need ctor copying */ if (!1) { - zval_copy_ctor(copy); + zval_copy_ctor(&generator->value); } - - generator->value = copy; } else { - zval **value_ptr = NULL; + zval *value_ptr = NULL; - if (IS_TMP_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) { + if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference"); } /* If a function call result is yielded and the function did * not return by reference we throw a notice. */ - if (IS_TMP_VAR == IS_VAR && !Z_ISREF_PP(value_ptr) + if (IS_TMP_VAR == IS_VAR && !Z_ISREF_P(value_ptr) && !(opline->extended_value == ZEND_RETURNS_FUNCTION - && EX_T(opline->op1.var).var.fcall_returned_reference) - && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) { + && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); - - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } else { SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr); - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } + ZVAL_COPY(&generator->value, value_ptr); } } else { zval *value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); /* Consts, temporary variables and references need copying */ - if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR - || PZVAL_IS_REF(value) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); - - /* Temporary variables don't need ctor copying */ - if (!1) { - zval_copy_ctor(copy); - } - - generator->value = copy; + if (IS_TMP_VAR == IS_CONST) { + ZVAL_DUP(&generator->value, value); + } else if (IS_TMP_VAR == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->value, value); + } else if (Z_ISREF_P(value)) { + ZVAL_DUP(&generator->value, Z_REFVAL_P(value)); } else { if (IS_TMP_VAR == IS_CV) { - Z_ADDREF_P(value); + if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value); } - generator->value = value; + ZVAL_COPY_VALUE(&generator->value, value); } } } else { /* If no value was specified yield null */ - Z_ADDREF(EG(uninitialized_zval)); - generator->value = &EG(uninitialized_zval); + ZVAL_NULL(&generator->value); } /* Set the new yielded key */ @@ -9709,45 +9357,36 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ zval *key = opline->op2.zv; /* Consts, temporary variables and references need copying */ - if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR - || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, key); - - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } + if (IS_CONST == IS_CONST) { + ZVAL_DUP(&generator->key, key); + } else if (IS_CONST == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->key, key); + } else if (Z_ISREF_P(key)) { + ZVAL_DUP(&generator->key, Z_REFVAL_P(key)); - generator->key = copy; } else { - Z_ADDREF_P(key); - generator->key = key; + if (IS_CONST == IS_CV) { + if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key); + } + ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE_P(generator->key) == IS_LONG - && Z_LVAL_P(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_LONG + && Z_LVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL_P(generator->key); + generator->largest_used_integer_key = Z_LVAL(generator->key); } - } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - - ALLOC_INIT_ZVAL(generator->key); - ZVAL_LONG(generator->key, generator->largest_used_integer_key); + ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ - generator->send_target = &EX_T(opline->result.var).var.ptr; - Z_ADDREF(EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + generator->send_target = EX_VAR(opline->result.var); + ZVAL_NULL(generator->send_target); } else { generator->send_target = NULL; } @@ -9769,7 +9408,7 @@ static int ZEND_FASTCALL ZEND_POW_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR zend_free_op free_op1; SAVE_OPLINE(); - pow_function(&EX_T(opline->result.var).tmp_var, + pow_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), opline->op2.zv TSRMLS_CC); zval_dtor(free_op1.var); @@ -9784,7 +9423,7 @@ static int ZEND_FASTCALL ZEND_ADD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS zend_free_op free_op1, free_op2; SAVE_OPLINE(); - fast_add_function(&EX_T(opline->result.var).tmp_var, + fast_add_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); @@ -9799,7 +9438,7 @@ static int ZEND_FASTCALL ZEND_SUB_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS zend_free_op free_op1, free_op2; SAVE_OPLINE(); - fast_sub_function(&EX_T(opline->result.var).tmp_var, + fast_sub_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); @@ -9814,7 +9453,7 @@ static int ZEND_FASTCALL ZEND_MUL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS zend_free_op free_op1, free_op2; SAVE_OPLINE(); - fast_mul_function(&EX_T(opline->result.var).tmp_var, + fast_mul_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); @@ -9829,7 +9468,7 @@ static int ZEND_FASTCALL ZEND_DIV_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS zend_free_op free_op1, free_op2; SAVE_OPLINE(); - fast_div_function(&EX_T(opline->result.var).tmp_var, + fast_div_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); @@ -9844,7 +9483,7 @@ static int ZEND_FASTCALL ZEND_MOD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS zend_free_op free_op1, free_op2; SAVE_OPLINE(); - fast_mod_function(&EX_T(opline->result.var).tmp_var, + fast_mod_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); @@ -9859,7 +9498,7 @@ static int ZEND_FASTCALL ZEND_SL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op1, free_op2; SAVE_OPLINE(); - shift_left_function(&EX_T(opline->result.var).tmp_var, + shift_left_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); @@ -9874,7 +9513,7 @@ static int ZEND_FASTCALL ZEND_SR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op1, free_op2; SAVE_OPLINE(); - shift_right_function(&EX_T(opline->result.var).tmp_var, + shift_right_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); @@ -9889,7 +9528,7 @@ static int ZEND_FASTCALL ZEND_CONCAT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_A zend_free_op free_op1, free_op2; SAVE_OPLINE(); - concat_function(&EX_T(opline->result.var).tmp_var, + concat_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); @@ -9904,7 +9543,7 @@ static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HAN zend_free_op free_op1, free_op2; SAVE_OPLINE(); - is_identical_function(&EX_T(opline->result.var).tmp_var, + fast_is_identical_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); @@ -9917,13 +9556,12 @@ static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE { USE_OPLINE zend_free_op free_op1, free_op2; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - is_identical_function(result, + fast_is_not_identical_function(result, _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - Z_LVAL_P(result) = !Z_LVAL_P(result); zval_dtor(free_op1.var); zval_dtor(free_op2.var); CHECK_EXCEPTION(); @@ -9934,12 +9572,12 @@ static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER { USE_OPLINE zend_free_op free_op1, free_op2; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_equal_function(result, + fast_equal_function(result, _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); zval_dtor(free_op2.var); CHECK_EXCEPTION(); @@ -9950,12 +9588,12 @@ static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HAN { USE_OPLINE zend_free_op free_op1, free_op2; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_not_equal_function(result, + fast_not_equal_function(result, _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); zval_dtor(free_op2.var); CHECK_EXCEPTION(); @@ -9966,12 +9604,12 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDL { USE_OPLINE zend_free_op free_op1, free_op2; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_is_smaller_function(result, + fast_is_smaller_function(result, _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); zval_dtor(free_op2.var); CHECK_EXCEPTION(); @@ -9982,12 +9620,12 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_TMP_HANDLER(ZEND_OPC { USE_OPLINE zend_free_op free_op1, free_op2; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, + fast_is_smaller_or_equal_function(result, _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); zval_dtor(free_op2.var); CHECK_EXCEPTION(); @@ -10000,7 +9638,7 @@ static int ZEND_FASTCALL ZEND_BW_OR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR zend_free_op free_op1, free_op2; SAVE_OPLINE(); - bitwise_or_function(&EX_T(opline->result.var).tmp_var, + bitwise_or_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); @@ -10015,7 +9653,7 @@ static int ZEND_FASTCALL ZEND_BW_AND_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_A zend_free_op free_op1, free_op2; SAVE_OPLINE(); - bitwise_and_function(&EX_T(opline->result.var).tmp_var, + bitwise_and_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); @@ -10030,7 +9668,7 @@ static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_A zend_free_op free_op1, free_op2; SAVE_OPLINE(); - bitwise_xor_function(&EX_T(opline->result.var).tmp_var, + bitwise_xor_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); @@ -10045,7 +9683,7 @@ static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER zend_free_op free_op1, free_op2; SAVE_OPLINE(); - boolean_xor_function(&EX_T(opline->result.var).tmp_var, + boolean_xor_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); @@ -10062,7 +9700,7 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HAND SAVE_OPLINE(); container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC); zval_dtor(free_op2.var); if (IS_TMP_VAR != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) { zval_dtor(free_op1.var); @@ -10075,7 +9713,7 @@ static int ZEND_FASTCALL ZEND_ADD_VAR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ { USE_OPLINE zend_free_op free_op2; - zval *str = &EX_T(opline->result.var).tmp_var; + zval *str = EX_VAR(opline->result.var); zval *var; zval var_copy; int use_copy = 0; @@ -10085,18 +9723,17 @@ static int ZEND_FASTCALL ZEND_ADD_VAR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ if (IS_TMP_VAR == IS_UNUSED) { /* Initialize for erealloc in add_string_to_string */ - Z_STRVAL_P(str) = NULL; - Z_STRLEN_P(str) = 0; - Z_TYPE_P(str) = IS_STRING; - - INIT_PZVAL(str); + ZVAL_EMPTY_STRING(str); } if (Z_TYPE_P(var) != IS_STRING) { - zend_make_printable_zval(var, &var_copy, &use_copy); + ZVAL_DEREF(var); + if (Z_TYPE_P(var) != IS_STRING) { + zend_make_printable_zval(var, &var_copy, &use_copy); - if (use_copy) { - var = &var_copy; + if (use_copy) { + var = &var_copy; + } } } add_string_to_string(str, str, var); @@ -10120,10 +9757,9 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE { USE_OPLINE zval *function_name; - char *function_name_strval; - int function_name_strlen; zend_free_op free_op1, free_op2; call_slot *call = EX(call_slots) + opline->result.num; + zval *object; SAVE_OPLINE(); @@ -10137,33 +9773,30 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE zend_error_noreturn(E_ERROR, "Method name must be a string"); } - function_name_strval = Z_STRVAL_P(function_name); - function_name_strlen = Z_STRLEN_P(function_name); - - call->object = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + object = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL; - if (EXPECTED(call->object != NULL) && - EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) { - call->called_scope = Z_OBJCE_P(call->object); + if (EXPECTED(call->object != NULL)) { + call->called_scope = zend_get_class_entry(call->object TSRMLS_CC); if (IS_TMP_VAR != IS_CONST || - (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) { - zval *object = call->object; + (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope)) == NULL) { + zend_object *object = call->object; - if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) { + if (UNEXPECTED(object->handlers->get_method == NULL)) { zend_error_noreturn(E_ERROR, "Object does not support method calls"); } /* First, locate the function. */ - call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); + call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); if (UNEXPECTED(call->fbc == NULL)) { - zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval); + zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name)); } if (IS_TMP_VAR == IS_CONST && EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) && EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) && EXPECTED(call->object == object)) { - CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc); + CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope, call->fbc); } } } else { @@ -10171,21 +9804,13 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE zval_dtor(free_op2.var); HANDLE_EXCEPTION(); } - zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval); + zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", Z_STRVAL_P(function_name)); } if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) { call->object = NULL; } else { - if (!PZVAL_IS_REF(call->object)) { - Z_ADDREF_P(call->object); /* For $this pointer */ - } else { - zval *this_ptr; - ALLOC_ZVAL(this_ptr); - INIT_PZVAL_COPY(this_ptr, call->object); - zval_copy_ctor(this_ptr); - call->object = this_ptr; - } + GC_REFCOUNT(call->object)++; /* For $this pointer */ } call->num_additional_args = 0; @@ -10202,11 +9827,12 @@ static int ZEND_FASTCALL ZEND_CASE_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG { USE_OPLINE zend_free_op free_op1, free_op2; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - is_equal_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + fast_equal_function(result, + _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op2.var); CHECK_EXCEPTION(); @@ -10217,35 +9843,31 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP_HANDLER(ZEND_OPCOD { USE_OPLINE zend_free_op free_op1; - zval *expr_ptr; + zval *expr_ptr, new_expr; SAVE_OPLINE(); - if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) { - zval **expr_ptr_ptr = NULL; - - if (IS_TMP_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) { + if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && + (opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) { + expr_ptr = NULL; + if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets"); } - SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); - expr_ptr = *expr_ptr_ptr; + SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr); Z_ADDREF_P(expr_ptr); + } else { - expr_ptr=_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + expr_ptr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (1) { /* temporary variable */ - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - } else if (IS_TMP_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) { - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - zendi_zval_copy_ctor(*expr_ptr); + ZVAL_COPY_VALUE(&new_expr, expr_ptr); + expr_ptr = &new_expr; + } else if (IS_TMP_VAR == IS_CONST) { + ZVAL_DUP(&new_expr, expr_ptr); + expr_ptr = &new_expr; + } else if (Z_ISREF_P(expr_ptr)) { + ZVAL_DUP(&new_expr, Z_REFVAL_P(expr_ptr)); + expr_ptr = &new_expr; - } else if (IS_TMP_VAR == IS_CV) { + } else if (IS_TMP_VAR == IS_CV && Z_REFCOUNTED_P(expr_ptr)) { Z_ADDREF_P(expr_ptr); } } @@ -10253,42 +9875,49 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP_HANDLER(ZEND_OPCOD if (IS_TMP_VAR != IS_UNUSED) { zend_free_op free_op2; zval *offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + zend_string *str; ulong hval; +add_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: hval = zend_dval_to_lval(Z_DVAL_P(offset)); goto num_index; case IS_LONG: - case IS_BOOL: hval = Z_LVAL_P(offset); num_index: - zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL); + zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); break; case IS_STRING: - if (IS_TMP_VAR == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); + str = Z_STR_P(offset); + if (IS_TMP_VAR != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index); } - zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL); +str_index: + zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); break; case IS_NULL: - zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); + str = STR_EMPTY_ALLOC(); + goto str_index; + case IS_FALSE: + hval = 0; + goto num_index; + case IS_TRUE: + hval = 1; + goto num_index; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto add_again; break; default: zend_error(E_WARNING, "Illegal offset type"); - zval_ptr_dtor(&expr_ptr); + zval_ptr_dtor(expr_ptr); /* do nothing */ break; } zval_dtor(free_op2.var); } else { - zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL); - } - if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) { - + zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -10296,9 +9925,26 @@ num_index: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { + zval *array; + zend_uint size; USE_OPLINE - array_init(&EX_T(opline->result.var).tmp_var); + array = EX_VAR(opline->result.var); + if (IS_TMP_VAR != IS_UNUSED) { + size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; + } else { + size = 0; + } + ZVAL_NEW_ARR(array); + zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); + + if (IS_TMP_VAR != IS_UNUSED) { + /* Explicitly initialize array as not-packed if flag is set */ + if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) { + zend_hash_real_init(Z_ARRVAL_P(array), 0); + } + } + if (IS_TMP_VAR == IS_UNUSED) { ZEND_VM_NEXT_OPCODE(); #if 0 || IS_TMP_VAR != IS_UNUSED @@ -10312,22 +9958,18 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR { USE_OPLINE - /* The generator object is stored in return_value_ptr_ptr */ - zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr); + /* The generator object is stored in EX(return_value) */ + zend_generator *generator = (zend_generator *) EX(return_value); if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) { zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator"); } /* Destroy the previously yielded value */ - if (generator->value) { - zval_ptr_dtor(&generator->value); - } + zval_ptr_dtor(&generator->value); /* Destroy the previously yielded key */ - if (generator->key) { - zval_ptr_dtor(&generator->key); - } + zval_ptr_dtor(&generator->key); /* Set the new yielded value */ if (IS_TMP_VAR != IS_UNUSED) { @@ -10337,74 +9979,58 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR /* Constants and temporary variables aren't yieldable by reference, * but we still allow them with a notice. */ if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) { - zval *value, *copy; + zval *value; zend_error(E_NOTICE, "Only variable references should be yielded by reference"); value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); + ZVAL_COPY_VALUE(&generator->value, value); + if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1); /* Temporary variables don't need ctor copying */ if (!1) { - zval_copy_ctor(copy); + zval_copy_ctor(&generator->value); } - - generator->value = copy; } else { - zval **value_ptr = NULL; + zval *value_ptr = NULL; - if (IS_TMP_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) { + if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference"); } /* If a function call result is yielded and the function did * not return by reference we throw a notice. */ - if (IS_TMP_VAR == IS_VAR && !Z_ISREF_PP(value_ptr) + if (IS_TMP_VAR == IS_VAR && !Z_ISREF_P(value_ptr) && !(opline->extended_value == ZEND_RETURNS_FUNCTION - && EX_T(opline->op1.var).var.fcall_returned_reference) - && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) { + && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); - - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } else { SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr); - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } + ZVAL_COPY(&generator->value, value_ptr); } } else { zval *value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); /* Consts, temporary variables and references need copying */ - if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR - || PZVAL_IS_REF(value) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); - - /* Temporary variables don't need ctor copying */ - if (!1) { - zval_copy_ctor(copy); - } - - generator->value = copy; + if (IS_TMP_VAR == IS_CONST) { + ZVAL_DUP(&generator->value, value); + } else if (IS_TMP_VAR == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->value, value); + } else if (Z_ISREF_P(value)) { + ZVAL_DUP(&generator->value, Z_REFVAL_P(value)); } else { if (IS_TMP_VAR == IS_CV) { - Z_ADDREF_P(value); + if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value); } - generator->value = value; + ZVAL_COPY_VALUE(&generator->value, value); } } } else { /* If no value was specified yield null */ - Z_ADDREF(EG(uninitialized_zval)); - generator->value = &EG(uninitialized_zval); + ZVAL_NULL(&generator->value); } /* Set the new yielded key */ @@ -10413,45 +10039,36 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); /* Consts, temporary variables and references need copying */ - if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR - || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, key); - - /* Temporary variables don't need ctor copying */ - if (!1) { - zval_copy_ctor(copy); - } + if (IS_TMP_VAR == IS_CONST) { + ZVAL_DUP(&generator->key, key); + } else if (IS_TMP_VAR == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->key, key); + } else if (Z_ISREF_P(key)) { + ZVAL_DUP(&generator->key, Z_REFVAL_P(key)); - generator->key = copy; } else { - Z_ADDREF_P(key); - generator->key = key; + if (IS_TMP_VAR == IS_CV) { + if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key); + } + ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE_P(generator->key) == IS_LONG - && Z_LVAL_P(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_LONG + && Z_LVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL_P(generator->key); + generator->largest_used_integer_key = Z_LVAL(generator->key); } - } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - - ALLOC_INIT_ZVAL(generator->key); - ZVAL_LONG(generator->key, generator->largest_used_integer_key); + ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ - generator->send_target = &EX_T(opline->result.var).var.ptr; - Z_ADDREF(EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + generator->send_target = EX_VAR(opline->result.var); + ZVAL_NULL(generator->send_target); } else { generator->send_target = NULL; } @@ -10473,7 +10090,7 @@ static int ZEND_FASTCALL ZEND_POW_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS zend_free_op free_op1, free_op2; SAVE_OPLINE(); - pow_function(&EX_T(opline->result.var).tmp_var, + pow_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); @@ -10488,11 +10105,11 @@ static int ZEND_FASTCALL ZEND_ADD_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS zend_free_op free_op1, free_op2; SAVE_OPLINE(); - fast_add_function(&EX_T(opline->result.var).tmp_var, + fast_add_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -10503,11 +10120,11 @@ static int ZEND_FASTCALL ZEND_SUB_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS zend_free_op free_op1, free_op2; SAVE_OPLINE(); - fast_sub_function(&EX_T(opline->result.var).tmp_var, + fast_sub_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -10518,11 +10135,11 @@ static int ZEND_FASTCALL ZEND_MUL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS zend_free_op free_op1, free_op2; SAVE_OPLINE(); - fast_mul_function(&EX_T(opline->result.var).tmp_var, + fast_mul_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -10533,11 +10150,11 @@ static int ZEND_FASTCALL ZEND_DIV_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS zend_free_op free_op1, free_op2; SAVE_OPLINE(); - fast_div_function(&EX_T(opline->result.var).tmp_var, + fast_div_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -10548,11 +10165,11 @@ static int ZEND_FASTCALL ZEND_MOD_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS zend_free_op free_op1, free_op2; SAVE_OPLINE(); - fast_mod_function(&EX_T(opline->result.var).tmp_var, + fast_mod_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -10563,11 +10180,11 @@ static int ZEND_FASTCALL ZEND_SL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op1, free_op2; SAVE_OPLINE(); - shift_left_function(&EX_T(opline->result.var).tmp_var, + shift_left_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -10578,11 +10195,11 @@ static int ZEND_FASTCALL ZEND_SR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op1, free_op2; SAVE_OPLINE(); - shift_right_function(&EX_T(opline->result.var).tmp_var, + shift_right_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -10593,11 +10210,11 @@ static int ZEND_FASTCALL ZEND_CONCAT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_A zend_free_op free_op1, free_op2; SAVE_OPLINE(); - concat_function(&EX_T(opline->result.var).tmp_var, + concat_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -10608,11 +10225,11 @@ static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HAN zend_free_op free_op1, free_op2; SAVE_OPLINE(); - is_identical_function(&EX_T(opline->result.var).tmp_var, + fast_is_identical_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -10621,15 +10238,14 @@ static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE { USE_OPLINE zend_free_op free_op1, free_op2; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - is_identical_function(result, + fast_is_not_identical_function(result, _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - Z_LVAL_P(result) = !Z_LVAL_P(result); + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -10638,14 +10254,14 @@ static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER { USE_OPLINE zend_free_op free_op1, free_op2; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_equal_function(result, + fast_equal_function(result, _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -10654,14 +10270,14 @@ static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HAN { USE_OPLINE zend_free_op free_op1, free_op2; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_not_equal_function(result, + fast_not_equal_function(result, _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -10670,14 +10286,14 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDL { USE_OPLINE zend_free_op free_op1, free_op2; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_is_smaller_function(result, + fast_is_smaller_function(result, _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -10686,14 +10302,14 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_VAR_HANDLER(ZEND_OPC { USE_OPLINE zend_free_op free_op1, free_op2; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, + fast_is_smaller_or_equal_function(result, _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -10704,11 +10320,11 @@ static int ZEND_FASTCALL ZEND_BW_OR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR zend_free_op free_op1, free_op2; SAVE_OPLINE(); - bitwise_or_function(&EX_T(opline->result.var).tmp_var, + bitwise_or_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -10719,11 +10335,11 @@ static int ZEND_FASTCALL ZEND_BW_AND_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_A zend_free_op free_op1, free_op2; SAVE_OPLINE(); - bitwise_and_function(&EX_T(opline->result.var).tmp_var, + bitwise_and_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -10734,11 +10350,11 @@ static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_A zend_free_op free_op1, free_op2; SAVE_OPLINE(); - bitwise_xor_function(&EX_T(opline->result.var).tmp_var, + bitwise_xor_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -10749,11 +10365,11 @@ static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER zend_free_op free_op1, free_op2; SAVE_OPLINE(); - boolean_xor_function(&EX_T(opline->result.var).tmp_var, + boolean_xor_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -10763,19 +10379,16 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_VAR(int type, ZE USE_OPLINE zend_free_op free_op1; zval *varname; - zval **retval; + zval *retval; zval tmp_varname; HashTable *target_symbol_table; - ulong hash_value; SAVE_OPLINE(); varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + ZVAL_UNDEF(&tmp_varname); if (IS_TMP_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) { - ZVAL_COPY_VALUE(&tmp_varname, varname); - zval_copy_ctor(&tmp_varname); - Z_SET_REFCOUNT(tmp_varname, 1); - Z_UNSET_ISREF(tmp_varname); + ZVAL_DUP_DEREF(&tmp_varname, varname); convert_to_string(&tmp_varname); varname = &tmp_varname; } @@ -10784,105 +10397,88 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_VAR(int type, ZE zend_class_entry *ce; if (IS_VAR == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { - if (IS_TMP_VAR != IS_CONST && varname == &tmp_varname) { + if (IS_TMP_VAR != IS_CONST) { zval_dtor(&tmp_varname); } zval_dtor(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(opline->op2.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); } } else { - ce = EX_T(opline->op2.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op2.var)); } - retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); + retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC); zval_dtor(free_op1.var); } else { target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); -/* - if (!target_symbol_table) { - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); - } -*/ - if (IS_TMP_VAR == IS_CONST) { - hash_value = Z_HASH_P(varname); - } else { - hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname)); - } - - if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) { + retval = zend_hash_find(target_symbol_table, Z_STR_P(varname)); + if (retval == NULL) { switch (type) { case BP_VAR_R: case BP_VAR_UNSET: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); /* break missing intentionally */ case BP_VAR_IS: - retval = &EG(uninitialized_zval_ptr); + retval = EX_VAR(opline->result.var); + ZVAL_NULL(retval); break; case BP_VAR_RW: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); /* break missing intentionally */ case BP_VAR_W: - Z_ADDREF_P(&EG(uninitialized_zval)); - zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval); + retval = zend_hash_update(target_symbol_table, Z_STR_P(varname), &EG(uninitialized_zval)); break; EMPTY_SWITCH_DEFAULT_CASE() } - } - switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) { - case ZEND_FETCH_GLOBAL: - if (IS_TMP_VAR != IS_TMP_VAR) { - zval_dtor(free_op1.var); - } - break; - case ZEND_FETCH_LOCAL: - zval_dtor(free_op1.var); - break; - case ZEND_FETCH_STATIC: - zval_update_constant(retval, 1 TSRMLS_CC); - break; - case ZEND_FETCH_GLOBAL_LOCK: - if (IS_TMP_VAR == IS_VAR && !free_op1.var) { - PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); + /* GLOBAL or $$name variable may be an INDIRECT pointer to CV */ + } else if (Z_TYPE_P(retval) == IS_INDIRECT) { + retval = Z_INDIRECT_P(retval); + if (Z_TYPE_P(retval) == IS_UNDEF) { + switch (type) { + case BP_VAR_R: + case BP_VAR_UNSET: + zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); + /* break missing intentionally */ + case BP_VAR_IS: + retval = EX_VAR(opline->result.var); + ZVAL_NULL(retval); + break; + case BP_VAR_RW: + zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); + /* break missing intentionally */ + case BP_VAR_W: + ZVAL_NULL(retval); + break; + EMPTY_SWITCH_DEFAULT_CASE() } - break; + } + } + if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC) { + zval_update_constant(retval, 1 TSRMLS_CC); + } else if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) != ZEND_FETCH_GLOBAL_LOCK) { + zval_dtor(free_op1.var); } } - - if (IS_TMP_VAR != IS_CONST && varname == &tmp_varname) { + if (IS_TMP_VAR != IS_CONST) { zval_dtor(&tmp_varname); } - if (opline->extended_value & ZEND_FETCH_MAKE_REF) { - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval); - } - PZVAL_LOCK(*retval); - switch (type) { - case BP_VAR_R: - case BP_VAR_IS: - EX_T(opline->result.var).var.ptr = *retval; - break; - case BP_VAR_UNSET: { - zend_free_op free_res; - PZVAL_UNLOCK(*retval, &free_res); - if (retval != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(retval); - } - PZVAL_LOCK(*retval); - FREE_OP_VAR_PTR(free_res); + ZEND_ASSERT(retval != NULL); + if (type == BP_VAR_R || type == BP_VAR_IS) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); + } else { + if (/*type == BP_VAR_W &&*/ (opline->extended_value & ZEND_FETCH_MAKE_REF)) { + SEPARATE_ZVAL_TO_MAKE_IS_REF(retval); } - /* break missing intentionally */ - default: - EX_T(opline->result.var).var.ptr_ptr = retval; - break; + ZVAL_INDIRECT(EX_VAR(opline->result.var), retval); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -10907,7 +10503,11 @@ static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_H { USE_OPLINE - return zend_fetch_var_address_helper_SPEC_TMP_VAR(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { + return zend_fetch_var_address_helper_SPEC_TMP_VAR(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else { + return zend_fetch_var_address_helper_SPEC_TMP_VAR(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -10928,8 +10528,8 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HAND SAVE_OPLINE(); container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC); + zval_ptr_dtor_nogc(free_op2.var); if (IS_TMP_VAR != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) { zval_dtor(free_op1.var); } @@ -10941,7 +10541,7 @@ static int ZEND_FASTCALL ZEND_ADD_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ { USE_OPLINE zend_free_op free_op2; - zval *str = &EX_T(opline->result.var).tmp_var; + zval *str = EX_VAR(opline->result.var); zval *var; zval var_copy; int use_copy = 0; @@ -10951,18 +10551,17 @@ static int ZEND_FASTCALL ZEND_ADD_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ if (IS_TMP_VAR == IS_UNUSED) { /* Initialize for erealloc in add_string_to_string */ - Z_STRVAL_P(str) = NULL; - Z_STRLEN_P(str) = 0; - Z_TYPE_P(str) = IS_STRING; - - INIT_PZVAL(str); + ZVAL_EMPTY_STRING(str); } if (Z_TYPE_P(var) != IS_STRING) { - zend_make_printable_zval(var, &var_copy, &use_copy); + ZVAL_DEREF(var); + if (Z_TYPE_P(var) != IS_STRING) { + zend_make_printable_zval(var, &var_copy, &use_copy); - if (use_copy) { - var = &var_copy; + if (use_copy) { + var = &var_copy; + } } } add_string_to_string(str, str, var); @@ -10976,7 +10575,7 @@ static int ZEND_FASTCALL ZEND_ADD_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ * which aren't affected by FREE_OP(Ts, )'s anyway, unless they're * string offsets or overloaded objects */ - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -10986,10 +10585,9 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE { USE_OPLINE zval *function_name; - char *function_name_strval; - int function_name_strlen; zend_free_op free_op1, free_op2; call_slot *call = EX(call_slots) + opline->result.num; + zval *object; SAVE_OPLINE(); @@ -11003,62 +10601,51 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE zend_error_noreturn(E_ERROR, "Method name must be a string"); } - function_name_strval = Z_STRVAL_P(function_name); - function_name_strlen = Z_STRLEN_P(function_name); - - call->object = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + object = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL; - if (EXPECTED(call->object != NULL) && - EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) { - call->called_scope = Z_OBJCE_P(call->object); + if (EXPECTED(call->object != NULL)) { + call->called_scope = zend_get_class_entry(call->object TSRMLS_CC); if (IS_VAR != IS_CONST || - (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) { - zval *object = call->object; + (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope)) == NULL) { + zend_object *object = call->object; - if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) { + if (UNEXPECTED(object->handlers->get_method == NULL)) { zend_error_noreturn(E_ERROR, "Object does not support method calls"); } /* First, locate the function. */ - call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); + call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_VAR == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); if (UNEXPECTED(call->fbc == NULL)) { - zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval); + zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name)); } if (IS_VAR == IS_CONST && EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) && EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) && EXPECTED(call->object == object)) { - CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc); + CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope, call->fbc); } } } else { if (UNEXPECTED(EG(exception) != NULL)) { - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); HANDLE_EXCEPTION(); } - zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval); + zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", Z_STRVAL_P(function_name)); } if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) { call->object = NULL; } else { - if (!PZVAL_IS_REF(call->object)) { - Z_ADDREF_P(call->object); /* For $this pointer */ - } else { - zval *this_ptr; - ALLOC_ZVAL(this_ptr); - INIT_PZVAL_COPY(this_ptr, call->object); - zval_copy_ctor(this_ptr); - call->object = this_ptr; - } + GC_REFCOUNT(call->object)++; /* For $this pointer */ } call->num_additional_args = 0; call->is_ctor_call = 0; EX(call) = call; - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -11068,13 +10655,14 @@ static int ZEND_FASTCALL ZEND_CASE_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG { USE_OPLINE zend_free_op free_op1, free_op2; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - is_equal_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + fast_equal_function(result, + _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -11083,35 +10671,31 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_VAR_HANDLER(ZEND_OPCOD { USE_OPLINE zend_free_op free_op1; - zval *expr_ptr; + zval *expr_ptr, new_expr; SAVE_OPLINE(); - if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) { - zval **expr_ptr_ptr = NULL; - - if (IS_TMP_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) { + if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && + (opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) { + expr_ptr = NULL; + if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets"); } - SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); - expr_ptr = *expr_ptr_ptr; + SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr); Z_ADDREF_P(expr_ptr); + } else { - expr_ptr=_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + expr_ptr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (1) { /* temporary variable */ - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - } else if (IS_TMP_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) { - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - zendi_zval_copy_ctor(*expr_ptr); + ZVAL_COPY_VALUE(&new_expr, expr_ptr); + expr_ptr = &new_expr; + } else if (IS_TMP_VAR == IS_CONST) { + ZVAL_DUP(&new_expr, expr_ptr); + expr_ptr = &new_expr; + } else if (Z_ISREF_P(expr_ptr)) { + ZVAL_DUP(&new_expr, Z_REFVAL_P(expr_ptr)); + expr_ptr = &new_expr; - } else if (IS_TMP_VAR == IS_CV) { + } else if (IS_TMP_VAR == IS_CV && Z_REFCOUNTED_P(expr_ptr)) { Z_ADDREF_P(expr_ptr); } } @@ -11119,42 +10703,49 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_VAR_HANDLER(ZEND_OPCOD if (IS_VAR != IS_UNUSED) { zend_free_op free_op2; zval *offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + zend_string *str; ulong hval; +add_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: hval = zend_dval_to_lval(Z_DVAL_P(offset)); goto num_index; case IS_LONG: - case IS_BOOL: hval = Z_LVAL_P(offset); num_index: - zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL); + zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); break; case IS_STRING: - if (IS_VAR == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); + str = Z_STR_P(offset); + if (IS_VAR != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index); } - zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL); +str_index: + zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); break; case IS_NULL: - zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); + str = STR_EMPTY_ALLOC(); + goto str_index; + case IS_FALSE: + hval = 0; + goto num_index; + case IS_TRUE: + hval = 1; + goto num_index; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto add_again; break; default: zend_error(E_WARNING, "Illegal offset type"); - zval_ptr_dtor(&expr_ptr); + zval_ptr_dtor(expr_ptr); /* do nothing */ break; } - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); } else { - zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL); - } - if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) { - + zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -11162,9 +10753,26 @@ num_index: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { + zval *array; + zend_uint size; USE_OPLINE - array_init(&EX_T(opline->result.var).tmp_var); + array = EX_VAR(opline->result.var); + if (IS_TMP_VAR != IS_UNUSED) { + size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; + } else { + size = 0; + } + ZVAL_NEW_ARR(array); + zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); + + if (IS_TMP_VAR != IS_UNUSED) { + /* Explicitly initialize array as not-packed if flag is set */ + if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) { + zend_hash_real_init(Z_ARRVAL_P(array), 0); + } + } + if (IS_TMP_VAR == IS_UNUSED) { ZEND_VM_NEXT_OPCODE(); #if 0 || IS_TMP_VAR != IS_UNUSED @@ -11180,20 +10788,15 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLE zval tmp, *varname; HashTable *target_symbol_table; zend_free_op free_op1; + zend_bool tmp_is_dup = 0; SAVE_OPLINE(); if (IS_TMP_VAR == IS_CV && IS_VAR == IS_UNUSED && (opline->extended_value & ZEND_QUICK_SET)) { - if (EG(active_symbol_table)) { - zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); - - zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC); - EX_CV(opline->op1.var) = NULL; - } else if (EX_CV(opline->op1.var)) { - zval_ptr_dtor(EX_CV(opline->op1.var)); - EX_CV(opline->op1.var) = NULL; - } + ZVAL_COPY_VALUE(&tmp, EX_VAR(opline->op1.var)); + ZVAL_UNDEF(EX_VAR(opline->op1.var)); + zval_ptr_dtor(&tmp); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -11201,27 +10804,28 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLE varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { - ZVAL_COPY_VALUE(&tmp, varname); - zval_copy_ctor(&tmp); + ZVAL_DUP(&tmp, varname); convert_to_string(&tmp); varname = &tmp; + tmp_is_dup = 1; } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) { - Z_ADDREF_P(varname); + ZVAL_COPY(&tmp, varname); + varname = &tmp; } if (IS_VAR != IS_UNUSED) { zend_class_entry *ce; if (IS_VAR == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { - if (IS_TMP_VAR != IS_CONST && varname == &tmp) { + if (IS_TMP_VAR != IS_CONST && tmp_is_dup) { zval_dtor(&tmp); } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) { - zval_ptr_dtor(&varname); + zval_ptr_dtor(&tmp); } zval_dtor(free_op1.var); HANDLE_EXCEPTION(); @@ -11229,23 +10833,21 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLE if (UNEXPECTED(ce == NULL)) { zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv)); } - CACHE_PTR(opline->op2.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); } } else { - ce = EX_T(opline->op2.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op2.var)); } - zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); + zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC); } else { - ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1); - target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); - zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC); + zend_hash_del_ind(target_symbol_table, Z_STR_P(varname)); } - if (IS_TMP_VAR != IS_CONST && varname == &tmp) { + if (IS_TMP_VAR != IS_CONST && tmp_is_dup) { zval_dtor(&tmp); } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) { - zval_ptr_dtor(&varname); + zval_ptr_dtor(&tmp); } zval_dtor(free_op1.var); CHECK_EXCEPTION(); @@ -11255,21 +10857,16 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLE static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval **value; + zval *value; zend_bool isset = 1; SAVE_OPLINE(); if (IS_TMP_VAR == IS_CV && IS_VAR == IS_UNUSED && (opline->extended_value & ZEND_QUICK_SET)) { - if (EX_CV(opline->op1.var)) { - value = EX_CV(opline->op1.var); - } else if (EG(active_symbol_table)) { - zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); - - if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) { - isset = 0; - } + if (Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_UNDEF) { + value = EX_VAR(opline->op1.var); + ZVAL_DEREF(value); } else { isset = 0; } @@ -11279,8 +10876,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCOD zval tmp, *varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { - ZVAL_COPY_VALUE(&tmp, varname); - zval_copy_ctor(&tmp); + ZVAL_DUP(&tmp, varname); convert_to_string(&tmp); varname = &tmp; } @@ -11289,26 +10885,26 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCOD zend_class_entry *ce; if (IS_VAR == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(opline->op2.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); } } else { - ce = EX_T(opline->op2.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op2.var)); } - value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); + value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC); if (!value) { isset = 0; } } else { target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); - if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) { + if ((value = zend_hash_find(target_symbol_table, Z_STR_P(varname))) == NULL) { isset = 0; } } @@ -11320,16 +10916,16 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCOD } if (opline->extended_value & ZEND_ISSET) { - if (isset && Z_TYPE_PP(value) != IS_NULL) { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); + if (isset && Z_TYPE_P(value) != IS_NULL) { + ZVAL_BOOL(EX_VAR(opline->result.var), 1); } else { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); + ZVAL_BOOL(EX_VAR(opline->result.var), 0); } } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { - if (!isset || !i_zend_is_true(*value TSRMLS_CC)) { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); + if (!isset || !i_zend_is_true(value TSRMLS_CC)) { + ZVAL_BOOL(EX_VAR(opline->result.var), 1); } else { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); + ZVAL_BOOL(EX_VAR(opline->result.var), 0); } } @@ -11341,22 +10937,18 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR { USE_OPLINE - /* The generator object is stored in return_value_ptr_ptr */ - zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr); + /* The generator object is stored in EX(return_value) */ + zend_generator *generator = (zend_generator *) EX(return_value); if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) { zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator"); } /* Destroy the previously yielded value */ - if (generator->value) { - zval_ptr_dtor(&generator->value); - } + zval_ptr_dtor(&generator->value); /* Destroy the previously yielded key */ - if (generator->key) { - zval_ptr_dtor(&generator->key); - } + zval_ptr_dtor(&generator->key); /* Set the new yielded value */ if (IS_TMP_VAR != IS_UNUSED) { @@ -11366,74 +10958,58 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR /* Constants and temporary variables aren't yieldable by reference, * but we still allow them with a notice. */ if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) { - zval *value, *copy; + zval *value; zend_error(E_NOTICE, "Only variable references should be yielded by reference"); value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); + ZVAL_COPY_VALUE(&generator->value, value); + if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1); /* Temporary variables don't need ctor copying */ if (!1) { - zval_copy_ctor(copy); + zval_copy_ctor(&generator->value); } - - generator->value = copy; } else { - zval **value_ptr = NULL; + zval *value_ptr = NULL; - if (IS_TMP_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) { + if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference"); } /* If a function call result is yielded and the function did * not return by reference we throw a notice. */ - if (IS_TMP_VAR == IS_VAR && !Z_ISREF_PP(value_ptr) + if (IS_TMP_VAR == IS_VAR && !Z_ISREF_P(value_ptr) && !(opline->extended_value == ZEND_RETURNS_FUNCTION - && EX_T(opline->op1.var).var.fcall_returned_reference) - && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) { + && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); - - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } else { SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr); - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } + ZVAL_COPY(&generator->value, value_ptr); } } else { zval *value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); /* Consts, temporary variables and references need copying */ - if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR - || PZVAL_IS_REF(value) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); - - /* Temporary variables don't need ctor copying */ - if (!1) { - zval_copy_ctor(copy); - } - - generator->value = copy; + if (IS_TMP_VAR == IS_CONST) { + ZVAL_DUP(&generator->value, value); + } else if (IS_TMP_VAR == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->value, value); + } else if (Z_ISREF_P(value)) { + ZVAL_DUP(&generator->value, Z_REFVAL_P(value)); } else { if (IS_TMP_VAR == IS_CV) { - Z_ADDREF_P(value); + if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value); } - generator->value = value; + ZVAL_COPY_VALUE(&generator->value, value); } } } else { /* If no value was specified yield null */ - Z_ADDREF(EG(uninitialized_zval)); - generator->value = &EG(uninitialized_zval); + ZVAL_NULL(&generator->value); } /* Set the new yielded key */ @@ -11442,46 +11018,36 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); /* Consts, temporary variables and references need copying */ - if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR - || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, key); - - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } - - generator->key = copy; + if (IS_VAR == IS_CONST) { + ZVAL_DUP(&generator->key, key); + } else if (IS_VAR == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->key, key); + } else if (Z_ISREF_P(key)) { + ZVAL_DUP(&generator->key, Z_REFVAL_P(key)); + zval_ptr_dtor_nogc(free_op2.var); } else { - Z_ADDREF_P(key); - generator->key = key; + if (IS_VAR == IS_CV) { + if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key); + } + ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE_P(generator->key) == IS_LONG - && Z_LVAL_P(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_LONG + && Z_LVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL_P(generator->key); + generator->largest_used_integer_key = Z_LVAL(generator->key); } - - zval_ptr_dtor_nogc(&free_op2.var); } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - - ALLOC_INIT_ZVAL(generator->key); - ZVAL_LONG(generator->key, generator->largest_used_integer_key); + ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ - generator->send_target = &EX_T(opline->result.var).var.ptr; - Z_ADDREF(EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + generator->send_target = EX_VAR(opline->result.var); + ZVAL_NULL(generator->send_target); } else { generator->send_target = NULL; } @@ -11503,11 +11069,11 @@ static int ZEND_FASTCALL ZEND_POW_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS zend_free_op free_op1, free_op2; SAVE_OPLINE(); - pow_function(&EX_T(opline->result.var).tmp_var, + pow_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -11517,19 +11083,16 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_UNUSED(int type, USE_OPLINE zend_free_op free_op1; zval *varname; - zval **retval; + zval *retval; zval tmp_varname; HashTable *target_symbol_table; - ulong hash_value; SAVE_OPLINE(); varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + ZVAL_UNDEF(&tmp_varname); if (IS_TMP_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) { - ZVAL_COPY_VALUE(&tmp_varname, varname); - zval_copy_ctor(&tmp_varname); - Z_SET_REFCOUNT(tmp_varname, 1); - Z_UNSET_ISREF(tmp_varname); + ZVAL_DUP_DEREF(&tmp_varname, varname); convert_to_string(&tmp_varname); varname = &tmp_varname; } @@ -11538,105 +11101,88 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_UNUSED(int type, zend_class_entry *ce; if (IS_UNUSED == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { - if (IS_TMP_VAR != IS_CONST && varname == &tmp_varname) { + if (IS_TMP_VAR != IS_CONST) { zval_dtor(&tmp_varname); } zval_dtor(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(opline->op2.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); } } else { - ce = EX_T(opline->op2.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op2.var)); } - retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); + retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC); zval_dtor(free_op1.var); } else { target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); -/* - if (!target_symbol_table) { - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); - } -*/ - if (IS_TMP_VAR == IS_CONST) { - hash_value = Z_HASH_P(varname); - } else { - hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname)); - } - - if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) { + retval = zend_hash_find(target_symbol_table, Z_STR_P(varname)); + if (retval == NULL) { switch (type) { case BP_VAR_R: case BP_VAR_UNSET: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); /* break missing intentionally */ case BP_VAR_IS: - retval = &EG(uninitialized_zval_ptr); + retval = EX_VAR(opline->result.var); + ZVAL_NULL(retval); break; case BP_VAR_RW: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); /* break missing intentionally */ case BP_VAR_W: - Z_ADDREF_P(&EG(uninitialized_zval)); - zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval); + retval = zend_hash_update(target_symbol_table, Z_STR_P(varname), &EG(uninitialized_zval)); break; EMPTY_SWITCH_DEFAULT_CASE() } - } - switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) { - case ZEND_FETCH_GLOBAL: - if (IS_TMP_VAR != IS_TMP_VAR) { - zval_dtor(free_op1.var); - } - break; - case ZEND_FETCH_LOCAL: - zval_dtor(free_op1.var); - break; - case ZEND_FETCH_STATIC: - zval_update_constant(retval, 1 TSRMLS_CC); - break; - case ZEND_FETCH_GLOBAL_LOCK: - if (IS_TMP_VAR == IS_VAR && !free_op1.var) { - PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); + /* GLOBAL or $$name variable may be an INDIRECT pointer to CV */ + } else if (Z_TYPE_P(retval) == IS_INDIRECT) { + retval = Z_INDIRECT_P(retval); + if (Z_TYPE_P(retval) == IS_UNDEF) { + switch (type) { + case BP_VAR_R: + case BP_VAR_UNSET: + zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); + /* break missing intentionally */ + case BP_VAR_IS: + retval = EX_VAR(opline->result.var); + ZVAL_NULL(retval); + break; + case BP_VAR_RW: + zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); + /* break missing intentionally */ + case BP_VAR_W: + ZVAL_NULL(retval); + break; + EMPTY_SWITCH_DEFAULT_CASE() } - break; + } + } + if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC) { + zval_update_constant(retval, 1 TSRMLS_CC); + } else if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) != ZEND_FETCH_GLOBAL_LOCK) { + zval_dtor(free_op1.var); } } - - if (IS_TMP_VAR != IS_CONST && varname == &tmp_varname) { + if (IS_TMP_VAR != IS_CONST) { zval_dtor(&tmp_varname); } - if (opline->extended_value & ZEND_FETCH_MAKE_REF) { - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval); - } - PZVAL_LOCK(*retval); - switch (type) { - case BP_VAR_R: - case BP_VAR_IS: - EX_T(opline->result.var).var.ptr = *retval; - break; - case BP_VAR_UNSET: { - zend_free_op free_res; - PZVAL_UNLOCK(*retval, &free_res); - if (retval != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(retval); - } - PZVAL_LOCK(*retval); - FREE_OP_VAR_PTR(free_res); + ZEND_ASSERT(retval != NULL); + if (type == BP_VAR_R || type == BP_VAR_IS) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); + } else { + if (/*type == BP_VAR_W &&*/ (opline->extended_value & ZEND_FETCH_MAKE_REF)) { + SEPARATE_ZVAL_TO_MAKE_IS_REF(retval); } - /* break missing intentionally */ - default: - EX_T(opline->result.var).var.ptr_ptr = retval; - break; + ZVAL_INDIRECT(EX_VAR(opline->result.var), retval); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -11661,7 +11207,11 @@ static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCOD { USE_OPLINE - return zend_fetch_var_address_helper_SPEC_TMP_UNUSED(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { + return zend_fetch_var_address_helper_SPEC_TMP_UNUSED(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else { + return zend_fetch_var_address_helper_SPEC_TMP_UNUSED(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -11678,35 +11228,31 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OP { USE_OPLINE zend_free_op free_op1; - zval *expr_ptr; + zval *expr_ptr, new_expr; SAVE_OPLINE(); - if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) { - zval **expr_ptr_ptr = NULL; - - if (IS_TMP_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) { + if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && + (opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) { + expr_ptr = NULL; + if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets"); } - SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); - expr_ptr = *expr_ptr_ptr; + SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr); Z_ADDREF_P(expr_ptr); + } else { - expr_ptr=_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + expr_ptr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (1) { /* temporary variable */ - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - } else if (IS_TMP_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) { - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - zendi_zval_copy_ctor(*expr_ptr); + ZVAL_COPY_VALUE(&new_expr, expr_ptr); + expr_ptr = &new_expr; + } else if (IS_TMP_VAR == IS_CONST) { + ZVAL_DUP(&new_expr, expr_ptr); + expr_ptr = &new_expr; + } else if (Z_ISREF_P(expr_ptr)) { + ZVAL_DUP(&new_expr, Z_REFVAL_P(expr_ptr)); + expr_ptr = &new_expr; - } else if (IS_TMP_VAR == IS_CV) { + } else if (IS_TMP_VAR == IS_CV && Z_REFCOUNTED_P(expr_ptr)) { Z_ADDREF_P(expr_ptr); } } @@ -11714,42 +11260,49 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OP if (IS_UNUSED != IS_UNUSED) { zval *offset = NULL; + zend_string *str; ulong hval; +add_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: hval = zend_dval_to_lval(Z_DVAL_P(offset)); goto num_index; case IS_LONG: - case IS_BOOL: hval = Z_LVAL_P(offset); num_index: - zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL); + zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); break; case IS_STRING: - if (IS_UNUSED == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); + str = Z_STR_P(offset); + if (IS_UNUSED != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index); } - zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL); +str_index: + zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); break; case IS_NULL: - zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); + str = STR_EMPTY_ALLOC(); + goto str_index; + case IS_FALSE: + hval = 0; + goto num_index; + case IS_TRUE: + hval = 1; + goto num_index; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto add_again; break; default: zend_error(E_WARNING, "Illegal offset type"); - zval_ptr_dtor(&expr_ptr); + zval_ptr_dtor(expr_ptr); /* do nothing */ break; } } else { - zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL); - } - if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) { - + zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -11757,9 +11310,26 @@ num_index: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { + zval *array; + zend_uint size; USE_OPLINE - array_init(&EX_T(opline->result.var).tmp_var); + array = EX_VAR(opline->result.var); + if (IS_TMP_VAR != IS_UNUSED) { + size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; + } else { + size = 0; + } + ZVAL_NEW_ARR(array); + zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); + + if (IS_TMP_VAR != IS_UNUSED) { + /* Explicitly initialize array as not-packed if flag is set */ + if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) { + zend_hash_real_init(Z_ARRVAL_P(array), 0); + } + } + if (IS_TMP_VAR == IS_UNUSED) { ZEND_VM_NEXT_OPCODE(); #if 0 || IS_TMP_VAR != IS_UNUSED @@ -11775,20 +11345,15 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HAN zval tmp, *varname; HashTable *target_symbol_table; zend_free_op free_op1; + zend_bool tmp_is_dup = 0; SAVE_OPLINE(); if (IS_TMP_VAR == IS_CV && IS_UNUSED == IS_UNUSED && (opline->extended_value & ZEND_QUICK_SET)) { - if (EG(active_symbol_table)) { - zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); - - zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC); - EX_CV(opline->op1.var) = NULL; - } else if (EX_CV(opline->op1.var)) { - zval_ptr_dtor(EX_CV(opline->op1.var)); - EX_CV(opline->op1.var) = NULL; - } + ZVAL_COPY_VALUE(&tmp, EX_VAR(opline->op1.var)); + ZVAL_UNDEF(EX_VAR(opline->op1.var)); + zval_ptr_dtor(&tmp); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -11796,27 +11361,28 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HAN varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { - ZVAL_COPY_VALUE(&tmp, varname); - zval_copy_ctor(&tmp); + ZVAL_DUP(&tmp, varname); convert_to_string(&tmp); varname = &tmp; + tmp_is_dup = 1; } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) { - Z_ADDREF_P(varname); + ZVAL_COPY(&tmp, varname); + varname = &tmp; } if (IS_UNUSED != IS_UNUSED) { zend_class_entry *ce; if (IS_UNUSED == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { - if (IS_TMP_VAR != IS_CONST && varname == &tmp) { + if (IS_TMP_VAR != IS_CONST && tmp_is_dup) { zval_dtor(&tmp); } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) { - zval_ptr_dtor(&varname); + zval_ptr_dtor(&tmp); } zval_dtor(free_op1.var); HANDLE_EXCEPTION(); @@ -11824,23 +11390,21 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HAN if (UNEXPECTED(ce == NULL)) { zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv)); } - CACHE_PTR(opline->op2.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); } } else { - ce = EX_T(opline->op2.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op2.var)); } - zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); + zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC); } else { - ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1); - target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); - zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC); + zend_hash_del_ind(target_symbol_table, Z_STR_P(varname)); } - if (IS_TMP_VAR != IS_CONST && varname == &tmp) { + if (IS_TMP_VAR != IS_CONST && tmp_is_dup) { zval_dtor(&tmp); } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) { - zval_ptr_dtor(&varname); + zval_ptr_dtor(&tmp); } zval_dtor(free_op1.var); CHECK_EXCEPTION(); @@ -11850,21 +11414,16 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HAN static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval **value; + zval *value; zend_bool isset = 1; SAVE_OPLINE(); if (IS_TMP_VAR == IS_CV && IS_UNUSED == IS_UNUSED && (opline->extended_value & ZEND_QUICK_SET)) { - if (EX_CV(opline->op1.var)) { - value = EX_CV(opline->op1.var); - } else if (EG(active_symbol_table)) { - zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); - - if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) { - isset = 0; - } + if (Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_UNDEF) { + value = EX_VAR(opline->op1.var); + ZVAL_DEREF(value); } else { isset = 0; } @@ -11874,8 +11433,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_UNUSED_HANDLER(ZEND_OP zval tmp, *varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { - ZVAL_COPY_VALUE(&tmp, varname); - zval_copy_ctor(&tmp); + ZVAL_DUP(&tmp, varname); convert_to_string(&tmp); varname = &tmp; } @@ -11884,26 +11442,26 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_UNUSED_HANDLER(ZEND_OP zend_class_entry *ce; if (IS_UNUSED == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(opline->op2.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); } } else { - ce = EX_T(opline->op2.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op2.var)); } - value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); + value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC); if (!value) { isset = 0; } } else { target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); - if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) { + if ((value = zend_hash_find(target_symbol_table, Z_STR_P(varname))) == NULL) { isset = 0; } } @@ -11915,16 +11473,16 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_UNUSED_HANDLER(ZEND_OP } if (opline->extended_value & ZEND_ISSET) { - if (isset && Z_TYPE_PP(value) != IS_NULL) { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); + if (isset && Z_TYPE_P(value) != IS_NULL) { + ZVAL_BOOL(EX_VAR(opline->result.var), 1); } else { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); + ZVAL_BOOL(EX_VAR(opline->result.var), 0); } } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { - if (!isset || !i_zend_is_true(*value TSRMLS_CC)) { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); + if (!isset || !i_zend_is_true(value TSRMLS_CC)) { + ZVAL_BOOL(EX_VAR(opline->result.var), 1); } else { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); + ZVAL_BOOL(EX_VAR(opline->result.var), 0); } } @@ -11936,22 +11494,18 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER { USE_OPLINE - /* The generator object is stored in return_value_ptr_ptr */ - zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr); + /* The generator object is stored in EX(return_value) */ + zend_generator *generator = (zend_generator *) EX(return_value); if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) { zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator"); } /* Destroy the previously yielded value */ - if (generator->value) { - zval_ptr_dtor(&generator->value); - } + zval_ptr_dtor(&generator->value); /* Destroy the previously yielded key */ - if (generator->key) { - zval_ptr_dtor(&generator->key); - } + zval_ptr_dtor(&generator->key); /* Set the new yielded value */ if (IS_TMP_VAR != IS_UNUSED) { @@ -11961,74 +11515,58 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER /* Constants and temporary variables aren't yieldable by reference, * but we still allow them with a notice. */ if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) { - zval *value, *copy; + zval *value; zend_error(E_NOTICE, "Only variable references should be yielded by reference"); value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); + ZVAL_COPY_VALUE(&generator->value, value); + if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1); /* Temporary variables don't need ctor copying */ if (!1) { - zval_copy_ctor(copy); + zval_copy_ctor(&generator->value); } - - generator->value = copy; } else { - zval **value_ptr = NULL; + zval *value_ptr = NULL; - if (IS_TMP_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) { + if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference"); } /* If a function call result is yielded and the function did * not return by reference we throw a notice. */ - if (IS_TMP_VAR == IS_VAR && !Z_ISREF_PP(value_ptr) + if (IS_TMP_VAR == IS_VAR && !Z_ISREF_P(value_ptr) && !(opline->extended_value == ZEND_RETURNS_FUNCTION - && EX_T(opline->op1.var).var.fcall_returned_reference) - && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) { + && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); - - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } else { SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr); - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } + ZVAL_COPY(&generator->value, value_ptr); } } else { zval *value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); /* Consts, temporary variables and references need copying */ - if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR - || PZVAL_IS_REF(value) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); - - /* Temporary variables don't need ctor copying */ - if (!1) { - zval_copy_ctor(copy); - } - - generator->value = copy; + if (IS_TMP_VAR == IS_CONST) { + ZVAL_DUP(&generator->value, value); + } else if (IS_TMP_VAR == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->value, value); + } else if (Z_ISREF_P(value)) { + ZVAL_DUP(&generator->value, Z_REFVAL_P(value)); } else { if (IS_TMP_VAR == IS_CV) { - Z_ADDREF_P(value); + if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value); } - generator->value = value; + ZVAL_COPY_VALUE(&generator->value, value); } } } else { /* If no value was specified yield null */ - Z_ADDREF(EG(uninitialized_zval)); - generator->value = &EG(uninitialized_zval); + ZVAL_NULL(&generator->value); } /* Set the new yielded key */ @@ -12037,45 +11575,36 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER zval *key = NULL; /* Consts, temporary variables and references need copying */ - if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR - || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, key); - - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } + if (IS_UNUSED == IS_CONST) { + ZVAL_DUP(&generator->key, key); + } else if (IS_UNUSED == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->key, key); + } else if (Z_ISREF_P(key)) { + ZVAL_DUP(&generator->key, Z_REFVAL_P(key)); - generator->key = copy; } else { - Z_ADDREF_P(key); - generator->key = key; + if (IS_UNUSED == IS_CV) { + if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key); + } + ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE_P(generator->key) == IS_LONG - && Z_LVAL_P(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_LONG + && Z_LVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL_P(generator->key); + generator->largest_used_integer_key = Z_LVAL(generator->key); } - } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - - ALLOC_INIT_ZVAL(generator->key); - ZVAL_LONG(generator->key, generator->largest_used_integer_key); + ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ - generator->send_target = &EX_T(opline->result.var).var.ptr; - Z_ADDREF(EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + generator->send_target = EX_VAR(opline->result.var); + ZVAL_NULL(generator->send_target); } else { generator->send_target = NULL; } @@ -12097,7 +11626,7 @@ static int ZEND_FASTCALL ZEND_ADD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op1; SAVE_OPLINE(); - fast_add_function(&EX_T(opline->result.var).tmp_var, + fast_add_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); @@ -12112,7 +11641,7 @@ static int ZEND_FASTCALL ZEND_SUB_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op1; SAVE_OPLINE(); - fast_sub_function(&EX_T(opline->result.var).tmp_var, + fast_sub_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); @@ -12127,7 +11656,7 @@ static int ZEND_FASTCALL ZEND_MUL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op1; SAVE_OPLINE(); - fast_mul_function(&EX_T(opline->result.var).tmp_var, + fast_mul_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); @@ -12142,7 +11671,7 @@ static int ZEND_FASTCALL ZEND_DIV_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op1; SAVE_OPLINE(); - fast_div_function(&EX_T(opline->result.var).tmp_var, + fast_div_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); @@ -12157,9 +11686,9 @@ static int ZEND_FASTCALL ZEND_MOD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op1; SAVE_OPLINE(); - fast_mod_function(&EX_T(opline->result.var).tmp_var, + fast_mod_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); CHECK_EXCEPTION(); @@ -12172,9 +11701,9 @@ static int ZEND_FASTCALL ZEND_SL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op1; SAVE_OPLINE(); - shift_left_function(&EX_T(opline->result.var).tmp_var, + shift_left_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); CHECK_EXCEPTION(); @@ -12187,9 +11716,9 @@ static int ZEND_FASTCALL ZEND_SR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op1; SAVE_OPLINE(); - shift_right_function(&EX_T(opline->result.var).tmp_var, + shift_right_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); CHECK_EXCEPTION(); @@ -12202,9 +11731,9 @@ static int ZEND_FASTCALL ZEND_CONCAT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_AR zend_free_op free_op1; SAVE_OPLINE(); - concat_function(&EX_T(opline->result.var).tmp_var, + concat_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); CHECK_EXCEPTION(); @@ -12217,9 +11746,9 @@ static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HAND zend_free_op free_op1; SAVE_OPLINE(); - is_identical_function(&EX_T(opline->result.var).tmp_var, + fast_is_identical_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); CHECK_EXCEPTION(); @@ -12230,13 +11759,12 @@ static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_ { USE_OPLINE zend_free_op free_op1; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - is_identical_function(result, + fast_is_not_identical_function(result, _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); - Z_LVAL_P(result) = !Z_LVAL_P(result); + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); CHECK_EXCEPTION(); @@ -12247,12 +11775,12 @@ static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ { USE_OPLINE zend_free_op free_op1; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_equal_function(result, + fast_equal_function(result, _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); CHECK_EXCEPTION(); @@ -12263,12 +11791,12 @@ static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HAND { USE_OPLINE zend_free_op free_op1; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_not_equal_function(result, + fast_not_equal_function(result, _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); CHECK_EXCEPTION(); @@ -12279,12 +11807,12 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLE { USE_OPLINE zend_free_op free_op1; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_is_smaller_function(result, + fast_is_smaller_function(result, _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); CHECK_EXCEPTION(); @@ -12295,12 +11823,12 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_CV_HANDLER(ZEND_OPCO { USE_OPLINE zend_free_op free_op1; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, + fast_is_smaller_or_equal_function(result, _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); CHECK_EXCEPTION(); @@ -12313,9 +11841,9 @@ static int ZEND_FASTCALL ZEND_BW_OR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG zend_free_op free_op1; SAVE_OPLINE(); - bitwise_or_function(&EX_T(opline->result.var).tmp_var, + bitwise_or_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); CHECK_EXCEPTION(); @@ -12328,9 +11856,9 @@ static int ZEND_FASTCALL ZEND_BW_AND_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_AR zend_free_op free_op1; SAVE_OPLINE(); - bitwise_and_function(&EX_T(opline->result.var).tmp_var, + bitwise_and_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); CHECK_EXCEPTION(); @@ -12343,9 +11871,9 @@ static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_AR zend_free_op free_op1; SAVE_OPLINE(); - bitwise_xor_function(&EX_T(opline->result.var).tmp_var, + bitwise_xor_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); CHECK_EXCEPTION(); @@ -12358,9 +11886,9 @@ static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ zend_free_op free_op1; SAVE_OPLINE(); - boolean_xor_function(&EX_T(opline->result.var).tmp_var, + boolean_xor_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); CHECK_EXCEPTION(); @@ -12375,7 +11903,7 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDL SAVE_OPLINE(); container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC); if (IS_TMP_VAR != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) { zval_dtor(free_op1.var); @@ -12388,7 +11916,7 @@ static int ZEND_FASTCALL ZEND_ADD_VAR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_A { USE_OPLINE - zval *str = &EX_T(opline->result.var).tmp_var; + zval *str = EX_VAR(opline->result.var); zval *var; zval var_copy; int use_copy = 0; @@ -12398,18 +11926,17 @@ static int ZEND_FASTCALL ZEND_ADD_VAR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_A if (IS_TMP_VAR == IS_UNUSED) { /* Initialize for erealloc in add_string_to_string */ - Z_STRVAL_P(str) = NULL; - Z_STRLEN_P(str) = 0; - Z_TYPE_P(str) = IS_STRING; - - INIT_PZVAL(str); + ZVAL_EMPTY_STRING(str); } if (Z_TYPE_P(var) != IS_STRING) { - zend_make_printable_zval(var, &var_copy, &use_copy); + ZVAL_DEREF(var); + if (Z_TYPE_P(var) != IS_STRING) { + zend_make_printable_zval(var, &var_copy, &use_copy); - if (use_copy) { - var = &var_copy; + if (use_copy) { + var = &var_copy; + } } } add_string_to_string(str, str, var); @@ -12432,10 +11959,9 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_ { USE_OPLINE zval *function_name; - char *function_name_strval; - int function_name_strlen; zend_free_op free_op1; call_slot *call = EX(call_slots) + opline->result.num; + zval *object; SAVE_OPLINE(); @@ -12449,33 +11975,30 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_ zend_error_noreturn(E_ERROR, "Method name must be a string"); } - function_name_strval = Z_STRVAL_P(function_name); - function_name_strlen = Z_STRLEN_P(function_name); - - call->object = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + object = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL; - if (EXPECTED(call->object != NULL) && - EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) { - call->called_scope = Z_OBJCE_P(call->object); + if (EXPECTED(call->object != NULL)) { + call->called_scope = zend_get_class_entry(call->object TSRMLS_CC); if (IS_CV != IS_CONST || - (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) { - zval *object = call->object; + (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope)) == NULL) { + zend_object *object = call->object; - if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) { + if (UNEXPECTED(object->handlers->get_method == NULL)) { zend_error_noreturn(E_ERROR, "Object does not support method calls"); } /* First, locate the function. */ - call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); + call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); if (UNEXPECTED(call->fbc == NULL)) { - zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval); + zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name)); } if (IS_CV == IS_CONST && EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) && EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) && EXPECTED(call->object == object)) { - CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc); + CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope, call->fbc); } } } else { @@ -12483,21 +12006,13 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_ HANDLE_EXCEPTION(); } - zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval); + zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", Z_STRVAL_P(function_name)); } if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) { call->object = NULL; } else { - if (!PZVAL_IS_REF(call->object)) { - Z_ADDREF_P(call->object); /* For $this pointer */ - } else { - zval *this_ptr; - ALLOC_ZVAL(this_ptr); - INIT_PZVAL_COPY(this_ptr, call->object); - zval_copy_ctor(this_ptr); - call->object = this_ptr; - } + GC_REFCOUNT(call->object)++; /* For $this pointer */ } call->num_additional_args = 0; @@ -12513,11 +12028,12 @@ static int ZEND_FASTCALL ZEND_CASE_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS { USE_OPLINE zend_free_op free_op1; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - is_equal_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + fast_equal_function(result, + _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -12527,35 +12043,31 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE { USE_OPLINE zend_free_op free_op1; - zval *expr_ptr; + zval *expr_ptr, new_expr; SAVE_OPLINE(); - if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) { - zval **expr_ptr_ptr = NULL; - - if (IS_TMP_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) { + if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && + (opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) { + expr_ptr = NULL; + if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets"); } - SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); - expr_ptr = *expr_ptr_ptr; + SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr); Z_ADDREF_P(expr_ptr); + } else { - expr_ptr=_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + expr_ptr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (1) { /* temporary variable */ - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - } else if (IS_TMP_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) { - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - zendi_zval_copy_ctor(*expr_ptr); + ZVAL_COPY_VALUE(&new_expr, expr_ptr); + expr_ptr = &new_expr; + } else if (IS_TMP_VAR == IS_CONST) { + ZVAL_DUP(&new_expr, expr_ptr); + expr_ptr = &new_expr; + } else if (Z_ISREF_P(expr_ptr)) { + ZVAL_DUP(&new_expr, Z_REFVAL_P(expr_ptr)); + expr_ptr = &new_expr; - } else if (IS_TMP_VAR == IS_CV) { + } else if (IS_TMP_VAR == IS_CV && Z_REFCOUNTED_P(expr_ptr)) { Z_ADDREF_P(expr_ptr); } } @@ -12563,42 +12075,49 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE if (IS_CV != IS_UNUSED) { zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); + zend_string *str; ulong hval; +add_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: hval = zend_dval_to_lval(Z_DVAL_P(offset)); goto num_index; case IS_LONG: - case IS_BOOL: hval = Z_LVAL_P(offset); num_index: - zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL); + zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); break; case IS_STRING: - if (IS_CV == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); + str = Z_STR_P(offset); + if (IS_CV != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index); } - zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL); +str_index: + zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); break; case IS_NULL: - zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); + str = STR_EMPTY_ALLOC(); + goto str_index; + case IS_FALSE: + hval = 0; + goto num_index; + case IS_TRUE: + hval = 1; + goto num_index; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto add_again; break; default: zend_error(E_WARNING, "Illegal offset type"); - zval_ptr_dtor(&expr_ptr); + zval_ptr_dtor(expr_ptr); /* do nothing */ break; } } else { - zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL); - } - if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) { - + zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -12606,9 +12125,26 @@ num_index: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { + zval *array; + zend_uint size; USE_OPLINE - array_init(&EX_T(opline->result.var).tmp_var); + array = EX_VAR(opline->result.var); + if (IS_TMP_VAR != IS_UNUSED) { + size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; + } else { + size = 0; + } + ZVAL_NEW_ARR(array); + zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); + + if (IS_TMP_VAR != IS_UNUSED) { + /* Explicitly initialize array as not-packed if flag is set */ + if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) { + zend_hash_real_init(Z_ARRVAL_P(array), 0); + } + } + if (IS_TMP_VAR == IS_UNUSED) { ZEND_VM_NEXT_OPCODE(); #if 0 || IS_TMP_VAR != IS_UNUSED @@ -12622,22 +12158,18 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG { USE_OPLINE - /* The generator object is stored in return_value_ptr_ptr */ - zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr); + /* The generator object is stored in EX(return_value) */ + zend_generator *generator = (zend_generator *) EX(return_value); if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) { zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator"); } /* Destroy the previously yielded value */ - if (generator->value) { - zval_ptr_dtor(&generator->value); - } + zval_ptr_dtor(&generator->value); /* Destroy the previously yielded key */ - if (generator->key) { - zval_ptr_dtor(&generator->key); - } + zval_ptr_dtor(&generator->key); /* Set the new yielded value */ if (IS_TMP_VAR != IS_UNUSED) { @@ -12647,74 +12179,58 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG /* Constants and temporary variables aren't yieldable by reference, * but we still allow them with a notice. */ if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) { - zval *value, *copy; + zval *value; zend_error(E_NOTICE, "Only variable references should be yielded by reference"); value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); + ZVAL_COPY_VALUE(&generator->value, value); + if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1); /* Temporary variables don't need ctor copying */ if (!1) { - zval_copy_ctor(copy); + zval_copy_ctor(&generator->value); } - - generator->value = copy; } else { - zval **value_ptr = NULL; + zval *value_ptr = NULL; - if (IS_TMP_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) { + if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference"); } /* If a function call result is yielded and the function did * not return by reference we throw a notice. */ - if (IS_TMP_VAR == IS_VAR && !Z_ISREF_PP(value_ptr) + if (IS_TMP_VAR == IS_VAR && !Z_ISREF_P(value_ptr) && !(opline->extended_value == ZEND_RETURNS_FUNCTION - && EX_T(opline->op1.var).var.fcall_returned_reference) - && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) { + && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); - - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } else { SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr); - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } + ZVAL_COPY(&generator->value, value_ptr); } } else { zval *value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); /* Consts, temporary variables and references need copying */ - if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR - || PZVAL_IS_REF(value) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); - - /* Temporary variables don't need ctor copying */ - if (!1) { - zval_copy_ctor(copy); - } - - generator->value = copy; + if (IS_TMP_VAR == IS_CONST) { + ZVAL_DUP(&generator->value, value); + } else if (IS_TMP_VAR == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->value, value); + } else if (Z_ISREF_P(value)) { + ZVAL_DUP(&generator->value, Z_REFVAL_P(value)); } else { if (IS_TMP_VAR == IS_CV) { - Z_ADDREF_P(value); + if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value); } - generator->value = value; + ZVAL_COPY_VALUE(&generator->value, value); } } } else { /* If no value was specified yield null */ - Z_ADDREF(EG(uninitialized_zval)); - generator->value = &EG(uninitialized_zval); + ZVAL_NULL(&generator->value); } /* Set the new yielded key */ @@ -12723,45 +12239,36 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); /* Consts, temporary variables and references need copying */ - if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR - || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, key); - - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } + if (IS_CV == IS_CONST) { + ZVAL_DUP(&generator->key, key); + } else if (IS_CV == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->key, key); + } else if (Z_ISREF_P(key)) { + ZVAL_DUP(&generator->key, Z_REFVAL_P(key)); - generator->key = copy; } else { - Z_ADDREF_P(key); - generator->key = key; + if (IS_CV == IS_CV) { + if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key); + } + ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE_P(generator->key) == IS_LONG - && Z_LVAL_P(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_LONG + && Z_LVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL_P(generator->key); + generator->largest_used_integer_key = Z_LVAL(generator->key); } - } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - - ALLOC_INIT_ZVAL(generator->key); - ZVAL_LONG(generator->key, generator->largest_used_integer_key); + ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ - generator->send_target = &EX_T(opline->result.var).var.ptr; - Z_ADDREF(EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + generator->send_target = EX_VAR(opline->result.var); + ZVAL_NULL(generator->send_target); } else { generator->send_target = NULL; } @@ -12783,9 +12290,9 @@ static int ZEND_FASTCALL ZEND_POW_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op1; SAVE_OPLINE(); - pow_function(&EX_T(opline->result.var).tmp_var, + pow_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op1.var); CHECK_EXCEPTION(); @@ -12798,9 +12305,9 @@ static int ZEND_FASTCALL ZEND_BW_NOT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op1; SAVE_OPLINE(); - bitwise_not_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + bitwise_not_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -12811,9 +12318,9 @@ static int ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG zend_free_op free_op1; SAVE_OPLINE(); - boolean_not_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + boolean_not_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -12822,45 +12329,56 @@ static int ZEND_FASTCALL ZEND_PRE_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS { USE_OPLINE zend_free_op free_op1; - zval **var_ptr; + zval *var_ptr; SAVE_OPLINE(); var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == NULL)) { + if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) { + fast_increment_function(var_ptr); + if (RETURN_VALUE_USED(opline)) { + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr); + } + ZEND_VM_NEXT_OPCODE(); + } + + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } - if (IS_VAR == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) { + if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) { if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - SEPARATE_ZVAL_IF_NOT_REF(var_ptr); + if (UNEXPECTED(Z_ISREF_P(var_ptr))) { + var_ptr = Z_REFVAL_P(var_ptr); + } else { + SEPARATE_ZVAL(var_ptr); + } - if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) - && Z_OBJ_HANDLER_PP(var_ptr, get) - && Z_OBJ_HANDLER_PP(var_ptr, set)) { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) + && Z_OBJ_HANDLER_P(var_ptr, get) + && Z_OBJ_HANDLER_P(var_ptr, set)) { /* proxy object */ - zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); + zval rv; + zval *val = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC); Z_ADDREF_P(val); fast_increment_function(val); - Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC); - zval_ptr_dtor(&val); + Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC); + zval_ptr_dtor(val); } else { - fast_increment_function(*var_ptr); + increment_function(var_ptr); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(*var_ptr); - EX_T(opline->result.var).var.ptr = *var_ptr; + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -12869,45 +12387,56 @@ static int ZEND_FASTCALL ZEND_PRE_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS { USE_OPLINE zend_free_op free_op1; - zval **var_ptr; + zval *var_ptr; SAVE_OPLINE(); var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == NULL)) { + if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) { + fast_decrement_function(var_ptr); + if (RETURN_VALUE_USED(opline)) { + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr); + } + ZEND_VM_NEXT_OPCODE(); + } + + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } - if (IS_VAR == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) { + if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) { if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - SEPARATE_ZVAL_IF_NOT_REF(var_ptr); + if (UNEXPECTED(Z_ISREF_P(var_ptr))) { + var_ptr = Z_REFVAL_P(var_ptr); + } else { + SEPARATE_ZVAL(var_ptr); + } - if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) - && Z_OBJ_HANDLER_PP(var_ptr, get) - && Z_OBJ_HANDLER_PP(var_ptr, set)) { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) + && Z_OBJ_HANDLER_P(var_ptr, get) + && Z_OBJ_HANDLER_P(var_ptr, set)) { /* proxy object */ - zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); + zval rv; + zval *val = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC); Z_ADDREF_P(val); fast_decrement_function(val); - Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC); - zval_ptr_dtor(&val); + Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC); + zval_ptr_dtor(val); } else { - fast_decrement_function(*var_ptr); + decrement_function(var_ptr); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(*var_ptr); - EX_T(opline->result.var).var.ptr = *var_ptr; + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -12916,41 +12445,52 @@ static int ZEND_FASTCALL ZEND_POST_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG { USE_OPLINE zend_free_op free_op1; - zval **var_ptr, *retval; + zval *var_ptr, *retval; SAVE_OPLINE(); var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == NULL)) { + if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) { + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr); + fast_increment_function(var_ptr); + ZEND_VM_NEXT_OPCODE(); + } + + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } - if (IS_VAR == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) { - ZVAL_NULL(&EX_T(opline->result.var).tmp_var); - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) { + ZVAL_NULL(EX_VAR(opline->result.var)); + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - retval = &EX_T(opline->result.var).tmp_var; - ZVAL_COPY_VALUE(retval, *var_ptr); - zendi_zval_copy_ctor(*retval); + retval = EX_VAR(opline->result.var); - SEPARATE_ZVAL_IF_NOT_REF(var_ptr); + if (UNEXPECTED(Z_ISREF_P(var_ptr))) { + var_ptr = Z_REFVAL_P(var_ptr); + ZVAL_DUP(retval, var_ptr); + } else { + ZVAL_DUP(retval, var_ptr); + SEPARATE_ZVAL(var_ptr); + } - if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) - && Z_OBJ_HANDLER_PP(var_ptr, get) - && Z_OBJ_HANDLER_PP(var_ptr, set)) { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) + && Z_OBJ_HANDLER_P(var_ptr, get) + && Z_OBJ_HANDLER_P(var_ptr, set)) { /* proxy object */ - zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); + zval rv; + zval *val = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC); Z_ADDREF_P(val); fast_increment_function(val); - Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC); - zval_ptr_dtor(&val); + Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC); + zval_ptr_dtor(val); } else { - fast_increment_function(*var_ptr); + increment_function(var_ptr); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -12959,41 +12499,52 @@ static int ZEND_FASTCALL ZEND_POST_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG { USE_OPLINE zend_free_op free_op1; - zval **var_ptr, *retval; + zval *var_ptr, *retval; SAVE_OPLINE(); var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == NULL)) { + if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) { + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr); + fast_decrement_function(var_ptr); + ZEND_VM_NEXT_OPCODE(); + } + + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } - if (IS_VAR == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) { - ZVAL_NULL(&EX_T(opline->result.var).tmp_var); - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) { + ZVAL_NULL(EX_VAR(opline->result.var)); + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - retval = &EX_T(opline->result.var).tmp_var; - ZVAL_COPY_VALUE(retval, *var_ptr); - zendi_zval_copy_ctor(*retval); + retval = EX_VAR(opline->result.var); - SEPARATE_ZVAL_IF_NOT_REF(var_ptr); + if (UNEXPECTED(Z_ISREF_P(var_ptr))) { + var_ptr = Z_REFVAL_P(var_ptr); + ZVAL_DUP(retval, var_ptr); + } else { + ZVAL_DUP(retval, var_ptr); + SEPARATE_ZVAL(var_ptr); + } - if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) - && Z_OBJ_HANDLER_PP(var_ptr, get) - && Z_OBJ_HANDLER_PP(var_ptr, set)) { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) + && Z_OBJ_HANDLER_P(var_ptr, get) + && Z_OBJ_HANDLER_P(var_ptr, set)) { /* proxy object */ - zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); + zval rv; + zval *val = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC); Z_ADDREF_P(val); fast_decrement_function(val); - Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC); - zval_ptr_dtor(&val); + Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC); + zval_ptr_dtor(val); } else { - fast_decrement_function(*var_ptr); + decrement_function(var_ptr); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -13005,14 +12556,11 @@ static int ZEND_FASTCALL ZEND_ECHO_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zval *z; SAVE_OPLINE(); - z = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + z = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_TMP_VAR && Z_TYPE_P(z) == IS_OBJECT) { - INIT_PZVAL(z); - } - zend_print_variable(z); + zend_print_variable(z TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -13021,7 +12569,7 @@ static int ZEND_FASTCALL ZEND_PRINT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - ZVAL_LONG(&EX_T(opline->result.var).tmp_var, 1); + ZVAL_LONG(EX_VAR(opline->result.var), 1); return ZEND_ECHO_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } @@ -13030,29 +12578,30 @@ static int ZEND_FASTCALL ZEND_JMPZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) USE_OPLINE zend_free_op free_op1; zval *val; - int ret; SAVE_OPLINE(); - val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + val = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { - ret = Z_LVAL_P(val); - } else { - ret = i_zend_is_true(val TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); + if (IS_VAR == IS_TMP_VAR) { + if (Z_TYPE_P(val) == IS_TRUE) { + ZEND_VM_SET_OPCODE(opline + 1); + ZEND_VM_CONTINUE(); + } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { + ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); + ZEND_VM_CONTINUE(); } } - if (!ret) { -#if DEBUG_ZEND>=2 - printf("Conditional jmp to %d\n", opline->op2.opline_num); -#endif - ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); - ZEND_VM_CONTINUE(); - } - ZEND_VM_NEXT_OPCODE(); + if (i_zend_is_true(val TSRMLS_CC)) { + opline++; + } else { + opline = opline->op2.jmp_addr; + } + zval_ptr_dtor_nogc(free_op1.var); + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } + ZEND_VM_JMP(opline); } static int ZEND_FASTCALL ZEND_JMPNZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -13060,29 +12609,30 @@ static int ZEND_FASTCALL ZEND_JMPNZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) USE_OPLINE zend_free_op free_op1; zval *val; - int ret; SAVE_OPLINE(); - val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + val = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { - ret = Z_LVAL_P(val); - } else { - ret = i_zend_is_true(val TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); + if (IS_VAR == IS_TMP_VAR) { + if (Z_TYPE_P(val) == IS_TRUE) { + ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); + ZEND_VM_CONTINUE(); + } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { + ZEND_VM_SET_OPCODE(opline + 1); + ZEND_VM_CONTINUE(); } } - if (ret) { -#if DEBUG_ZEND>=2 - printf("Conditional jmp to %d\n", opline->op2.opline_num); -#endif - ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); - ZEND_VM_CONTINUE(); - } - ZEND_VM_NEXT_OPCODE(); + if (i_zend_is_true(val TSRMLS_CC)) { + opline = opline->op2.jmp_addr; + } else { + opline++; + } + zval_ptr_dtor_nogc(free_op1.var); + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } + ZEND_VM_JMP(opline); } static int ZEND_FASTCALL ZEND_JMPZNZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -13090,33 +12640,30 @@ static int ZEND_FASTCALL ZEND_JMPZNZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) USE_OPLINE zend_free_op free_op1; zval *val; - int retval; SAVE_OPLINE(); - val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + val = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { - retval = Z_LVAL_P(val); - } else { - retval = i_zend_is_true(val TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); + if (IS_VAR == IS_TMP_VAR) { + if (EXPECTED(Z_TYPE_P(val) == IS_TRUE)) { + ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value); + ZEND_VM_CONTINUE(); + } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { + ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); + ZEND_VM_CONTINUE(); } } - if (EXPECTED(retval != 0)) { -#if DEBUG_ZEND>=2 - printf("Conditional jmp on true to %d\n", opline->extended_value); -#endif - ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]); - ZEND_VM_CONTINUE(); /* CHECK_ME */ + + if (i_zend_is_true(val TSRMLS_CC)) { + opline = (zend_op*)(((char*)opline) + opline->extended_value); } else { -#if DEBUG_ZEND>=2 - printf("Conditional jmp on false to %d\n", opline->op2.opline_num); -#endif - ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->op2.opline_num]); - ZEND_VM_CONTINUE(); /* CHECK_ME */ + opline = opline->op2.jmp_addr; } + zval_ptr_dtor_nogc(free_op1.var); + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } + ZEND_VM_JMP(opline); } static int ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -13124,30 +12671,34 @@ static int ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS USE_OPLINE zend_free_op free_op1; zval *val; - int retval; SAVE_OPLINE(); - val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + val = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { - retval = Z_LVAL_P(val); - } else { - retval = i_zend_is_true(val TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); + if (IS_VAR == IS_TMP_VAR) { + if (Z_TYPE_P(val) == IS_TRUE) { + ZVAL_TRUE(EX_VAR(opline->result.var)); + ZEND_VM_SET_OPCODE(opline + 1); + ZEND_VM_CONTINUE(); + } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { + ZVAL_FALSE(EX_VAR(opline->result.var)); + ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); + ZEND_VM_CONTINUE(); } } - Z_LVAL(EX_T(opline->result.var).tmp_var) = retval; - Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; - if (!retval) { -#if DEBUG_ZEND>=2 - printf("Conditional jmp to %d\n", opline->op2.opline_num); -#endif - ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); - ZEND_VM_CONTINUE(); + + if (i_zend_is_true(val TSRMLS_CC)) { + ZVAL_TRUE(EX_VAR(opline->result.var)); + opline++; + } else { + ZVAL_FALSE(EX_VAR(opline->result.var)); + opline = opline->op2.jmp_addr; } - ZEND_VM_NEXT_OPCODE(); + zval_ptr_dtor_nogc(free_op1.var); + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } + ZEND_VM_JMP(opline); } static int ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -13155,30 +12706,33 @@ static int ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG USE_OPLINE zend_free_op free_op1; zval *val; - int retval; SAVE_OPLINE(); - val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + val = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { - retval = Z_LVAL_P(val); - } else { - retval = i_zend_is_true(val TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); + if (IS_VAR == IS_TMP_VAR) { + if (Z_TYPE_P(val) == IS_TRUE) { + ZVAL_TRUE(EX_VAR(opline->result.var)); + ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); + ZEND_VM_CONTINUE(); + } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { + ZVAL_FALSE(EX_VAR(opline->result.var)); + ZEND_VM_SET_OPCODE(opline + 1); + ZEND_VM_CONTINUE(); } } - Z_LVAL(EX_T(opline->result.var).tmp_var) = retval; - Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; - if (retval) { -#if DEBUG_ZEND>=2 - printf("Conditional jmp to %d\n", opline->op2.opline_num); -#endif - ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); - ZEND_VM_CONTINUE(); + if (i_zend_is_true(val TSRMLS_CC)) { + ZVAL_TRUE(EX_VAR(opline->result.var)); + opline = opline->op2.jmp_addr; + } else { + ZVAL_FALSE(EX_VAR(opline->result.var)); + opline++; } - ZEND_VM_NEXT_OPCODE(); + zval_ptr_dtor_nogc(free_op1.var); + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } + ZEND_VM_JMP(opline); } static int ZEND_FASTCALL ZEND_FREE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -13187,9 +12741,9 @@ static int ZEND_FASTCALL ZEND_FREE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) SAVE_OPLINE(); if (IS_VAR == IS_TMP_VAR) { - zendi_zval_dtor(EX_T(opline->op1.var).tmp_var); + zval_dtor(EX_VAR(opline->op1.var)); } else { - zval_ptr_dtor(&EX_T(opline->op1.var).var.ptr); + zval_ptr_dtor(EX_VAR(opline->op1.var)); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -13204,34 +12758,21 @@ static int ZEND_FASTCALL ZEND_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) SAVE_OPLINE(); retval_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (!EG(return_value_ptr_ptr)) { - zval_ptr_dtor_nogc(&free_op1.var); + if (!EX(return_value)) { + zval_ptr_dtor_nogc(free_op1.var); } else { - if (IS_VAR == IS_CONST || - IS_VAR == IS_TMP_VAR || - PZVAL_IS_REF(retval_ptr)) { - zval *ret; - - ALLOC_ZVAL(ret); - INIT_PZVAL_COPY(ret, retval_ptr); + if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) { + ZVAL_COPY_VALUE(EX(return_value), retval_ptr); if (IS_VAR != IS_TMP_VAR) { - zval_copy_ctor(ret); + zval_opt_copy_ctor(EX(return_value)); } - *EG(return_value_ptr_ptr) = ret; - zval_ptr_dtor_nogc(&free_op1.var); - } else if ((IS_VAR == IS_CV || IS_VAR == IS_VAR) && - retval_ptr == &EG(uninitialized_zval)) { - zval *ret; - - if (IS_VAR == IS_VAR) { - Z_DELREF_P(retval_ptr); - } - ALLOC_INIT_ZVAL(ret); - *EG(return_value_ptr_ptr) = ret; + } else if (Z_ISREF_P(retval_ptr)) { + ZVAL_DUP(EX(return_value), Z_REFVAL_P(retval_ptr)); + zval_ptr_dtor_nogc(free_op1.var); } else { - *EG(return_value_ptr_ptr) = retval_ptr; + ZVAL_COPY_VALUE(EX(return_value), retval_ptr); if (IS_VAR == IS_CV) { - Z_ADDREF_P(retval_ptr); + if (Z_OPT_REFCOUNTED_P(retval_ptr)) Z_ADDREF_P(retval_ptr); } } } @@ -13242,7 +12783,6 @@ static int ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLE { USE_OPLINE zval *retval_ptr; - zval **retval_ptr_ptr; zend_free_op free_op1; SAVE_OPLINE(); @@ -13254,59 +12794,45 @@ static int ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLE zend_error(E_NOTICE, "Only variable references should be returned by reference"); retval_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (!EG(return_value_ptr_ptr)) { + if (!EX(return_value)) { if (IS_VAR == IS_TMP_VAR) { - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); } } else if (!0) { /* Not a temp var */ - zval *ret; - - ALLOC_ZVAL(ret); - INIT_PZVAL_COPY(ret, retval_ptr); - zval_copy_ctor(ret); - *EG(return_value_ptr_ptr) = ret; + ZVAL_DUP(EX(return_value), retval_ptr); } else { - zval *ret; - - ALLOC_ZVAL(ret); - INIT_PZVAL_COPY(ret, retval_ptr); - *EG(return_value_ptr_ptr) = ret; + ZVAL_COPY_VALUE(EX(return_value), retval_ptr); } break; } - retval_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + retval_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_VAR && UNEXPECTED(retval_ptr_ptr == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(retval_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference"); } - if (IS_VAR == IS_VAR && !Z_ISREF_PP(retval_ptr_ptr)) { + if (IS_VAR == IS_VAR && !Z_ISREF_P(retval_ptr)) { if (opline->extended_value == ZEND_RETURNS_FUNCTION && - EX_T(opline->op1.var).var.fcall_returned_reference) { - } else if (EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) { + (Z_VAR_FLAGS_P(retval_ptr) & IS_VAR_RET_REF)) { + } else { zend_error(E_NOTICE, "Only variable references should be returned by reference"); - if (EG(return_value_ptr_ptr)) { - zval *ret; - - ALLOC_ZVAL(ret); - INIT_PZVAL_COPY(ret, *retval_ptr_ptr); - zval_copy_ctor(ret); - *EG(return_value_ptr_ptr) = ret; + if (EX(return_value)) { + zval tmp; + ZVAL_DUP(&tmp, retval_ptr); + ZVAL_NEW_REF(EX(return_value), &tmp); } break; } } - if (EG(return_value_ptr_ptr)) { - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr); - Z_ADDREF_PP(retval_ptr_ptr); - - *EG(return_value_ptr_ptr) = *retval_ptr_ptr; + if (EX(return_value)) { + SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); + ZVAL_COPY(EX(return_value), retval_ptr); } } while (0); - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } @@ -13314,7 +12840,7 @@ static int ZEND_FASTCALL ZEND_THROW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *value; - zval *exception; + zval exception; zend_free_op free_op1; SAVE_OPLINE(); @@ -13328,49 +12854,36 @@ static int ZEND_FASTCALL ZEND_THROW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) } zend_exception_save(TSRMLS_C); - /* Not sure if a complete copy is what we want here */ - ALLOC_ZVAL(exception); - INIT_PZVAL_COPY(exception, value); - if (!0) { - zval_copy_ctor(exception); + if (IS_VAR == IS_CONST) { + ZVAL_DUP(&exception, value); + value = &exception; + } else if (IS_VAR != IS_TMP_VAR) { + if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value); } - zend_throw_exception_object(exception TSRMLS_CC); + zend_throw_exception_object(value TSRMLS_CC); zend_exception_restore(TSRMLS_C); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); HANDLE_EXCEPTION(); } static int ZEND_FASTCALL zend_send_by_var_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *varptr; + zval *varptr, *top; zend_free_op free_op1; - varptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - - if (varptr == &EG(uninitialized_zval)) { - if (IS_VAR == IS_VAR) { - Z_DELREF_P(varptr); - } - ALLOC_INIT_ZVAL(varptr); - } else if (PZVAL_IS_REF(varptr)) { - if (IS_VAR == IS_CV || - (IS_VAR == IS_VAR && Z_REFCOUNT_P(varptr) > 2)) { - zval *original_var = varptr; - ALLOC_ZVAL(varptr); - INIT_PZVAL_COPY(varptr, original_var); - zval_copy_ctor(varptr); - zval_ptr_dtor_nogc(&free_op1.var); - } else { - Z_UNSET_ISREF_P(varptr); + varptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + top = zend_vm_stack_top_inc(TSRMLS_C); + if (Z_ISREF_P(varptr)) { + ZVAL_DUP(top, Z_REFVAL_P(varptr)); + zval_ptr_dtor_nogc(free_op1.var); + } else { + ZVAL_COPY_VALUE(top, varptr); + if (IS_VAR == IS_CV) { + if (Z_OPT_REFCOUNTED_P(varptr)) Z_ADDREF_P(varptr); } - } else if (IS_VAR == IS_CV) { - Z_ADDREF_P(varptr); } - zend_vm_stack_push(varptr TSRMLS_CC); - - CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -13378,7 +12891,7 @@ static int ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HAND { USE_OPLINE zend_free_op free_op1; - zval *varptr; + zval *varptr, *top; SAVE_OPLINE(); if (opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) { /* Had function_ptr at compile_time */ @@ -13393,29 +12906,29 @@ static int ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HAND varptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if ((!(opline->extended_value & ZEND_ARG_SEND_FUNCTION) || - EX_T(opline->op1.var).var.fcall_returned_reference) && - varptr != &EG(uninitialized_zval) && - (PZVAL_IS_REF(varptr) || Z_REFCOUNT_P(varptr) == 1)) { - Z_SET_ISREF_P(varptr); + (Z_VAR_FLAGS_P(varptr) & IS_VAR_RET_REF)) && + ((!Z_REFCOUNTED_P(varptr) && Z_TYPE_P(varptr) != IS_STRING) || + Z_ISREF_P(varptr) || + Z_TYPE_P(varptr) == IS_OBJECT || + (Z_REFCOUNTED_P(varptr) && Z_REFCOUNT_P(varptr) == 1))) { + + if (!Z_ISREF_P(varptr)) { + ZVAL_NEW_REF(varptr, varptr); + } if (IS_VAR == IS_CV) { Z_ADDREF_P(varptr); } zend_vm_stack_push(varptr TSRMLS_CC); } else { - zval *valptr; - if ((opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) ? !(opline->extended_value & ZEND_ARG_SEND_SILENT) : !ARG_MAY_BE_SENT_BY_REF(EX(call)->fbc, opline->op2.num)) { zend_error(E_STRICT, "Only variables should be passed by reference"); } - ALLOC_ZVAL(valptr); - INIT_PZVAL_COPY(valptr, varptr); - if (!0) { - zval_copy_ctor(valptr); - } - zval_ptr_dtor_nogc(&free_op1.var); - zend_vm_stack_push(valptr TSRMLS_CC); + top = zend_vm_stack_top_inc(TSRMLS_C); + ZVAL_COPY_VALUE(top, varptr); + zval_opt_copy_ctor(top); + zval_ptr_dtor_nogc(free_op1.var); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -13425,63 +12938,74 @@ static int ZEND_FASTCALL ZEND_SEND_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG { USE_OPLINE zend_free_op free_op1; - zval **varptr_ptr; - zval *varptr; + zval *varptr, *top; SAVE_OPLINE(); - varptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + varptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_VAR && UNEXPECTED(varptr_ptr == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(varptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Only variables can be passed by reference"); } - if (IS_VAR == IS_VAR && UNEXPECTED(*varptr_ptr == &EG(error_zval))) { - ALLOC_INIT_ZVAL(varptr); - zend_vm_stack_push(varptr TSRMLS_CC); - CHECK_EXCEPTION(); + top = zend_vm_stack_top_inc(TSRMLS_C); + if (IS_VAR == IS_VAR && UNEXPECTED(varptr == &EG(error_zval))) { + ZVAL_NEW_REF(top, &EG(uninitialized_zval)); ZEND_VM_NEXT_OPCODE(); } - if (opline->extended_value == ZEND_DO_FCALL_BY_NAME && - EX(function_state).function->type == ZEND_INTERNAL_FUNCTION) { - if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->fbc, opline->op2.num)) { - return zend_send_by_var_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - } + if (Z_ISREF_P(varptr)) { + Z_ADDREF_P(varptr); + ZVAL_COPY_VALUE(top, varptr); + } else if (IS_VAR == IS_VAR && + UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) { + ZVAL_COPY_VALUE(top, varptr); + SEPARATE_ZVAL_TO_MAKE_IS_REF(top); + } else { + SEPARATE_ZVAL_TO_MAKE_IS_REF(varptr); + Z_ADDREF_P(varptr); + ZVAL_COPY_VALUE(top, varptr); } - SEPARATE_ZVAL_TO_MAKE_IS_REF(varptr_ptr); - varptr = *varptr_ptr; - Z_ADDREF_P(varptr); - zend_vm_stack_push(varptr TSRMLS_CC); - - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - CHECK_EXCEPTION(); + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_SEND_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE + zval *varptr, *top; + zend_free_op free_op1; if (opline->extended_value == ZEND_DO_FCALL_BY_NAME) { if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->fbc, opline->op2.num)) { return ZEND_SEND_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } } - SAVE_OPLINE(); - return zend_send_by_var_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + + varptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + top = zend_vm_stack_top_inc(TSRMLS_C); + if (Z_ISREF_P(varptr)) { + ZVAL_DUP(top, Z_REFVAL_P(varptr)); + zval_ptr_dtor_nogc(free_op1.var); + } else { + ZVAL_COPY_VALUE(top, varptr); + if (IS_VAR == IS_CV) { + if (Z_OPT_REFCOUNTED_P(varptr)) Z_ADDREF_P(varptr); + } + } + ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_BOOL_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_free_op free_op1; - zval *retval = &EX_T(opline->result.var).tmp_var; + zval *retval = EX_VAR(opline->result.var); SAVE_OPLINE(); /* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */ ZVAL_BOOL(retval, i_zend_is_true(_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC) TSRMLS_CC)); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -13492,7 +13016,7 @@ static int ZEND_FASTCALL ZEND_SWITCH_FREE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ USE_OPLINE SAVE_OPLINE(); - zval_ptr_dtor(&EX_T(opline->op1.var).var.ptr); + zval_ptr_dtor(EX_VAR(opline->op1.var)); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -13522,7 +13046,7 @@ static int ZEND_FASTCALL ZEND_CLONE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) clone_call = Z_OBJ_HT_P(obj)->clone_obj; if (UNEXPECTED(clone_call == NULL)) { if (ce) { - zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name); + zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name->val); } else { zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object"); } @@ -13533,32 +13057,24 @@ static int ZEND_FASTCALL ZEND_CLONE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) /* Ensure that if we're calling a private function, we're allowed to do so. */ if (UNEXPECTED(ce != EG(scope))) { - zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : ""); + zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name->val, EG(scope) ? EG(scope)->name->val : ""); } } else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) { /* Ensure that if we're calling a protected function, we're allowed to do so. */ if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), EG(scope)))) { - zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : ""); + zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name->val, EG(scope) ? EG(scope)->name->val : ""); } } } if (EXPECTED(EG(exception) == NULL)) { - zval *retval; - - ALLOC_ZVAL(retval); - Z_OBJVAL_P(retval) = clone_call(obj TSRMLS_CC); - Z_TYPE_P(retval) = IS_OBJECT; - Z_SET_REFCOUNT_P(retval, 1); - Z_SET_ISREF_P(retval); + ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(obj TSRMLS_CC)); if (!RETURN_VALUE_USED(opline) || UNEXPECTED(EG(exception) != NULL)) { - zval_ptr_dtor(&retval); - } else { - EX_T(opline->result.var).var.ptr = retval; + zval_ptr_dtor(EX_VAR(opline->result.var)); } } - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -13568,56 +13084,74 @@ static int ZEND_FASTCALL ZEND_CAST_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) USE_OPLINE zend_free_op free_op1; zval *expr; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); expr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (opline->extended_value != IS_STRING) { - ZVAL_COPY_VALUE(result, expr); - if (!0) { - zendi_zval_copy_ctor(*result); - } - } switch (opline->extended_value) { case IS_NULL: - convert_to_null(result); + /* This code is taken from convert_to_null. However, it does not seems very useful, + * because a conversion to null always results in the same value. This could only + * be relevant if a cast_object handler for IS_NULL has some kind of side-effect. */ +#if 0 + if (IS_VAR == IS_VAR || IS_VAR == IS_CV) { + ZVAL_DEREF(expr); + } + if (Z_TYPE_P(expr) == IS_OBJECT && Z_OBJ_HT_P(expr)->cast_object) { + if (Z_OBJ_HT_P(expr)->cast_object(expr, result, IS_NULL TSRMLS_CC) == SUCCESS) { + break; + } + } +#endif + + ZVAL_NULL(result); break; - case IS_BOOL: - convert_to_boolean(result); + case _IS_BOOL: + ZVAL_BOOL(result, zend_is_true(expr TSRMLS_CC)); break; case IS_LONG: - convert_to_long(result); + ZVAL_LONG(result, zval_get_long(expr)); break; case IS_DOUBLE: - convert_to_double(result); + ZVAL_DOUBLE(result, zval_get_double(expr)); break; - case IS_STRING: { - zval var_copy; - int use_copy; - - zend_make_printable_zval(expr, &var_copy, &use_copy); - if (use_copy) { - ZVAL_COPY_VALUE(result, &var_copy); - if (0) { - zval_ptr_dtor_nogc(&free_op1.var); - } - } else { + case IS_STRING: + ZVAL_STR(result, zval_get_string(expr)); + break; + default: + /* If value is already of correct type, return it directly */ + if (Z_TYPE_P(expr) == opline->extended_value) { ZVAL_COPY_VALUE(result, expr); - if (!0) { - zendi_zval_copy_ctor(*result); + if (IS_VAR == IS_CONST) { + zval_opt_copy_ctor(result); + } else if (IS_VAR == IS_CV) { + if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr); } + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } - break; - } - case IS_ARRAY: - convert_to_array(result); - break; - case IS_OBJECT: - convert_to_object(result); - break; + + if (IS_VAR == IS_VAR || IS_VAR == IS_CV) { + ZVAL_DEREF(expr); + } + ZVAL_COPY_VALUE(result, expr); + if (!0) { + zval_opt_copy_ctor(result); + } + + if (opline->extended_value == IS_ARRAY) { + convert_to_array(result); + } else { + convert_to_object(result); + } + + zval_ptr_dtor_nogc(free_op1.var); + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -13628,18 +13162,17 @@ static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER(ZEND_OPCODE_HAND zend_op_array *new_op_array=NULL; zend_free_op free_op1; zval *inc_filename; - zval *tmp_inc_filename = NULL; + zval tmp_inc_filename; zend_bool failure_retval=0; SAVE_OPLINE(); inc_filename = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (inc_filename->type!=IS_STRING) { - MAKE_STD_ZVAL(tmp_inc_filename); - ZVAL_COPY_VALUE(tmp_inc_filename, inc_filename); - zval_copy_ctor(tmp_inc_filename); - convert_to_string(tmp_inc_filename); - inc_filename = tmp_inc_filename; + ZVAL_UNDEF(&tmp_inc_filename); + if (Z_TYPE_P(inc_filename) != IS_STRING) { + ZVAL_DUP(&tmp_inc_filename, inc_filename); + convert_to_string(&tmp_inc_filename); + inc_filename = &tmp_inc_filename; } if (opline->extended_value != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRLEN_P(inc_filename)) { @@ -13657,7 +13190,7 @@ static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER(ZEND_OPCODE_HAND resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename) TSRMLS_CC); if (resolved_path) { - failure_retval = zend_hash_exists(&EG(included_files), resolved_path, strlen(resolved_path)+1); + failure_retval = zend_hash_str_exists(&EG(included_files), resolved_path, strlen(resolved_path)); } else { resolved_path = Z_STRVAL_P(inc_filename); } @@ -13670,7 +13203,7 @@ static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER(ZEND_OPCODE_HAND file_handle.opened_path = estrdup(resolved_path); } - if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1)==SUCCESS) { + if (zend_hash_str_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path))) { new_op_array = zend_compile_file(&file_handle, (opline->extended_value==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) TSRMLS_CC); zend_destroy_file_handle(&file_handle TSRMLS_CC); } else { @@ -13703,40 +13236,37 @@ static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER(ZEND_OPCODE_HAND EMPTY_SWITCH_DEFAULT_CASE() } } - if (tmp_inc_filename) { + if (Z_TYPE(tmp_inc_filename) != IS_UNDEF) { zval_ptr_dtor(&tmp_inc_filename); } - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } else if (EXPECTED(new_op_array != NULL)) { - EX(original_return_value) = EG(return_value_ptr_ptr); + zval *return_value = NULL; + EG(active_op_array) = new_op_array; if (RETURN_VALUE_USED(opline)) { - EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; - EG(return_value_ptr_ptr) = EX_T(opline->result.var).var.ptr_ptr; - } else { - EG(return_value_ptr_ptr) = NULL; + return_value = EX_VAR(opline->result.var); } EX(function_state).function = (zend_function *) new_op_array; - EX(object) = NULL; if (!EG(active_symbol_table)) { zend_rebuild_symbol_table(TSRMLS_C); } if (EXPECTED(zend_execute_ex == execute_ex)) { + i_create_execute_data_from_op_array(new_op_array, return_value, VM_FRAME_NESTED_CODE TSRMLS_CC); ZEND_VM_ENTER(); } else { - zend_execute(new_op_array TSRMLS_CC); + zend_execute(new_op_array, return_value TSRMLS_CC); } EX(function_state).function = (zend_function *) EX(op_array); EG(opline_ptr) = &EX(opline); EG(active_op_array) = EX(op_array); - EG(return_value_ptr_ptr) = EX(original_return_value); destroy_op_array(new_op_array TSRMLS_CC); efree(new_op_array); if (UNEXPECTED(EG(exception) != NULL)) { @@ -13745,12 +13275,7 @@ static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER(ZEND_OPCODE_HAND } } else if (RETURN_VALUE_USED(opline)) { - zval *retval; - - ALLOC_ZVAL(retval); - ZVAL_BOOL(retval, failure_retval); - INIT_PZVAL(retval); - EX_T(opline->result.var).var.ptr = retval; + ZVAL_BOOL(EX_VAR(opline->result.var), failure_retval); } ZEND_VM_NEXT_OPCODE(); } @@ -13759,7 +13284,7 @@ static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG { USE_OPLINE zend_free_op free_op1; - zval *array_ptr, **array_ptr_ptr; + zval *array_ptr, *array_ref, iterator; HashTable *fe_ht; zend_object_iterator *iter = NULL; zend_class_entry *ce = NULL; @@ -13769,71 +13294,79 @@ static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG if ((IS_VAR == IS_CV || IS_VAR == IS_VAR) && (opline->extended_value & ZEND_FE_RESET_VARIABLE)) { - array_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (array_ptr_ptr == NULL || array_ptr_ptr == &EG(uninitialized_zval_ptr)) { - MAKE_STD_ZVAL(array_ptr); - ZVAL_NULL(array_ptr); - } else if (Z_TYPE_PP(array_ptr_ptr) == IS_OBJECT) { - if(Z_OBJ_HT_PP(array_ptr_ptr)->get_class_entry == NULL) { + array_ptr = array_ref = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + ZVAL_DEREF(array_ptr); + if (Z_TYPE_P(array_ptr) == IS_ARRAY) { + if (!Z_ISREF_P(array_ref)) { + SEPARATE_ZVAL(array_ptr); + array_ref = array_ptr; + if (opline->extended_value & ZEND_FE_FETCH_BYREF) { + ZVAL_NEW_REF(array_ptr, array_ptr); + array_ref = array_ptr; + array_ptr = Z_REFVAL_P(array_ptr); + } + } + if (Z_REFCOUNTED_P(array_ref)) Z_ADDREF_P(array_ref); + } else if (Z_TYPE_P(array_ptr) == IS_OBJECT) { + if(Z_OBJ_HT_P(array_ptr)->get_class_entry == NULL) { zend_error(E_WARNING, "foreach() cannot iterate over objects without PHP class"); ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num); } - ce = Z_OBJCE_PP(array_ptr_ptr); + ce = Z_OBJCE_P(array_ptr); if (!ce || ce->get_iterator == NULL) { - SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr); - Z_ADDREF_PP(array_ptr_ptr); - } - array_ptr = *array_ptr_ptr; - } else { - if (Z_TYPE_PP(array_ptr_ptr) == IS_ARRAY) { - SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr); - if (opline->extended_value & ZEND_FE_FETCH_BYREF) { - Z_SET_ISREF_PP(array_ptr_ptr); + if (!Z_ISREF_P(array_ref)) { + SEPARATE_ZVAL(array_ptr); } + Z_ADDREF_P(array_ptr); } - array_ptr = *array_ptr_ptr; - Z_ADDREF_P(array_ptr); + array_ref = array_ptr; + } else { + if (Z_REFCOUNTED_P(array_ref)) Z_ADDREF_P(array_ref); } } else { - array_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + array_ptr = array_ref = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + ZVAL_DEREF(array_ptr); if (0) { /* IS_TMP_VAR */ - zval *tmp; + zval tmp; - ALLOC_ZVAL(tmp); - INIT_PZVAL_COPY(tmp, array_ptr); - array_ptr = tmp; + ZVAL_COPY_VALUE(&tmp, array_ptr); + array_ptr = &tmp; if (Z_TYPE_P(array_ptr) == IS_OBJECT) { ce = Z_OBJCE_P(array_ptr); if (ce && ce->get_iterator) { - Z_DELREF_P(array_ptr); + Z_DELREF_P(array_ref); } } } else if (Z_TYPE_P(array_ptr) == IS_OBJECT) { ce = Z_OBJCE_P(array_ptr); if (!ce || !ce->get_iterator) { if (IS_VAR == IS_CV) { - Z_ADDREF_P(array_ptr); + Z_ADDREF_P(array_ref); } } - } else if (IS_VAR == IS_CONST || - (IS_VAR == IS_CV && - !Z_ISREF_P(array_ptr) && - Z_REFCOUNT_P(array_ptr) > 1) || - (IS_VAR == IS_VAR && - !Z_ISREF_P(array_ptr) && - Z_REFCOUNT_P(array_ptr) > 2)) { - zval *tmp; + } else if (Z_REFCOUNTED_P(array_ref)) { + if (IS_VAR == IS_CONST || + (IS_VAR == IS_CV && + !Z_ISREF_P(array_ref) && + Z_REFCOUNT_P(array_ref) > 1) || + (IS_VAR == IS_VAR && + !Z_ISREF_P(array_ref) && + Z_REFCOUNT_P(array_ref) > 2)) { + zval tmp; - if (IS_VAR == IS_VAR) { - Z_DELREF_P(array_ptr); + if (IS_VAR == IS_VAR) { + Z_DELREF_P(array_ref); + } + ZVAL_DUP(&tmp, array_ref); + array_ptr = array_ref = &tmp; + } else if (IS_VAR == IS_CV) { + if (Z_ISREF_P(array_ref) && Z_REFCOUNT_P(array_ref) == 1) { + ZVAL_UNREF(array_ref); + array_ptr = array_ref; + } + Z_ADDREF_P(array_ref); } - ALLOC_ZVAL(tmp); - INIT_PZVAL_COPY(tmp, array_ptr); - zval_copy_ctor(tmp); - array_ptr = tmp; - } else if (IS_VAR == IS_CV) { - Z_ADDREF_P(array_ptr); } } @@ -13841,41 +13374,42 @@ static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG iter = ce->get_iterator(ce, array_ptr, opline->extended_value & ZEND_FE_RESET_REFERENCE TSRMLS_CC); if (IS_VAR == IS_VAR && !(opline->extended_value & ZEND_FE_RESET_VARIABLE)) { - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); } if (iter && EXPECTED(EG(exception) == NULL)) { - array_ptr = zend_iterator_wrap(iter TSRMLS_CC); + ZVAL_OBJ(&iterator, &iter->std); + array_ptr = array_ref = &iterator; } else { if (IS_VAR == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) { - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; } if (!EG(exception)) { - zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name); + zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name->val); } zend_throw_exception_internal(NULL TSRMLS_CC); HANDLE_EXCEPTION(); } } - EX_T(opline->result.var).fe.ptr = array_ptr; + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref); if (iter) { iter->index = 0; if (iter->funcs->rewind) { iter->funcs->rewind(iter TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { - zval_ptr_dtor(&array_ptr); + zval_ptr_dtor(array_ref); if (IS_VAR == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) { - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; } HANDLE_EXCEPTION(); } } is_empty = iter->funcs->valid(iter TSRMLS_CC) != SUCCESS; if (UNEXPECTED(EG(exception) != NULL)) { - zval_ptr_dtor(&array_ptr); + zval_ptr_dtor(array_ref); if (IS_VAR == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) { - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; } HANDLE_EXCEPTION(); } @@ -13883,31 +13417,30 @@ static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG } else if ((fe_ht = HASH_OF(array_ptr)) != NULL) { zend_hash_internal_pointer_reset(fe_ht); if (ce) { - zend_object *zobj = zend_objects_get_address(array_ptr TSRMLS_CC); + zend_object *zobj = Z_OBJ_P(array_ptr); while (zend_hash_has_more_elements(fe_ht) == SUCCESS) { - char *str_key; - uint str_key_len; + zend_string *str_key; ulong int_key; zend_uchar key_type; - key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL); + key_type = zend_hash_get_current_key(fe_ht, &str_key, &int_key, 0); if (key_type != HASH_KEY_NON_EXISTENT && (key_type == HASH_KEY_IS_LONG || - zend_check_property_access(zobj, str_key, str_key_len-1 TSRMLS_CC) == SUCCESS)) { + zend_check_property_access(zobj, str_key TSRMLS_CC) == SUCCESS)) { break; } zend_hash_move_forward(fe_ht); } } is_empty = zend_hash_has_more_elements(fe_ht) != SUCCESS; - zend_hash_get_pointer(fe_ht, &EX_T(opline->result.var).fe.fe_pos); + zend_hash_get_pointer(fe_ht, (HashPointer*)EX_VAR((opline+2)->op1.var)); } else { zend_error(E_WARNING, "Invalid argument supplied for foreach()"); is_empty = 1; } if (IS_VAR == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) { - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; } if (is_empty) { ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num); @@ -13921,14 +13454,16 @@ static int ZEND_FASTCALL ZEND_FE_FETCH_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG { USE_OPLINE - zval *array = EX_T(opline->op1.var).fe.ptr; - zval **value; + zval *array, *array_ref; + zval *value; HashTable *fe_ht; zend_object_iterator *iter = NULL; - zval *key = NULL; + + array = array_ref = EX_VAR(opline->op1.var); + ZVAL_DEREF(array); if (opline->extended_value & ZEND_FE_FETCH_WITH_KEY) { - key = &EX_T((opline+1)->result.var).tmp_var; + key = EX_VAR((opline+1)->result.var); } SAVE_OPLINE(); @@ -13940,24 +13475,35 @@ static int ZEND_FASTCALL ZEND_FE_FETCH_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num); case ZEND_ITER_PLAIN_OBJECT: { - zend_object *zobj = zend_objects_get_address(array TSRMLS_CC); + zend_object *zobj = Z_OBJ_P(array); int key_type; - char *str_key; - zend_uint str_key_len; + zend_string *str_key; zend_ulong int_key; fe_ht = Z_OBJPROP_P(array); - zend_hash_set_pointer(fe_ht, &EX_T(opline->op1.var).fe.fe_pos); - do { - if (zend_hash_get_current_data(fe_ht, (void **) &value)==FAILURE) { + zend_hash_set_pointer(fe_ht, (HashPointer*)EX_VAR((opline+1)->op1.var)); + while (1) { + if ((value = zend_hash_get_current_data(fe_ht)) == NULL) { /* reached end of iteration */ ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num); } - key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL); + + if (Z_TYPE_P(value) == IS_INDIRECT) { + value = Z_INDIRECT_P(value); + if (Z_TYPE_P(value) == IS_UNDEF) { + zend_hash_move_forward(fe_ht); + continue; + } + } + + key_type = zend_hash_get_current_key(fe_ht, &str_key, &int_key, 0); zend_hash_move_forward(fe_ht); - } while (key_type != HASH_KEY_IS_LONG && - zend_check_property_access(zobj, str_key, str_key_len - 1 TSRMLS_CC) != SUCCESS); + if (key_type == HASH_KEY_IS_LONG || + zend_check_property_access(zobj, str_key TSRMLS_CC) == SUCCESS) { + break; + } + } if (key) { if (key_type == HASH_KEY_IS_LONG) { @@ -13966,20 +13512,20 @@ static int ZEND_FASTCALL ZEND_FE_FETCH_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG const char *class_name, *prop_name; int prop_name_len; zend_unmangle_property_name_ex( - str_key, str_key_len - 1, &class_name, &prop_name, &prop_name_len + str_key->val, str_key->len, &class_name, &prop_name, &prop_name_len ); - ZVAL_STRINGL(key, prop_name, prop_name_len, 1); + ZVAL_STRINGL(key, prop_name, prop_name_len); } } - zend_hash_get_pointer(fe_ht, &EX_T(opline->op1.var).fe.fe_pos); + zend_hash_get_pointer(fe_ht, (HashPointer*)EX_VAR((opline+1)->op1.var)); break; } case ZEND_ITER_PLAIN_ARRAY: fe_ht = Z_ARRVAL_P(array); - zend_hash_set_pointer(fe_ht, &EX_T(opline->op1.var).fe.fe_pos); - if (zend_hash_get_current_data(fe_ht, (void **) &value)==FAILURE) { + zend_hash_set_pointer(fe_ht, (HashPointer*)EX_VAR((opline+1)->op1.var)); + if ((value = zend_hash_get_current_data(fe_ht)) == NULL) { /* reached end of iteration */ ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num); } @@ -13987,7 +13533,7 @@ static int ZEND_FASTCALL ZEND_FE_FETCH_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG zend_hash_get_current_key_zval(fe_ht, key); } zend_hash_move_forward(fe_ht); - zend_hash_get_pointer(fe_ht, &EX_T(opline->op1.var).fe.fe_pos); + zend_hash_get_pointer(fe_ht, (HashPointer*)EX_VAR((opline+1)->op1.var)); break; case ZEND_ITER_OBJECT: @@ -13997,7 +13543,7 @@ static int ZEND_FASTCALL ZEND_FE_FETCH_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG * In case that ever happens we need an additional flag. */ iter->funcs->move_forward(iter TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { - zval_ptr_dtor(&array); + zval_ptr_dtor(array_ref); HANDLE_EXCEPTION(); } } @@ -14005,14 +13551,14 @@ static int ZEND_FASTCALL ZEND_FE_FETCH_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG if (!iter || (iter->index > 0 && iter->funcs->valid(iter TSRMLS_CC) == FAILURE)) { /* reached end of iteration */ if (UNEXPECTED(EG(exception) != NULL)) { - zval_ptr_dtor(&array); + zval_ptr_dtor(array_ref); HANDLE_EXCEPTION(); } ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num); } - iter->funcs->get_current_data(iter, &value TSRMLS_CC); + value = iter->funcs->get_current_data(iter TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { - zval_ptr_dtor(&array); + zval_ptr_dtor(array_ref); HANDLE_EXCEPTION(); } if (!value) { @@ -14023,7 +13569,7 @@ static int ZEND_FASTCALL ZEND_FE_FETCH_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG if (iter->funcs->get_current_key) { iter->funcs->get_current_key(iter, key TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { - zval_ptr_dtor(&array); + zval_ptr_dtor(array_ref); HANDLE_EXCEPTION(); } } else { @@ -14034,14 +13580,9 @@ static int ZEND_FASTCALL ZEND_FE_FETCH_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG } if (opline->extended_value & ZEND_FE_FETCH_BYREF) { - SEPARATE_ZVAL_IF_NOT_REF(value); - Z_SET_ISREF_PP(value); - EX_T(opline->result.var).var.ptr_ptr = value; - Z_ADDREF_PP(value); - } else { - PZVAL_LOCK(*value); - EX_T(opline->result.var).var.ptr = *value; + SEPARATE_ZVAL_TO_MAKE_IS_REF(value); } + ZVAL_COPY(EX_VAR(opline->result.var), value); CHECK_EXCEPTION(); ZEND_VM_INC_OPCODE(); @@ -14061,9 +13602,9 @@ static int ZEND_FASTCALL ZEND_EXIT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) if (Z_TYPE_P(ptr) == IS_LONG) { EG(exit_status) = Z_LVAL_P(ptr); } else { - zend_print_variable(ptr); + zend_print_variable(ptr TSRMLS_CC); } - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); } #endif zend_bailout(); @@ -14080,18 +13621,15 @@ static int ZEND_FASTCALL ZEND_JMP_SET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (i_zend_is_true(value TSRMLS_CC)) { - ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value); + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value); if (!0) { - zendi_zval_copy_ctor(EX_T(opline->result.var).tmp_var); + zval_opt_copy_ctor(EX_VAR(opline->result.var)); } - zval_ptr_dtor_nogc(&free_op1.var); -#if DEBUG_ZEND>=2 - printf("Conditional jmp to %d\n", opline->op2.opline_num); -#endif + zval_ptr_dtor_nogc(free_op1.var); ZEND_VM_JMP(opline->op2.jmp_addr); } - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -14100,33 +13638,25 @@ static int ZEND_FASTCALL ZEND_JMP_SET_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ { USE_OPLINE zend_free_op free_op1; - zval *value, *ret; + zval *value; SAVE_OPLINE(); value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (i_zend_is_true(value TSRMLS_CC)) { if (IS_VAR == IS_VAR || IS_VAR == IS_CV) { - Z_ADDREF_P(value); - EX_T(opline->result.var).var.ptr = value; - EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; - } else { - ALLOC_ZVAL(ret); - INIT_PZVAL_COPY(ret, value); - EX_T(opline->result.var).var.ptr = ret; - EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; + ZVAL_COPY(EX_VAR(opline->result.var), value); + } else { + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value); if (!0) { - zval_copy_ctor(EX_T(opline->result.var).var.ptr); + zval_opt_copy_ctor(EX_VAR(opline->result.var)); } } - zval_ptr_dtor_nogc(&free_op1.var); -#if DEBUG_ZEND>=2 - printf("Conditional jmp to %d\n", opline->op2.opline_num); -#endif + zval_ptr_dtor_nogc(free_op1.var); ZEND_VM_JMP(opline->op2.jmp_addr); } - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -14140,11 +13670,11 @@ static int ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR SAVE_OPLINE(); value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value); + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value); if (!0) { - zval_copy_ctor(&EX_T(opline->result.var).tmp_var); + zval_opt_copy_ctor(EX_VAR(opline->result.var)); } - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -14153,26 +13683,21 @@ static int ZEND_FASTCALL ZEND_QM_ASSIGN_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLE { USE_OPLINE zend_free_op free_op1; - zval *value, *ret; + zval *value; SAVE_OPLINE(); value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (IS_VAR == IS_VAR || IS_VAR == IS_CV) { - Z_ADDREF_P(value); - EX_T(opline->result.var).var.ptr = value; - EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; - } else { - ALLOC_ZVAL(ret); - INIT_PZVAL_COPY(ret, value); - EX_T(opline->result.var).var.ptr = ret; - EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; + ZVAL_COPY(EX_VAR(opline->result.var), value); + } else { + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value); if (!0) { - zval_copy_ctor(EX_T(opline->result.var).var.ptr); + zval_opt_copy_ctor(EX_VAR(opline->result.var)); } } - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -14185,15 +13710,15 @@ static int ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_A zend_bool result; SAVE_OPLINE(); - expr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + expr = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (Z_TYPE_P(expr) == IS_OBJECT && Z_OBJ_HT_P(expr)->get_class_entry) { - result = instanceof_function(Z_OBJCE_P(expr), EX_T(opline->op2.var).class_entry TSRMLS_CC); + result = instanceof_function(Z_OBJCE_P(expr), Z_CE_P(EX_VAR(opline->op2.var)) TSRMLS_CC); } else { result = 0; } - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, result); - zval_ptr_dtor_nogc(&free_op1.var); + ZVAL_BOOL(EX_VAR(opline->result.var), result); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -14204,10 +13729,10 @@ static int ZEND_FASTCALL ZEND_ADD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR zend_free_op free_op1; SAVE_OPLINE(); - fast_add_function(&EX_T(opline->result.var).tmp_var, + fast_add_function(EX_VAR(opline->result.var), _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), opline->op2.zv TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -14219,10 +13744,10 @@ static int ZEND_FASTCALL ZEND_SUB_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR zend_free_op free_op1; SAVE_OPLINE(); - fast_sub_function(&EX_T(opline->result.var).tmp_var, + fast_sub_function(EX_VAR(opline->result.var), _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), opline->op2.zv TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -14234,10 +13759,10 @@ static int ZEND_FASTCALL ZEND_MUL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR zend_free_op free_op1; SAVE_OPLINE(); - fast_mul_function(&EX_T(opline->result.var).tmp_var, + fast_mul_function(EX_VAR(opline->result.var), _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), opline->op2.zv TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -14249,10 +13774,10 @@ static int ZEND_FASTCALL ZEND_DIV_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR zend_free_op free_op1; SAVE_OPLINE(); - fast_div_function(&EX_T(opline->result.var).tmp_var, + fast_div_function(EX_VAR(opline->result.var), _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), opline->op2.zv TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -14264,10 +13789,10 @@ static int ZEND_FASTCALL ZEND_MOD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR zend_free_op free_op1; SAVE_OPLINE(); - fast_mod_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + fast_mod_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), opline->op2.zv TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -14279,10 +13804,10 @@ static int ZEND_FASTCALL ZEND_SL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG zend_free_op free_op1; SAVE_OPLINE(); - shift_left_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + shift_left_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), opline->op2.zv TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -14294,10 +13819,10 @@ static int ZEND_FASTCALL ZEND_SR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG zend_free_op free_op1; SAVE_OPLINE(); - shift_right_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + shift_right_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), opline->op2.zv TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -14309,10 +13834,10 @@ static int ZEND_FASTCALL ZEND_CONCAT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER zend_free_op free_op1; SAVE_OPLINE(); - concat_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + concat_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), opline->op2.zv TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -14324,10 +13849,10 @@ static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_H zend_free_op free_op1; SAVE_OPLINE(); - is_identical_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + fast_is_identical_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), opline->op2.zv TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -14337,14 +13862,13 @@ static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCO { USE_OPLINE zend_free_op free_op1; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - is_identical_function(result, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + fast_is_not_identical_function(result, + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), opline->op2.zv TSRMLS_CC); - Z_LVAL_P(result) = !Z_LVAL_P(result); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -14354,13 +13878,13 @@ static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDL { USE_OPLINE zend_free_op free_op1; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_equal_function(result, + fast_equal_function(result, _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - opline->op2.zv TSRMLS_CC)); - zval_ptr_dtor_nogc(&free_op1.var); + opline->op2.zv TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -14370,13 +13894,13 @@ static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_H { USE_OPLINE zend_free_op free_op1; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_not_equal_function(result, + fast_not_equal_function(result, _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - opline->op2.zv TSRMLS_CC)); - zval_ptr_dtor_nogc(&free_op1.var); + opline->op2.zv TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -14386,13 +13910,13 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAN { USE_OPLINE zend_free_op free_op1; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_is_smaller_function(result, + fast_is_smaller_function(result, _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - opline->op2.zv TSRMLS_CC)); - zval_ptr_dtor_nogc(&free_op1.var); + opline->op2.zv TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -14402,13 +13926,13 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_CONST_HANDLER(ZEND_O { USE_OPLINE zend_free_op free_op1; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, + fast_is_smaller_or_equal_function(result, _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - opline->op2.zv TSRMLS_CC)); - zval_ptr_dtor_nogc(&free_op1.var); + opline->op2.zv TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -14420,10 +13944,10 @@ static int ZEND_FASTCALL ZEND_BW_OR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ zend_free_op free_op1; SAVE_OPLINE(); - bitwise_or_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + bitwise_or_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), opline->op2.zv TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -14435,10 +13959,10 @@ static int ZEND_FASTCALL ZEND_BW_AND_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER zend_free_op free_op1; SAVE_OPLINE(); - bitwise_and_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + bitwise_and_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), opline->op2.zv TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -14450,10 +13974,10 @@ static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER zend_free_op free_op1; SAVE_OPLINE(); - bitwise_xor_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + bitwise_xor_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), opline->op2.zv TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -14465,10 +13989,10 @@ static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDL zend_free_op free_op1; SAVE_OPLINE(); - boolean_xor_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + boolean_xor_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), opline->op2.zv TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -14478,18 +14002,18 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(int (*b { USE_OPLINE zend_free_op free_op1, free_op_data1; - zval **object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - zval *object; + zval *object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); zval *property = opline->op2.zv; - zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); + zval *value; int have_get_ptr = 0; - if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - make_real_object(object_ptr TSRMLS_CC); - object = *object_ptr; + object = make_real_object(object TSRMLS_CC); + + value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { zend_error(E_WARNING, "Attempt to assign property of non-object"); @@ -14497,325 +14021,411 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(int (*b FREE_OP(free_op_data1); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } } else { /* here we are sure we are dealing with an object */ - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - - /* here property is a string */ if (opline->extended_value == ZEND_ASSIGN_OBJ && Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); if (zptr != NULL) { /* NULL means no success in getting PTR */ SEPARATE_ZVAL_IF_NOT_REF(zptr); have_get_ptr = 1; - binary_op(*zptr, *zptr, value TSRMLS_CC); + binary_op(zptr, zptr, value TSRMLS_CC); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(*zptr); - EX_T(opline->result.var).var.ptr = *zptr; + ZVAL_COPY(EX_VAR(opline->result.var), zptr); } } } if (!have_get_ptr) { zval *z = NULL; + zval rv; if (opline->extended_value == ZEND_ASSIGN_OBJ) { if (Z_OBJ_HT_P(object)->read_property) { - z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC); } } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { if (Z_OBJ_HT_P(object)->read_dimension) { - z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC); + z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R, &rv TSRMLS_CC); } } if (z) { if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); zval_dtor(z); - FREE_ZVAL(z); } - z = value; + ZVAL_COPY_VALUE(z, value); } - Z_ADDREF_P(z); - SEPARATE_ZVAL_IF_NOT_REF(&z); +//??? if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); + SEPARATE_ZVAL_IF_NOT_REF(z); binary_op(z, z, value TSRMLS_CC); if (opline->extended_value == ZEND_ASSIGN_OBJ) { - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(z); - EX_T(opline->result.var).var.ptr = z; + ZVAL_COPY(EX_VAR(opline->result.var), z); } - zval_ptr_dtor(&z); + zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to assign property of non-object"); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } } } - if (0) { - zval_ptr_dtor(&property); - } else { - - } FREE_OP(free_op_data1); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; /* assign_obj has two opcodes! */ CHECK_EXCEPTION(); ZEND_VM_INC_OPCODE(); ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_free_op free_op1, free_op_data2, free_op_data1; - zval **var_ptr; - zval *value; + zval *var_ptr; + zval *value, *container; SAVE_OPLINE(); - switch (opline->extended_value) { - case ZEND_ASSIGN_OBJ: - return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - break; - case ZEND_ASSIGN_DIM: { - zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); - } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) { - if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) { - Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */ - } - return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - } else { - zval *dim = opline->op2.zv; + container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { + zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); + } else if (UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { + if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) { + Z_ADDREF_P(container); /* undo the effect of get_obj_zval_ptr_ptr() */ + } + return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else { + zval *dim = opline->op2.zv; - zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_CONST, BP_VAR_RW TSRMLS_CC); - value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); - var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); - } - } - break; - default: - value = opline->op2.zv; - var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - /* do nothing */ - break; + zend_fetch_dimension_address_RW(EX_VAR((opline+1)->op2.var), container, dim, IS_CONST TSRMLS_CC); + value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); + var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); } - if (UNEXPECTED(var_ptr == NULL)) { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); } - if (UNEXPECTED(*var_ptr == &EG(error_zval))) { - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + if (UNEXPECTED(var_ptr == &EG(error_zval))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); } - - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - CHECK_EXCEPTION(); - if (opline->extended_value == ZEND_ASSIGN_DIM) { - ZEND_VM_INC_OPCODE(); - } - ZEND_VM_NEXT_OPCODE(); + goto assign_op_dim_exit; } SEPARATE_ZVAL_IF_NOT_REF(var_ptr); + ZVAL_DEREF(var_ptr); - if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) - && Z_OBJ_HANDLER_PP(var_ptr, get) - && Z_OBJ_HANDLER_PP(var_ptr, set)) { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) && + UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) { /* proxy object */ - zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); + zval rv; + zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC); Z_ADDREF_P(objval); binary_op(objval, objval, value TSRMLS_CC); - Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC); - zval_ptr_dtor(&objval); + Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); + zval_ptr_dtor(objval); } else { - binary_op(*var_ptr, *var_ptr, value TSRMLS_CC); + binary_op(var_ptr, var_ptr, value TSRMLS_CC); } - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(*var_ptr); - EX_T(opline->result.var).var.ptr = *var_ptr; + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } - if (opline->extended_value == ZEND_ASSIGN_DIM) { - FREE_OP(free_op_data1); - FREE_OP_VAR_PTR(free_op_data2); - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - CHECK_EXCEPTION(); - ZEND_VM_INC_OPCODE(); +assign_op_dim_exit: + + FREE_OP(free_op_data1); + FREE_OP_VAR_PTR(free_op_data2); + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; + CHECK_EXCEPTION(); + ZEND_VM_INC_OPCODE(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_free_op free_op1; + zval *var_ptr; + zval *value; + + SAVE_OPLINE(); + value = opline->op2.zv; + var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { + zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); + } + + if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } + goto assign_op_exit; + } + + SEPARATE_ZVAL_IF_NOT_REF(var_ptr); + ZVAL_DEREF(var_ptr); + + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) && + UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) { + /* proxy object */ + zval rv; + zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC); + Z_ADDREF_P(objval); + binary_op(objval, objval, value TSRMLS_CC); + Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); + zval_ptr_dtor(objval); } else { - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - CHECK_EXCEPTION(); + binary_op(var_ptr, var_ptr, value TSRMLS_CC); } + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + } + +assign_op_exit: + + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; + CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_free_op free_op1; - zval **object_ptr; zval *object; zval *property; - zval **retval; + zval *retval; int have_get_ptr = 0; SAVE_OPLINE(); - object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); property = opline->op2.zv; - retval = &EX_T(opline->result.var).var.ptr; + retval = EX_VAR(opline->result.var); - if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } - make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ - object = *object_ptr; + object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */ if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - *retval = &EG(uninitialized_zval); + ZVAL_NULL(retval); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } /* here we are sure we are dealing with an object */ - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); if (zptr != NULL) { /* NULL means no success in getting PTR */ SEPARATE_ZVAL_IF_NOT_REF(zptr); have_get_ptr = 1; - incdec_op(*zptr); + incdec_op(zptr); if (RETURN_VALUE_USED(opline)) { - *retval = *zptr; - PZVAL_LOCK(*retval); + ZVAL_COPY(retval, zptr); } } } if (!have_get_ptr) { + zval rv; + if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC); if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); zval_dtor(z); - FREE_ZVAL(z); } - z = value; + ZVAL_COPY_VALUE(z, value); } - Z_ADDREF_P(z); - SEPARATE_ZVAL_IF_NOT_REF(&z); + if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); + SEPARATE_ZVAL_IF_NOT_REF(z); incdec_op(z); - *retval = z; - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - SELECTIVE_PZVAL_LOCK(*retval, opline); - zval_ptr_dtor(&z); + ZVAL_COPY_VALUE(retval, z); + Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); + SELECTIVE_PZVAL_LOCK(retval, opline); + zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - *retval = &EG(uninitialized_zval); + ZVAL_NULL(retval); } } } - if (0) { - zval_ptr_dtor(&property); - } else { - - } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -14834,90 +14444,75 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_CONST(incdec_ { USE_OPLINE zend_free_op free_op1; - zval **object_ptr; zval *object; zval *property; zval *retval; int have_get_ptr = 0; SAVE_OPLINE(); - object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); property = opline->op2.zv; - retval = &EX_T(opline->result.var).tmp_var; + retval = EX_VAR(opline->result.var); - if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } - make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ - object = *object_ptr; + object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */ if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); ZVAL_NULL(retval); - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } /* here we are sure we are dealing with an object */ - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); if (zptr != NULL) { /* NULL means no success in getting PTR */ have_get_ptr = 1; SEPARATE_ZVAL_IF_NOT_REF(zptr); - ZVAL_COPY_VALUE(retval, *zptr); - zendi_zval_copy_ctor(*retval); + ZVAL_DUP(retval, zptr); - incdec_op(*zptr); + incdec_op(zptr); } } if (!have_get_ptr) { if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - zval *z_copy; + zval rv; + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC); + zval z_copy; if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); zval_dtor(z); - FREE_ZVAL(z); } - z = value; + ZVAL_COPY_VALUE(z, value); } - ZVAL_COPY_VALUE(retval, z); - zendi_zval_copy_ctor(*retval); - ALLOC_ZVAL(z_copy); - INIT_PZVAL_COPY(z_copy, z); - zendi_zval_copy_ctor(*z_copy); - incdec_op(z_copy); - Z_ADDREF_P(z); - Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + ZVAL_DUP(retval, z); + ZVAL_DUP(&z_copy, z); + incdec_op(&z_copy); + if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); + Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); zval_ptr_dtor(&z_copy); - zval_ptr_dtor(&z); + zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); ZVAL_NULL(retval); } } - if (0) { - zval_ptr_dtor(&property); - } else { - - } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -14937,19 +14532,16 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_CONST(int type, USE_OPLINE zend_free_op free_op1; zval *varname; - zval **retval; + zval *retval; zval tmp_varname; HashTable *target_symbol_table; - ulong hash_value; SAVE_OPLINE(); varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + ZVAL_UNDEF(&tmp_varname); if (IS_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) { - ZVAL_COPY_VALUE(&tmp_varname, varname); - zval_copy_ctor(&tmp_varname); - Z_SET_REFCOUNT(tmp_varname, 1); - Z_UNSET_ISREF(tmp_varname); + ZVAL_DUP_DEREF(&tmp_varname, varname); convert_to_string(&tmp_varname); varname = &tmp_varname; } @@ -14958,105 +14550,88 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_CONST(int type, zend_class_entry *ce; if (IS_CONST == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { - if (IS_VAR != IS_CONST && varname == &tmp_varname) { + if (IS_VAR != IS_CONST) { zval_dtor(&tmp_varname); } - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(opline->op2.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); } } else { - ce = EX_T(opline->op2.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op2.var)); } - retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); } else { target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); -/* - if (!target_symbol_table) { - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); - } -*/ - if (IS_VAR == IS_CONST) { - hash_value = Z_HASH_P(varname); - } else { - hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname)); - } - - if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) { + retval = zend_hash_find(target_symbol_table, Z_STR_P(varname)); + if (retval == NULL) { switch (type) { case BP_VAR_R: case BP_VAR_UNSET: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); /* break missing intentionally */ case BP_VAR_IS: - retval = &EG(uninitialized_zval_ptr); + retval = EX_VAR(opline->result.var); + ZVAL_NULL(retval); break; case BP_VAR_RW: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); /* break missing intentionally */ case BP_VAR_W: - Z_ADDREF_P(&EG(uninitialized_zval)); - zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval); + retval = zend_hash_update(target_symbol_table, Z_STR_P(varname), &EG(uninitialized_zval)); break; EMPTY_SWITCH_DEFAULT_CASE() } - } - switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) { - case ZEND_FETCH_GLOBAL: - if (IS_VAR != IS_TMP_VAR) { - zval_ptr_dtor_nogc(&free_op1.var); - } - break; - case ZEND_FETCH_LOCAL: - zval_ptr_dtor_nogc(&free_op1.var); - break; - case ZEND_FETCH_STATIC: - zval_update_constant(retval, 1 TSRMLS_CC); - break; - case ZEND_FETCH_GLOBAL_LOCK: - if (IS_VAR == IS_VAR && !free_op1.var) { - PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); + /* GLOBAL or $$name variable may be an INDIRECT pointer to CV */ + } else if (Z_TYPE_P(retval) == IS_INDIRECT) { + retval = Z_INDIRECT_P(retval); + if (Z_TYPE_P(retval) == IS_UNDEF) { + switch (type) { + case BP_VAR_R: + case BP_VAR_UNSET: + zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); + /* break missing intentionally */ + case BP_VAR_IS: + retval = EX_VAR(opline->result.var); + ZVAL_NULL(retval); + break; + case BP_VAR_RW: + zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); + /* break missing intentionally */ + case BP_VAR_W: + ZVAL_NULL(retval); + break; + EMPTY_SWITCH_DEFAULT_CASE() } - break; + } + } + if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC) { + zval_update_constant(retval, 1 TSRMLS_CC); + } else if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) != ZEND_FETCH_GLOBAL_LOCK) { + zval_ptr_dtor_nogc(free_op1.var); } } - - if (IS_VAR != IS_CONST && varname == &tmp_varname) { + if (IS_VAR != IS_CONST) { zval_dtor(&tmp_varname); } - if (opline->extended_value & ZEND_FETCH_MAKE_REF) { - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval); - } - PZVAL_LOCK(*retval); - switch (type) { - case BP_VAR_R: - case BP_VAR_IS: - EX_T(opline->result.var).var.ptr = *retval; - break; - case BP_VAR_UNSET: { - zend_free_op free_res; - PZVAL_UNLOCK(*retval, &free_res); - if (retval != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(retval); - } - PZVAL_LOCK(*retval); - FREE_OP_VAR_PTR(free_res); + ZEND_ASSERT(retval != NULL); + if (type == BP_VAR_R || type == BP_VAR_IS) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); + } else { + if (/*type == BP_VAR_W &&*/ (opline->extended_value & ZEND_FETCH_MAKE_REF)) { + SEPARATE_ZVAL_TO_MAKE_IS_REF(retval); } - /* break missing intentionally */ - default: - EX_T(opline->result.var).var.ptr_ptr = retval; - break; + ZVAL_INDIRECT(EX_VAR(opline->result.var), retval); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -15081,7 +14656,11 @@ static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE { USE_OPLINE - return zend_fetch_var_address_helper_SPEC_VAR_CONST(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { + return zend_fetch_var_address_helper_SPEC_VAR_CONST(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else { + return zend_fetch_var_address_helper_SPEC_VAR_CONST(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -15102,10 +14681,10 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HA SAVE_OPLINE(); container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); if (IS_VAR != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) { - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -15115,32 +14694,24 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HA { USE_OPLINE zend_free_op free_op1; - zval **container; + zval *container; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_W TSRMLS_CC); - - if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + if (EXPECTED(opline->extended_value == 0)) { + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); + } else { + zend_fetch_dimension_address_W_ref(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - /* We are going to assign the result by reference */ - if (UNEXPECTED(opline->extended_value != 0)) { - zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; - - if (retval_ptr) { - Z_DELREF_PP(retval_ptr); - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); - Z_ADDREF_PP(retval_ptr); - } + if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -15149,20 +14720,20 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_H { USE_OPLINE zend_free_op free_op1; - zval **container; + zval *container; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_RW TSRMLS_CC); + zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -15175,9 +14746,9 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_H SAVE_OPLINE(); container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_IS TSRMLS_CC); + zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -15185,31 +14756,30 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_H static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE + zval *container; zend_free_op free_op1; SAVE_OPLINE(); if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { - zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_W TSRMLS_CC); + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; } else { - zval *container; - if (IS_CONST == IS_UNUSED) { zend_error_noreturn(E_ERROR, "Cannot use [] for reading"); } container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -15219,41 +14789,22 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCOD { USE_OPLINE zend_free_op free_op1; - zval **container; + zval *container; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_CV) { - if (container != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(container); - } - } - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_UNSET TSRMLS_CC); + zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); - } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); - ZEND_VM_NEXT_OPCODE(); - } else { - zend_free_op free_res; - zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; - - PZVAL_UNLOCK(*retval_ptr, &free_res); - if (retval_ptr != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(retval_ptr); - } - PZVAL_LOCK(*retval_ptr); - FREE_OP_VAR_PTR(free_res); - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_CONST(ZEND_OPCODE_HANDLER_ARGS) @@ -15265,36 +14816,25 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_CONST( zval *offset; SAVE_OPLINE(); - container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); offset = opline->op2.zv; if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { zend_error(E_NOTICE, "Trying to get property of non-object"); - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - + ZVAL_NULL(EX_VAR(opline->result.var)); } else { zval *retval; - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - /* here we are sure we are dealing with an object */ - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - - PZVAL_LOCK(retval); - EX_T(opline->result.var).var.ptr = retval; - - if (0) { - zval_ptr_dtor(&offset); - } else { + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC); + if (retval != EX_VAR(opline->result.var)) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); } } - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -15309,41 +14849,22 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HA USE_OPLINE zend_free_op free_op1; zval *property; - zval **container; + zval *container; SAVE_OPLINE(); property = opline->op2.zv; - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property); - } else { + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC); - } if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - - /* We are going to assign the result by reference */ - if (opline->extended_value & ZEND_FETCH_MAKE_REF) { - zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; - - Z_DELREF_PP(retval_ptr); - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); - Z_ADDREF_PP(retval_ptr); - EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr; - EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; - } - + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -15353,28 +14874,21 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_H USE_OPLINE zend_free_op free_op1; zval *property; - zval **container; + zval *container; SAVE_OPLINE(); property = opline->op2.zv; container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property); - } else { + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_RW, 0 TSRMLS_CC); - } if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -15388,35 +14902,24 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_H zval *offset; SAVE_OPLINE(); - container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); offset = opline->op2.zv; if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - + ZVAL_NULL(EX_VAR(opline->result.var)); } else { zval *retval; - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - /* here we are sure we are dealing with an object */ - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - - PZVAL_LOCK(retval); - EX_T(opline->result.var).var.ptr = retval; - - if (0) { - zval_ptr_dtor(&offset); - } else { + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC); + if (retval != EX_VAR(opline->result.var)) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); } } - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -15424,33 +14927,26 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_H static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE + zval *container; if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { /* Behave like FETCH_OBJ_W */ zend_free_op free_op1; zval *property; - zval **container; SAVE_OPLINE(); property = opline->op2.zv; container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property); - } else { + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, 0 TSRMLS_CC); - } if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } else { @@ -15461,42 +14957,22 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OP static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_free_op free_op1, free_res; - zval **container; - zval *property; + zend_free_op free_op1; + zval *container, *property; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); property = opline->op2.zv; - if (IS_VAR == IS_CV) { - if (container != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(container); - } - } - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property); - } else { + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_UNSET, 0 TSRMLS_CC); - } if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); - } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - - PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res); - if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr); - FREE_OP_VAR_PTR(free_res); + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -15505,26 +14981,19 @@ static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAN { USE_OPLINE zend_free_op free_op1; - zval **object_ptr; + zval *object; zval *property_name; SAVE_OPLINE(); - object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); property_name = opline->op2.zv; - if (0) { - MAKE_REAL_ZVAL_PTR(property_name); - } - if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property_name); - } else { + zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC); - } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; /* assign_obj has two opcodes! */ CHECK_EXCEPTION(); ZEND_VM_INC_OPCODE(); @@ -15535,76 +15004,59 @@ static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAN { USE_OPLINE zend_free_op free_op1; - zval **object_ptr; + zval *object_ptr; SAVE_OPLINE(); object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - if (Z_TYPE_PP(object_ptr) == IS_OBJECT) { + if (UNEXPECTED(Z_ISREF_P(object_ptr)) && Z_TYPE_P(Z_REFVAL_P(object_ptr)) == IS_OBJECT) { + object_ptr = Z_REFVAL_P(object_ptr); + } + if (Z_TYPE_P(object_ptr) == IS_OBJECT) { zval *property_name = opline->op2.zv; - if (0) { - MAKE_REAL_ZVAL_PTR(property_name); - } - zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property_name); - } else { + zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC); - } } else { zend_free_op free_op_data1, free_op_data2; zval *value; zval *dim = opline->op2.zv; - zval **variable_ptr_ptr; + zval *variable_ptr; - zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_CONST, BP_VAR_W TSRMLS_CC); + zend_fetch_dimension_address_W(EX_VAR((opline+1)->op2.var), object_ptr, dim, IS_CONST TSRMLS_CC); value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); - variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); - if (UNEXPECTED(variable_ptr_ptr == NULL)) { - if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) { - if (RETURN_VALUE_USED(opline)) { - zval *retval; - - ALLOC_ZVAL(retval); - ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1); - INIT_PZVAL(retval); - EX_T(opline->result.var).var.ptr = retval; - } - } else if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - } - } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) { + variable_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); + if (UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) { + zend_assign_to_string_offset(variable_ptr, value, (opline+1)->op1_type, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC); + } else if (UNEXPECTED(variable_ptr == &EG(error_zval))) { if (IS_TMP_FREE(free_op_data1)) { zval_dtor(value); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } + FREE_OP_VAR_PTR(free_op_data2); } else { if ((opline+1)->op1_type == IS_TMP_VAR) { - value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_tmp_to_variable(variable_ptr, value TSRMLS_CC); } else if ((opline+1)->op1_type == IS_CONST) { - value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_const_to_variable(variable_ptr, value TSRMLS_CC); } else { - value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_to_variable(variable_ptr, value TSRMLS_CC); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(value); - EX_T(opline->result.var).var.ptr = value; + ZVAL_COPY(EX_VAR(opline->result.var), value); } + FREE_OP_VAR_PTR(free_op_data2); } - FREE_OP_VAR_PTR(free_op_data2); FREE_OP_IF_VAR(free_op_data1); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; /* assign_dim has two opcodes! */ CHECK_EXCEPTION(); ZEND_VM_INC_OPCODE(); @@ -15616,50 +15068,35 @@ static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER USE_OPLINE zend_free_op free_op1; zval *value; - zval **variable_ptr_ptr; + zval *variable_ptr; SAVE_OPLINE(); value = opline->op2.zv; - variable_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) { - if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_CONST TSRMLS_CC)) { - if (RETURN_VALUE_USED(opline)) { - zval *retval; - - ALLOC_ZVAL(retval); - ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1); - INIT_PZVAL(retval); - EX_T(opline->result.var).var.ptr = retval; - } - } else if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - } - } else if (IS_VAR == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) { + zend_assign_to_string_offset(variable_ptr, value, IS_CONST, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC); + } else if (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) { if (0) { zval_dtor(value); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } } else { if (IS_CONST == IS_TMP_VAR) { - value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_tmp_to_variable(variable_ptr, value TSRMLS_CC); } else if (IS_CONST == IS_CONST) { - value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_const_to_variable(variable_ptr, value TSRMLS_CC); } else { - value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_to_variable(variable_ptr, value TSRMLS_CC); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(value); - EX_T(opline->result.var).var.ptr = value; + ZVAL_COPY(EX_VAR(opline->result.var), value); } + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - /* zend_assign_to_variable() always takes care of op2, never free it! */ CHECK_EXCEPTION(); @@ -15670,10 +15107,9 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCO { USE_OPLINE zval *function_name; - char *function_name_strval; - int function_name_strlen; zend_free_op free_op1; call_slot *call = EX(call_slots) + opline->result.num; + zval *object; SAVE_OPLINE(); @@ -15687,33 +15123,30 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCO zend_error_noreturn(E_ERROR, "Method name must be a string"); } - function_name_strval = Z_STRVAL_P(function_name); - function_name_strlen = Z_STRLEN_P(function_name); - - call->object = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + object = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL; - if (EXPECTED(call->object != NULL) && - EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) { - call->called_scope = Z_OBJCE_P(call->object); + if (EXPECTED(call->object != NULL)) { + call->called_scope = zend_get_class_entry(call->object TSRMLS_CC); if (IS_CONST != IS_CONST || - (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) { - zval *object = call->object; + (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope)) == NULL) { + zend_object *object = call->object; - if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) { + if (UNEXPECTED(object->handlers->get_method == NULL)) { zend_error_noreturn(E_ERROR, "Object does not support method calls"); } /* First, locate the function. */ - call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); + call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); if (UNEXPECTED(call->fbc == NULL)) { - zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval); + zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name)); } if (IS_CONST == IS_CONST && EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) && EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) && EXPECTED(call->object == object)) { - CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc); + CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope, call->fbc); } } } else { @@ -15721,28 +15154,20 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCO HANDLE_EXCEPTION(); } - zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval); + zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", Z_STRVAL_P(function_name)); } if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) { call->object = NULL; } else { - if (!PZVAL_IS_REF(call->object)) { - Z_ADDREF_P(call->object); /* For $this pointer */ - } else { - zval *this_ptr; - ALLOC_ZVAL(this_ptr); - INIT_PZVAL_COPY(this_ptr, call->object); - zval_copy_ctor(this_ptr); - call->object = this_ptr; - } + GC_REFCOUNT(call->object)++; /* For $this pointer */ } call->num_additional_args = 0; call->is_ctor_call = 0; EX(call) = call; - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -15759,21 +15184,21 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZE if (IS_VAR == IS_CONST) { /* no function found. try a static method in class */ - if (CACHED_PTR(opline->op1.literal->cache_slot)) { - ce = CACHED_PTR(opline->op1.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } if (UNEXPECTED(ce == NULL)) { zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv)); } - CACHE_PTR(opline->op1.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce); } call->called_scope = ce; } else { - ce = EX_T(opline->op1.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op1.var)); if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) { call->called_scope = EG(called_scope); @@ -15784,51 +15209,40 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZE if (IS_VAR == IS_CONST && IS_CONST == IS_CONST && - CACHED_PTR(opline->op2.literal->cache_slot)) { - call->fbc = CACHED_PTR(opline->op2.literal->cache_slot); + CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else if (IS_VAR != IS_CONST && IS_CONST == IS_CONST && - (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) { + (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce))) { /* do nothing */ } else if (IS_CONST != IS_UNUSED) { - char *function_name_strval = NULL; - int function_name_strlen = 0; - if (IS_CONST == IS_CONST) { - function_name_strval = Z_STRVAL_P(opline->op2.zv); - function_name_strlen = Z_STRLEN_P(opline->op2.zv); - } else { - function_name = opline->op2.zv; - + function_name = opline->op2.zv; + if (IS_CONST != IS_CONST) { if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } zend_error_noreturn(E_ERROR, "Function name must be a string"); - } else { - function_name_strval = Z_STRVAL_P(function_name); - function_name_strlen = Z_STRLEN_P(function_name); } } - if (function_name_strval) { - if (ce->get_static_method) { - call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC); + if (ce->get_static_method) { + call->fbc = ce->get_static_method(ce, Z_STR_P(function_name) TSRMLS_CC); + } else { + call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); + } + if (UNEXPECTED(call->fbc == NULL)) { + zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name)); + } + if (IS_CONST == IS_CONST && + EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) && + EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) { + if (IS_VAR == IS_CONST) { + CACHE_PTR(Z_CACHE_SLOT_P(function_name), call->fbc); } else { - call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); - } - if (UNEXPECTED(call->fbc == NULL)) { - zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval); - } - if (IS_CONST == IS_CONST && - EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) && - EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) { - if (IS_VAR == IS_CONST) { - CACHE_PTR(opline->op2.literal->cache_slot, call->fbc); - } else { - CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc); - } + CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), ce, call->fbc); } } if (IS_CONST != IS_CONST) { @@ -15838,8 +15252,8 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZE if (UNEXPECTED(ce->constructor == NULL)) { zend_error_noreturn(E_ERROR, "Cannot call constructor"); } - if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { - zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name); + if (Z_OBJ(EG(This)) && Z_OBJCE(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { + zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name->val); } call->fbc = ce->constructor; } @@ -15847,21 +15261,21 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZE if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) { call->object = NULL; } else { - if (EG(This) && - Z_OBJ_HT_P(EG(This))->get_class_entry && - !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) { + if (Z_OBJ(EG(This)) && + Z_OBJ_HT(EG(This))->get_class_entry && + !instanceof_function(Z_OBJCE(EG(This)), ce TSRMLS_CC)) { /* We are calling method of the other (incompatible) class, but passing $this. This is done for compatibility with php-4. */ if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { - zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name); + zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val); } else { /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */ - zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name); + zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val); } } - if ((call->object = EG(This))) { - Z_ADDREF_P(call->object); - call->called_scope = Z_OBJCE_P(call->object); + call->object = Z_OBJ(EG(This)); + if (call->object) { + GC_REFCOUNT(call->object)++; } } @@ -15877,11 +15291,12 @@ static int ZEND_FASTCALL ZEND_CASE_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_A { USE_OPLINE zend_free_op free_op1; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - is_equal_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - opline->op2.zv TSRMLS_CC); + fast_equal_function(result, + _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + opline->op2.zv TSRMLS_CC); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -15896,9 +15311,9 @@ static int ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE zend_constant *c; zval *retval; - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - c = CACHED_PTR(opline->op2.literal->cache_slot); - } else if ((c = zend_quick_get_constant(opline->op2.literal + 1, opline->extended_value TSRMLS_CC)) == NULL) { + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + c = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + } else if ((c = zend_quick_get_constant(opline->op2.zv + 1, opline->extended_value TSRMLS_CC)) == NULL) { if ((opline->extended_value & IS_CONSTANT_UNQUALIFIED) != 0) { char *actual = (char *)zend_memrchr(Z_STRVAL_P(opline->op2.zv), '\\', Z_STRLEN_P(opline->op2.zv)); if(!actual) { @@ -15908,52 +15323,52 @@ static int ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE } /* non-qualified constant - allow text substitution */ zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'", actual, actual); - ZVAL_STRINGL(&EX_T(opline->result.var).tmp_var, actual, Z_STRLEN_P(opline->op2.zv)-(actual - Z_STRVAL_P(opline->op2.zv)), 1); + ZVAL_STRINGL(EX_VAR(opline->result.var), actual, Z_STRLEN_P(opline->op2.zv)-(actual - Z_STRVAL_P(opline->op2.zv))); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } else { zend_error_noreturn(E_ERROR, "Undefined constant '%s'", Z_STRVAL_P(opline->op2.zv)); } } else { - CACHE_PTR(opline->op2.literal->cache_slot, c); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), c); } - retval = &EX_T(opline->result.var).tmp_var; - ZVAL_COPY_VALUE(retval, &c->value); - zval_copy_ctor(retval); + retval = EX_VAR(opline->result.var); + ZVAL_DUP(retval, &c->value); } else { /* class constant */ zend_class_entry *ce; - zval **value; + zval *value; if (IS_VAR == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - value = CACHED_PTR(opline->op2.literal->cache_slot); - ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value); - zval_copy_ctor(&EX_T(opline->result.var).tmp_var); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + value = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + ZVAL_DUP(EX_VAR(opline->result.var), value); goto constant_fetch_end; - } else if (CACHED_PTR(opline->op1.literal->cache_slot)) { - ce = CACHED_PTR(opline->op1.literal->cache_slot); + } else if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } if (UNEXPECTED(ce == NULL)) { zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv)); } - CACHE_PTR(opline->op1.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce); } } else { - ce = EX_T(opline->op1.var).class_entry; - if ((value = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce)) != NULL) { - ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value); - zval_copy_ctor(&EX_T(opline->result.var).tmp_var); + ce = Z_CE_P(EX_VAR(opline->op1.var)); + if ((value = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce)) != NULL) { + ZVAL_DUP(EX_VAR(opline->result.var), value); goto constant_fetch_end; } } - if (EXPECTED(zend_hash_quick_find(&ce->constants_table, Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv)+1, Z_HASH_P(opline->op2.zv), (void **) &value) == SUCCESS)) { - if (IS_CONSTANT_TYPE(Z_TYPE_PP(value))) { + if (EXPECTED((value = zend_hash_find(&ce->constants_table, Z_STR_P(opline->op2.zv))) != NULL)) { + if (Z_ISREF_P(value)) { + value = Z_REFVAL_P(value); + } + if (Z_CONSTANT_P(value)) { zend_class_entry *old_scope = EG(scope); EG(scope) = ce; @@ -15961,23 +15376,20 @@ static int ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE EG(scope) = old_scope; } if (IS_VAR == IS_CONST) { - CACHE_PTR(opline->op2.literal->cache_slot, value); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), value); } else { - CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, value); + CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce, value); } - ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value); - zval_copy_ctor(&EX_T(opline->result.var).tmp_var); + ZVAL_DUP(EX_VAR(opline->result.var), value); } else if (Z_STRLEN_P(opline->op2.zv) == sizeof("class")-1 && memcmp(Z_STRVAL_P(opline->op2.zv), "class", sizeof("class") - 1) == 0) { /* "class" is assigned as a case-sensitive keyword from zend_do_resolve_class_name */ - ZVAL_STRINGL(&EX_T(opline->result.var).tmp_var, ce->name, ce->name_length, 1); + ZVAL_STR(EX_VAR(opline->result.var), ce->name); + STR_ADDREF(ce->name); } else { zend_error_noreturn(E_ERROR, "Undefined class constant '%s'", Z_STRVAL_P(opline->op2.zv)); } } constant_fetch_end: - if (Z_TYPE(EX_T(opline->result.var).tmp_var) == IS_ARRAY) { - zend_error_noreturn(E_ERROR, "Arrays are not allowed in constants at run-time"); - } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -15986,35 +15398,31 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPC { USE_OPLINE zend_free_op free_op1; - zval *expr_ptr; + zval *expr_ptr, new_expr; SAVE_OPLINE(); - if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) { - zval **expr_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - - if (IS_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) { + if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && + (opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) { + expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets"); } - SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); - expr_ptr = *expr_ptr_ptr; + SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr); Z_ADDREF_P(expr_ptr); + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; } else { - expr_ptr=_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + expr_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (0) { /* temporary variable */ - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - } else if (IS_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) { - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - zendi_zval_copy_ctor(*expr_ptr); - zval_ptr_dtor_nogc(&free_op1.var); - } else if (IS_VAR == IS_CV) { + ZVAL_COPY_VALUE(&new_expr, expr_ptr); + expr_ptr = &new_expr; + } else if (IS_VAR == IS_CONST) { + ZVAL_DUP(&new_expr, expr_ptr); + expr_ptr = &new_expr; + } else if (Z_ISREF_P(expr_ptr)) { + ZVAL_DUP(&new_expr, Z_REFVAL_P(expr_ptr)); + expr_ptr = &new_expr; + zval_ptr_dtor_nogc(free_op1.var); + } else if (IS_VAR == IS_CV && Z_REFCOUNTED_P(expr_ptr)) { Z_ADDREF_P(expr_ptr); } } @@ -16022,42 +15430,49 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPC if (IS_CONST != IS_UNUSED) { zval *offset = opline->op2.zv; + zend_string *str; ulong hval; +add_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: hval = zend_dval_to_lval(Z_DVAL_P(offset)); goto num_index; case IS_LONG: - case IS_BOOL: hval = Z_LVAL_P(offset); num_index: - zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL); + zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); break; case IS_STRING: - if (IS_CONST == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); + str = Z_STR_P(offset); + if (IS_CONST != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index); } - zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL); +str_index: + zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); break; case IS_NULL: - zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); + str = STR_EMPTY_ALLOC(); + goto str_index; + case IS_FALSE: + hval = 0; + goto num_index; + case IS_TRUE: + hval = 1; + goto num_index; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto add_again; break; default: zend_error(E_WARNING, "Illegal offset type"); - zval_ptr_dtor(&expr_ptr); + zval_ptr_dtor(expr_ptr); /* do nothing */ break; } } else { - zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL); - } - if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) { - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -16065,9 +15480,26 @@ num_index: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { + zval *array; + zend_uint size; USE_OPLINE - array_init(&EX_T(opline->result.var).tmp_var); + array = EX_VAR(opline->result.var); + if (IS_VAR != IS_UNUSED) { + size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; + } else { + size = 0; + } + ZVAL_NEW_ARR(array); + zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); + + if (IS_VAR != IS_UNUSED) { + /* Explicitly initialize array as not-packed if flag is set */ + if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) { + zend_hash_real_init(Z_ARRVAL_P(array), 0); + } + } + if (IS_VAR == IS_UNUSED) { ZEND_VM_NEXT_OPCODE(); #if 0 || IS_VAR != IS_UNUSED @@ -16083,20 +15515,15 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAND zval tmp, *varname; HashTable *target_symbol_table; zend_free_op free_op1; + zend_bool tmp_is_dup = 0; SAVE_OPLINE(); if (IS_VAR == IS_CV && IS_CONST == IS_UNUSED && (opline->extended_value & ZEND_QUICK_SET)) { - if (EG(active_symbol_table)) { - zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); - - zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC); - EX_CV(opline->op1.var) = NULL; - } else if (EX_CV(opline->op1.var)) { - zval_ptr_dtor(EX_CV(opline->op1.var)); - EX_CV(opline->op1.var) = NULL; - } + ZVAL_COPY_VALUE(&tmp, EX_VAR(opline->op1.var)); + ZVAL_UNDEF(EX_VAR(opline->op1.var)); + zval_ptr_dtor(&tmp); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -16104,53 +15531,52 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAND varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { - ZVAL_COPY_VALUE(&tmp, varname); - zval_copy_ctor(&tmp); + ZVAL_DUP(&tmp, varname); convert_to_string(&tmp); varname = &tmp; + tmp_is_dup = 1; } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) { - Z_ADDREF_P(varname); + ZVAL_COPY(&tmp, varname); + varname = &tmp; } if (IS_CONST != IS_UNUSED) { zend_class_entry *ce; if (IS_CONST == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { - if (IS_VAR != IS_CONST && varname == &tmp) { + if (IS_VAR != IS_CONST && tmp_is_dup) { zval_dtor(&tmp); } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) { - zval_ptr_dtor(&varname); + zval_ptr_dtor(&tmp); } - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); HANDLE_EXCEPTION(); } if (UNEXPECTED(ce == NULL)) { zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv)); } - CACHE_PTR(opline->op2.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); } } else { - ce = EX_T(opline->op2.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op2.var)); } - zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); + zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC); } else { - ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1); - target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); - zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC); + zend_hash_del_ind(target_symbol_table, Z_STR_P(varname)); } - if (IS_VAR != IS_CONST && varname == &tmp) { + if (IS_VAR != IS_CONST && tmp_is_dup) { zval_dtor(&tmp); } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) { - zval_ptr_dtor(&varname); + zval_ptr_dtor(&tmp); } - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -16159,94 +15585,100 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAND { USE_OPLINE zend_free_op free_op1; - zval **container; + zval *container; zval *offset; ulong hval; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) { + if (IS_VAR != IS_UNUSED) { SEPARATE_ZVAL_IF_NOT_REF(container); } offset = opline->op2.zv; - if (IS_VAR != IS_VAR || container) { - switch (Z_TYPE_PP(container)) { - case IS_ARRAY: { - HashTable *ht = Z_ARRVAL_PP(container); - - switch (Z_TYPE_P(offset)) { - case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); - zend_hash_index_del(ht, hval); - break; - case IS_RESOURCE: - case IS_BOOL: - case IS_LONG: - hval = Z_LVAL_P(offset); - zend_hash_index_del(ht, hval); - break; - case IS_STRING: - if (IS_CONST == IS_CV || IS_CONST == IS_VAR) { - Z_ADDREF_P(offset); - } - if (IS_CONST == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); - } - if (ht == &EG(symbol_table)) { - zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC); - } else { - zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval); - } - if (IS_CONST == IS_CV || IS_CONST == IS_VAR) { - zval_ptr_dtor(&offset); - } - break; +container_again: + switch (Z_TYPE_P(container)) { + case IS_ARRAY: { + HashTable *ht = Z_ARRVAL_P(container); +offset_again: + switch (Z_TYPE_P(offset)) { + case IS_DOUBLE: + hval = zend_dval_to_lval(Z_DVAL_P(offset)); + zend_hash_index_del(ht, hval); + break; + case IS_LONG: + hval = Z_LVAL_P(offset); num_index_dim: - zend_hash_index_del(ht, hval); - if (IS_CONST == IS_CV || IS_CONST == IS_VAR) { - zval_ptr_dtor(&offset); - } - break; - case IS_NULL: - zend_hash_del(ht, "", sizeof("")); - break; - default: - zend_error(E_WARNING, "Illegal offset type in unset"); - break; - } - - break; + zend_hash_index_del(ht, hval); + break; + case IS_STRING: + if (IS_CONST == IS_CV || IS_CONST == IS_VAR) { + if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset); + } + if (IS_CONST != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto numeric_index_dim); + } + if (ht == &EG(symbol_table).ht) { + zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC); + } else { + zend_hash_del(ht, Z_STR_P(offset)); + } + if (IS_CONST == IS_CV || IS_CONST == IS_VAR) { + zval_ptr_dtor(offset); + } + break; +numeric_index_dim: + zend_hash_index_del(ht, hval); + if (IS_CONST == IS_CV || IS_CONST == IS_VAR) { + zval_ptr_dtor(offset); + } + break; + case IS_NULL: + zend_hash_del(ht, STR_EMPTY_ALLOC()); + break; + case IS_FALSE: + hval = 0; + goto num_index_dim; + case IS_TRUE: + hval = 1; + goto num_index_dim; + case IS_RESOURCE: + hval = Z_RES_HANDLE_P(offset); + goto num_index_dim; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto offset_again; + break; + default: + zend_error(E_WARNING, "Illegal offset type in unset"); + break; } - case IS_OBJECT: - if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use object as array"); - } - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC); - if (0) { - zval_ptr_dtor(&offset); - } else { - } - break; - case IS_STRING: - zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); - ZEND_VM_CONTINUE(); /* bailed out before */ - default: - - break; + break; } - } else { + case IS_OBJECT: + if (UNEXPECTED(Z_OBJ_HT_P(container)->unset_dimension == NULL)) { + zend_error_noreturn(E_ERROR, "Cannot use object as array"); + } +//??? if (IS_CONST == IS_CONST) { +//??? zval_copy_ctor(offset); +//??? } + Z_OBJ_HT_P(container)->unset_dimension(container, offset TSRMLS_CC); - } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + break; + case IS_STRING: + case IS_STR_OFFSET: + zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); + ZEND_VM_CONTINUE(); /* bailed out before */ + case IS_REFERENCE: + container = Z_REFVAL_P(container); + goto container_again; + break; + default: + break; + } + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -16255,39 +15687,26 @@ static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAND { USE_OPLINE zend_free_op free_op1; - zval **container; + zval *container; zval *offset; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + if (IS_VAR == IS_VAR && Z_TYPE_P(container) == IS_STR_OFFSET) { + zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); + } offset = opline->op2.zv; - if (IS_VAR != IS_VAR || container) { - if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(container); - } - if (Z_TYPE_PP(container) == IS_OBJECT) { - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - if (Z_OBJ_HT_P(*container)->unset_property) { - Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to unset property of non-object"); - } - if (0) { - zval_ptr_dtor(&offset); - } else { - - } + ZVAL_DEREF(container); + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->unset_property) { + Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); } else { - + zend_error(E_NOTICE, "Trying to unset property of non-object"); } - } else { - } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -16295,21 +15714,16 @@ static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAND static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval **value; + zval *value; zend_bool isset = 1; SAVE_OPLINE(); if (IS_VAR == IS_CV && IS_CONST == IS_UNUSED && (opline->extended_value & ZEND_QUICK_SET)) { - if (EX_CV(opline->op1.var)) { - value = EX_CV(opline->op1.var); - } else if (EG(active_symbol_table)) { - zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); - - if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) { - isset = 0; - } + if (Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_UNDEF) { + value = EX_VAR(opline->op1.var); + ZVAL_DEREF(value); } else { isset = 0; } @@ -16319,8 +15733,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPC zval tmp, *varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { - ZVAL_COPY_VALUE(&tmp, varname); - zval_copy_ctor(&tmp); + ZVAL_DUP(&tmp, varname); convert_to_string(&tmp); varname = &tmp; } @@ -16329,26 +15742,26 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPC zend_class_entry *ce; if (IS_CONST == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(opline->op2.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); } } else { - ce = EX_T(opline->op2.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op2.var)); } - value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); + value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC); if (!value) { isset = 0; } } else { target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); - if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) { + if ((value = zend_hash_find(target_symbol_table, Z_STR_P(varname))) == NULL) { isset = 0; } } @@ -16356,20 +15769,20 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPC if (IS_VAR != IS_CONST && varname == &tmp) { zval_dtor(&tmp); } - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); } if (opline->extended_value & ZEND_ISSET) { - if (isset && Z_TYPE_PP(value) != IS_NULL) { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); + if (isset && Z_TYPE_P(value) != IS_NULL) { + ZVAL_BOOL(EX_VAR(opline->result.var), 1); } else { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); + ZVAL_BOOL(EX_VAR(opline->result.var), 0); } } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { - if (!isset || !i_zend_is_true(*value TSRMLS_CC)) { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); + if (!isset || !i_zend_is_true(value TSRMLS_CC)) { + ZVAL_BOOL(EX_VAR(opline->result.var), 1); } else { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); + ZVAL_BOOL(EX_VAR(opline->result.var), 0); } } @@ -16377,54 +15790,58 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPC ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CONST(int prop_dim, ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_free_op free_op1; zval *container; - zval **value = NULL; - int result = 0; + int result; ulong hval; zval *offset; SAVE_OPLINE(); - container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); offset = opline->op2.zv; - if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) { - HashTable *ht; - int isset = 0; - - ht = Z_ARRVAL_P(container); + if (Z_TYPE_P(container) == IS_ARRAY) { + HashTable *ht = Z_ARRVAL_P(container); + zval *value = NULL; + zend_string *str; +isset_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: hval = zend_dval_to_lval(Z_DVAL_P(offset)); goto num_index_prop; - case IS_RESOURCE: - case IS_BOOL: case IS_LONG: hval = Z_LVAL_P(offset); num_index_prop: - if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) { - isset = 1; - } + value = zend_hash_index_find(ht, hval); break; case IS_STRING: - if (IS_CONST == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); - } - if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) { - isset = 1; + str = Z_STR_P(offset); + if (IS_CONST != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index_prop); } +str_index_prop: + value = zend_hash_find_ind(ht, str); break; case IS_NULL: - if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) { - isset = 1; - } + str = STR_EMPTY_ALLOC(); + goto str_index_prop; + break; + case IS_FALSE: + hval = 0; + goto num_index_prop; + case IS_TRUE: + hval = 0; + goto num_index_prop; + case IS_RESOURCE: + hval = Z_RES_HANDLE_P(offset); + goto num_index_prop; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto isset_again; break; default: zend_error(E_WARNING, "Illegal offset type in isset or empty"); @@ -16432,118 +15849,103 @@ num_index_prop: } if (opline->extended_value & ZEND_ISSET) { - if (isset && Z_TYPE_PP(value) == IS_NULL) { - result = 0; - } else { - result = isset; - } + /* > IS_NULL means not IS_UNDEF and not IS_NULL */ + result = (value != NULL && Z_TYPE_P(value) > IS_NULL); } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { - if (!isset || !i_zend_is_true(*value TSRMLS_CC)) { - result = 0; - } else { - result = 1; - } + result = (value == NULL || !i_zend_is_true(value TSRMLS_CC)); } - } else if (Z_TYPE_P(container) == IS_OBJECT) { - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - if (prop_dim) { - if (Z_OBJ_HT_P(container)->has_property) { - result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check property of non-object"); - result = 0; - } + if (Z_OBJ_HT_P(container)->has_dimension) { + result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); } else { - if (Z_OBJ_HT_P(container)->has_dimension) { - result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check element of non-array"); - result = 0; - } + zend_error(E_NOTICE, "Trying to check element of non-array"); + result = 0; } - if (0) { - zval_ptr_dtor(&offset); - } else { - + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; } - } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */ + } else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */ zval tmp; - if (Z_TYPE_P(offset) != IS_LONG) { - if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */ + result = 0; + if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) { + if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */ || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { - ZVAL_COPY_VALUE(&tmp, offset); - zval_copy_ctor(&tmp); + ZVAL_DUP(&tmp, offset); convert_to_long(&tmp); offset = &tmp; - } else { - /* can not be converted to proper offset, return "not set" */ - result = 0; } } if (Z_TYPE_P(offset) == IS_LONG) { - if (opline->extended_value & ZEND_ISSET) { - if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { - result = 1; - } - } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { - if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') { + if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { + if ((opline->extended_value & ZEND_ISSET) || + Z_STRVAL_P(container)[offset->value.lval] != '0') { result = 1; } } } - - } else { - - } - - Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; - if (opline->extended_value & ZEND_ISSET) { - Z_LVAL(EX_T(opline->result.var).tmp_var) = result; + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } } else { - Z_LVAL(EX_T(opline->result.var).tmp_var) = !result; + result = ((opline->extended_value & ZEND_ISSET) == 0); } - zval_ptr_dtor_nogc(&free_op1.var); - + ZVAL_BOOL(EX_VAR(opline->result.var), result); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CONST(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} - static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CONST(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + zend_free_op free_op1; + zval *container; + int result; + zval *offset; + + SAVE_OPLINE(); + container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + offset = opline->op2.zv; + + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->has_property) { + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); + } else { + zend_error(E_NOTICE, "Trying to check property of non-object"); + result = 0; + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else { + result = ((opline->extended_value & ZEND_ISSET) == 0); + } + + ZVAL_BOOL(EX_VAR(opline->result.var), result); + zval_ptr_dtor_nogc(free_op1.var); + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - /* The generator object is stored in return_value_ptr_ptr */ - zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr); + /* The generator object is stored in EX(return_value) */ + zend_generator *generator = (zend_generator *) EX(return_value); if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) { zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator"); } /* Destroy the previously yielded value */ - if (generator->value) { - zval_ptr_dtor(&generator->value); - } + zval_ptr_dtor(&generator->value); /* Destroy the previously yielded key */ - if (generator->key) { - zval_ptr_dtor(&generator->key); - } + zval_ptr_dtor(&generator->key); /* Set the new yielded value */ if (IS_VAR != IS_UNUSED) { @@ -16553,75 +15955,59 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ /* Constants and temporary variables aren't yieldable by reference, * but we still allow them with a notice. */ if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) { - zval *value, *copy; + zval *value; zend_error(E_NOTICE, "Only variable references should be yielded by reference"); value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); + ZVAL_COPY_VALUE(&generator->value, value); + if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1); /* Temporary variables don't need ctor copying */ if (!0) { - zval_copy_ctor(copy); + zval_copy_ctor(&generator->value); } - - generator->value = copy; } else { - zval **value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference"); } /* If a function call result is yielded and the function did * not return by reference we throw a notice. */ - if (IS_VAR == IS_VAR && !Z_ISREF_PP(value_ptr) + if (IS_VAR == IS_VAR && !Z_ISREF_P(value_ptr) && !(opline->extended_value == ZEND_RETURNS_FUNCTION - && EX_T(opline->op1.var).var.fcall_returned_reference) - && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) { + && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); - - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } else { SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr); - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } + ZVAL_COPY(&generator->value, value_ptr); - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; } } else { zval *value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); /* Consts, temporary variables and references need copying */ - if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR - || PZVAL_IS_REF(value) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); - - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } - - generator->value = copy; - zval_ptr_dtor_nogc(&free_op1.var); + if (IS_VAR == IS_CONST) { + ZVAL_DUP(&generator->value, value); + } else if (IS_VAR == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->value, value); + } else if (Z_ISREF_P(value)) { + ZVAL_DUP(&generator->value, Z_REFVAL_P(value)); + zval_ptr_dtor_nogc(free_op1.var); } else { if (IS_VAR == IS_CV) { - Z_ADDREF_P(value); + if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value); } - generator->value = value; + ZVAL_COPY_VALUE(&generator->value, value); } } } else { /* If no value was specified yield null */ - Z_ADDREF(EG(uninitialized_zval)); - generator->value = &EG(uninitialized_zval); + ZVAL_NULL(&generator->value); } /* Set the new yielded key */ @@ -16630,45 +16016,36 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ zval *key = opline->op2.zv; /* Consts, temporary variables and references need copying */ - if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR - || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, key); - - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } + if (IS_CONST == IS_CONST) { + ZVAL_DUP(&generator->key, key); + } else if (IS_CONST == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->key, key); + } else if (Z_ISREF_P(key)) { + ZVAL_DUP(&generator->key, Z_REFVAL_P(key)); - generator->key = copy; } else { - Z_ADDREF_P(key); - generator->key = key; + if (IS_CONST == IS_CV) { + if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key); + } + ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE_P(generator->key) == IS_LONG - && Z_LVAL_P(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_LONG + && Z_LVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL_P(generator->key); + generator->largest_used_integer_key = Z_LVAL(generator->key); } - } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - - ALLOC_INIT_ZVAL(generator->key); - ZVAL_LONG(generator->key, generator->largest_used_integer_key); + ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ - generator->send_target = &EX_T(opline->result.var).var.ptr; - Z_ADDREF(EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + generator->send_target = EX_VAR(opline->result.var); + ZVAL_NULL(generator->send_target); } else { generator->send_target = NULL; } @@ -16690,10 +16067,10 @@ static int ZEND_FASTCALL ZEND_POW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR zend_free_op free_op1; SAVE_OPLINE(); - pow_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + pow_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), opline->op2.zv TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -16710,10 +16087,10 @@ static int ZEND_FASTCALL ZEND_ADD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS zend_free_op free_op1, free_op2; SAVE_OPLINE(); - fast_add_function(&EX_T(opline->result.var).tmp_var, + fast_add_function(EX_VAR(opline->result.var), _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); zval_dtor(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -16725,10 +16102,10 @@ static int ZEND_FASTCALL ZEND_SUB_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS zend_free_op free_op1, free_op2; SAVE_OPLINE(); - fast_sub_function(&EX_T(opline->result.var).tmp_var, + fast_sub_function(EX_VAR(opline->result.var), _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); zval_dtor(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -16740,10 +16117,10 @@ static int ZEND_FASTCALL ZEND_MUL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS zend_free_op free_op1, free_op2; SAVE_OPLINE(); - fast_mul_function(&EX_T(opline->result.var).tmp_var, + fast_mul_function(EX_VAR(opline->result.var), _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); zval_dtor(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -16755,10 +16132,10 @@ static int ZEND_FASTCALL ZEND_DIV_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS zend_free_op free_op1, free_op2; SAVE_OPLINE(); - fast_div_function(&EX_T(opline->result.var).tmp_var, + fast_div_function(EX_VAR(opline->result.var), _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); zval_dtor(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -16770,10 +16147,10 @@ static int ZEND_FASTCALL ZEND_MOD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS zend_free_op free_op1, free_op2; SAVE_OPLINE(); - fast_mod_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + fast_mod_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); zval_dtor(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -16785,10 +16162,10 @@ static int ZEND_FASTCALL ZEND_SL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op1, free_op2; SAVE_OPLINE(); - shift_left_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + shift_left_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); zval_dtor(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -16800,10 +16177,10 @@ static int ZEND_FASTCALL ZEND_SR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op1, free_op2; SAVE_OPLINE(); - shift_right_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + shift_right_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); zval_dtor(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -16815,10 +16192,10 @@ static int ZEND_FASTCALL ZEND_CONCAT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_A zend_free_op free_op1, free_op2; SAVE_OPLINE(); - concat_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + concat_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); zval_dtor(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -16830,10 +16207,10 @@ static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HAN zend_free_op free_op1, free_op2; SAVE_OPLINE(); - is_identical_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + fast_is_identical_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); zval_dtor(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -16843,14 +16220,13 @@ static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE { USE_OPLINE zend_free_op free_op1, free_op2; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - is_identical_function(result, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + fast_is_not_identical_function(result, + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - Z_LVAL_P(result) = !Z_LVAL_P(result); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); zval_dtor(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -16860,13 +16236,13 @@ static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER { USE_OPLINE zend_free_op free_op1, free_op2; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_equal_function(result, + fast_equal_function(result, _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); - zval_ptr_dtor_nogc(&free_op1.var); + _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); zval_dtor(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -16876,13 +16252,13 @@ static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HAN { USE_OPLINE zend_free_op free_op1, free_op2; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_not_equal_function(result, + fast_not_equal_function(result, _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); - zval_ptr_dtor_nogc(&free_op1.var); + _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); zval_dtor(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -16892,13 +16268,13 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDL { USE_OPLINE zend_free_op free_op1, free_op2; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_is_smaller_function(result, + fast_is_smaller_function(result, _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); - zval_ptr_dtor_nogc(&free_op1.var); + _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); zval_dtor(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -16908,13 +16284,13 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_TMP_HANDLER(ZEND_OPC { USE_OPLINE zend_free_op free_op1, free_op2; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, + fast_is_smaller_or_equal_function(result, _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); - zval_ptr_dtor_nogc(&free_op1.var); + _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); zval_dtor(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -16926,10 +16302,10 @@ static int ZEND_FASTCALL ZEND_BW_OR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR zend_free_op free_op1, free_op2; SAVE_OPLINE(); - bitwise_or_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + bitwise_or_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); zval_dtor(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -16941,10 +16317,10 @@ static int ZEND_FASTCALL ZEND_BW_AND_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_A zend_free_op free_op1, free_op2; SAVE_OPLINE(); - bitwise_and_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + bitwise_and_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); zval_dtor(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -16956,10 +16332,10 @@ static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_A zend_free_op free_op1, free_op2; SAVE_OPLINE(); - bitwise_xor_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + bitwise_xor_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); zval_dtor(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -16971,10 +16347,10 @@ static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER zend_free_op free_op1, free_op2; SAVE_OPLINE(); - boolean_xor_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + boolean_xor_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); zval_dtor(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -16984,18 +16360,18 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(int (*bin { USE_OPLINE zend_free_op free_op1, free_op2, free_op_data1; - zval **object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - zval *object; + zval *object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); zval *property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); + zval *value; int have_get_ptr = 0; - if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - make_real_object(object_ptr TSRMLS_CC); - object = *object_ptr; + object = make_real_object(object TSRMLS_CC); + + value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { zend_error(E_WARNING, "Attempt to assign property of non-object"); @@ -17003,326 +16379,413 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(int (*bin FREE_OP(free_op_data1); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } } else { /* here we are sure we are dealing with an object */ - if (1) { - MAKE_REAL_ZVAL_PTR(property); - } - - /* here property is a string */ if (opline->extended_value == ZEND_ASSIGN_OBJ && Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); if (zptr != NULL) { /* NULL means no success in getting PTR */ SEPARATE_ZVAL_IF_NOT_REF(zptr); have_get_ptr = 1; - binary_op(*zptr, *zptr, value TSRMLS_CC); + binary_op(zptr, zptr, value TSRMLS_CC); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(*zptr); - EX_T(opline->result.var).var.ptr = *zptr; + ZVAL_COPY(EX_VAR(opline->result.var), zptr); } } } if (!have_get_ptr) { zval *z = NULL; + zval rv; if (opline->extended_value == ZEND_ASSIGN_OBJ) { if (Z_OBJ_HT_P(object)->read_property) { - z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC); } } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { if (Z_OBJ_HT_P(object)->read_dimension) { - z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC); + z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R, &rv TSRMLS_CC); } } if (z) { if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); zval_dtor(z); - FREE_ZVAL(z); } - z = value; + ZVAL_COPY_VALUE(z, value); } - Z_ADDREF_P(z); - SEPARATE_ZVAL_IF_NOT_REF(&z); +//??? if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); + SEPARATE_ZVAL_IF_NOT_REF(z); binary_op(z, z, value TSRMLS_CC); if (opline->extended_value == ZEND_ASSIGN_OBJ) { - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(z); - EX_T(opline->result.var).var.ptr = z; + ZVAL_COPY(EX_VAR(opline->result.var), z); } - zval_ptr_dtor(&z); + zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to assign property of non-object"); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } } } - if (1) { - zval_ptr_dtor(&property); - } else { - zval_dtor(free_op2.var); - } + zval_dtor(free_op2.var); FREE_OP(free_op_data1); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; /* assign_obj has two opcodes! */ CHECK_EXCEPTION(); ZEND_VM_INC_OPCODE(); ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_VAR_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_free_op free_op1, free_op2, free_op_data2, free_op_data1; - zval **var_ptr; - zval *value; + zval *var_ptr; + zval *value, *container; SAVE_OPLINE(); - switch (opline->extended_value) { - case ZEND_ASSIGN_OBJ: - return zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - break; - case ZEND_ASSIGN_DIM: { - zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); - } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) { - if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) { - Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */ - } - return zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - } else { - zval *dim = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { + zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); + } else if (UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { + if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) { + Z_ADDREF_P(container); /* undo the effect of get_obj_zval_ptr_ptr() */ + } + return zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else { + zval *dim = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_TMP_VAR, BP_VAR_RW TSRMLS_CC); - value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); - var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); - } - } - break; - default: - value = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - /* do nothing */ - break; + zend_fetch_dimension_address_RW(EX_VAR((opline+1)->op2.var), container, dim, IS_TMP_VAR TSRMLS_CC); + value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); + var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); } - if (UNEXPECTED(var_ptr == NULL)) { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); } - if (UNEXPECTED(*var_ptr == &EG(error_zval))) { - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + if (UNEXPECTED(var_ptr == &EG(error_zval))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); } - zval_dtor(free_op2.var); - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - CHECK_EXCEPTION(); - if (opline->extended_value == ZEND_ASSIGN_DIM) { - ZEND_VM_INC_OPCODE(); - } - ZEND_VM_NEXT_OPCODE(); + goto assign_op_dim_exit; } SEPARATE_ZVAL_IF_NOT_REF(var_ptr); + ZVAL_DEREF(var_ptr); - if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) - && Z_OBJ_HANDLER_PP(var_ptr, get) - && Z_OBJ_HANDLER_PP(var_ptr, set)) { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) && + UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) { /* proxy object */ - zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); + zval rv; + zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC); Z_ADDREF_P(objval); binary_op(objval, objval, value TSRMLS_CC); - Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC); - zval_ptr_dtor(&objval); + Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); + zval_ptr_dtor(objval); } else { - binary_op(*var_ptr, *var_ptr, value TSRMLS_CC); + binary_op(var_ptr, var_ptr, value TSRMLS_CC); } - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(*var_ptr); - EX_T(opline->result.var).var.ptr = *var_ptr; + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } + +assign_op_dim_exit: zval_dtor(free_op2.var); + FREE_OP(free_op_data1); + FREE_OP_VAR_PTR(free_op_data2); + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; + CHECK_EXCEPTION(); + ZEND_VM_INC_OPCODE(); + ZEND_VM_NEXT_OPCODE(); +} - if (opline->extended_value == ZEND_ASSIGN_DIM) { - FREE_OP(free_op_data1); - FREE_OP_VAR_PTR(free_op_data2); - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - CHECK_EXCEPTION(); - ZEND_VM_INC_OPCODE(); +static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_free_op free_op1, free_op2; + zval *var_ptr; + zval *value; + + SAVE_OPLINE(); + value = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { + zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); + } + + if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } + goto assign_op_exit; + } + + SEPARATE_ZVAL_IF_NOT_REF(var_ptr); + ZVAL_DEREF(var_ptr); + + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) && + UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) { + /* proxy object */ + zval rv; + zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC); + Z_ADDREF_P(objval); + binary_op(objval, objval, value TSRMLS_CC); + Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); + zval_ptr_dtor(objval); } else { - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - CHECK_EXCEPTION(); + binary_op(var_ptr, var_ptr, value TSRMLS_CC); } + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + } + +assign_op_exit: + zval_dtor(free_op2.var); + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; + CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_TMP(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_TMP(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_TMP(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_TMP(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_TMP(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_TMP(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_TMP(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_TMP(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_TMP(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_TMP(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_TMP(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_TMP(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_TMP(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_TMP(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_TMP(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_TMP(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_TMP(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_TMP(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_TMP(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_TMP(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_TMP(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_TMP(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_TMP(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_TMP(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_TMP(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_TMP(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_TMP(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_TMP(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_TMP(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_TMP(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_TMP(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_TMP(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_TMP(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_TMP(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_free_op free_op1, free_op2; - zval **object_ptr; zval *object; zval *property; - zval **retval; + zval *retval; int have_get_ptr = 0; SAVE_OPLINE(); - object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - retval = &EX_T(opline->result.var).var.ptr; + retval = EX_VAR(opline->result.var); - if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } - make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ - object = *object_ptr; + object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */ if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); zval_dtor(free_op2.var); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - *retval = &EG(uninitialized_zval); + ZVAL_NULL(retval); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } /* here we are sure we are dealing with an object */ - if (1) { - MAKE_REAL_ZVAL_PTR(property); - } - if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); if (zptr != NULL) { /* NULL means no success in getting PTR */ SEPARATE_ZVAL_IF_NOT_REF(zptr); have_get_ptr = 1; - incdec_op(*zptr); + incdec_op(zptr); if (RETURN_VALUE_USED(opline)) { - *retval = *zptr; - PZVAL_LOCK(*retval); + ZVAL_COPY(retval, zptr); } } } if (!have_get_ptr) { + zval rv; + if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC); if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); zval_dtor(z); - FREE_ZVAL(z); } - z = value; + ZVAL_COPY_VALUE(z, value); } - Z_ADDREF_P(z); - SEPARATE_ZVAL_IF_NOT_REF(&z); + if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); + SEPARATE_ZVAL_IF_NOT_REF(z); incdec_op(z); - *retval = z; - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - SELECTIVE_PZVAL_LOCK(*retval, opline); - zval_ptr_dtor(&z); + ZVAL_COPY_VALUE(retval, z); + Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); + SELECTIVE_PZVAL_LOCK(retval, opline); + zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - *retval = &EG(uninitialized_zval); + ZVAL_NULL(retval); } } } - if (1) { - zval_ptr_dtor(&property); - } else { - zval_dtor(free_op2.var); - } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + zval_dtor(free_op2.var); + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -17341,90 +16804,76 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_TMP(incdec_t { USE_OPLINE zend_free_op free_op1, free_op2; - zval **object_ptr; zval *object; zval *property; zval *retval; int have_get_ptr = 0; SAVE_OPLINE(); - object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - retval = &EX_T(opline->result.var).tmp_var; + retval = EX_VAR(opline->result.var); - if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } - make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ - object = *object_ptr; + object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */ if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); zval_dtor(free_op2.var); ZVAL_NULL(retval); - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } /* here we are sure we are dealing with an object */ - if (1) { - MAKE_REAL_ZVAL_PTR(property); - } - if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); if (zptr != NULL) { /* NULL means no success in getting PTR */ have_get_ptr = 1; SEPARATE_ZVAL_IF_NOT_REF(zptr); - ZVAL_COPY_VALUE(retval, *zptr); - zendi_zval_copy_ctor(*retval); + ZVAL_DUP(retval, zptr); - incdec_op(*zptr); + incdec_op(zptr); } } if (!have_get_ptr) { if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - zval *z_copy; + zval rv; + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC); + zval z_copy; if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); zval_dtor(z); - FREE_ZVAL(z); } - z = value; + ZVAL_COPY_VALUE(z, value); } - ZVAL_COPY_VALUE(retval, z); - zendi_zval_copy_ctor(*retval); - ALLOC_ZVAL(z_copy); - INIT_PZVAL_COPY(z_copy, z); - zendi_zval_copy_ctor(*z_copy); - incdec_op(z_copy); - Z_ADDREF_P(z); - Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + ZVAL_DUP(retval, z); + ZVAL_DUP(&z_copy, z); + incdec_op(&z_copy); + if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); + Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); zval_ptr_dtor(&z_copy); - zval_ptr_dtor(&z); + zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); ZVAL_NULL(retval); } } - if (1) { - zval_ptr_dtor(&property); - } else { - zval_dtor(free_op2.var); - } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + zval_dtor(free_op2.var); + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -17447,10 +16896,10 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HAND SAVE_OPLINE(); container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC); zval_dtor(free_op2.var); if (IS_VAR != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) { - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -17460,32 +16909,24 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HAND { USE_OPLINE zend_free_op free_op1, free_op2; - zval **container; + zval *container; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_W TSRMLS_CC); + if (EXPECTED(opline->extended_value == 0)) { + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC); + } else { + zend_fetch_dimension_address_W_ref(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC); + } zval_dtor(free_op2.var); if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); - } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - - /* We are going to assign the result by reference */ - if (UNEXPECTED(opline->extended_value != 0)) { - zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; - - if (retval_ptr) { - Z_DELREF_PP(retval_ptr); - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); - Z_ADDREF_PP(retval_ptr); - } + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -17494,20 +16935,20 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HAN { USE_OPLINE zend_free_op free_op1, free_op2; - zval **container; + zval *container; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_RW TSRMLS_CC); + zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC); zval_dtor(free_op2.var); if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -17520,9 +16961,9 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HAN SAVE_OPLINE(); container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_IS TSRMLS_CC); + zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC); zval_dtor(free_op2.var); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -17530,31 +16971,30 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HAN static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE + zval *container; zend_free_op free_op1, free_op2; SAVE_OPLINE(); if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { - zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_W TSRMLS_CC); + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC); if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } zval_dtor(free_op2.var); - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; } else { - zval *container; - if (IS_TMP_VAR == IS_UNUSED) { zend_error_noreturn(E_ERROR, "Cannot use [] for reading"); } container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC); zval_dtor(free_op2.var); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -17564,41 +17004,22 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_ { USE_OPLINE zend_free_op free_op1, free_op2; - zval **container; + zval *container; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_CV) { - if (container != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(container); - } - } - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_UNSET TSRMLS_CC); + zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC); zval_dtor(free_op2.var); if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); - } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); - ZEND_VM_NEXT_OPCODE(); - } else { - zend_free_op free_res; - zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; - - PZVAL_UNLOCK(*retval_ptr, &free_res); - if (retval_ptr != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(retval_ptr); - } - PZVAL_LOCK(*retval_ptr); - FREE_OP_VAR_PTR(free_res); - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_TMP(ZEND_OPCODE_HANDLER_ARGS) @@ -17610,36 +17031,26 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_TMP(ZE zval *offset; SAVE_OPLINE(); - container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { zend_error(E_NOTICE, "Trying to get property of non-object"); - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - zval_dtor(free_op2.var); + ZVAL_NULL(EX_VAR(opline->result.var)); } else { zval *retval; - if (1) { - MAKE_REAL_ZVAL_PTR(offset); - } - /* here we are sure we are dealing with an object */ - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - - PZVAL_LOCK(retval); - EX_T(opline->result.var).var.ptr = retval; + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC); - if (1) { - zval_ptr_dtor(&offset); - } else { - zval_dtor(free_op2.var); + if (retval != EX_VAR(opline->result.var)) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); } } - zval_ptr_dtor_nogc(&free_op1.var); + zval_dtor(free_op2.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -17654,41 +17065,22 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HAND USE_OPLINE zend_free_op free_op1, free_op2; zval *property; - zval **container; + zval *container; SAVE_OPLINE(); property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (1) { - MAKE_REAL_ZVAL_PTR(property); - } container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); - if (1) { - zval_ptr_dtor(&property); - } else { - zval_dtor(free_op2.var); - } + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC); + zval_dtor(free_op2.var); if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - - /* We are going to assign the result by reference */ - if (opline->extended_value & ZEND_FETCH_MAKE_REF) { - zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; - - Z_DELREF_PP(retval_ptr); - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); - Z_ADDREF_PP(retval_ptr); - EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr; - EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; - } - + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -17698,28 +17090,21 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HAN USE_OPLINE zend_free_op free_op1, free_op2; zval *property; - zval **container; + zval *container; SAVE_OPLINE(); property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (1) { - MAKE_REAL_ZVAL_PTR(property); - } - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC); - if (1) { - zval_ptr_dtor(&property); - } else { - zval_dtor(free_op2.var); - } + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_RW, 0 TSRMLS_CC); + zval_dtor(free_op2.var); if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -17733,35 +17118,25 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HAN zval *offset; SAVE_OPLINE(); - container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - zval_dtor(free_op2.var); + ZVAL_NULL(EX_VAR(opline->result.var)); } else { zval *retval; - if (1) { - MAKE_REAL_ZVAL_PTR(offset); - } - /* here we are sure we are dealing with an object */ - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - - PZVAL_LOCK(retval); - EX_T(opline->result.var).var.ptr = retval; + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC); - if (1) { - zval_ptr_dtor(&offset); - } else { - zval_dtor(free_op2.var); + if (retval != EX_VAR(opline->result.var)) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); } } - zval_ptr_dtor_nogc(&free_op1.var); + zval_dtor(free_op2.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -17769,33 +17144,26 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HAN static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE + zval *container; if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { /* Behave like FETCH_OBJ_W */ zend_free_op free_op1, free_op2; zval *property; - zval **container; SAVE_OPLINE(); property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (1) { - MAKE_REAL_ZVAL_PTR(property); - } - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); - if (1) { - zval_ptr_dtor(&property); - } else { - zval_dtor(free_op2.var); - } + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, 0 TSRMLS_CC); + zval_dtor(free_op2.var); if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } else { @@ -17806,42 +17174,22 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMP_HANDLER(ZEND_OPCO static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_free_op free_op1, free_op2, free_res; - zval **container; - zval *property; + zend_free_op free_op1, free_op2; + zval *container, *property; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (IS_VAR == IS_CV) { - if (container != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(container); - } - } - if (1) { - MAKE_REAL_ZVAL_PTR(property); - } - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC); - if (1) { - zval_ptr_dtor(&property); - } else { - zval_dtor(free_op2.var); - } + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_UNSET, 0 TSRMLS_CC); + zval_dtor(free_op2.var); if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - - PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res); - if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr); - } - PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr); - FREE_OP_VAR_PTR(free_res); + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -17850,26 +17198,19 @@ static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDL { USE_OPLINE zend_free_op free_op1, free_op2; - zval **object_ptr; + zval *object; zval *property_name; SAVE_OPLINE(); - object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); property_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (1) { - MAKE_REAL_ZVAL_PTR(property_name); - } - if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - if (1) { - zval_ptr_dtor(&property_name); - } else { - zval_dtor(free_op2.var); - } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC); + zval_dtor(free_op2.var); + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; /* assign_obj has two opcodes! */ CHECK_EXCEPTION(); ZEND_VM_INC_OPCODE(); @@ -17880,77 +17221,60 @@ static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDL { USE_OPLINE zend_free_op free_op1; - zval **object_ptr; + zval *object_ptr; SAVE_OPLINE(); object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - if (Z_TYPE_PP(object_ptr) == IS_OBJECT) { + if (UNEXPECTED(Z_ISREF_P(object_ptr)) && Z_TYPE_P(Z_REFVAL_P(object_ptr)) == IS_OBJECT) { + object_ptr = Z_REFVAL_P(object_ptr); + } + if (Z_TYPE_P(object_ptr) == IS_OBJECT) { zend_free_op free_op2; zval *property_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (1) { - MAKE_REAL_ZVAL_PTR(property_name); - } - zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - if (1) { - zval_ptr_dtor(&property_name); - } else { - zval_dtor(free_op2.var); - } + zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC); + zval_dtor(free_op2.var); } else { zend_free_op free_op2, free_op_data1, free_op_data2; zval *value; zval *dim = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - zval **variable_ptr_ptr; + zval *variable_ptr; - zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_TMP_VAR, BP_VAR_W TSRMLS_CC); + zend_fetch_dimension_address_W(EX_VAR((opline+1)->op2.var), object_ptr, dim, IS_TMP_VAR TSRMLS_CC); zval_dtor(free_op2.var); value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); - variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); - if (UNEXPECTED(variable_ptr_ptr == NULL)) { - if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) { - if (RETURN_VALUE_USED(opline)) { - zval *retval; - - ALLOC_ZVAL(retval); - ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1); - INIT_PZVAL(retval); - EX_T(opline->result.var).var.ptr = retval; - } - } else if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - } - } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) { + variable_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); + if (UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) { + zend_assign_to_string_offset(variable_ptr, value, (opline+1)->op1_type, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC); + } else if (UNEXPECTED(variable_ptr == &EG(error_zval))) { if (IS_TMP_FREE(free_op_data1)) { zval_dtor(value); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } + FREE_OP_VAR_PTR(free_op_data2); } else { if ((opline+1)->op1_type == IS_TMP_VAR) { - value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_tmp_to_variable(variable_ptr, value TSRMLS_CC); } else if ((opline+1)->op1_type == IS_CONST) { - value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_const_to_variable(variable_ptr, value TSRMLS_CC); } else { - value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_to_variable(variable_ptr, value TSRMLS_CC); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(value); - EX_T(opline->result.var).var.ptr = value; + ZVAL_COPY(EX_VAR(opline->result.var), value); } + FREE_OP_VAR_PTR(free_op_data2); } - FREE_OP_VAR_PTR(free_op_data2); FREE_OP_IF_VAR(free_op_data1); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; /* assign_dim has two opcodes! */ CHECK_EXCEPTION(); ZEND_VM_INC_OPCODE(); @@ -17962,50 +17286,35 @@ static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_A USE_OPLINE zend_free_op free_op1, free_op2; zval *value; - zval **variable_ptr_ptr; + zval *variable_ptr; SAVE_OPLINE(); value = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - variable_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) { - if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_TMP_VAR TSRMLS_CC)) { - if (RETURN_VALUE_USED(opline)) { - zval *retval; - - ALLOC_ZVAL(retval); - ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1); - INIT_PZVAL(retval); - EX_T(opline->result.var).var.ptr = retval; - } - } else if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - } - } else if (IS_VAR == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) { + zend_assign_to_string_offset(variable_ptr, value, IS_TMP_VAR, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC); + } else if (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) { if (1) { zval_dtor(value); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } } else { if (IS_TMP_VAR == IS_TMP_VAR) { - value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_tmp_to_variable(variable_ptr, value TSRMLS_CC); } else if (IS_TMP_VAR == IS_CONST) { - value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_const_to_variable(variable_ptr, value TSRMLS_CC); } else { - value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_to_variable(variable_ptr, value TSRMLS_CC); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(value); - EX_T(opline->result.var).var.ptr = value; + ZVAL_COPY(EX_VAR(opline->result.var), value); } + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - /* zend_assign_to_variable() always takes care of op2, never free it! */ CHECK_EXCEPTION(); @@ -18016,10 +17325,9 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE { USE_OPLINE zval *function_name; - char *function_name_strval; - int function_name_strlen; zend_free_op free_op1, free_op2; call_slot *call = EX(call_slots) + opline->result.num; + zval *object; SAVE_OPLINE(); @@ -18033,33 +17341,30 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE zend_error_noreturn(E_ERROR, "Method name must be a string"); } - function_name_strval = Z_STRVAL_P(function_name); - function_name_strlen = Z_STRLEN_P(function_name); - - call->object = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + object = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL; - if (EXPECTED(call->object != NULL) && - EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) { - call->called_scope = Z_OBJCE_P(call->object); + if (EXPECTED(call->object != NULL)) { + call->called_scope = zend_get_class_entry(call->object TSRMLS_CC); if (IS_TMP_VAR != IS_CONST || - (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) { - zval *object = call->object; + (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope)) == NULL) { + zend_object *object = call->object; - if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) { + if (UNEXPECTED(object->handlers->get_method == NULL)) { zend_error_noreturn(E_ERROR, "Object does not support method calls"); } /* First, locate the function. */ - call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); + call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); if (UNEXPECTED(call->fbc == NULL)) { - zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval); + zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name)); } if (IS_TMP_VAR == IS_CONST && EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) && EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) && EXPECTED(call->object == object)) { - CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc); + CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope, call->fbc); } } } else { @@ -18067,21 +17372,13 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE zval_dtor(free_op2.var); HANDLE_EXCEPTION(); } - zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval); + zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", Z_STRVAL_P(function_name)); } if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) { call->object = NULL; } else { - if (!PZVAL_IS_REF(call->object)) { - Z_ADDREF_P(call->object); /* For $this pointer */ - } else { - zval *this_ptr; - ALLOC_ZVAL(this_ptr); - INIT_PZVAL_COPY(this_ptr, call->object); - zval_copy_ctor(this_ptr); - call->object = this_ptr; - } + GC_REFCOUNT(call->object)++; /* For $this pointer */ } call->num_additional_args = 0; @@ -18089,7 +17386,7 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE EX(call) = call; zval_dtor(free_op2.var); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -18106,21 +17403,21 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND if (IS_VAR == IS_CONST) { /* no function found. try a static method in class */ - if (CACHED_PTR(opline->op1.literal->cache_slot)) { - ce = CACHED_PTR(opline->op1.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } if (UNEXPECTED(ce == NULL)) { zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv)); } - CACHE_PTR(opline->op1.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce); } call->called_scope = ce; } else { - ce = EX_T(opline->op1.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op1.var)); if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) { call->called_scope = EG(called_scope); @@ -18131,51 +17428,40 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND if (IS_VAR == IS_CONST && IS_TMP_VAR == IS_CONST && - CACHED_PTR(opline->op2.literal->cache_slot)) { - call->fbc = CACHED_PTR(opline->op2.literal->cache_slot); + CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else if (IS_VAR != IS_CONST && IS_TMP_VAR == IS_CONST && - (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) { + (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce))) { /* do nothing */ } else if (IS_TMP_VAR != IS_UNUSED) { - char *function_name_strval = NULL; - int function_name_strlen = 0; zend_free_op free_op2; - if (IS_TMP_VAR == IS_CONST) { - function_name_strval = Z_STRVAL_P(opline->op2.zv); - function_name_strlen = Z_STRLEN_P(opline->op2.zv); - } else { - function_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - + function_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + if (IS_TMP_VAR != IS_CONST) { if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } zend_error_noreturn(E_ERROR, "Function name must be a string"); - } else { - function_name_strval = Z_STRVAL_P(function_name); - function_name_strlen = Z_STRLEN_P(function_name); } } - if (function_name_strval) { - if (ce->get_static_method) { - call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC); + if (ce->get_static_method) { + call->fbc = ce->get_static_method(ce, Z_STR_P(function_name) TSRMLS_CC); + } else { + call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); + } + if (UNEXPECTED(call->fbc == NULL)) { + zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name)); + } + if (IS_TMP_VAR == IS_CONST && + EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) && + EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) { + if (IS_VAR == IS_CONST) { + CACHE_PTR(Z_CACHE_SLOT_P(function_name), call->fbc); } else { - call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); - } - if (UNEXPECTED(call->fbc == NULL)) { - zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval); - } - if (IS_TMP_VAR == IS_CONST && - EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) && - EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) { - if (IS_VAR == IS_CONST) { - CACHE_PTR(opline->op2.literal->cache_slot, call->fbc); - } else { - CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc); - } + CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), ce, call->fbc); } } if (IS_TMP_VAR != IS_CONST) { @@ -18185,8 +17471,8 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND if (UNEXPECTED(ce->constructor == NULL)) { zend_error_noreturn(E_ERROR, "Cannot call constructor"); } - if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { - zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name); + if (Z_OBJ(EG(This)) && Z_OBJCE(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { + zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name->val); } call->fbc = ce->constructor; } @@ -18194,21 +17480,21 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) { call->object = NULL; } else { - if (EG(This) && - Z_OBJ_HT_P(EG(This))->get_class_entry && - !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) { + if (Z_OBJ(EG(This)) && + Z_OBJ_HT(EG(This))->get_class_entry && + !instanceof_function(Z_OBJCE(EG(This)), ce TSRMLS_CC)) { /* We are calling method of the other (incompatible) class, but passing $this. This is done for compatibility with php-4. */ if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { - zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name); + zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val); } else { /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */ - zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name); + zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val); } } - if ((call->object = EG(This))) { - Z_ADDREF_P(call->object); - call->called_scope = Z_OBJCE_P(call->object); + call->object = Z_OBJ(EG(This)); + if (call->object) { + GC_REFCOUNT(call->object)++; } } @@ -18224,11 +17510,12 @@ static int ZEND_FASTCALL ZEND_CASE_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG { USE_OPLINE zend_free_op free_op1, free_op2; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - is_equal_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + fast_equal_function(result, + _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op2.var); CHECK_EXCEPTION(); @@ -18239,35 +17526,31 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP_HANDLER(ZEND_OPCOD { USE_OPLINE zend_free_op free_op1; - zval *expr_ptr; + zval *expr_ptr, new_expr; SAVE_OPLINE(); - if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) { - zval **expr_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - - if (IS_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) { + if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && + (opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) { + expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets"); } - SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); - expr_ptr = *expr_ptr_ptr; + SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr); Z_ADDREF_P(expr_ptr); + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; } else { - expr_ptr=_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + expr_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (0) { /* temporary variable */ - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - } else if (IS_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) { - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - zendi_zval_copy_ctor(*expr_ptr); - zval_ptr_dtor_nogc(&free_op1.var); - } else if (IS_VAR == IS_CV) { + ZVAL_COPY_VALUE(&new_expr, expr_ptr); + expr_ptr = &new_expr; + } else if (IS_VAR == IS_CONST) { + ZVAL_DUP(&new_expr, expr_ptr); + expr_ptr = &new_expr; + } else if (Z_ISREF_P(expr_ptr)) { + ZVAL_DUP(&new_expr, Z_REFVAL_P(expr_ptr)); + expr_ptr = &new_expr; + zval_ptr_dtor_nogc(free_op1.var); + } else if (IS_VAR == IS_CV && Z_REFCOUNTED_P(expr_ptr)) { Z_ADDREF_P(expr_ptr); } } @@ -18275,42 +17558,49 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP_HANDLER(ZEND_OPCOD if (IS_TMP_VAR != IS_UNUSED) { zend_free_op free_op2; zval *offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + zend_string *str; ulong hval; +add_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: hval = zend_dval_to_lval(Z_DVAL_P(offset)); goto num_index; case IS_LONG: - case IS_BOOL: hval = Z_LVAL_P(offset); num_index: - zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL); + zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); break; case IS_STRING: - if (IS_TMP_VAR == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); + str = Z_STR_P(offset); + if (IS_TMP_VAR != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index); } - zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL); +str_index: + zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); break; case IS_NULL: - zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); + str = STR_EMPTY_ALLOC(); + goto str_index; + case IS_FALSE: + hval = 0; + goto num_index; + case IS_TRUE: + hval = 1; + goto num_index; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto add_again; break; default: zend_error(E_WARNING, "Illegal offset type"); - zval_ptr_dtor(&expr_ptr); + zval_ptr_dtor(expr_ptr); /* do nothing */ break; } zval_dtor(free_op2.var); } else { - zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL); - } - if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) { - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -18318,9 +17608,26 @@ num_index: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { + zval *array; + zend_uint size; USE_OPLINE - array_init(&EX_T(opline->result.var).tmp_var); + array = EX_VAR(opline->result.var); + if (IS_VAR != IS_UNUSED) { + size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; + } else { + size = 0; + } + ZVAL_NEW_ARR(array); + zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); + + if (IS_VAR != IS_UNUSED) { + /* Explicitly initialize array as not-packed if flag is set */ + if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) { + zend_hash_real_init(Z_ARRVAL_P(array), 0); + } + } + if (IS_VAR == IS_UNUSED) { ZEND_VM_NEXT_OPCODE(); #if 0 || IS_VAR != IS_UNUSED @@ -18334,94 +17641,100 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLE { USE_OPLINE zend_free_op free_op1, free_op2; - zval **container; + zval *container; zval *offset; ulong hval; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) { + if (IS_VAR != IS_UNUSED) { SEPARATE_ZVAL_IF_NOT_REF(container); } offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (IS_VAR != IS_VAR || container) { - switch (Z_TYPE_PP(container)) { - case IS_ARRAY: { - HashTable *ht = Z_ARRVAL_PP(container); - - switch (Z_TYPE_P(offset)) { - case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); - zend_hash_index_del(ht, hval); - break; - case IS_RESOURCE: - case IS_BOOL: - case IS_LONG: - hval = Z_LVAL_P(offset); - zend_hash_index_del(ht, hval); - break; - case IS_STRING: - if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { - Z_ADDREF_P(offset); - } - if (IS_TMP_VAR == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); - } - if (ht == &EG(symbol_table)) { - zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC); - } else { - zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval); - } - if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { - zval_ptr_dtor(&offset); - } - break; +container_again: + switch (Z_TYPE_P(container)) { + case IS_ARRAY: { + HashTable *ht = Z_ARRVAL_P(container); +offset_again: + switch (Z_TYPE_P(offset)) { + case IS_DOUBLE: + hval = zend_dval_to_lval(Z_DVAL_P(offset)); + zend_hash_index_del(ht, hval); + break; + case IS_LONG: + hval = Z_LVAL_P(offset); num_index_dim: - zend_hash_index_del(ht, hval); - if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { - zval_ptr_dtor(&offset); - } - break; - case IS_NULL: - zend_hash_del(ht, "", sizeof("")); - break; - default: - zend_error(E_WARNING, "Illegal offset type in unset"); - break; - } - zval_dtor(free_op2.var); - break; + zend_hash_index_del(ht, hval); + break; + case IS_STRING: + if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { + if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset); + } + if (IS_TMP_VAR != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto numeric_index_dim); + } + if (ht == &EG(symbol_table).ht) { + zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC); + } else { + zend_hash_del(ht, Z_STR_P(offset)); + } + if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { + zval_ptr_dtor(offset); + } + break; +numeric_index_dim: + zend_hash_index_del(ht, hval); + if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { + zval_ptr_dtor(offset); + } + break; + case IS_NULL: + zend_hash_del(ht, STR_EMPTY_ALLOC()); + break; + case IS_FALSE: + hval = 0; + goto num_index_dim; + case IS_TRUE: + hval = 1; + goto num_index_dim; + case IS_RESOURCE: + hval = Z_RES_HANDLE_P(offset); + goto num_index_dim; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto offset_again; + break; + default: + zend_error(E_WARNING, "Illegal offset type in unset"); + break; } - case IS_OBJECT: - if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use object as array"); - } - if (1) { - MAKE_REAL_ZVAL_PTR(offset); - } - Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC); - if (1) { - zval_ptr_dtor(&offset); - } else { - zval_dtor(free_op2.var); - } - break; - case IS_STRING: - zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); - ZEND_VM_CONTINUE(); /* bailed out before */ - default: - zval_dtor(free_op2.var); - break; + zval_dtor(free_op2.var); + break; } - } else { - zval_dtor(free_op2.var); + case IS_OBJECT: + if (UNEXPECTED(Z_OBJ_HT_P(container)->unset_dimension == NULL)) { + zend_error_noreturn(E_ERROR, "Cannot use object as array"); + } +//??? if (IS_TMP_VAR == IS_CONST) { +//??? zval_copy_ctor(offset); +//??? } + Z_OBJ_HT_P(container)->unset_dimension(container, offset TSRMLS_CC); + zval_dtor(free_op2.var); + break; + case IS_STRING: + case IS_STR_OFFSET: + zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); + ZEND_VM_CONTINUE(); /* bailed out before */ + case IS_REFERENCE: + container = Z_REFVAL_P(container); + goto container_again; + break; + default: + zval_dtor(free_op2.var); + break; } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -18430,91 +17743,82 @@ static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLE { USE_OPLINE zend_free_op free_op1, free_op2; - zval **container; + zval *container; zval *offset; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + if (IS_VAR == IS_VAR && Z_TYPE_P(container) == IS_STR_OFFSET) { + zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); + } offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (IS_VAR != IS_VAR || container) { - if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(container); - } - if (Z_TYPE_PP(container) == IS_OBJECT) { - if (1) { - MAKE_REAL_ZVAL_PTR(offset); - } - if (Z_OBJ_HT_P(*container)->unset_property) { - Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to unset property of non-object"); - } - if (1) { - zval_ptr_dtor(&offset); - } else { - zval_dtor(free_op2.var); - } + ZVAL_DEREF(container); + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->unset_property) { + Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); } else { - zval_dtor(free_op2.var); + zend_error(E_NOTICE, "Trying to unset property of non-object"); } - } else { - zval_dtor(free_op2.var); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - + zval_dtor(free_op2.var); + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_TMP(int prop_dim, ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_free_op free_op1, free_op2; zval *container; - zval **value = NULL; - int result = 0; + int result; ulong hval; zval *offset; SAVE_OPLINE(); - container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) { - HashTable *ht; - int isset = 0; - - ht = Z_ARRVAL_P(container); + if (Z_TYPE_P(container) == IS_ARRAY) { + HashTable *ht = Z_ARRVAL_P(container); + zval *value = NULL; + zend_string *str; +isset_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: hval = zend_dval_to_lval(Z_DVAL_P(offset)); goto num_index_prop; - case IS_RESOURCE: - case IS_BOOL: case IS_LONG: hval = Z_LVAL_P(offset); num_index_prop: - if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) { - isset = 1; - } + value = zend_hash_index_find(ht, hval); break; case IS_STRING: - if (IS_TMP_VAR == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); - } - if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) { - isset = 1; + str = Z_STR_P(offset); + if (IS_TMP_VAR != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index_prop); } +str_index_prop: + value = zend_hash_find_ind(ht, str); break; case IS_NULL: - if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) { - isset = 1; - } + str = STR_EMPTY_ALLOC(); + goto str_index_prop; + break; + case IS_FALSE: + hval = 0; + goto num_index_prop; + case IS_TRUE: + hval = 0; + goto num_index_prop; + case IS_RESOURCE: + hval = Z_RES_HANDLE_P(offset); + goto num_index_prop; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto isset_again; break; default: zend_error(E_WARNING, "Illegal offset type in isset or empty"); @@ -18522,118 +17826,105 @@ num_index_prop: } if (opline->extended_value & ZEND_ISSET) { - if (isset && Z_TYPE_PP(value) == IS_NULL) { - result = 0; - } else { - result = isset; - } + /* > IS_NULL means not IS_UNDEF and not IS_NULL */ + result = (value != NULL && Z_TYPE_P(value) > IS_NULL); } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { - if (!isset || !i_zend_is_true(*value TSRMLS_CC)) { - result = 0; - } else { - result = 1; - } + result = (value == NULL || !i_zend_is_true(value TSRMLS_CC)); } - zval_dtor(free_op2.var); } else if (Z_TYPE_P(container) == IS_OBJECT) { - if (1) { - MAKE_REAL_ZVAL_PTR(offset); - } - if (prop_dim) { - if (Z_OBJ_HT_P(container)->has_property) { - result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check property of non-object"); - result = 0; - } + if (Z_OBJ_HT_P(container)->has_dimension) { + result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); } else { - if (Z_OBJ_HT_P(container)->has_dimension) { - result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check element of non-array"); - result = 0; - } + zend_error(E_NOTICE, "Trying to check element of non-array"); + result = 0; } - if (1) { - zval_ptr_dtor(&offset); - } else { - zval_dtor(free_op2.var); + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; } - } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */ + } else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */ zval tmp; - if (Z_TYPE_P(offset) != IS_LONG) { - if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */ + result = 0; + if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) { + if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */ || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { - ZVAL_COPY_VALUE(&tmp, offset); - zval_copy_ctor(&tmp); + ZVAL_DUP(&tmp, offset); convert_to_long(&tmp); offset = &tmp; - } else { - /* can not be converted to proper offset, return "not set" */ - result = 0; } } if (Z_TYPE_P(offset) == IS_LONG) { - if (opline->extended_value & ZEND_ISSET) { - if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { - result = 1; - } - } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { - if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') { + if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { + if ((opline->extended_value & ZEND_ISSET) || + Z_STRVAL_P(container)[offset->value.lval] != '0') { result = 1; } } } - zval_dtor(free_op2.var); - } else { - zval_dtor(free_op2.var); - } - - Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; - if (opline->extended_value & ZEND_ISSET) { - Z_LVAL(EX_T(opline->result.var).tmp_var) = result; + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } } else { - Z_LVAL(EX_T(opline->result.var).tmp_var) = !result; + result = ((opline->extended_value & ZEND_ISSET) == 0); } - zval_ptr_dtor_nogc(&free_op1.var); - + zval_dtor(free_op2.var); + ZVAL_BOOL(EX_VAR(opline->result.var), result); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_TMP(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} - static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_TMP(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + zend_free_op free_op1, free_op2; + zval *container; + int result; + zval *offset; + + SAVE_OPLINE(); + container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->has_property) { + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); + } else { + zend_error(E_NOTICE, "Trying to check property of non-object"); + result = 0; + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else { + result = ((opline->extended_value & ZEND_ISSET) == 0); + } + + zval_dtor(free_op2.var); + ZVAL_BOOL(EX_VAR(opline->result.var), result); + zval_ptr_dtor_nogc(free_op1.var); + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - /* The generator object is stored in return_value_ptr_ptr */ - zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr); + /* The generator object is stored in EX(return_value) */ + zend_generator *generator = (zend_generator *) EX(return_value); if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) { zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator"); } /* Destroy the previously yielded value */ - if (generator->value) { - zval_ptr_dtor(&generator->value); - } + zval_ptr_dtor(&generator->value); /* Destroy the previously yielded key */ - if (generator->key) { - zval_ptr_dtor(&generator->key); - } + zval_ptr_dtor(&generator->key); /* Set the new yielded value */ if (IS_VAR != IS_UNUSED) { @@ -18643,75 +17934,59 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR /* Constants and temporary variables aren't yieldable by reference, * but we still allow them with a notice. */ if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) { - zval *value, *copy; + zval *value; zend_error(E_NOTICE, "Only variable references should be yielded by reference"); value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); + ZVAL_COPY_VALUE(&generator->value, value); + if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1); /* Temporary variables don't need ctor copying */ if (!0) { - zval_copy_ctor(copy); + zval_copy_ctor(&generator->value); } - - generator->value = copy; } else { - zval **value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference"); } /* If a function call result is yielded and the function did * not return by reference we throw a notice. */ - if (IS_VAR == IS_VAR && !Z_ISREF_PP(value_ptr) + if (IS_VAR == IS_VAR && !Z_ISREF_P(value_ptr) && !(opline->extended_value == ZEND_RETURNS_FUNCTION - && EX_T(opline->op1.var).var.fcall_returned_reference) - && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) { + && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); - - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } else { SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr); - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } + ZVAL_COPY(&generator->value, value_ptr); - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; } } else { zval *value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); /* Consts, temporary variables and references need copying */ - if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR - || PZVAL_IS_REF(value) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); - - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } - - generator->value = copy; - zval_ptr_dtor_nogc(&free_op1.var); + if (IS_VAR == IS_CONST) { + ZVAL_DUP(&generator->value, value); + } else if (IS_VAR == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->value, value); + } else if (Z_ISREF_P(value)) { + ZVAL_DUP(&generator->value, Z_REFVAL_P(value)); + zval_ptr_dtor_nogc(free_op1.var); } else { if (IS_VAR == IS_CV) { - Z_ADDREF_P(value); + if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value); } - generator->value = value; + ZVAL_COPY_VALUE(&generator->value, value); } } } else { /* If no value was specified yield null */ - Z_ADDREF(EG(uninitialized_zval)); - generator->value = &EG(uninitialized_zval); + ZVAL_NULL(&generator->value); } /* Set the new yielded key */ @@ -18720,45 +17995,36 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); /* Consts, temporary variables and references need copying */ - if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR - || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, key); - - /* Temporary variables don't need ctor copying */ - if (!1) { - zval_copy_ctor(copy); - } + if (IS_TMP_VAR == IS_CONST) { + ZVAL_DUP(&generator->key, key); + } else if (IS_TMP_VAR == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->key, key); + } else if (Z_ISREF_P(key)) { + ZVAL_DUP(&generator->key, Z_REFVAL_P(key)); - generator->key = copy; } else { - Z_ADDREF_P(key); - generator->key = key; + if (IS_TMP_VAR == IS_CV) { + if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key); + } + ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE_P(generator->key) == IS_LONG - && Z_LVAL_P(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_LONG + && Z_LVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL_P(generator->key); + generator->largest_used_integer_key = Z_LVAL(generator->key); } - } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - - ALLOC_INIT_ZVAL(generator->key); - ZVAL_LONG(generator->key, generator->largest_used_integer_key); + ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ - generator->send_target = &EX_T(opline->result.var).var.ptr; - Z_ADDREF(EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + generator->send_target = EX_VAR(opline->result.var); + ZVAL_NULL(generator->send_target); } else { generator->send_target = NULL; } @@ -18780,10 +18046,10 @@ static int ZEND_FASTCALL ZEND_POW_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS zend_free_op free_op1, free_op2; SAVE_OPLINE(); - pow_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + pow_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); zval_dtor(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -18800,11 +18066,11 @@ static int ZEND_FASTCALL ZEND_ADD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS zend_free_op free_op1, free_op2; SAVE_OPLINE(); - fast_add_function(&EX_T(opline->result.var).tmp_var, + fast_add_function(EX_VAR(opline->result.var), _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op1.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -18815,11 +18081,11 @@ static int ZEND_FASTCALL ZEND_SUB_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS zend_free_op free_op1, free_op2; SAVE_OPLINE(); - fast_sub_function(&EX_T(opline->result.var).tmp_var, + fast_sub_function(EX_VAR(opline->result.var), _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op1.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -18830,11 +18096,11 @@ static int ZEND_FASTCALL ZEND_MUL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS zend_free_op free_op1, free_op2; SAVE_OPLINE(); - fast_mul_function(&EX_T(opline->result.var).tmp_var, + fast_mul_function(EX_VAR(opline->result.var), _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op1.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -18845,11 +18111,11 @@ static int ZEND_FASTCALL ZEND_DIV_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS zend_free_op free_op1, free_op2; SAVE_OPLINE(); - fast_div_function(&EX_T(opline->result.var).tmp_var, + fast_div_function(EX_VAR(opline->result.var), _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op1.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -18860,11 +18126,11 @@ static int ZEND_FASTCALL ZEND_MOD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS zend_free_op free_op1, free_op2; SAVE_OPLINE(); - fast_mod_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); - zval_ptr_dtor_nogc(&free_op2.var); + fast_mod_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -18875,11 +18141,11 @@ static int ZEND_FASTCALL ZEND_SL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op1, free_op2; SAVE_OPLINE(); - shift_left_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); - zval_ptr_dtor_nogc(&free_op2.var); + shift_left_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -18890,11 +18156,11 @@ static int ZEND_FASTCALL ZEND_SR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op1, free_op2; SAVE_OPLINE(); - shift_right_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); - zval_ptr_dtor_nogc(&free_op2.var); + shift_right_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -18905,11 +18171,11 @@ static int ZEND_FASTCALL ZEND_CONCAT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_A zend_free_op free_op1, free_op2; SAVE_OPLINE(); - concat_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); - zval_ptr_dtor_nogc(&free_op2.var); + concat_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -18920,11 +18186,11 @@ static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HAN zend_free_op free_op1, free_op2; SAVE_OPLINE(); - is_identical_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); - zval_ptr_dtor_nogc(&free_op2.var); + fast_is_identical_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -18933,15 +18199,14 @@ static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE { USE_OPLINE zend_free_op free_op1, free_op2; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - is_identical_function(result, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - Z_LVAL_P(result) = !Z_LVAL_P(result); - zval_ptr_dtor_nogc(&free_op1.var); - zval_ptr_dtor_nogc(&free_op2.var); + fast_is_not_identical_function(result, + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -18950,14 +18215,14 @@ static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER { USE_OPLINE zend_free_op free_op1, free_op2; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_equal_function(result, + fast_equal_function(result, _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); - zval_ptr_dtor_nogc(&free_op1.var); - zval_ptr_dtor_nogc(&free_op2.var); + _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -18966,14 +18231,14 @@ static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HAN { USE_OPLINE zend_free_op free_op1, free_op2; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_not_equal_function(result, + fast_not_equal_function(result, _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); - zval_ptr_dtor_nogc(&free_op1.var); - zval_ptr_dtor_nogc(&free_op2.var); + _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -18982,14 +18247,14 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDL { USE_OPLINE zend_free_op free_op1, free_op2; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_is_smaller_function(result, + fast_is_smaller_function(result, _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); - zval_ptr_dtor_nogc(&free_op1.var); - zval_ptr_dtor_nogc(&free_op2.var); + _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -18998,14 +18263,14 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_VAR_HANDLER(ZEND_OPC { USE_OPLINE zend_free_op free_op1, free_op2; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, + fast_is_smaller_or_equal_function(result, _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); - zval_ptr_dtor_nogc(&free_op1.var); - zval_ptr_dtor_nogc(&free_op2.var); + _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -19016,11 +18281,11 @@ static int ZEND_FASTCALL ZEND_BW_OR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR zend_free_op free_op1, free_op2; SAVE_OPLINE(); - bitwise_or_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); - zval_ptr_dtor_nogc(&free_op2.var); + bitwise_or_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -19031,11 +18296,11 @@ static int ZEND_FASTCALL ZEND_BW_AND_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_A zend_free_op free_op1, free_op2; SAVE_OPLINE(); - bitwise_and_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); - zval_ptr_dtor_nogc(&free_op2.var); + bitwise_and_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -19046,11 +18311,11 @@ static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_A zend_free_op free_op1, free_op2; SAVE_OPLINE(); - bitwise_xor_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); - zval_ptr_dtor_nogc(&free_op2.var); + bitwise_xor_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -19061,11 +18326,11 @@ static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER zend_free_op free_op1, free_op2; SAVE_OPLINE(); - boolean_xor_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); - zval_ptr_dtor_nogc(&free_op2.var); + boolean_xor_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -19074,345 +18339,432 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(int (*bin { USE_OPLINE zend_free_op free_op1, free_op2, free_op_data1; - zval **object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - zval *object; + zval *object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); zval *property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); + zval *value; int have_get_ptr = 0; - if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - make_real_object(object_ptr TSRMLS_CC); - object = *object_ptr; + object = make_real_object(object TSRMLS_CC); + + value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { zend_error(E_WARNING, "Attempt to assign property of non-object"); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); FREE_OP(free_op_data1); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } } else { /* here we are sure we are dealing with an object */ - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - - /* here property is a string */ if (opline->extended_value == ZEND_ASSIGN_OBJ && Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); if (zptr != NULL) { /* NULL means no success in getting PTR */ SEPARATE_ZVAL_IF_NOT_REF(zptr); have_get_ptr = 1; - binary_op(*zptr, *zptr, value TSRMLS_CC); + binary_op(zptr, zptr, value TSRMLS_CC); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(*zptr); - EX_T(opline->result.var).var.ptr = *zptr; + ZVAL_COPY(EX_VAR(opline->result.var), zptr); } } } if (!have_get_ptr) { zval *z = NULL; + zval rv; if (opline->extended_value == ZEND_ASSIGN_OBJ) { if (Z_OBJ_HT_P(object)->read_property) { - z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC); } } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { if (Z_OBJ_HT_P(object)->read_dimension) { - z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC); + z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R, &rv TSRMLS_CC); } } if (z) { if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); zval_dtor(z); - FREE_ZVAL(z); } - z = value; + ZVAL_COPY_VALUE(z, value); } - Z_ADDREF_P(z); - SEPARATE_ZVAL_IF_NOT_REF(&z); +//??? if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); + SEPARATE_ZVAL_IF_NOT_REF(z); binary_op(z, z, value TSRMLS_CC); if (opline->extended_value == ZEND_ASSIGN_OBJ) { - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(z); - EX_T(opline->result.var).var.ptr = z; + ZVAL_COPY(EX_VAR(opline->result.var), z); } - zval_ptr_dtor(&z); + zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to assign property of non-object"); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } } } - if (0) { - zval_ptr_dtor(&property); - } else { - zval_ptr_dtor_nogc(&free_op2.var); - } + zval_ptr_dtor_nogc(free_op2.var); FREE_OP(free_op_data1); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; /* assign_obj has two opcodes! */ CHECK_EXCEPTION(); ZEND_VM_INC_OPCODE(); ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_VAR_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_free_op free_op1, free_op2, free_op_data2, free_op_data1; - zval **var_ptr; - zval *value; + zval *var_ptr; + zval *value, *container; SAVE_OPLINE(); - switch (opline->extended_value) { - case ZEND_ASSIGN_OBJ: - return zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - break; - case ZEND_ASSIGN_DIM: { - zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); - } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) { - if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) { - Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */ - } - return zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - } else { - zval *dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { + zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); + } else if (UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { + if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) { + Z_ADDREF_P(container); /* undo the effect of get_obj_zval_ptr_ptr() */ + } + return zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else { + zval *dim = _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_VAR, BP_VAR_RW TSRMLS_CC); - value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); - var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); - } - } - break; - default: - value = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - /* do nothing */ - break; + zend_fetch_dimension_address_RW(EX_VAR((opline+1)->op2.var), container, dim, IS_VAR TSRMLS_CC); + value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); + var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); } - if (UNEXPECTED(var_ptr == NULL)) { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); } - if (UNEXPECTED(*var_ptr == &EG(error_zval))) { - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - } - zval_ptr_dtor_nogc(&free_op2.var); - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - CHECK_EXCEPTION(); - if (opline->extended_value == ZEND_ASSIGN_DIM) { - ZEND_VM_INC_OPCODE(); + if (UNEXPECTED(var_ptr == &EG(error_zval))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); } - ZEND_VM_NEXT_OPCODE(); + goto assign_op_dim_exit; } SEPARATE_ZVAL_IF_NOT_REF(var_ptr); + ZVAL_DEREF(var_ptr); - if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) - && Z_OBJ_HANDLER_PP(var_ptr, get) - && Z_OBJ_HANDLER_PP(var_ptr, set)) { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) && + UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) { /* proxy object */ - zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); + zval rv; + zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC); Z_ADDREF_P(objval); binary_op(objval, objval, value TSRMLS_CC); - Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC); - zval_ptr_dtor(&objval); + Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); + zval_ptr_dtor(objval); } else { - binary_op(*var_ptr, *var_ptr, value TSRMLS_CC); + binary_op(var_ptr, var_ptr, value TSRMLS_CC); } - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(*var_ptr); - EX_T(opline->result.var).var.ptr = *var_ptr; + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } - zval_ptr_dtor_nogc(&free_op2.var); - if (opline->extended_value == ZEND_ASSIGN_DIM) { - FREE_OP(free_op_data1); - FREE_OP_VAR_PTR(free_op_data2); - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - CHECK_EXCEPTION(); - ZEND_VM_INC_OPCODE(); +assign_op_dim_exit: + zval_ptr_dtor_nogc(free_op2.var); + FREE_OP(free_op_data1); + FREE_OP_VAR_PTR(free_op_data2); + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; + CHECK_EXCEPTION(); + ZEND_VM_INC_OPCODE(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_free_op free_op1, free_op2; + zval *var_ptr; + zval *value; + + SAVE_OPLINE(); + value = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { + zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); + } + + if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } + goto assign_op_exit; + } + + SEPARATE_ZVAL_IF_NOT_REF(var_ptr); + ZVAL_DEREF(var_ptr); + + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) && + UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) { + /* proxy object */ + zval rv; + zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC); + Z_ADDREF_P(objval); + binary_op(objval, objval, value TSRMLS_CC); + Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); + zval_ptr_dtor(objval); } else { - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - CHECK_EXCEPTION(); + binary_op(var_ptr, var_ptr, value TSRMLS_CC); + } + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } + +assign_op_exit: + zval_ptr_dtor_nogc(free_op2.var); + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; + CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_VAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_VAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_VAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_VAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_VAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_VAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_VAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_VAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_VAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_VAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_VAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_VAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_VAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_VAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_VAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_VAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_VAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_VAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_VAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_VAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_VAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_VAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_VAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_VAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_VAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_VAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_VAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_VAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_VAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_VAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_VAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_VAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_VAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_VAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_free_op free_op1, free_op2; - zval **object_ptr; zval *object; zval *property; - zval **retval; + zval *retval; int have_get_ptr = 0; SAVE_OPLINE(); - object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - retval = &EX_T(opline->result.var).var.ptr; + retval = EX_VAR(opline->result.var); - if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } - make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ - object = *object_ptr; + object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */ if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - *retval = &EG(uninitialized_zval); + ZVAL_NULL(retval); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } /* here we are sure we are dealing with an object */ - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); if (zptr != NULL) { /* NULL means no success in getting PTR */ SEPARATE_ZVAL_IF_NOT_REF(zptr); have_get_ptr = 1; - incdec_op(*zptr); + incdec_op(zptr); if (RETURN_VALUE_USED(opline)) { - *retval = *zptr; - PZVAL_LOCK(*retval); + ZVAL_COPY(retval, zptr); } } } if (!have_get_ptr) { + zval rv; + if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC); if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); zval_dtor(z); - FREE_ZVAL(z); } - z = value; + ZVAL_COPY_VALUE(z, value); } - Z_ADDREF_P(z); - SEPARATE_ZVAL_IF_NOT_REF(&z); + if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); + SEPARATE_ZVAL_IF_NOT_REF(z); incdec_op(z); - *retval = z; - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - SELECTIVE_PZVAL_LOCK(*retval, opline); - zval_ptr_dtor(&z); + ZVAL_COPY_VALUE(retval, z); + Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); + SELECTIVE_PZVAL_LOCK(retval, opline); + zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - *retval = &EG(uninitialized_zval); + ZVAL_NULL(retval); } } } - if (0) { - zval_ptr_dtor(&property); - } else { - zval_ptr_dtor_nogc(&free_op2.var); - } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + zval_ptr_dtor_nogc(free_op2.var); + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -19431,90 +18783,76 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_VAR(incdec_t { USE_OPLINE zend_free_op free_op1, free_op2; - zval **object_ptr; zval *object; zval *property; zval *retval; int have_get_ptr = 0; SAVE_OPLINE(); - object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - retval = &EX_T(opline->result.var).tmp_var; + retval = EX_VAR(opline->result.var); - if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } - make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ - object = *object_ptr; + object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */ if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); ZVAL_NULL(retval); - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } /* here we are sure we are dealing with an object */ - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); if (zptr != NULL) { /* NULL means no success in getting PTR */ have_get_ptr = 1; SEPARATE_ZVAL_IF_NOT_REF(zptr); - ZVAL_COPY_VALUE(retval, *zptr); - zendi_zval_copy_ctor(*retval); + ZVAL_DUP(retval, zptr); - incdec_op(*zptr); + incdec_op(zptr); } } if (!have_get_ptr) { if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - zval *z_copy; + zval rv; + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC); + zval z_copy; if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); zval_dtor(z); - FREE_ZVAL(z); } - z = value; + ZVAL_COPY_VALUE(z, value); } - ZVAL_COPY_VALUE(retval, z); - zendi_zval_copy_ctor(*retval); - ALLOC_ZVAL(z_copy); - INIT_PZVAL_COPY(z_copy, z); - zendi_zval_copy_ctor(*z_copy); - incdec_op(z_copy); - Z_ADDREF_P(z); - Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + ZVAL_DUP(retval, z); + ZVAL_DUP(&z_copy, z); + incdec_op(&z_copy); + if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); + Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); zval_ptr_dtor(&z_copy); - zval_ptr_dtor(&z); + zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); ZVAL_NULL(retval); } } - if (0) { - zval_ptr_dtor(&property); - } else { - zval_ptr_dtor_nogc(&free_op2.var); - } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + zval_ptr_dtor_nogc(free_op2.var); + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -19534,19 +18872,16 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_VAR(int type, ZE USE_OPLINE zend_free_op free_op1; zval *varname; - zval **retval; + zval *retval; zval tmp_varname; HashTable *target_symbol_table; - ulong hash_value; SAVE_OPLINE(); varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + ZVAL_UNDEF(&tmp_varname); if (IS_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) { - ZVAL_COPY_VALUE(&tmp_varname, varname); - zval_copy_ctor(&tmp_varname); - Z_SET_REFCOUNT(tmp_varname, 1); - Z_UNSET_ISREF(tmp_varname); + ZVAL_DUP_DEREF(&tmp_varname, varname); convert_to_string(&tmp_varname); varname = &tmp_varname; } @@ -19555,105 +18890,88 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_VAR(int type, ZE zend_class_entry *ce; if (IS_VAR == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { - if (IS_VAR != IS_CONST && varname == &tmp_varname) { + if (IS_VAR != IS_CONST) { zval_dtor(&tmp_varname); } - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(opline->op2.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); } } else { - ce = EX_T(opline->op2.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op2.var)); } - retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); } else { target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); -/* - if (!target_symbol_table) { - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); - } -*/ - if (IS_VAR == IS_CONST) { - hash_value = Z_HASH_P(varname); - } else { - hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname)); - } - - if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) { + retval = zend_hash_find(target_symbol_table, Z_STR_P(varname)); + if (retval == NULL) { switch (type) { case BP_VAR_R: case BP_VAR_UNSET: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); /* break missing intentionally */ case BP_VAR_IS: - retval = &EG(uninitialized_zval_ptr); + retval = EX_VAR(opline->result.var); + ZVAL_NULL(retval); break; case BP_VAR_RW: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); /* break missing intentionally */ case BP_VAR_W: - Z_ADDREF_P(&EG(uninitialized_zval)); - zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval); + retval = zend_hash_update(target_symbol_table, Z_STR_P(varname), &EG(uninitialized_zval)); break; EMPTY_SWITCH_DEFAULT_CASE() } - } - switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) { - case ZEND_FETCH_GLOBAL: - if (IS_VAR != IS_TMP_VAR) { - zval_ptr_dtor_nogc(&free_op1.var); - } - break; - case ZEND_FETCH_LOCAL: - zval_ptr_dtor_nogc(&free_op1.var); - break; - case ZEND_FETCH_STATIC: - zval_update_constant(retval, 1 TSRMLS_CC); - break; - case ZEND_FETCH_GLOBAL_LOCK: - if (IS_VAR == IS_VAR && !free_op1.var) { - PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); + /* GLOBAL or $$name variable may be an INDIRECT pointer to CV */ + } else if (Z_TYPE_P(retval) == IS_INDIRECT) { + retval = Z_INDIRECT_P(retval); + if (Z_TYPE_P(retval) == IS_UNDEF) { + switch (type) { + case BP_VAR_R: + case BP_VAR_UNSET: + zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); + /* break missing intentionally */ + case BP_VAR_IS: + retval = EX_VAR(opline->result.var); + ZVAL_NULL(retval); + break; + case BP_VAR_RW: + zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); + /* break missing intentionally */ + case BP_VAR_W: + ZVAL_NULL(retval); + break; + EMPTY_SWITCH_DEFAULT_CASE() } - break; + } + } + if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC) { + zval_update_constant(retval, 1 TSRMLS_CC); + } else if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) != ZEND_FETCH_GLOBAL_LOCK) { + zval_ptr_dtor_nogc(free_op1.var); } } - - if (IS_VAR != IS_CONST && varname == &tmp_varname) { + if (IS_VAR != IS_CONST) { zval_dtor(&tmp_varname); } - if (opline->extended_value & ZEND_FETCH_MAKE_REF) { - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval); - } - PZVAL_LOCK(*retval); - switch (type) { - case BP_VAR_R: - case BP_VAR_IS: - EX_T(opline->result.var).var.ptr = *retval; - break; - case BP_VAR_UNSET: { - zend_free_op free_res; - PZVAL_UNLOCK(*retval, &free_res); - if (retval != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(retval); - } - PZVAL_LOCK(*retval); - FREE_OP_VAR_PTR(free_res); + ZEND_ASSERT(retval != NULL); + if (type == BP_VAR_R || type == BP_VAR_IS) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); + } else { + if (/*type == BP_VAR_W &&*/ (opline->extended_value & ZEND_FETCH_MAKE_REF)) { + SEPARATE_ZVAL_TO_MAKE_IS_REF(retval); } - /* break missing intentionally */ - default: - EX_T(opline->result.var).var.ptr_ptr = retval; - break; + ZVAL_INDIRECT(EX_VAR(opline->result.var), retval); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -19678,7 +18996,11 @@ static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_H { USE_OPLINE - return zend_fetch_var_address_helper_SPEC_VAR_VAR(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { + return zend_fetch_var_address_helper_SPEC_VAR_VAR(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else { + return zend_fetch_var_address_helper_SPEC_VAR_VAR(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -19699,10 +19021,10 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HAND SAVE_OPLINE(); container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC); + zval_ptr_dtor_nogc(free_op2.var); if (IS_VAR != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) { - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -19712,32 +19034,24 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HAND { USE_OPLINE zend_free_op free_op1, free_op2; - zval **container; + zval *container; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_W TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); - if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + if (EXPECTED(opline->extended_value == 0)) { + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC); + } else { + zend_fetch_dimension_address_W_ref(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - - /* We are going to assign the result by reference */ - if (UNEXPECTED(opline->extended_value != 0)) { - zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; - - if (retval_ptr) { - Z_DELREF_PP(retval_ptr); - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); - Z_ADDREF_PP(retval_ptr); - } + zval_ptr_dtor_nogc(free_op2.var); + if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -19746,20 +19060,20 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HAN { USE_OPLINE zend_free_op free_op1, free_op2; - zval **container; + zval *container; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_RW TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC); + zval_ptr_dtor_nogc(free_op2.var); if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -19772,9 +19086,9 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HAN SAVE_OPLINE(); container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_IS TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); - zval_ptr_dtor_nogc(&free_op1.var); + zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC); + zval_ptr_dtor_nogc(free_op2.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -19782,31 +19096,30 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HAN static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE + zval *container; zend_free_op free_op1, free_op2; SAVE_OPLINE(); if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { - zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_W TSRMLS_CC); + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC); if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - zval_ptr_dtor_nogc(&free_op2.var); - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + zval_ptr_dtor_nogc(free_op2.var); + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; } else { - zval *container; - if (IS_VAR == IS_UNUSED) { zend_error_noreturn(E_ERROR, "Cannot use [] for reading"); } container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); - zval_ptr_dtor_nogc(&free_op1.var); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC); + zval_ptr_dtor_nogc(free_op2.var); + zval_ptr_dtor_nogc(free_op1.var); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -19816,41 +19129,22 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_ { USE_OPLINE zend_free_op free_op1, free_op2; - zval **container; + zval *container; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_CV) { - if (container != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(container); - } - } - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_UNSET TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC); + zval_ptr_dtor_nogc(free_op2.var); if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); - } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); - ZEND_VM_NEXT_OPCODE(); - } else { - zend_free_op free_res; - zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; - - PZVAL_UNLOCK(*retval_ptr, &free_res); - if (retval_ptr != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(retval_ptr); - } - PZVAL_LOCK(*retval_ptr); - FREE_OP_VAR_PTR(free_res); - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_VAR(ZEND_OPCODE_HANDLER_ARGS) @@ -19862,36 +19156,26 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_VAR(ZE zval *offset; SAVE_OPLINE(); - container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { zend_error(E_NOTICE, "Trying to get property of non-object"); - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - zval_ptr_dtor_nogc(&free_op2.var); + ZVAL_NULL(EX_VAR(opline->result.var)); } else { zval *retval; - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - /* here we are sure we are dealing with an object */ - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC); - PZVAL_LOCK(retval); - EX_T(opline->result.var).var.ptr = retval; - - if (0) { - zval_ptr_dtor(&offset); - } else { - zval_ptr_dtor_nogc(&free_op2.var); + if (retval != EX_VAR(opline->result.var)) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); } } - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op2.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -19906,41 +19190,22 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HAND USE_OPLINE zend_free_op free_op1, free_op2; zval *property; - zval **container; + zval *container; SAVE_OPLINE(); property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property); - } else { - zval_ptr_dtor_nogc(&free_op2.var); - } + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC); + zval_ptr_dtor_nogc(free_op2.var); if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); - } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - - /* We are going to assign the result by reference */ - if (opline->extended_value & ZEND_FETCH_MAKE_REF) { - zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; - - Z_DELREF_PP(retval_ptr); - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); - Z_ADDREF_PP(retval_ptr); - EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr; - EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -19950,28 +19215,21 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HAN USE_OPLINE zend_free_op free_op1, free_op2; zval *property; - zval **container; + zval *container; SAVE_OPLINE(); property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property); - } else { - zval_ptr_dtor_nogc(&free_op2.var); - } + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_RW, 0 TSRMLS_CC); + zval_ptr_dtor_nogc(free_op2.var); if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -19985,35 +19243,25 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HAN zval *offset; SAVE_OPLINE(); - container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - zval_ptr_dtor_nogc(&free_op2.var); + ZVAL_NULL(EX_VAR(opline->result.var)); } else { zval *retval; - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - /* here we are sure we are dealing with an object */ - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - - PZVAL_LOCK(retval); - EX_T(opline->result.var).var.ptr = retval; + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC); - if (0) { - zval_ptr_dtor(&offset); - } else { - zval_ptr_dtor_nogc(&free_op2.var); + if (retval != EX_VAR(opline->result.var)) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); } } - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op2.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -20021,33 +19269,26 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HAN static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE + zval *container; if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { /* Behave like FETCH_OBJ_W */ zend_free_op free_op1, free_op2; zval *property; - zval **container; SAVE_OPLINE(); property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property); - } else { - zval_ptr_dtor_nogc(&free_op2.var); - } + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, 0 TSRMLS_CC); + zval_ptr_dtor_nogc(free_op2.var); if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } else { @@ -20058,42 +19299,22 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_VAR_HANDLER(ZEND_OPCO static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_free_op free_op1, free_op2, free_res; - zval **container; - zval *property; + zend_free_op free_op1, free_op2; + zval *container, *property; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (IS_VAR == IS_CV) { - if (container != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(container); - } - } - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property); - } else { - zval_ptr_dtor_nogc(&free_op2.var); - } + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_UNSET, 0 TSRMLS_CC); + zval_ptr_dtor_nogc(free_op2.var); if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); - } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - - PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res); - if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr); - FREE_OP_VAR_PTR(free_res); + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -20102,26 +19323,19 @@ static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDL { USE_OPLINE zend_free_op free_op1, free_op2; - zval **object_ptr; + zval *object; zval *property_name; SAVE_OPLINE(); - object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (0) { - MAKE_REAL_ZVAL_PTR(property_name); - } - if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property_name); - } else { - zval_ptr_dtor_nogc(&free_op2.var); - } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op2.var); + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; /* assign_obj has two opcodes! */ CHECK_EXCEPTION(); ZEND_VM_INC_OPCODE(); @@ -20132,77 +19346,60 @@ static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDL { USE_OPLINE zend_free_op free_op1; - zval **object_ptr; + zval *object_ptr; SAVE_OPLINE(); object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - if (Z_TYPE_PP(object_ptr) == IS_OBJECT) { + if (UNEXPECTED(Z_ISREF_P(object_ptr)) && Z_TYPE_P(Z_REFVAL_P(object_ptr)) == IS_OBJECT) { + object_ptr = Z_REFVAL_P(object_ptr); + } + if (Z_TYPE_P(object_ptr) == IS_OBJECT) { zend_free_op free_op2; zval *property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (0) { - MAKE_REAL_ZVAL_PTR(property_name); - } - zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property_name); - } else { - zval_ptr_dtor_nogc(&free_op2.var); - } + zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op2.var); } else { zend_free_op free_op2, free_op_data1, free_op_data2; zval *value; - zval *dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - zval **variable_ptr_ptr; + zval *dim = _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + zval *variable_ptr; - zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_VAR, BP_VAR_W TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zend_fetch_dimension_address_W(EX_VAR((opline+1)->op2.var), object_ptr, dim, IS_VAR TSRMLS_CC); + zval_ptr_dtor_nogc(free_op2.var); value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); - variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); - if (UNEXPECTED(variable_ptr_ptr == NULL)) { - if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) { - if (RETURN_VALUE_USED(opline)) { - zval *retval; - - ALLOC_ZVAL(retval); - ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1); - INIT_PZVAL(retval); - EX_T(opline->result.var).var.ptr = retval; - } - } else if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - } - } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) { + variable_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); + if (UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) { + zend_assign_to_string_offset(variable_ptr, value, (opline+1)->op1_type, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC); + } else if (UNEXPECTED(variable_ptr == &EG(error_zval))) { if (IS_TMP_FREE(free_op_data1)) { zval_dtor(value); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } + FREE_OP_VAR_PTR(free_op_data2); } else { if ((opline+1)->op1_type == IS_TMP_VAR) { - value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_tmp_to_variable(variable_ptr, value TSRMLS_CC); } else if ((opline+1)->op1_type == IS_CONST) { - value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_const_to_variable(variable_ptr, value TSRMLS_CC); } else { - value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_to_variable(variable_ptr, value TSRMLS_CC); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(value); - EX_T(opline->result.var).var.ptr = value; + ZVAL_COPY(EX_VAR(opline->result.var), value); } + FREE_OP_VAR_PTR(free_op_data2); } - FREE_OP_VAR_PTR(free_op_data2); FREE_OP_IF_VAR(free_op_data1); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; /* assign_dim has two opcodes! */ CHECK_EXCEPTION(); ZEND_VM_INC_OPCODE(); @@ -20214,52 +19411,37 @@ static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_A USE_OPLINE zend_free_op free_op1, free_op2; zval *value; - zval **variable_ptr_ptr; + zval *variable_ptr; SAVE_OPLINE(); value = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - variable_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - - if (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) { - if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_VAR TSRMLS_CC)) { - if (RETURN_VALUE_USED(opline)) { - zval *retval; + variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - ALLOC_ZVAL(retval); - ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1); - INIT_PZVAL(retval); - EX_T(opline->result.var).var.ptr = retval; - } - } else if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - } - } else if (IS_VAR == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) { + zend_assign_to_string_offset(variable_ptr, value, IS_VAR, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC); + } else if (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) { if (0) { zval_dtor(value); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } } else { if (IS_VAR == IS_TMP_VAR) { - value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_tmp_to_variable(variable_ptr, value TSRMLS_CC); } else if (IS_VAR == IS_CONST) { - value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_const_to_variable(variable_ptr, value TSRMLS_CC); } else { - value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_to_variable(variable_ptr, value TSRMLS_CC); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(value); - EX_T(opline->result.var).var.ptr = value; + ZVAL_COPY(EX_VAR(opline->result.var), value); } + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - /* zend_assign_to_variable() always takes care of op2, never free it! */ - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -20269,51 +19451,60 @@ static int ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDL { USE_OPLINE zend_free_op free_op1, free_op2; - zval **variable_ptr_ptr; - zval **value_ptr_ptr; + zval *variable_ptr; + zval *value_ptr; SAVE_OPLINE(); - value_ptr_ptr = _get_zval_ptr_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + value_ptr = _get_zval_ptr_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); if (IS_VAR == IS_VAR && - value_ptr_ptr && - !Z_ISREF_PP(value_ptr_ptr) && opline->extended_value == ZEND_RETURNS_FUNCTION && - !EX_T(opline->op2.var).var.fcall_returned_reference) { - if (free_op2.var == NULL) { - PZVAL_LOCK(*value_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */ + !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF) && + !Z_ISREF_P(value_ptr)) { + if (!(free_op2.var != NULL)) { + PZVAL_LOCK(value_ptr); /* undo the effect of get_zval_ptr_ptr() */ } zend_error(E_STRICT, "Only variables should be assigned by reference"); if (UNEXPECTED(EG(exception) != NULL)) { - if (free_op2.var) {zval_ptr_dtor_nogc(&free_op2.var);}; + if (free_op2.var) {zval_ptr_dtor_nogc(free_op2.var);}; HANDLE_EXCEPTION(); } return ZEND_ASSIGN_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } else if (IS_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) { - PZVAL_LOCK(*value_ptr_ptr); + if (!(free_op2.var != NULL)) { + PZVAL_LOCK(value_ptr); + } } - if (IS_VAR == IS_VAR && UNEXPECTED(EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr)) { + + variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + if (IS_VAR == IS_VAR && + UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT) && + UNEXPECTED(!Z_ISREF_P(variable_ptr))) { zend_error_noreturn(E_ERROR, "Cannot assign by reference to overloaded object"); } - - variable_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if ((IS_VAR == IS_VAR && UNEXPECTED(value_ptr_ptr == NULL)) || - (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL))) { + if ((IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) || + (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET))) { zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets nor overloaded objects"); } - zend_assign_to_variable_reference(variable_ptr_ptr, value_ptr_ptr TSRMLS_CC); + if ((IS_VAR == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) || + (IS_VAR == IS_VAR && UNEXPECTED(value_ptr == &EG(error_zval)))) { + variable_ptr = &EG(uninitialized_zval); + } else { + zend_assign_to_variable_reference(variable_ptr, value_ptr TSRMLS_CC); + } if (IS_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) { - Z_DELREF_PP(variable_ptr_ptr); + if (!(free_op2.var != NULL)) { + Z_DELREF_P(variable_ptr); + } } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(*variable_ptr_ptr); - EX_T(opline->result.var).var.ptr = *variable_ptr_ptr; + ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - if (free_op2.var) {zval_ptr_dtor_nogc(&free_op2.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; + if (free_op2.var) {zval_ptr_dtor_nogc(free_op2.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -20323,10 +19514,9 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE { USE_OPLINE zval *function_name; - char *function_name_strval; - int function_name_strlen; zend_free_op free_op1, free_op2; call_slot *call = EX(call_slots) + opline->result.num; + zval *object; SAVE_OPLINE(); @@ -20340,63 +19530,52 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE zend_error_noreturn(E_ERROR, "Method name must be a string"); } - function_name_strval = Z_STRVAL_P(function_name); - function_name_strlen = Z_STRLEN_P(function_name); + object = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL; - call->object = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - - if (EXPECTED(call->object != NULL) && - EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) { - call->called_scope = Z_OBJCE_P(call->object); + if (EXPECTED(call->object != NULL)) { + call->called_scope = zend_get_class_entry(call->object TSRMLS_CC); if (IS_VAR != IS_CONST || - (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) { - zval *object = call->object; + (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope)) == NULL) { + zend_object *object = call->object; - if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) { + if (UNEXPECTED(object->handlers->get_method == NULL)) { zend_error_noreturn(E_ERROR, "Object does not support method calls"); } /* First, locate the function. */ - call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); + call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_VAR == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); if (UNEXPECTED(call->fbc == NULL)) { - zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval); + zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name)); } if (IS_VAR == IS_CONST && EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) && EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) && EXPECTED(call->object == object)) { - CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc); + CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope, call->fbc); } } } else { if (UNEXPECTED(EG(exception) != NULL)) { - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); HANDLE_EXCEPTION(); } - zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval); + zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", Z_STRVAL_P(function_name)); } if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) { call->object = NULL; } else { - if (!PZVAL_IS_REF(call->object)) { - Z_ADDREF_P(call->object); /* For $this pointer */ - } else { - zval *this_ptr; - ALLOC_ZVAL(this_ptr); - INIT_PZVAL_COPY(this_ptr, call->object); - zval_copy_ctor(this_ptr); - call->object = this_ptr; - } + GC_REFCOUNT(call->object)++; /* For $this pointer */ } call->num_additional_args = 0; call->is_ctor_call = 0; EX(call) = call; - zval_ptr_dtor_nogc(&free_op2.var); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op2.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -20413,21 +19592,21 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_VAR_HANDLER(ZEND if (IS_VAR == IS_CONST) { /* no function found. try a static method in class */ - if (CACHED_PTR(opline->op1.literal->cache_slot)) { - ce = CACHED_PTR(opline->op1.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } if (UNEXPECTED(ce == NULL)) { zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv)); } - CACHE_PTR(opline->op1.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce); } call->called_scope = ce; } else { - ce = EX_T(opline->op1.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op1.var)); if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) { call->called_scope = EG(called_scope); @@ -20438,62 +19617,51 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_VAR_HANDLER(ZEND if (IS_VAR == IS_CONST && IS_VAR == IS_CONST && - CACHED_PTR(opline->op2.literal->cache_slot)) { - call->fbc = CACHED_PTR(opline->op2.literal->cache_slot); + CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else if (IS_VAR != IS_CONST && IS_VAR == IS_CONST && - (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) { + (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce))) { /* do nothing */ } else if (IS_VAR != IS_UNUSED) { - char *function_name_strval = NULL; - int function_name_strlen = 0; zend_free_op free_op2; - if (IS_VAR == IS_CONST) { - function_name_strval = Z_STRVAL_P(opline->op2.zv); - function_name_strlen = Z_STRLEN_P(opline->op2.zv); - } else { - function_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - + function_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + if (IS_VAR != IS_CONST) { if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } zend_error_noreturn(E_ERROR, "Function name must be a string"); - } else { - function_name_strval = Z_STRVAL_P(function_name); - function_name_strlen = Z_STRLEN_P(function_name); } } - if (function_name_strval) { - if (ce->get_static_method) { - call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC); + if (ce->get_static_method) { + call->fbc = ce->get_static_method(ce, Z_STR_P(function_name) TSRMLS_CC); + } else { + call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_VAR == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); + } + if (UNEXPECTED(call->fbc == NULL)) { + zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name)); + } + if (IS_VAR == IS_CONST && + EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) && + EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) { + if (IS_VAR == IS_CONST) { + CACHE_PTR(Z_CACHE_SLOT_P(function_name), call->fbc); } else { - call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); - } - if (UNEXPECTED(call->fbc == NULL)) { - zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval); - } - if (IS_VAR == IS_CONST && - EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) && - EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) { - if (IS_VAR == IS_CONST) { - CACHE_PTR(opline->op2.literal->cache_slot, call->fbc); - } else { - CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc); - } + CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), ce, call->fbc); } } if (IS_VAR != IS_CONST) { - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); } } else { if (UNEXPECTED(ce->constructor == NULL)) { zend_error_noreturn(E_ERROR, "Cannot call constructor"); } - if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { - zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name); + if (Z_OBJ(EG(This)) && Z_OBJCE(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { + zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name->val); } call->fbc = ce->constructor; } @@ -20501,21 +19669,21 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_VAR_HANDLER(ZEND if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) { call->object = NULL; } else { - if (EG(This) && - Z_OBJ_HT_P(EG(This))->get_class_entry && - !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) { + if (Z_OBJ(EG(This)) && + Z_OBJ_HT(EG(This))->get_class_entry && + !instanceof_function(Z_OBJCE(EG(This)), ce TSRMLS_CC)) { /* We are calling method of the other (incompatible) class, but passing $this. This is done for compatibility with php-4. */ if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { - zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name); + zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val); } else { /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */ - zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name); + zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val); } } - if ((call->object = EG(This))) { - Z_ADDREF_P(call->object); - call->called_scope = Z_OBJCE_P(call->object); + call->object = Z_OBJ(EG(This)); + if (call->object) { + GC_REFCOUNT(call->object)++; } } @@ -20531,13 +19699,14 @@ static int ZEND_FASTCALL ZEND_CASE_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG { USE_OPLINE zend_free_op free_op1, free_op2; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - is_equal_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + fast_equal_function(result, + _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -20546,35 +19715,31 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_VAR_HANDLER(ZEND_OPCOD { USE_OPLINE zend_free_op free_op1; - zval *expr_ptr; + zval *expr_ptr, new_expr; SAVE_OPLINE(); - if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) { - zval **expr_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - - if (IS_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) { + if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && + (opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) { + expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets"); } - SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); - expr_ptr = *expr_ptr_ptr; + SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr); Z_ADDREF_P(expr_ptr); + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; } else { - expr_ptr=_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + expr_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (0) { /* temporary variable */ - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - } else if (IS_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) { - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - zendi_zval_copy_ctor(*expr_ptr); - zval_ptr_dtor_nogc(&free_op1.var); - } else if (IS_VAR == IS_CV) { + ZVAL_COPY_VALUE(&new_expr, expr_ptr); + expr_ptr = &new_expr; + } else if (IS_VAR == IS_CONST) { + ZVAL_DUP(&new_expr, expr_ptr); + expr_ptr = &new_expr; + } else if (Z_ISREF_P(expr_ptr)) { + ZVAL_DUP(&new_expr, Z_REFVAL_P(expr_ptr)); + expr_ptr = &new_expr; + zval_ptr_dtor_nogc(free_op1.var); + } else if (IS_VAR == IS_CV && Z_REFCOUNTED_P(expr_ptr)) { Z_ADDREF_P(expr_ptr); } } @@ -20582,42 +19747,49 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_VAR_HANDLER(ZEND_OPCOD if (IS_VAR != IS_UNUSED) { zend_free_op free_op2; zval *offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + zend_string *str; ulong hval; +add_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: hval = zend_dval_to_lval(Z_DVAL_P(offset)); goto num_index; case IS_LONG: - case IS_BOOL: hval = Z_LVAL_P(offset); num_index: - zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL); + zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); break; case IS_STRING: - if (IS_VAR == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); + str = Z_STR_P(offset); + if (IS_VAR != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index); } - zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL); +str_index: + zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); break; case IS_NULL: - zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); + str = STR_EMPTY_ALLOC(); + goto str_index; + case IS_FALSE: + hval = 0; + goto num_index; + case IS_TRUE: + hval = 1; + goto num_index; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto add_again; break; default: zend_error(E_WARNING, "Illegal offset type"); - zval_ptr_dtor(&expr_ptr); + zval_ptr_dtor(expr_ptr); /* do nothing */ break; } - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); } else { - zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL); - } - if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) { - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -20625,9 +19797,26 @@ num_index: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { + zval *array; + zend_uint size; USE_OPLINE - array_init(&EX_T(opline->result.var).tmp_var); + array = EX_VAR(opline->result.var); + if (IS_VAR != IS_UNUSED) { + size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; + } else { + size = 0; + } + ZVAL_NEW_ARR(array); + zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); + + if (IS_VAR != IS_UNUSED) { + /* Explicitly initialize array as not-packed if flag is set */ + if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) { + zend_hash_real_init(Z_ARRVAL_P(array), 0); + } + } + if (IS_VAR == IS_UNUSED) { ZEND_VM_NEXT_OPCODE(); #if 0 || IS_VAR != IS_UNUSED @@ -20643,20 +19832,15 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLE zval tmp, *varname; HashTable *target_symbol_table; zend_free_op free_op1; + zend_bool tmp_is_dup = 0; SAVE_OPLINE(); if (IS_VAR == IS_CV && IS_VAR == IS_UNUSED && (opline->extended_value & ZEND_QUICK_SET)) { - if (EG(active_symbol_table)) { - zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); - - zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC); - EX_CV(opline->op1.var) = NULL; - } else if (EX_CV(opline->op1.var)) { - zval_ptr_dtor(EX_CV(opline->op1.var)); - EX_CV(opline->op1.var) = NULL; - } + ZVAL_COPY_VALUE(&tmp, EX_VAR(opline->op1.var)); + ZVAL_UNDEF(EX_VAR(opline->op1.var)); + zval_ptr_dtor(&tmp); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -20664,53 +19848,52 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLE varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { - ZVAL_COPY_VALUE(&tmp, varname); - zval_copy_ctor(&tmp); + ZVAL_DUP(&tmp, varname); convert_to_string(&tmp); varname = &tmp; + tmp_is_dup = 1; } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) { - Z_ADDREF_P(varname); + ZVAL_COPY(&tmp, varname); + varname = &tmp; } if (IS_VAR != IS_UNUSED) { zend_class_entry *ce; if (IS_VAR == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { - if (IS_VAR != IS_CONST && varname == &tmp) { + if (IS_VAR != IS_CONST && tmp_is_dup) { zval_dtor(&tmp); } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) { - zval_ptr_dtor(&varname); + zval_ptr_dtor(&tmp); } - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); HANDLE_EXCEPTION(); } if (UNEXPECTED(ce == NULL)) { zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv)); } - CACHE_PTR(opline->op2.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); } } else { - ce = EX_T(opline->op2.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op2.var)); } - zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); + zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC); } else { - ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1); - target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); - zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC); + zend_hash_del_ind(target_symbol_table, Z_STR_P(varname)); } - if (IS_VAR != IS_CONST && varname == &tmp) { + if (IS_VAR != IS_CONST && tmp_is_dup) { zval_dtor(&tmp); } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) { - zval_ptr_dtor(&varname); + zval_ptr_dtor(&tmp); } - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -20719,94 +19902,100 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLE { USE_OPLINE zend_free_op free_op1, free_op2; - zval **container; + zval *container; zval *offset; ulong hval; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) { + if (IS_VAR != IS_UNUSED) { SEPARATE_ZVAL_IF_NOT_REF(container); } offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (IS_VAR != IS_VAR || container) { - switch (Z_TYPE_PP(container)) { - case IS_ARRAY: { - HashTable *ht = Z_ARRVAL_PP(container); - - switch (Z_TYPE_P(offset)) { - case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); - zend_hash_index_del(ht, hval); - break; - case IS_RESOURCE: - case IS_BOOL: - case IS_LONG: - hval = Z_LVAL_P(offset); - zend_hash_index_del(ht, hval); - break; - case IS_STRING: - if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { - Z_ADDREF_P(offset); - } - if (IS_VAR == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); - } - if (ht == &EG(symbol_table)) { - zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC); - } else { - zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval); - } - if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { - zval_ptr_dtor(&offset); - } - break; +container_again: + switch (Z_TYPE_P(container)) { + case IS_ARRAY: { + HashTable *ht = Z_ARRVAL_P(container); +offset_again: + switch (Z_TYPE_P(offset)) { + case IS_DOUBLE: + hval = zend_dval_to_lval(Z_DVAL_P(offset)); + zend_hash_index_del(ht, hval); + break; + case IS_LONG: + hval = Z_LVAL_P(offset); num_index_dim: - zend_hash_index_del(ht, hval); - if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { - zval_ptr_dtor(&offset); - } - break; - case IS_NULL: - zend_hash_del(ht, "", sizeof("")); - break; - default: - zend_error(E_WARNING, "Illegal offset type in unset"); - break; - } - zval_ptr_dtor_nogc(&free_op2.var); - break; + zend_hash_index_del(ht, hval); + break; + case IS_STRING: + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset); + } + if (IS_VAR != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto numeric_index_dim); + } + if (ht == &EG(symbol_table).ht) { + zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC); + } else { + zend_hash_del(ht, Z_STR_P(offset)); + } + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + zval_ptr_dtor(offset); + } + break; +numeric_index_dim: + zend_hash_index_del(ht, hval); + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + zval_ptr_dtor(offset); + } + break; + case IS_NULL: + zend_hash_del(ht, STR_EMPTY_ALLOC()); + break; + case IS_FALSE: + hval = 0; + goto num_index_dim; + case IS_TRUE: + hval = 1; + goto num_index_dim; + case IS_RESOURCE: + hval = Z_RES_HANDLE_P(offset); + goto num_index_dim; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto offset_again; + break; + default: + zend_error(E_WARNING, "Illegal offset type in unset"); + break; } - case IS_OBJECT: - if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use object as array"); - } - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC); - if (0) { - zval_ptr_dtor(&offset); - } else { - zval_ptr_dtor_nogc(&free_op2.var); - } - break; - case IS_STRING: - zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); - ZEND_VM_CONTINUE(); /* bailed out before */ - default: - zval_ptr_dtor_nogc(&free_op2.var); - break; + zval_ptr_dtor_nogc(free_op2.var); + break; } - } else { - zval_ptr_dtor_nogc(&free_op2.var); + case IS_OBJECT: + if (UNEXPECTED(Z_OBJ_HT_P(container)->unset_dimension == NULL)) { + zend_error_noreturn(E_ERROR, "Cannot use object as array"); + } +//??? if (IS_VAR == IS_CONST) { +//??? zval_copy_ctor(offset); +//??? } + Z_OBJ_HT_P(container)->unset_dimension(container, offset TSRMLS_CC); + zval_ptr_dtor_nogc(free_op2.var); + break; + case IS_STRING: + case IS_STR_OFFSET: + zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); + ZEND_VM_CONTINUE(); /* bailed out before */ + case IS_REFERENCE: + container = Z_REFVAL_P(container); + goto container_again; + break; + default: + zval_ptr_dtor_nogc(free_op2.var); + break; } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -20815,39 +20004,26 @@ static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLE { USE_OPLINE zend_free_op free_op1, free_op2; - zval **container; + zval *container; zval *offset; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + if (IS_VAR == IS_VAR && Z_TYPE_P(container) == IS_STR_OFFSET) { + zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); + } offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (IS_VAR != IS_VAR || container) { - if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(container); - } - if (Z_TYPE_PP(container) == IS_OBJECT) { - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - if (Z_OBJ_HT_P(*container)->unset_property) { - Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to unset property of non-object"); - } - if (0) { - zval_ptr_dtor(&offset); - } else { - zval_ptr_dtor_nogc(&free_op2.var); - } + ZVAL_DEREF(container); + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->unset_property) { + Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); } else { - zval_ptr_dtor_nogc(&free_op2.var); + zend_error(E_NOTICE, "Trying to unset property of non-object"); } - } else { - zval_ptr_dtor_nogc(&free_op2.var); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - + zval_ptr_dtor_nogc(free_op2.var); + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -20855,21 +20031,16 @@ static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLE static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval **value; + zval *value; zend_bool isset = 1; SAVE_OPLINE(); if (IS_VAR == IS_CV && IS_VAR == IS_UNUSED && (opline->extended_value & ZEND_QUICK_SET)) { - if (EX_CV(opline->op1.var)) { - value = EX_CV(opline->op1.var); - } else if (EG(active_symbol_table)) { - zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); - - if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) { - isset = 0; - } + if (Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_UNDEF) { + value = EX_VAR(opline->op1.var); + ZVAL_DEREF(value); } else { isset = 0; } @@ -20879,8 +20050,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_VAR_HANDLER(ZEND_OPCOD zval tmp, *varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { - ZVAL_COPY_VALUE(&tmp, varname); - zval_copy_ctor(&tmp); + ZVAL_DUP(&tmp, varname); convert_to_string(&tmp); varname = &tmp; } @@ -20889,26 +20059,26 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_VAR_HANDLER(ZEND_OPCOD zend_class_entry *ce; if (IS_VAR == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(opline->op2.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); } } else { - ce = EX_T(opline->op2.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op2.var)); } - value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); + value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC); if (!value) { isset = 0; } } else { target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); - if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) { + if ((value = zend_hash_find(target_symbol_table, Z_STR_P(varname))) == NULL) { isset = 0; } } @@ -20916,20 +20086,20 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_VAR_HANDLER(ZEND_OPCOD if (IS_VAR != IS_CONST && varname == &tmp) { zval_dtor(&tmp); } - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); } if (opline->extended_value & ZEND_ISSET) { - if (isset && Z_TYPE_PP(value) != IS_NULL) { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); + if (isset && Z_TYPE_P(value) != IS_NULL) { + ZVAL_BOOL(EX_VAR(opline->result.var), 1); } else { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); + ZVAL_BOOL(EX_VAR(opline->result.var), 0); } } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { - if (!isset || !i_zend_is_true(*value TSRMLS_CC)) { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); + if (!isset || !i_zend_is_true(value TSRMLS_CC)) { + ZVAL_BOOL(EX_VAR(opline->result.var), 1); } else { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); + ZVAL_BOOL(EX_VAR(opline->result.var), 0); } } @@ -20937,54 +20107,58 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_VAR_HANDLER(ZEND_OPCOD ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_VAR(int prop_dim, ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_free_op free_op1, free_op2; zval *container; - zval **value = NULL; - int result = 0; + int result; ulong hval; zval *offset; SAVE_OPLINE(); - container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) { - HashTable *ht; - int isset = 0; - - ht = Z_ARRVAL_P(container); + if (Z_TYPE_P(container) == IS_ARRAY) { + HashTable *ht = Z_ARRVAL_P(container); + zval *value = NULL; + zend_string *str; +isset_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: hval = zend_dval_to_lval(Z_DVAL_P(offset)); goto num_index_prop; - case IS_RESOURCE: - case IS_BOOL: case IS_LONG: hval = Z_LVAL_P(offset); num_index_prop: - if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) { - isset = 1; - } + value = zend_hash_index_find(ht, hval); break; case IS_STRING: - if (IS_VAR == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); - } - if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) { - isset = 1; + str = Z_STR_P(offset); + if (IS_VAR != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index_prop); } +str_index_prop: + value = zend_hash_find_ind(ht, str); break; case IS_NULL: - if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) { - isset = 1; - } + str = STR_EMPTY_ALLOC(); + goto str_index_prop; + break; + case IS_FALSE: + hval = 0; + goto num_index_prop; + case IS_TRUE: + hval = 0; + goto num_index_prop; + case IS_RESOURCE: + hval = Z_RES_HANDLE_P(offset); + goto num_index_prop; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto isset_again; break; default: zend_error(E_WARNING, "Illegal offset type in isset or empty"); @@ -20992,118 +20166,105 @@ num_index_prop: } if (opline->extended_value & ZEND_ISSET) { - if (isset && Z_TYPE_PP(value) == IS_NULL) { - result = 0; - } else { - result = isset; - } + /* > IS_NULL means not IS_UNDEF and not IS_NULL */ + result = (value != NULL && Z_TYPE_P(value) > IS_NULL); } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { - if (!isset || !i_zend_is_true(*value TSRMLS_CC)) { - result = 0; - } else { - result = 1; - } + result = (value == NULL || !i_zend_is_true(value TSRMLS_CC)); } - zval_ptr_dtor_nogc(&free_op2.var); } else if (Z_TYPE_P(container) == IS_OBJECT) { - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - if (prop_dim) { - if (Z_OBJ_HT_P(container)->has_property) { - result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check property of non-object"); - result = 0; - } + if (Z_OBJ_HT_P(container)->has_dimension) { + result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); } else { - if (Z_OBJ_HT_P(container)->has_dimension) { - result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check element of non-array"); - result = 0; - } + zend_error(E_NOTICE, "Trying to check element of non-array"); + result = 0; } - if (0) { - zval_ptr_dtor(&offset); - } else { - zval_ptr_dtor_nogc(&free_op2.var); + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; } - } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */ + } else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */ zval tmp; - if (Z_TYPE_P(offset) != IS_LONG) { - if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */ + result = 0; + if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) { + if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */ || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { - ZVAL_COPY_VALUE(&tmp, offset); - zval_copy_ctor(&tmp); + ZVAL_DUP(&tmp, offset); convert_to_long(&tmp); offset = &tmp; - } else { - /* can not be converted to proper offset, return "not set" */ - result = 0; } } if (Z_TYPE_P(offset) == IS_LONG) { - if (opline->extended_value & ZEND_ISSET) { - if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { - result = 1; - } - } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { - if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') { + if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { + if ((opline->extended_value & ZEND_ISSET) || + Z_STRVAL_P(container)[offset->value.lval] != '0') { result = 1; } } } - zval_ptr_dtor_nogc(&free_op2.var); - } else { - zval_ptr_dtor_nogc(&free_op2.var); - } - - Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; - if (opline->extended_value & ZEND_ISSET) { - Z_LVAL(EX_T(opline->result.var).tmp_var) = result; + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } } else { - Z_LVAL(EX_T(opline->result.var).tmp_var) = !result; + result = ((opline->extended_value & ZEND_ISSET) == 0); } - zval_ptr_dtor_nogc(&free_op1.var); - + zval_ptr_dtor_nogc(free_op2.var); + ZVAL_BOOL(EX_VAR(opline->result.var), result); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_VAR(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} - static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_VAR(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + zend_free_op free_op1, free_op2; + zval *container; + int result; + zval *offset; + + SAVE_OPLINE(); + container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->has_property) { + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); + } else { + zend_error(E_NOTICE, "Trying to check property of non-object"); + result = 0; + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else { + result = ((opline->extended_value & ZEND_ISSET) == 0); + } + + zval_ptr_dtor_nogc(free_op2.var); + ZVAL_BOOL(EX_VAR(opline->result.var), result); + zval_ptr_dtor_nogc(free_op1.var); + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - /* The generator object is stored in return_value_ptr_ptr */ - zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr); + /* The generator object is stored in EX(return_value) */ + zend_generator *generator = (zend_generator *) EX(return_value); if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) { zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator"); } /* Destroy the previously yielded value */ - if (generator->value) { - zval_ptr_dtor(&generator->value); - } + zval_ptr_dtor(&generator->value); /* Destroy the previously yielded key */ - if (generator->key) { - zval_ptr_dtor(&generator->key); - } + zval_ptr_dtor(&generator->key); /* Set the new yielded value */ if (IS_VAR != IS_UNUSED) { @@ -21113,75 +20274,59 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR /* Constants and temporary variables aren't yieldable by reference, * but we still allow them with a notice. */ if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) { - zval *value, *copy; + zval *value; zend_error(E_NOTICE, "Only variable references should be yielded by reference"); value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); + ZVAL_COPY_VALUE(&generator->value, value); + if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1); /* Temporary variables don't need ctor copying */ if (!0) { - zval_copy_ctor(copy); + zval_copy_ctor(&generator->value); } - - generator->value = copy; } else { - zval **value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference"); } /* If a function call result is yielded and the function did * not return by reference we throw a notice. */ - if (IS_VAR == IS_VAR && !Z_ISREF_PP(value_ptr) + if (IS_VAR == IS_VAR && !Z_ISREF_P(value_ptr) && !(opline->extended_value == ZEND_RETURNS_FUNCTION - && EX_T(opline->op1.var).var.fcall_returned_reference) - && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) { + && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); - - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } else { SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr); - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } + ZVAL_COPY(&generator->value, value_ptr); - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; } } else { zval *value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); /* Consts, temporary variables and references need copying */ - if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR - || PZVAL_IS_REF(value) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); - - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } - - generator->value = copy; - zval_ptr_dtor_nogc(&free_op1.var); + if (IS_VAR == IS_CONST) { + ZVAL_DUP(&generator->value, value); + } else if (IS_VAR == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->value, value); + } else if (Z_ISREF_P(value)) { + ZVAL_DUP(&generator->value, Z_REFVAL_P(value)); + zval_ptr_dtor_nogc(free_op1.var); } else { if (IS_VAR == IS_CV) { - Z_ADDREF_P(value); + if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value); } - generator->value = value; + ZVAL_COPY_VALUE(&generator->value, value); } } } else { /* If no value was specified yield null */ - Z_ADDREF(EG(uninitialized_zval)); - generator->value = &EG(uninitialized_zval); + ZVAL_NULL(&generator->value); } /* Set the new yielded key */ @@ -21190,46 +20335,36 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); /* Consts, temporary variables and references need copying */ - if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR - || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, key); - - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } - - generator->key = copy; + if (IS_VAR == IS_CONST) { + ZVAL_DUP(&generator->key, key); + } else if (IS_VAR == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->key, key); + } else if (Z_ISREF_P(key)) { + ZVAL_DUP(&generator->key, Z_REFVAL_P(key)); + zval_ptr_dtor_nogc(free_op2.var); } else { - Z_ADDREF_P(key); - generator->key = key; + if (IS_VAR == IS_CV) { + if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key); + } + ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE_P(generator->key) == IS_LONG - && Z_LVAL_P(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_LONG + && Z_LVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL_P(generator->key); + generator->largest_used_integer_key = Z_LVAL(generator->key); } - - zval_ptr_dtor_nogc(&free_op2.var); } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - - ALLOC_INIT_ZVAL(generator->key); - ZVAL_LONG(generator->key, generator->largest_used_integer_key); + ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ - generator->send_target = &EX_T(opline->result.var).var.ptr; - Z_ADDREF(EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + generator->send_target = EX_VAR(opline->result.var); + ZVAL_NULL(generator->send_target); } else { generator->send_target = NULL; } @@ -21251,11 +20386,11 @@ static int ZEND_FASTCALL ZEND_POW_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS zend_free_op free_op1, free_op2; SAVE_OPLINE(); - pow_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); - zval_ptr_dtor_nogc(&free_op2.var); + pow_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -21269,18 +20404,18 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(int (* { USE_OPLINE zend_free_op free_op1, free_op_data1; - zval **object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - zval *object; + zval *object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); zval *property = NULL; - zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); + zval *value; int have_get_ptr = 0; - if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - make_real_object(object_ptr TSRMLS_CC); - object = *object_ptr; + object = make_real_object(object TSRMLS_CC); + + value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { zend_error(E_WARNING, "Attempt to assign property of non-object"); @@ -21288,233 +20423,332 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(int (* FREE_OP(free_op_data1); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } } else { /* here we are sure we are dealing with an object */ - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - - /* here property is a string */ if (opline->extended_value == ZEND_ASSIGN_OBJ && Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_UNUSED == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); if (zptr != NULL) { /* NULL means no success in getting PTR */ SEPARATE_ZVAL_IF_NOT_REF(zptr); have_get_ptr = 1; - binary_op(*zptr, *zptr, value TSRMLS_CC); + binary_op(zptr, zptr, value TSRMLS_CC); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(*zptr); - EX_T(opline->result.var).var.ptr = *zptr; + ZVAL_COPY(EX_VAR(opline->result.var), zptr); } } } if (!have_get_ptr) { zval *z = NULL; + zval rv; if (opline->extended_value == ZEND_ASSIGN_OBJ) { if (Z_OBJ_HT_P(object)->read_property) { - z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_UNUSED == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC); } } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { if (Z_OBJ_HT_P(object)->read_dimension) { - z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC); + z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R, &rv TSRMLS_CC); } } if (z) { if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); zval_dtor(z); - FREE_ZVAL(z); } - z = value; + ZVAL_COPY_VALUE(z, value); } - Z_ADDREF_P(z); - SEPARATE_ZVAL_IF_NOT_REF(&z); +//??? if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); + SEPARATE_ZVAL_IF_NOT_REF(z); binary_op(z, z, value TSRMLS_CC); if (opline->extended_value == ZEND_ASSIGN_OBJ) { - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_UNUSED == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(z); - EX_T(opline->result.var).var.ptr = z; + ZVAL_COPY(EX_VAR(opline->result.var), z); } - zval_ptr_dtor(&z); + zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to assign property of non-object"); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } } } - if (0) { - zval_ptr_dtor(&property); - } else { - - } FREE_OP(free_op_data1); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; /* assign_obj has two opcodes! */ CHECK_EXCEPTION(); ZEND_VM_INC_OPCODE(); ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_VAR_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_free_op free_op1, free_op_data2, free_op_data1; - zval **var_ptr; - zval *value; + zval *var_ptr; + zval *value, *container; SAVE_OPLINE(); - switch (opline->extended_value) { - case ZEND_ASSIGN_OBJ: - return zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - break; - case ZEND_ASSIGN_DIM: { - zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); - } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) { - if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) { - Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */ - } - return zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - } else { - zval *dim = NULL; + container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { + zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); + } else if (UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { + if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) { + Z_ADDREF_P(container); /* undo the effect of get_obj_zval_ptr_ptr() */ + } + return zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else { + zval *dim = NULL; - zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_UNUSED, BP_VAR_RW TSRMLS_CC); - value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); - var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); - } - } - break; - default: - value = NULL; - var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - /* do nothing */ - break; + zend_fetch_dimension_address_RW(EX_VAR((opline+1)->op2.var), container, dim, IS_UNUSED TSRMLS_CC); + value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); + var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); } - if (UNEXPECTED(var_ptr == NULL)) { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); } - if (UNEXPECTED(*var_ptr == &EG(error_zval))) { - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - } - - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - CHECK_EXCEPTION(); - if (opline->extended_value == ZEND_ASSIGN_DIM) { - ZEND_VM_INC_OPCODE(); + if (UNEXPECTED(var_ptr == &EG(error_zval))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); } - ZEND_VM_NEXT_OPCODE(); + goto assign_op_dim_exit; } SEPARATE_ZVAL_IF_NOT_REF(var_ptr); + ZVAL_DEREF(var_ptr); - if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) - && Z_OBJ_HANDLER_PP(var_ptr, get) - && Z_OBJ_HANDLER_PP(var_ptr, set)) { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) && + UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) { /* proxy object */ - zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); + zval rv; + zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC); Z_ADDREF_P(objval); binary_op(objval, objval, value TSRMLS_CC); - Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC); - zval_ptr_dtor(&objval); + Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); + zval_ptr_dtor(objval); } else { - binary_op(*var_ptr, *var_ptr, value TSRMLS_CC); + binary_op(var_ptr, var_ptr, value TSRMLS_CC); } - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(*var_ptr); - EX_T(opline->result.var).var.ptr = *var_ptr; + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } - if (opline->extended_value == ZEND_ASSIGN_DIM) { - FREE_OP(free_op_data1); - FREE_OP_VAR_PTR(free_op_data2); - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - CHECK_EXCEPTION(); - ZEND_VM_INC_OPCODE(); +assign_op_dim_exit: + + FREE_OP(free_op_data1); + FREE_OP_VAR_PTR(free_op_data2); + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; + CHECK_EXCEPTION(); + ZEND_VM_INC_OPCODE(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_free_op free_op1; + zval *var_ptr; + zval *value; + + SAVE_OPLINE(); + value = NULL; + var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { + zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); + } + + if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } + goto assign_op_exit; + } + + SEPARATE_ZVAL_IF_NOT_REF(var_ptr); + ZVAL_DEREF(var_ptr); + + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) && + UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) { + /* proxy object */ + zval rv; + zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC); + Z_ADDREF_P(objval); + binary_op(objval, objval, value TSRMLS_CC); + Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); + zval_ptr_dtor(objval); } else { - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - CHECK_EXCEPTION(); + binary_op(var_ptr, var_ptr, value TSRMLS_CC); } + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + } + +assign_op_exit: + + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; + CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_UNUSED(int type, ZEND_OPCODE_HANDLER_ARGS) @@ -21522,19 +20756,16 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_UNUSED(int type, USE_OPLINE zend_free_op free_op1; zval *varname; - zval **retval; + zval *retval; zval tmp_varname; HashTable *target_symbol_table; - ulong hash_value; SAVE_OPLINE(); varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + ZVAL_UNDEF(&tmp_varname); if (IS_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) { - ZVAL_COPY_VALUE(&tmp_varname, varname); - zval_copy_ctor(&tmp_varname); - Z_SET_REFCOUNT(tmp_varname, 1); - Z_UNSET_ISREF(tmp_varname); + ZVAL_DUP_DEREF(&tmp_varname, varname); convert_to_string(&tmp_varname); varname = &tmp_varname; } @@ -21543,105 +20774,88 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_UNUSED(int type, zend_class_entry *ce; if (IS_UNUSED == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { - if (IS_VAR != IS_CONST && varname == &tmp_varname) { + if (IS_VAR != IS_CONST) { zval_dtor(&tmp_varname); } - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(opline->op2.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); } } else { - ce = EX_T(opline->op2.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op2.var)); } - retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); } else { target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); -/* - if (!target_symbol_table) { - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); - } -*/ - if (IS_VAR == IS_CONST) { - hash_value = Z_HASH_P(varname); - } else { - hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname)); - } - - if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) { + retval = zend_hash_find(target_symbol_table, Z_STR_P(varname)); + if (retval == NULL) { switch (type) { case BP_VAR_R: case BP_VAR_UNSET: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); /* break missing intentionally */ case BP_VAR_IS: - retval = &EG(uninitialized_zval_ptr); + retval = EX_VAR(opline->result.var); + ZVAL_NULL(retval); break; case BP_VAR_RW: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); /* break missing intentionally */ case BP_VAR_W: - Z_ADDREF_P(&EG(uninitialized_zval)); - zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval); + retval = zend_hash_update(target_symbol_table, Z_STR_P(varname), &EG(uninitialized_zval)); break; EMPTY_SWITCH_DEFAULT_CASE() } - } - switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) { - case ZEND_FETCH_GLOBAL: - if (IS_VAR != IS_TMP_VAR) { - zval_ptr_dtor_nogc(&free_op1.var); - } - break; - case ZEND_FETCH_LOCAL: - zval_ptr_dtor_nogc(&free_op1.var); - break; - case ZEND_FETCH_STATIC: - zval_update_constant(retval, 1 TSRMLS_CC); - break; - case ZEND_FETCH_GLOBAL_LOCK: - if (IS_VAR == IS_VAR && !free_op1.var) { - PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); + /* GLOBAL or $$name variable may be an INDIRECT pointer to CV */ + } else if (Z_TYPE_P(retval) == IS_INDIRECT) { + retval = Z_INDIRECT_P(retval); + if (Z_TYPE_P(retval) == IS_UNDEF) { + switch (type) { + case BP_VAR_R: + case BP_VAR_UNSET: + zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); + /* break missing intentionally */ + case BP_VAR_IS: + retval = EX_VAR(opline->result.var); + ZVAL_NULL(retval); + break; + case BP_VAR_RW: + zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); + /* break missing intentionally */ + case BP_VAR_W: + ZVAL_NULL(retval); + break; + EMPTY_SWITCH_DEFAULT_CASE() } - break; + } + } + if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC) { + zval_update_constant(retval, 1 TSRMLS_CC); + } else if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) != ZEND_FETCH_GLOBAL_LOCK) { + zval_ptr_dtor_nogc(free_op1.var); } } - - if (IS_VAR != IS_CONST && varname == &tmp_varname) { + if (IS_VAR != IS_CONST) { zval_dtor(&tmp_varname); } - if (opline->extended_value & ZEND_FETCH_MAKE_REF) { - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval); - } - PZVAL_LOCK(*retval); - switch (type) { - case BP_VAR_R: - case BP_VAR_IS: - EX_T(opline->result.var).var.ptr = *retval; - break; - case BP_VAR_UNSET: { - zend_free_op free_res; - PZVAL_UNLOCK(*retval, &free_res); - if (retval != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(retval); - } - PZVAL_LOCK(*retval); - FREE_OP_VAR_PTR(free_res); + ZEND_ASSERT(retval != NULL); + if (type == BP_VAR_R || type == BP_VAR_IS) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); + } else { + if (/*type == BP_VAR_W &&*/ (opline->extended_value & ZEND_FETCH_MAKE_REF)) { + SEPARATE_ZVAL_TO_MAKE_IS_REF(retval); } - /* break missing intentionally */ - default: - EX_T(opline->result.var).var.ptr_ptr = retval; - break; + ZVAL_INDIRECT(EX_VAR(opline->result.var), retval); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -21666,7 +20880,11 @@ static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCOD { USE_OPLINE - return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { + return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else { + return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -21683,32 +20901,24 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_H { USE_OPLINE zend_free_op free_op1; - zval **container; + zval *container; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_W TSRMLS_CC); - - if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + if (EXPECTED(opline->extended_value == 0)) { + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, NULL, IS_UNUSED TSRMLS_CC); + } else { + zend_fetch_dimension_address_W_ref(EX_VAR(opline->result.var), container, NULL, IS_UNUSED TSRMLS_CC); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - - /* We are going to assign the result by reference */ - if (UNEXPECTED(opline->extended_value != 0)) { - zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; - if (retval_ptr) { - Z_DELREF_PP(retval_ptr); - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); - Z_ADDREF_PP(retval_ptr); - } + if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -21717,20 +20927,20 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_ { USE_OPLINE zend_free_op free_op1; - zval **container; + zval *container; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_RW TSRMLS_CC); + zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, NULL, IS_UNUSED TSRMLS_CC); if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -21738,31 +20948,30 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_ static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE + zval *container; zend_free_op free_op1; SAVE_OPLINE(); if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { - zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_W TSRMLS_CC); + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, NULL, IS_UNUSED TSRMLS_CC); if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; } else { - zval *container; - if (IS_UNUSED == IS_UNUSED) { zend_error_noreturn(E_ERROR, "Cannot use [] for reading"); } container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_R TSRMLS_CC); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, NULL, IS_UNUSED TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -21772,76 +20981,59 @@ static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HA { USE_OPLINE zend_free_op free_op1; - zval **object_ptr; + zval *object_ptr; SAVE_OPLINE(); object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - if (Z_TYPE_PP(object_ptr) == IS_OBJECT) { + if (UNEXPECTED(Z_ISREF_P(object_ptr)) && Z_TYPE_P(Z_REFVAL_P(object_ptr)) == IS_OBJECT) { + object_ptr = Z_REFVAL_P(object_ptr); + } + if (Z_TYPE_P(object_ptr) == IS_OBJECT) { zval *property_name = NULL; - if (0) { - MAKE_REAL_ZVAL_PTR(property_name); - } - zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property_name); - } else { + zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_UNUSED == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC); - } } else { zend_free_op free_op_data1, free_op_data2; zval *value; zval *dim = NULL; - zval **variable_ptr_ptr; + zval *variable_ptr; - zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_UNUSED, BP_VAR_W TSRMLS_CC); + zend_fetch_dimension_address_W(EX_VAR((opline+1)->op2.var), object_ptr, dim, IS_UNUSED TSRMLS_CC); value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); - variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); - if (UNEXPECTED(variable_ptr_ptr == NULL)) { - if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) { - if (RETURN_VALUE_USED(opline)) { - zval *retval; - - ALLOC_ZVAL(retval); - ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1); - INIT_PZVAL(retval); - EX_T(opline->result.var).var.ptr = retval; - } - } else if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - } - } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) { + variable_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); + if (UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) { + zend_assign_to_string_offset(variable_ptr, value, (opline+1)->op1_type, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC); + } else if (UNEXPECTED(variable_ptr == &EG(error_zval))) { if (IS_TMP_FREE(free_op_data1)) { zval_dtor(value); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } + FREE_OP_VAR_PTR(free_op_data2); } else { if ((opline+1)->op1_type == IS_TMP_VAR) { - value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_tmp_to_variable(variable_ptr, value TSRMLS_CC); } else if ((opline+1)->op1_type == IS_CONST) { - value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_const_to_variable(variable_ptr, value TSRMLS_CC); } else { - value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_to_variable(variable_ptr, value TSRMLS_CC); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(value); - EX_T(opline->result.var).var.ptr = value; + ZVAL_COPY(EX_VAR(opline->result.var), value); } + FREE_OP_VAR_PTR(free_op_data2); } - FREE_OP_VAR_PTR(free_op_data2); FREE_OP_IF_VAR(free_op_data1); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; /* assign_dim has two opcodes! */ CHECK_EXCEPTION(); ZEND_VM_INC_OPCODE(); @@ -21859,21 +21051,21 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(Z if (IS_VAR == IS_CONST) { /* no function found. try a static method in class */ - if (CACHED_PTR(opline->op1.literal->cache_slot)) { - ce = CACHED_PTR(opline->op1.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } if (UNEXPECTED(ce == NULL)) { zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv)); } - CACHE_PTR(opline->op1.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce); } call->called_scope = ce; } else { - ce = EX_T(opline->op1.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op1.var)); if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) { call->called_scope = EG(called_scope); @@ -21884,51 +21076,40 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(Z if (IS_VAR == IS_CONST && IS_UNUSED == IS_CONST && - CACHED_PTR(opline->op2.literal->cache_slot)) { - call->fbc = CACHED_PTR(opline->op2.literal->cache_slot); + CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else if (IS_VAR != IS_CONST && IS_UNUSED == IS_CONST && - (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) { + (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce))) { /* do nothing */ } else if (IS_UNUSED != IS_UNUSED) { - char *function_name_strval = NULL; - int function_name_strlen = 0; - - if (IS_UNUSED == IS_CONST) { - function_name_strval = Z_STRVAL_P(opline->op2.zv); - function_name_strlen = Z_STRLEN_P(opline->op2.zv); - } else { - function_name = NULL; + function_name = NULL; + if (IS_UNUSED != IS_CONST) { if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } zend_error_noreturn(E_ERROR, "Function name must be a string"); - } else { - function_name_strval = Z_STRVAL_P(function_name); - function_name_strlen = Z_STRLEN_P(function_name); } } - if (function_name_strval) { - if (ce->get_static_method) { - call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC); + if (ce->get_static_method) { + call->fbc = ce->get_static_method(ce, Z_STR_P(function_name) TSRMLS_CC); + } else { + call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_UNUSED == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); + } + if (UNEXPECTED(call->fbc == NULL)) { + zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name)); + } + if (IS_UNUSED == IS_CONST && + EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) && + EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) { + if (IS_VAR == IS_CONST) { + CACHE_PTR(Z_CACHE_SLOT_P(function_name), call->fbc); } else { - call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_UNUSED == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); - } - if (UNEXPECTED(call->fbc == NULL)) { - zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval); - } - if (IS_UNUSED == IS_CONST && - EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) && - EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) { - if (IS_VAR == IS_CONST) { - CACHE_PTR(opline->op2.literal->cache_slot, call->fbc); - } else { - CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc); - } + CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), ce, call->fbc); } } if (IS_UNUSED != IS_CONST) { @@ -21938,8 +21119,8 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(Z if (UNEXPECTED(ce->constructor == NULL)) { zend_error_noreturn(E_ERROR, "Cannot call constructor"); } - if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { - zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name); + if (Z_OBJ(EG(This)) && Z_OBJCE(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { + zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name->val); } call->fbc = ce->constructor; } @@ -21947,21 +21128,21 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(Z if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) { call->object = NULL; } else { - if (EG(This) && - Z_OBJ_HT_P(EG(This))->get_class_entry && - !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) { + if (Z_OBJ(EG(This)) && + Z_OBJ_HT(EG(This))->get_class_entry && + !instanceof_function(Z_OBJCE(EG(This)), ce TSRMLS_CC)) { /* We are calling method of the other (incompatible) class, but passing $this. This is done for compatibility with php-4. */ if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { - zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name); + zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val); } else { /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */ - zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name); + zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val); } } - if ((call->object = EG(This))) { - Z_ADDREF_P(call->object); - call->called_scope = Z_OBJCE_P(call->object); + call->object = Z_OBJ(EG(This)); + if (call->object) { + GC_REFCOUNT(call->object)++; } } @@ -21977,35 +21158,31 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OP { USE_OPLINE zend_free_op free_op1; - zval *expr_ptr; + zval *expr_ptr, new_expr; SAVE_OPLINE(); - if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) { - zval **expr_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - - if (IS_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) { + if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && + (opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) { + expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets"); } - SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); - expr_ptr = *expr_ptr_ptr; + SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr); Z_ADDREF_P(expr_ptr); + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; } else { - expr_ptr=_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + expr_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (0) { /* temporary variable */ - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - } else if (IS_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) { - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - zendi_zval_copy_ctor(*expr_ptr); - zval_ptr_dtor_nogc(&free_op1.var); - } else if (IS_VAR == IS_CV) { + ZVAL_COPY_VALUE(&new_expr, expr_ptr); + expr_ptr = &new_expr; + } else if (IS_VAR == IS_CONST) { + ZVAL_DUP(&new_expr, expr_ptr); + expr_ptr = &new_expr; + } else if (Z_ISREF_P(expr_ptr)) { + ZVAL_DUP(&new_expr, Z_REFVAL_P(expr_ptr)); + expr_ptr = &new_expr; + zval_ptr_dtor_nogc(free_op1.var); + } else if (IS_VAR == IS_CV && Z_REFCOUNTED_P(expr_ptr)) { Z_ADDREF_P(expr_ptr); } } @@ -22013,42 +21190,49 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OP if (IS_UNUSED != IS_UNUSED) { zval *offset = NULL; + zend_string *str; ulong hval; +add_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: hval = zend_dval_to_lval(Z_DVAL_P(offset)); goto num_index; case IS_LONG: - case IS_BOOL: hval = Z_LVAL_P(offset); num_index: - zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL); + zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); break; case IS_STRING: - if (IS_UNUSED == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); + str = Z_STR_P(offset); + if (IS_UNUSED != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index); } - zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL); +str_index: + zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); break; case IS_NULL: - zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); + str = STR_EMPTY_ALLOC(); + goto str_index; + case IS_FALSE: + hval = 0; + goto num_index; + case IS_TRUE: + hval = 1; + goto num_index; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto add_again; break; default: zend_error(E_WARNING, "Illegal offset type"); - zval_ptr_dtor(&expr_ptr); + zval_ptr_dtor(expr_ptr); /* do nothing */ break; } } else { - zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL); - } - if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) { - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -22056,9 +21240,26 @@ num_index: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { + zval *array; + zend_uint size; USE_OPLINE - array_init(&EX_T(opline->result.var).tmp_var); + array = EX_VAR(opline->result.var); + if (IS_VAR != IS_UNUSED) { + size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; + } else { + size = 0; + } + ZVAL_NEW_ARR(array); + zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); + + if (IS_VAR != IS_UNUSED) { + /* Explicitly initialize array as not-packed if flag is set */ + if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) { + zend_hash_real_init(Z_ARRVAL_P(array), 0); + } + } + if (IS_VAR == IS_UNUSED) { ZEND_VM_NEXT_OPCODE(); #if 0 || IS_VAR != IS_UNUSED @@ -22074,20 +21275,15 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HAN zval tmp, *varname; HashTable *target_symbol_table; zend_free_op free_op1; + zend_bool tmp_is_dup = 0; SAVE_OPLINE(); if (IS_VAR == IS_CV && IS_UNUSED == IS_UNUSED && (opline->extended_value & ZEND_QUICK_SET)) { - if (EG(active_symbol_table)) { - zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); - - zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC); - EX_CV(opline->op1.var) = NULL; - } else if (EX_CV(opline->op1.var)) { - zval_ptr_dtor(EX_CV(opline->op1.var)); - EX_CV(opline->op1.var) = NULL; - } + ZVAL_COPY_VALUE(&tmp, EX_VAR(opline->op1.var)); + ZVAL_UNDEF(EX_VAR(opline->op1.var)); + zval_ptr_dtor(&tmp); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -22095,53 +21291,52 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HAN varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { - ZVAL_COPY_VALUE(&tmp, varname); - zval_copy_ctor(&tmp); + ZVAL_DUP(&tmp, varname); convert_to_string(&tmp); varname = &tmp; + tmp_is_dup = 1; } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) { - Z_ADDREF_P(varname); + ZVAL_COPY(&tmp, varname); + varname = &tmp; } if (IS_UNUSED != IS_UNUSED) { zend_class_entry *ce; if (IS_UNUSED == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { - if (IS_VAR != IS_CONST && varname == &tmp) { + if (IS_VAR != IS_CONST && tmp_is_dup) { zval_dtor(&tmp); } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) { - zval_ptr_dtor(&varname); + zval_ptr_dtor(&tmp); } - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); HANDLE_EXCEPTION(); } if (UNEXPECTED(ce == NULL)) { zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv)); } - CACHE_PTR(opline->op2.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); } } else { - ce = EX_T(opline->op2.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op2.var)); } - zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); + zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC); } else { - ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1); - target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); - zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC); + zend_hash_del_ind(target_symbol_table, Z_STR_P(varname)); } - if (IS_VAR != IS_CONST && varname == &tmp) { + if (IS_VAR != IS_CONST && tmp_is_dup) { zval_dtor(&tmp); } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) { - zval_ptr_dtor(&varname); + zval_ptr_dtor(&tmp); } - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -22149,21 +21344,16 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HAN static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval **value; + zval *value; zend_bool isset = 1; SAVE_OPLINE(); if (IS_VAR == IS_CV && IS_UNUSED == IS_UNUSED && (opline->extended_value & ZEND_QUICK_SET)) { - if (EX_CV(opline->op1.var)) { - value = EX_CV(opline->op1.var); - } else if (EG(active_symbol_table)) { - zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); - - if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) { - isset = 0; - } + if (Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_UNDEF) { + value = EX_VAR(opline->op1.var); + ZVAL_DEREF(value); } else { isset = 0; } @@ -22173,8 +21363,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OP zval tmp, *varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { - ZVAL_COPY_VALUE(&tmp, varname); - zval_copy_ctor(&tmp); + ZVAL_DUP(&tmp, varname); convert_to_string(&tmp); varname = &tmp; } @@ -22183,26 +21372,26 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OP zend_class_entry *ce; if (IS_UNUSED == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(opline->op2.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); } } else { - ce = EX_T(opline->op2.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op2.var)); } - value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); + value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC); if (!value) { isset = 0; } } else { target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); - if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) { + if ((value = zend_hash_find(target_symbol_table, Z_STR_P(varname))) == NULL) { isset = 0; } } @@ -22210,20 +21399,20 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OP if (IS_VAR != IS_CONST && varname == &tmp) { zval_dtor(&tmp); } - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); } if (opline->extended_value & ZEND_ISSET) { - if (isset && Z_TYPE_PP(value) != IS_NULL) { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); + if (isset && Z_TYPE_P(value) != IS_NULL) { + ZVAL_BOOL(EX_VAR(opline->result.var), 1); } else { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); + ZVAL_BOOL(EX_VAR(opline->result.var), 0); } } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { - if (!isset || !i_zend_is_true(*value TSRMLS_CC)) { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); + if (!isset || !i_zend_is_true(value TSRMLS_CC)) { + ZVAL_BOOL(EX_VAR(opline->result.var), 1); } else { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); + ZVAL_BOOL(EX_VAR(opline->result.var), 0); } } @@ -22234,20 +21423,17 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OP static int ZEND_FASTCALL ZEND_SEPARATE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *var_ptr, *new_zv; + zval *var_ptr; SAVE_OPLINE(); - var_ptr = EX_T(opline->op1.var).var.ptr; + var_ptr = EX_VAR(opline->op1.var); if (Z_TYPE_P(var_ptr) != IS_OBJECT && - !PZVAL_IS_REF(var_ptr) && - Z_REFCOUNT_P(var_ptr) > 1) { + !Z_ISREF_P(var_ptr) && + Z_REFCOUNTED_P(var_ptr) && + Z_REFCOUNT_P(var_ptr) > 1) { Z_DELREF_P(var_ptr); - ALLOC_ZVAL(new_zv); - INIT_PZVAL_COPY(new_zv, var_ptr); - var_ptr = new_zv; - zval_copy_ctor(var_ptr); - EX_T(opline->op1.var).var.ptr = var_ptr; + ZVAL_DUP(EX_VAR(opline->op1.var), var_ptr); } ZEND_VM_NEXT_OPCODE(); } @@ -22256,22 +21442,18 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER { USE_OPLINE - /* The generator object is stored in return_value_ptr_ptr */ - zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr); + /* The generator object is stored in EX(return_value) */ + zend_generator *generator = (zend_generator *) EX(return_value); if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) { zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator"); } /* Destroy the previously yielded value */ - if (generator->value) { - zval_ptr_dtor(&generator->value); - } + zval_ptr_dtor(&generator->value); /* Destroy the previously yielded key */ - if (generator->key) { - zval_ptr_dtor(&generator->key); - } + zval_ptr_dtor(&generator->key); /* Set the new yielded value */ if (IS_VAR != IS_UNUSED) { @@ -22281,75 +21463,59 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER /* Constants and temporary variables aren't yieldable by reference, * but we still allow them with a notice. */ if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) { - zval *value, *copy; + zval *value; zend_error(E_NOTICE, "Only variable references should be yielded by reference"); value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); + ZVAL_COPY_VALUE(&generator->value, value); + if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1); /* Temporary variables don't need ctor copying */ if (!0) { - zval_copy_ctor(copy); + zval_copy_ctor(&generator->value); } - - generator->value = copy; } else { - zval **value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference"); } /* If a function call result is yielded and the function did * not return by reference we throw a notice. */ - if (IS_VAR == IS_VAR && !Z_ISREF_PP(value_ptr) + if (IS_VAR == IS_VAR && !Z_ISREF_P(value_ptr) && !(opline->extended_value == ZEND_RETURNS_FUNCTION - && EX_T(opline->op1.var).var.fcall_returned_reference) - && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) { + && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); - - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } else { SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr); - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } + ZVAL_COPY(&generator->value, value_ptr); - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; } } else { zval *value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); /* Consts, temporary variables and references need copying */ - if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR - || PZVAL_IS_REF(value) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); - - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } - - generator->value = copy; - zval_ptr_dtor_nogc(&free_op1.var); + if (IS_VAR == IS_CONST) { + ZVAL_DUP(&generator->value, value); + } else if (IS_VAR == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->value, value); + } else if (Z_ISREF_P(value)) { + ZVAL_DUP(&generator->value, Z_REFVAL_P(value)); + zval_ptr_dtor_nogc(free_op1.var); } else { if (IS_VAR == IS_CV) { - Z_ADDREF_P(value); + if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value); } - generator->value = value; + ZVAL_COPY_VALUE(&generator->value, value); } } } else { /* If no value was specified yield null */ - Z_ADDREF(EG(uninitialized_zval)); - generator->value = &EG(uninitialized_zval); + ZVAL_NULL(&generator->value); } /* Set the new yielded key */ @@ -22358,45 +21524,36 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER zval *key = NULL; /* Consts, temporary variables and references need copying */ - if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR - || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, key); - - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } + if (IS_UNUSED == IS_CONST) { + ZVAL_DUP(&generator->key, key); + } else if (IS_UNUSED == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->key, key); + } else if (Z_ISREF_P(key)) { + ZVAL_DUP(&generator->key, Z_REFVAL_P(key)); - generator->key = copy; } else { - Z_ADDREF_P(key); - generator->key = key; + if (IS_UNUSED == IS_CV) { + if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key); + } + ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE_P(generator->key) == IS_LONG - && Z_LVAL_P(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_LONG + && Z_LVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL_P(generator->key); + generator->largest_used_integer_key = Z_LVAL(generator->key); } - } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - - ALLOC_INIT_ZVAL(generator->key); - ZVAL_LONG(generator->key, generator->largest_used_integer_key); + ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ - generator->send_target = &EX_T(opline->result.var).var.ptr; - Z_ADDREF(EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + generator->send_target = EX_VAR(opline->result.var); + ZVAL_NULL(generator->send_target); } else { generator->send_target = NULL; } @@ -22423,10 +21580,10 @@ static int ZEND_FASTCALL ZEND_ADD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op1; SAVE_OPLINE(); - fast_add_function(&EX_T(opline->result.var).tmp_var, + fast_add_function(EX_VAR(opline->result.var), _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -22438,10 +21595,10 @@ static int ZEND_FASTCALL ZEND_SUB_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op1; SAVE_OPLINE(); - fast_sub_function(&EX_T(opline->result.var).tmp_var, + fast_sub_function(EX_VAR(opline->result.var), _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -22453,10 +21610,10 @@ static int ZEND_FASTCALL ZEND_MUL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op1; SAVE_OPLINE(); - fast_mul_function(&EX_T(opline->result.var).tmp_var, + fast_mul_function(EX_VAR(opline->result.var), _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -22468,10 +21625,10 @@ static int ZEND_FASTCALL ZEND_DIV_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op1; SAVE_OPLINE(); - fast_div_function(&EX_T(opline->result.var).tmp_var, + fast_div_function(EX_VAR(opline->result.var), _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -22483,10 +21640,10 @@ static int ZEND_FASTCALL ZEND_MOD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op1; SAVE_OPLINE(); - fast_mod_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + fast_mod_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -22498,10 +21655,10 @@ static int ZEND_FASTCALL ZEND_SL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op1; SAVE_OPLINE(); - shift_left_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + shift_left_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -22513,10 +21670,10 @@ static int ZEND_FASTCALL ZEND_SR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op1; SAVE_OPLINE(); - shift_right_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + shift_right_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -22528,10 +21685,10 @@ static int ZEND_FASTCALL ZEND_CONCAT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_AR zend_free_op free_op1; SAVE_OPLINE(); - concat_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + concat_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -22543,10 +21700,10 @@ static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HAND zend_free_op free_op1; SAVE_OPLINE(); - is_identical_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + fast_is_identical_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -22556,14 +21713,13 @@ static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_ { USE_OPLINE zend_free_op free_op1; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - is_identical_function(result, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); - Z_LVAL_P(result) = !Z_LVAL_P(result); - zval_ptr_dtor_nogc(&free_op1.var); + fast_is_not_identical_function(result, + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -22573,13 +21729,13 @@ static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ { USE_OPLINE zend_free_op free_op1; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_equal_function(result, + fast_equal_function(result, _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); - zval_ptr_dtor_nogc(&free_op1.var); + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -22589,13 +21745,13 @@ static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HAND { USE_OPLINE zend_free_op free_op1; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_not_equal_function(result, + fast_not_equal_function(result, _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); - zval_ptr_dtor_nogc(&free_op1.var); + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -22605,13 +21761,13 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLE { USE_OPLINE zend_free_op free_op1; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_is_smaller_function(result, + fast_is_smaller_function(result, _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); - zval_ptr_dtor_nogc(&free_op1.var); + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -22621,13 +21777,13 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_CV_HANDLER(ZEND_OPCO { USE_OPLINE zend_free_op free_op1; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, + fast_is_smaller_or_equal_function(result, _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); - zval_ptr_dtor_nogc(&free_op1.var); + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -22639,10 +21795,10 @@ static int ZEND_FASTCALL ZEND_BW_OR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG zend_free_op free_op1; SAVE_OPLINE(); - bitwise_or_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + bitwise_or_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -22654,10 +21810,10 @@ static int ZEND_FASTCALL ZEND_BW_AND_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_AR zend_free_op free_op1; SAVE_OPLINE(); - bitwise_and_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + bitwise_and_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -22669,10 +21825,10 @@ static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_AR zend_free_op free_op1; SAVE_OPLINE(); - bitwise_xor_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + bitwise_xor_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -22684,10 +21840,10 @@ static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ zend_free_op free_op1; SAVE_OPLINE(); - boolean_xor_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + boolean_xor_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -22697,18 +21853,18 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CV(int (*bina { USE_OPLINE zend_free_op free_op1, free_op_data1; - zval **object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - zval *object; + zval *object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); zval *property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); + zval *value; int have_get_ptr = 0; - if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - make_real_object(object_ptr TSRMLS_CC); - object = *object_ptr; + object = make_real_object(object TSRMLS_CC); + + value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { zend_error(E_WARNING, "Attempt to assign property of non-object"); @@ -22716,325 +21872,411 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CV(int (*bina FREE_OP(free_op_data1); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } } else { /* here we are sure we are dealing with an object */ - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - - /* here property is a string */ if (opline->extended_value == ZEND_ASSIGN_OBJ && Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); if (zptr != NULL) { /* NULL means no success in getting PTR */ SEPARATE_ZVAL_IF_NOT_REF(zptr); have_get_ptr = 1; - binary_op(*zptr, *zptr, value TSRMLS_CC); + binary_op(zptr, zptr, value TSRMLS_CC); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(*zptr); - EX_T(opline->result.var).var.ptr = *zptr; + ZVAL_COPY(EX_VAR(opline->result.var), zptr); } } } if (!have_get_ptr) { zval *z = NULL; + zval rv; if (opline->extended_value == ZEND_ASSIGN_OBJ) { if (Z_OBJ_HT_P(object)->read_property) { - z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC); } } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { if (Z_OBJ_HT_P(object)->read_dimension) { - z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC); + z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R, &rv TSRMLS_CC); } } if (z) { if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); zval_dtor(z); - FREE_ZVAL(z); } - z = value; + ZVAL_COPY_VALUE(z, value); } - Z_ADDREF_P(z); - SEPARATE_ZVAL_IF_NOT_REF(&z); +//??? if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); + SEPARATE_ZVAL_IF_NOT_REF(z); binary_op(z, z, value TSRMLS_CC); if (opline->extended_value == ZEND_ASSIGN_OBJ) { - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(z); - EX_T(opline->result.var).var.ptr = z; + ZVAL_COPY(EX_VAR(opline->result.var), z); } - zval_ptr_dtor(&z); + zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to assign property of non-object"); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } } } - if (0) { - zval_ptr_dtor(&property); - } else { - - } FREE_OP(free_op_data1); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; /* assign_obj has two opcodes! */ CHECK_EXCEPTION(); ZEND_VM_INC_OPCODE(); ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_VAR_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_free_op free_op1, free_op_data2, free_op_data1; - zval **var_ptr; - zval *value; + zval *var_ptr; + zval *value, *container; SAVE_OPLINE(); - switch (opline->extended_value) { - case ZEND_ASSIGN_OBJ: - return zend_binary_assign_op_obj_helper_SPEC_VAR_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - break; - case ZEND_ASSIGN_DIM: { - zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); - } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) { - if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) { - Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */ - } - return zend_binary_assign_op_obj_helper_SPEC_VAR_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - } else { - zval *dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); + container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { + zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); + } else if (UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { + if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) { + Z_ADDREF_P(container); /* undo the effect of get_obj_zval_ptr_ptr() */ + } + return zend_binary_assign_op_obj_helper_SPEC_VAR_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else { + zval *dim = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_CV, BP_VAR_RW TSRMLS_CC); - value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); - var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); - } - } - break; - default: - value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - /* do nothing */ - break; + zend_fetch_dimension_address_RW(EX_VAR((opline+1)->op2.var), container, dim, IS_CV TSRMLS_CC); + value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); + var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); } - if (UNEXPECTED(var_ptr == NULL)) { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); } - if (UNEXPECTED(*var_ptr == &EG(error_zval))) { - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - } - - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - CHECK_EXCEPTION(); - if (opline->extended_value == ZEND_ASSIGN_DIM) { - ZEND_VM_INC_OPCODE(); + if (UNEXPECTED(var_ptr == &EG(error_zval))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); } - ZEND_VM_NEXT_OPCODE(); + goto assign_op_dim_exit; } SEPARATE_ZVAL_IF_NOT_REF(var_ptr); + ZVAL_DEREF(var_ptr); - if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) - && Z_OBJ_HANDLER_PP(var_ptr, get) - && Z_OBJ_HANDLER_PP(var_ptr, set)) { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) && + UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) { /* proxy object */ - zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); + zval rv; + zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC); Z_ADDREF_P(objval); binary_op(objval, objval, value TSRMLS_CC); - Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC); - zval_ptr_dtor(&objval); + Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); + zval_ptr_dtor(objval); } else { - binary_op(*var_ptr, *var_ptr, value TSRMLS_CC); + binary_op(var_ptr, var_ptr, value TSRMLS_CC); } - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(*var_ptr); - EX_T(opline->result.var).var.ptr = *var_ptr; + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } - if (opline->extended_value == ZEND_ASSIGN_DIM) { - FREE_OP(free_op_data1); - FREE_OP_VAR_PTR(free_op_data2); - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - CHECK_EXCEPTION(); - ZEND_VM_INC_OPCODE(); +assign_op_dim_exit: + + FREE_OP(free_op_data1); + FREE_OP_VAR_PTR(free_op_data2); + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; + CHECK_EXCEPTION(); + ZEND_VM_INC_OPCODE(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_free_op free_op1; + zval *var_ptr; + zval *value; + + SAVE_OPLINE(); + value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); + var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { + zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); + } + + if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } + goto assign_op_exit; + } + + SEPARATE_ZVAL_IF_NOT_REF(var_ptr); + ZVAL_DEREF(var_ptr); + + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) && + UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) { + /* proxy object */ + zval rv; + zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC); + Z_ADDREF_P(objval); + binary_op(objval, objval, value TSRMLS_CC); + Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); + zval_ptr_dtor(objval); } else { - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - CHECK_EXCEPTION(); + binary_op(var_ptr, var_ptr, value TSRMLS_CC); + } + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } + +assign_op_exit: + + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; + CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_VAR_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_VAR_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_VAR_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_VAR_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_free_op free_op1; - zval **object_ptr; zval *object; zval *property; - zval **retval; + zval *retval; int have_get_ptr = 0; SAVE_OPLINE(); - object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - retval = &EX_T(opline->result.var).var.ptr; + retval = EX_VAR(opline->result.var); - if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } - make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ - object = *object_ptr; + object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */ if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - *retval = &EG(uninitialized_zval); + ZVAL_NULL(retval); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } /* here we are sure we are dealing with an object */ - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); if (zptr != NULL) { /* NULL means no success in getting PTR */ SEPARATE_ZVAL_IF_NOT_REF(zptr); have_get_ptr = 1; - incdec_op(*zptr); + incdec_op(zptr); if (RETURN_VALUE_USED(opline)) { - *retval = *zptr; - PZVAL_LOCK(*retval); + ZVAL_COPY(retval, zptr); } } } if (!have_get_ptr) { + zval rv; + if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC); if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); zval_dtor(z); - FREE_ZVAL(z); } - z = value; + ZVAL_COPY_VALUE(z, value); } - Z_ADDREF_P(z); - SEPARATE_ZVAL_IF_NOT_REF(&z); + if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); + SEPARATE_ZVAL_IF_NOT_REF(z); incdec_op(z); - *retval = z; - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - SELECTIVE_PZVAL_LOCK(*retval, opline); - zval_ptr_dtor(&z); + ZVAL_COPY_VALUE(retval, z); + Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); + SELECTIVE_PZVAL_LOCK(retval, opline); + zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - *retval = &EG(uninitialized_zval); + ZVAL_NULL(retval); } } } - if (0) { - zval_ptr_dtor(&property); - } else { - - } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -23053,90 +22295,75 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_CV(incdec_t i { USE_OPLINE zend_free_op free_op1; - zval **object_ptr; zval *object; zval *property; zval *retval; int have_get_ptr = 0; SAVE_OPLINE(); - object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - retval = &EX_T(opline->result.var).tmp_var; + retval = EX_VAR(opline->result.var); - if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } - make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ - object = *object_ptr; + object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */ if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); ZVAL_NULL(retval); - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } /* here we are sure we are dealing with an object */ - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); if (zptr != NULL) { /* NULL means no success in getting PTR */ have_get_ptr = 1; SEPARATE_ZVAL_IF_NOT_REF(zptr); - ZVAL_COPY_VALUE(retval, *zptr); - zendi_zval_copy_ctor(*retval); + ZVAL_DUP(retval, zptr); - incdec_op(*zptr); + incdec_op(zptr); } } if (!have_get_ptr) { if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - zval *z_copy; + zval rv; + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC); + zval z_copy; if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); zval_dtor(z); - FREE_ZVAL(z); } - z = value; + ZVAL_COPY_VALUE(z, value); } - ZVAL_COPY_VALUE(retval, z); - zendi_zval_copy_ctor(*retval); - ALLOC_ZVAL(z_copy); - INIT_PZVAL_COPY(z_copy, z); - zendi_zval_copy_ctor(*z_copy); - incdec_op(z_copy); - Z_ADDREF_P(z); - Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + ZVAL_DUP(retval, z); + ZVAL_DUP(&z_copy, z); + incdec_op(&z_copy); + if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); + Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); zval_ptr_dtor(&z_copy); - zval_ptr_dtor(&z); + zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); ZVAL_NULL(retval); } } - if (0) { - zval_ptr_dtor(&property); - } else { - - } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -23159,10 +22386,10 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDL SAVE_OPLINE(); container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC); if (IS_VAR != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) { - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -23172,32 +22399,24 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDL { USE_OPLINE zend_free_op free_op1; - zval **container; + zval *container; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_W TSRMLS_CC); - - if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + if (EXPECTED(opline->extended_value == 0)) { + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC); + } else { + zend_fetch_dimension_address_W_ref(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - - /* We are going to assign the result by reference */ - if (UNEXPECTED(opline->extended_value != 0)) { - zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; - if (retval_ptr) { - Z_DELREF_PP(retval_ptr); - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); - Z_ADDREF_PP(retval_ptr); - } + if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -23206,20 +22425,20 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HAND { USE_OPLINE zend_free_op free_op1; - zval **container; + zval *container; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_RW TSRMLS_CC); + zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC); if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -23232,9 +22451,9 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HAND SAVE_OPLINE(); container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_IS TSRMLS_CC); + zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -23242,31 +22461,30 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HAND static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE + zval *container; zend_free_op free_op1; SAVE_OPLINE(); if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { - zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_W TSRMLS_CC); + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC); if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; } else { - zval *container; - if (IS_CV == IS_UNUSED) { zend_error_noreturn(E_ERROR, "Cannot use [] for reading"); } container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -23276,41 +22494,22 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_H { USE_OPLINE zend_free_op free_op1; - zval **container; + zval *container; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_CV) { - if (container != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(container); - } - } - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_UNSET TSRMLS_CC); + zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC); if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); - } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); - ZEND_VM_NEXT_OPCODE(); - } else { - zend_free_op free_res; - zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; - - PZVAL_UNLOCK(*retval_ptr, &free_res); - if (retval_ptr != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(retval_ptr); - } - PZVAL_LOCK(*retval_ptr); - FREE_OP_VAR_PTR(free_res); - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_CV(ZEND_OPCODE_HANDLER_ARGS) @@ -23322,36 +22521,25 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_CV(ZEN zval *offset; SAVE_OPLINE(); - container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { zend_error(E_NOTICE, "Trying to get property of non-object"); - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - + ZVAL_NULL(EX_VAR(opline->result.var)); } else { zval *retval; - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - /* here we are sure we are dealing with an object */ - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - - PZVAL_LOCK(retval); - EX_T(opline->result.var).var.ptr = retval; - - if (0) { - zval_ptr_dtor(&offset); - } else { + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC); + if (retval != EX_VAR(opline->result.var)) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); } } - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -23366,41 +22554,22 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDL USE_OPLINE zend_free_op free_op1; zval *property; - zval **container; + zval *container; SAVE_OPLINE(); property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property); - } else { + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC); - } if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - - /* We are going to assign the result by reference */ - if (opline->extended_value & ZEND_FETCH_MAKE_REF) { - zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; - - Z_DELREF_PP(retval_ptr); - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); - Z_ADDREF_PP(retval_ptr); - EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr; - EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; - } - + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -23410,28 +22579,21 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HAND USE_OPLINE zend_free_op free_op1; zval *property; - zval **container; + zval *container; SAVE_OPLINE(); property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property); - } else { + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_RW, 0 TSRMLS_CC); - } if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -23445,35 +22607,24 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HAND zval *offset; SAVE_OPLINE(); - container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - + ZVAL_NULL(EX_VAR(opline->result.var)); } else { zval *retval; - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - /* here we are sure we are dealing with an object */ - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - - PZVAL_LOCK(retval); - EX_T(opline->result.var).var.ptr = retval; - - if (0) { - zval_ptr_dtor(&offset); - } else { + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC); + if (retval != EX_VAR(opline->result.var)) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); } } - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -23481,33 +22632,26 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HAND static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE + zval *container; if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { /* Behave like FETCH_OBJ_W */ zend_free_op free_op1; zval *property; - zval **container; SAVE_OPLINE(); property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property); - } else { + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, 0 TSRMLS_CC); - } if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } else { @@ -23518,42 +22662,22 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCOD static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_free_op free_op1, free_res; - zval **container; - zval *property; + zend_free_op free_op1; + zval *container, *property; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - if (IS_VAR == IS_CV) { - if (container != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(container); - } - } - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property); - } else { + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_UNSET, 0 TSRMLS_CC); - } if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - - PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res); - if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr); - } - PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr); - FREE_OP_VAR_PTR(free_res); + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -23562,26 +22686,19 @@ static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLE { USE_OPLINE zend_free_op free_op1; - zval **object_ptr; + zval *object; zval *property_name; SAVE_OPLINE(); - object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - if (0) { - MAKE_REAL_ZVAL_PTR(property_name); - } - if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property_name); - } else { + zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC); - } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; /* assign_obj has two opcodes! */ CHECK_EXCEPTION(); ZEND_VM_INC_OPCODE(); @@ -23592,76 +22709,59 @@ static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLE { USE_OPLINE zend_free_op free_op1; - zval **object_ptr; + zval *object_ptr; SAVE_OPLINE(); object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - if (Z_TYPE_PP(object_ptr) == IS_OBJECT) { + if (UNEXPECTED(Z_ISREF_P(object_ptr)) && Z_TYPE_P(Z_REFVAL_P(object_ptr)) == IS_OBJECT) { + object_ptr = Z_REFVAL_P(object_ptr); + } + if (Z_TYPE_P(object_ptr) == IS_OBJECT) { zval *property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - if (0) { - MAKE_REAL_ZVAL_PTR(property_name); - } - zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property_name); - } else { + zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC); - } } else { zend_free_op free_op_data1, free_op_data2; zval *value; - zval *dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - zval **variable_ptr_ptr; + zval *dim = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); + zval *variable_ptr; - zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_CV, BP_VAR_W TSRMLS_CC); + zend_fetch_dimension_address_W(EX_VAR((opline+1)->op2.var), object_ptr, dim, IS_CV TSRMLS_CC); value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); - variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); - if (UNEXPECTED(variable_ptr_ptr == NULL)) { - if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) { - if (RETURN_VALUE_USED(opline)) { - zval *retval; - - ALLOC_ZVAL(retval); - ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1); - INIT_PZVAL(retval); - EX_T(opline->result.var).var.ptr = retval; - } - } else if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - } - } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) { + variable_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); + if (UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) { + zend_assign_to_string_offset(variable_ptr, value, (opline+1)->op1_type, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC); + } else if (UNEXPECTED(variable_ptr == &EG(error_zval))) { if (IS_TMP_FREE(free_op_data1)) { zval_dtor(value); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } + FREE_OP_VAR_PTR(free_op_data2); } else { if ((opline+1)->op1_type == IS_TMP_VAR) { - value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_tmp_to_variable(variable_ptr, value TSRMLS_CC); } else if ((opline+1)->op1_type == IS_CONST) { - value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_const_to_variable(variable_ptr, value TSRMLS_CC); } else { - value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_to_variable(variable_ptr, value TSRMLS_CC); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(value); - EX_T(opline->result.var).var.ptr = value; + ZVAL_COPY(EX_VAR(opline->result.var), value); } + FREE_OP_VAR_PTR(free_op_data2); } - FREE_OP_VAR_PTR(free_op_data2); FREE_OP_IF_VAR(free_op_data1); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; /* assign_dim has two opcodes! */ CHECK_EXCEPTION(); ZEND_VM_INC_OPCODE(); @@ -23673,50 +22773,35 @@ static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_AR USE_OPLINE zend_free_op free_op1; zval *value; - zval **variable_ptr_ptr; + zval *variable_ptr; SAVE_OPLINE(); value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - variable_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) { - if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_CV TSRMLS_CC)) { - if (RETURN_VALUE_USED(opline)) { - zval *retval; - - ALLOC_ZVAL(retval); - ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1); - INIT_PZVAL(retval); - EX_T(opline->result.var).var.ptr = retval; - } - } else if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - } - } else if (IS_VAR == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) { + zend_assign_to_string_offset(variable_ptr, value, IS_CV, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC); + } else if (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) { if (0) { zval_dtor(value); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } } else { if (IS_CV == IS_TMP_VAR) { - value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_tmp_to_variable(variable_ptr, value TSRMLS_CC); } else if (IS_CV == IS_CONST) { - value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_const_to_variable(variable_ptr, value TSRMLS_CC); } else { - value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_to_variable(variable_ptr, value TSRMLS_CC); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(value); - EX_T(opline->result.var).var.ptr = value; + ZVAL_COPY(EX_VAR(opline->result.var), value); } + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; - /* zend_assign_to_variable() always takes care of op2, never free it! */ CHECK_EXCEPTION(); @@ -23726,20 +22811,19 @@ static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_AR static int ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_free_op free_op1, free_op2; - zval **variable_ptr_ptr; - zval **value_ptr_ptr; + zend_free_op free_op1; + zval *variable_ptr; + zval *value_ptr; SAVE_OPLINE(); - value_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op2.var TSRMLS_CC); + value_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op2.var TSRMLS_CC); if (IS_CV == IS_VAR && - value_ptr_ptr && - !Z_ISREF_PP(value_ptr_ptr) && opline->extended_value == ZEND_RETURNS_FUNCTION && - !EX_T(opline->op2.var).var.fcall_returned_reference) { - if (free_op2.var == NULL) { - PZVAL_LOCK(*value_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */ + !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF) && + !Z_ISREF_P(value_ptr)) { + if (!0) { + PZVAL_LOCK(value_ptr); /* undo the effect of get_zval_ptr_ptr() */ } zend_error(E_STRICT, "Only variables should be assigned by reference"); if (UNEXPECTED(EG(exception) != NULL)) { @@ -23748,29 +22832,39 @@ static int ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLE } return ZEND_ASSIGN_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } else if (IS_CV == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) { - PZVAL_LOCK(*value_ptr_ptr); + if (!0) { + PZVAL_LOCK(value_ptr); + } } - if (IS_VAR == IS_VAR && UNEXPECTED(EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr)) { + + variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + if (IS_VAR == IS_VAR && + UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT) && + UNEXPECTED(!Z_ISREF_P(variable_ptr))) { zend_error_noreturn(E_ERROR, "Cannot assign by reference to overloaded object"); } - - variable_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if ((IS_CV == IS_VAR && UNEXPECTED(value_ptr_ptr == NULL)) || - (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL))) { + if ((IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) || + (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET))) { zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets nor overloaded objects"); } - zend_assign_to_variable_reference(variable_ptr_ptr, value_ptr_ptr TSRMLS_CC); + if ((IS_VAR == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) || + (IS_CV == IS_VAR && UNEXPECTED(value_ptr == &EG(error_zval)))) { + variable_ptr = &EG(uninitialized_zval); + } else { + zend_assign_to_variable_reference(variable_ptr, value_ptr TSRMLS_CC); + } if (IS_CV == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) { - Z_DELREF_PP(variable_ptr_ptr); + if (!0) { + Z_DELREF_P(variable_ptr); + } } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(*variable_ptr_ptr); - EX_T(opline->result.var).var.ptr = *variable_ptr_ptr; + ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr); } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -23780,10 +22874,9 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_ { USE_OPLINE zval *function_name; - char *function_name_strval; - int function_name_strlen; zend_free_op free_op1; call_slot *call = EX(call_slots) + opline->result.num; + zval *object; SAVE_OPLINE(); @@ -23797,33 +22890,30 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_ zend_error_noreturn(E_ERROR, "Method name must be a string"); } - function_name_strval = Z_STRVAL_P(function_name); - function_name_strlen = Z_STRLEN_P(function_name); + object = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL; - call->object = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - - if (EXPECTED(call->object != NULL) && - EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) { - call->called_scope = Z_OBJCE_P(call->object); + if (EXPECTED(call->object != NULL)) { + call->called_scope = zend_get_class_entry(call->object TSRMLS_CC); if (IS_CV != IS_CONST || - (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) { - zval *object = call->object; + (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope)) == NULL) { + zend_object *object = call->object; - if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) { + if (UNEXPECTED(object->handlers->get_method == NULL)) { zend_error_noreturn(E_ERROR, "Object does not support method calls"); } /* First, locate the function. */ - call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); + call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); if (UNEXPECTED(call->fbc == NULL)) { - zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval); + zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name)); } if (IS_CV == IS_CONST && EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) && EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) && EXPECTED(call->object == object)) { - CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc); + CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope, call->fbc); } } } else { @@ -23831,28 +22921,20 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_ HANDLE_EXCEPTION(); } - zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval); + zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", Z_STRVAL_P(function_name)); } if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) { call->object = NULL; } else { - if (!PZVAL_IS_REF(call->object)) { - Z_ADDREF_P(call->object); /* For $this pointer */ - } else { - zval *this_ptr; - ALLOC_ZVAL(this_ptr); - INIT_PZVAL_COPY(this_ptr, call->object); - zval_copy_ctor(this_ptr); - call->object = this_ptr; - } + GC_REFCOUNT(call->object)++; /* For $this pointer */ } call->num_additional_args = 0; call->is_ctor_call = 0; EX(call) = call; - zval_ptr_dtor_nogc(&free_op1.var); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -23869,21 +22951,21 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_ if (IS_VAR == IS_CONST) { /* no function found. try a static method in class */ - if (CACHED_PTR(opline->op1.literal->cache_slot)) { - ce = CACHED_PTR(opline->op1.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } if (UNEXPECTED(ce == NULL)) { zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv)); } - CACHE_PTR(opline->op1.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce); } call->called_scope = ce; } else { - ce = EX_T(opline->op1.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op1.var)); if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) { call->called_scope = EG(called_scope); @@ -23894,51 +22976,40 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_ if (IS_VAR == IS_CONST && IS_CV == IS_CONST && - CACHED_PTR(opline->op2.literal->cache_slot)) { - call->fbc = CACHED_PTR(opline->op2.literal->cache_slot); + CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else if (IS_VAR != IS_CONST && IS_CV == IS_CONST && - (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) { + (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce))) { /* do nothing */ } else if (IS_CV != IS_UNUSED) { - char *function_name_strval = NULL; - int function_name_strlen = 0; - if (IS_CV == IS_CONST) { - function_name_strval = Z_STRVAL_P(opline->op2.zv); - function_name_strlen = Z_STRLEN_P(opline->op2.zv); - } else { - function_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - + function_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); + if (IS_CV != IS_CONST) { if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } zend_error_noreturn(E_ERROR, "Function name must be a string"); - } else { - function_name_strval = Z_STRVAL_P(function_name); - function_name_strlen = Z_STRLEN_P(function_name); } } - if (function_name_strval) { - if (ce->get_static_method) { - call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC); + if (ce->get_static_method) { + call->fbc = ce->get_static_method(ce, Z_STR_P(function_name) TSRMLS_CC); + } else { + call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); + } + if (UNEXPECTED(call->fbc == NULL)) { + zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name)); + } + if (IS_CV == IS_CONST && + EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) && + EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) { + if (IS_VAR == IS_CONST) { + CACHE_PTR(Z_CACHE_SLOT_P(function_name), call->fbc); } else { - call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); - } - if (UNEXPECTED(call->fbc == NULL)) { - zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval); - } - if (IS_CV == IS_CONST && - EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) && - EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) { - if (IS_VAR == IS_CONST) { - CACHE_PTR(opline->op2.literal->cache_slot, call->fbc); - } else { - CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc); - } + CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), ce, call->fbc); } } if (IS_CV != IS_CONST) { @@ -23948,8 +23019,8 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_ if (UNEXPECTED(ce->constructor == NULL)) { zend_error_noreturn(E_ERROR, "Cannot call constructor"); } - if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { - zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name); + if (Z_OBJ(EG(This)) && Z_OBJCE(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { + zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name->val); } call->fbc = ce->constructor; } @@ -23957,21 +23028,21 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_ if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) { call->object = NULL; } else { - if (EG(This) && - Z_OBJ_HT_P(EG(This))->get_class_entry && - !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) { + if (Z_OBJ(EG(This)) && + Z_OBJ_HT(EG(This))->get_class_entry && + !instanceof_function(Z_OBJCE(EG(This)), ce TSRMLS_CC)) { /* We are calling method of the other (incompatible) class, but passing $this. This is done for compatibility with php-4. */ if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) { - zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name); + zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val); } else { /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */ - zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name); + zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val); } } - if ((call->object = EG(This))) { - Z_ADDREF_P(call->object); - call->called_scope = Z_OBJCE_P(call->object); + call->object = Z_OBJ(EG(This)); + if (call->object) { + GC_REFCOUNT(call->object)++; } } @@ -23987,11 +23058,12 @@ static int ZEND_FASTCALL ZEND_CASE_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS { USE_OPLINE zend_free_op free_op1; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - is_equal_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + fast_equal_function(result, + _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -24001,35 +23073,31 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE { USE_OPLINE zend_free_op free_op1; - zval *expr_ptr; + zval *expr_ptr, new_expr; SAVE_OPLINE(); - if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) { - zval **expr_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - - if (IS_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) { + if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && + (opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) { + expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets"); } - SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); - expr_ptr = *expr_ptr_ptr; + SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr); Z_ADDREF_P(expr_ptr); + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; } else { - expr_ptr=_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + expr_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); if (0) { /* temporary variable */ - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - } else if (IS_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) { - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - zendi_zval_copy_ctor(*expr_ptr); - zval_ptr_dtor_nogc(&free_op1.var); - } else if (IS_VAR == IS_CV) { + ZVAL_COPY_VALUE(&new_expr, expr_ptr); + expr_ptr = &new_expr; + } else if (IS_VAR == IS_CONST) { + ZVAL_DUP(&new_expr, expr_ptr); + expr_ptr = &new_expr; + } else if (Z_ISREF_P(expr_ptr)) { + ZVAL_DUP(&new_expr, Z_REFVAL_P(expr_ptr)); + expr_ptr = &new_expr; + zval_ptr_dtor_nogc(free_op1.var); + } else if (IS_VAR == IS_CV && Z_REFCOUNTED_P(expr_ptr)) { Z_ADDREF_P(expr_ptr); } } @@ -24037,42 +23105,49 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE if (IS_CV != IS_UNUSED) { zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); + zend_string *str; ulong hval; +add_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: hval = zend_dval_to_lval(Z_DVAL_P(offset)); goto num_index; case IS_LONG: - case IS_BOOL: hval = Z_LVAL_P(offset); num_index: - zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL); + zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); break; case IS_STRING: - if (IS_CV == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); + str = Z_STR_P(offset); + if (IS_CV != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index); } - zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL); +str_index: + zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); break; case IS_NULL: - zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); + str = STR_EMPTY_ALLOC(); + goto str_index; + case IS_FALSE: + hval = 0; + goto num_index; + case IS_TRUE: + hval = 1; + goto num_index; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto add_again; break; default: zend_error(E_WARNING, "Illegal offset type"); - zval_ptr_dtor(&expr_ptr); + zval_ptr_dtor(expr_ptr); /* do nothing */ break; } } else { - zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL); - } - if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) { - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -24080,9 +23155,26 @@ num_index: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { + zval *array; + zend_uint size; USE_OPLINE - array_init(&EX_T(opline->result.var).tmp_var); + array = EX_VAR(opline->result.var); + if (IS_VAR != IS_UNUSED) { + size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; + } else { + size = 0; + } + ZVAL_NEW_ARR(array); + zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); + + if (IS_VAR != IS_UNUSED) { + /* Explicitly initialize array as not-packed if flag is set */ + if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) { + zend_hash_real_init(Z_ARRVAL_P(array), 0); + } + } + if (IS_VAR == IS_UNUSED) { ZEND_VM_NEXT_OPCODE(); #if 0 || IS_VAR != IS_UNUSED @@ -24096,94 +23188,100 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER { USE_OPLINE zend_free_op free_op1; - zval **container; + zval *container; zval *offset; ulong hval; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) { + if (IS_VAR != IS_UNUSED) { SEPARATE_ZVAL_IF_NOT_REF(container); } offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - if (IS_VAR != IS_VAR || container) { - switch (Z_TYPE_PP(container)) { - case IS_ARRAY: { - HashTable *ht = Z_ARRVAL_PP(container); - - switch (Z_TYPE_P(offset)) { - case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); - zend_hash_index_del(ht, hval); - break; - case IS_RESOURCE: - case IS_BOOL: - case IS_LONG: - hval = Z_LVAL_P(offset); - zend_hash_index_del(ht, hval); - break; - case IS_STRING: - if (IS_CV == IS_CV || IS_CV == IS_VAR) { - Z_ADDREF_P(offset); - } - if (IS_CV == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); - } - if (ht == &EG(symbol_table)) { - zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC); - } else { - zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval); - } - if (IS_CV == IS_CV || IS_CV == IS_VAR) { - zval_ptr_dtor(&offset); - } - break; +container_again: + switch (Z_TYPE_P(container)) { + case IS_ARRAY: { + HashTable *ht = Z_ARRVAL_P(container); +offset_again: + switch (Z_TYPE_P(offset)) { + case IS_DOUBLE: + hval = zend_dval_to_lval(Z_DVAL_P(offset)); + zend_hash_index_del(ht, hval); + break; + case IS_LONG: + hval = Z_LVAL_P(offset); num_index_dim: - zend_hash_index_del(ht, hval); - if (IS_CV == IS_CV || IS_CV == IS_VAR) { - zval_ptr_dtor(&offset); - } - break; - case IS_NULL: - zend_hash_del(ht, "", sizeof("")); - break; - default: - zend_error(E_WARNING, "Illegal offset type in unset"); - break; - } - - break; + zend_hash_index_del(ht, hval); + break; + case IS_STRING: + if (IS_CV == IS_CV || IS_CV == IS_VAR) { + if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset); + } + if (IS_CV != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto numeric_index_dim); + } + if (ht == &EG(symbol_table).ht) { + zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC); + } else { + zend_hash_del(ht, Z_STR_P(offset)); + } + if (IS_CV == IS_CV || IS_CV == IS_VAR) { + zval_ptr_dtor(offset); + } + break; +numeric_index_dim: + zend_hash_index_del(ht, hval); + if (IS_CV == IS_CV || IS_CV == IS_VAR) { + zval_ptr_dtor(offset); + } + break; + case IS_NULL: + zend_hash_del(ht, STR_EMPTY_ALLOC()); + break; + case IS_FALSE: + hval = 0; + goto num_index_dim; + case IS_TRUE: + hval = 1; + goto num_index_dim; + case IS_RESOURCE: + hval = Z_RES_HANDLE_P(offset); + goto num_index_dim; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto offset_again; + break; + default: + zend_error(E_WARNING, "Illegal offset type in unset"); + break; } - case IS_OBJECT: - if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use object as array"); - } - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC); - if (0) { - zval_ptr_dtor(&offset); - } else { - - } - break; - case IS_STRING: - zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); - ZEND_VM_CONTINUE(); /* bailed out before */ - default: - break; + break; } - } else { + case IS_OBJECT: + if (UNEXPECTED(Z_OBJ_HT_P(container)->unset_dimension == NULL)) { + zend_error_noreturn(E_ERROR, "Cannot use object as array"); + } +//??? if (IS_CV == IS_CONST) { +//??? zval_copy_ctor(offset); +//??? } + Z_OBJ_HT_P(container)->unset_dimension(container, offset TSRMLS_CC); - } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + break; + case IS_STRING: + case IS_STR_OFFSET: + zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); + ZEND_VM_CONTINUE(); /* bailed out before */ + case IS_REFERENCE: + container = Z_REFVAL_P(container); + goto container_again; + break; + default: + break; + } + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -24192,91 +23290,82 @@ static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER { USE_OPLINE zend_free_op free_op1; - zval **container; + zval *container; zval *offset; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + if (IS_VAR == IS_VAR && Z_TYPE_P(container) == IS_STR_OFFSET) { + zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); + } offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - if (IS_VAR != IS_VAR || container) { - if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(container); - } - if (Z_TYPE_PP(container) == IS_OBJECT) { - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - if (Z_OBJ_HT_P(*container)->unset_property) { - Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to unset property of non-object"); - } - if (0) { - zval_ptr_dtor(&offset); - } else { - - } + ZVAL_DEREF(container); + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->unset_property) { + Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); } else { - + zend_error(E_NOTICE, "Trying to unset property of non-object"); } - } else { - } - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CV(int prop_dim, ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_free_op free_op1; zval *container; - zval **value = NULL; - int result = 0; + int result; ulong hval; zval *offset; SAVE_OPLINE(); - container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) { - HashTable *ht; - int isset = 0; - - ht = Z_ARRVAL_P(container); + if (Z_TYPE_P(container) == IS_ARRAY) { + HashTable *ht = Z_ARRVAL_P(container); + zval *value = NULL; + zend_string *str; +isset_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: hval = zend_dval_to_lval(Z_DVAL_P(offset)); goto num_index_prop; - case IS_RESOURCE: - case IS_BOOL: case IS_LONG: hval = Z_LVAL_P(offset); num_index_prop: - if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) { - isset = 1; - } + value = zend_hash_index_find(ht, hval); break; case IS_STRING: - if (IS_CV == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); - } - if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) { - isset = 1; + str = Z_STR_P(offset); + if (IS_CV != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index_prop); } +str_index_prop: + value = zend_hash_find_ind(ht, str); break; case IS_NULL: - if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) { - isset = 1; - } + str = STR_EMPTY_ALLOC(); + goto str_index_prop; + break; + case IS_FALSE: + hval = 0; + goto num_index_prop; + case IS_TRUE: + hval = 0; + goto num_index_prop; + case IS_RESOURCE: + hval = Z_RES_HANDLE_P(offset); + goto num_index_prop; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto isset_again; break; default: zend_error(E_WARNING, "Illegal offset type in isset or empty"); @@ -24284,118 +23373,103 @@ num_index_prop: } if (opline->extended_value & ZEND_ISSET) { - if (isset && Z_TYPE_PP(value) == IS_NULL) { - result = 0; - } else { - result = isset; - } + /* > IS_NULL means not IS_UNDEF and not IS_NULL */ + result = (value != NULL && Z_TYPE_P(value) > IS_NULL); } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { - if (!isset || !i_zend_is_true(*value TSRMLS_CC)) { - result = 0; - } else { - result = 1; - } + result = (value == NULL || !i_zend_is_true(value TSRMLS_CC)); } - } else if (Z_TYPE_P(container) == IS_OBJECT) { - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - if (prop_dim) { - if (Z_OBJ_HT_P(container)->has_property) { - result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check property of non-object"); - result = 0; - } + if (Z_OBJ_HT_P(container)->has_dimension) { + result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); } else { - if (Z_OBJ_HT_P(container)->has_dimension) { - result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check element of non-array"); - result = 0; - } + zend_error(E_NOTICE, "Trying to check element of non-array"); + result = 0; } - if (0) { - zval_ptr_dtor(&offset); - } else { - + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; } - } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */ + } else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */ zval tmp; - if (Z_TYPE_P(offset) != IS_LONG) { - if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */ + result = 0; + if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) { + if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */ || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { - ZVAL_COPY_VALUE(&tmp, offset); - zval_copy_ctor(&tmp); + ZVAL_DUP(&tmp, offset); convert_to_long(&tmp); offset = &tmp; - } else { - /* can not be converted to proper offset, return "not set" */ - result = 0; } } if (Z_TYPE_P(offset) == IS_LONG) { - if (opline->extended_value & ZEND_ISSET) { - if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { - result = 1; - } - } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { - if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') { + if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { + if ((opline->extended_value & ZEND_ISSET) || + Z_STRVAL_P(container)[offset->value.lval] != '0') { result = 1; } } } - - } else { - - } - - Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; - if (opline->extended_value & ZEND_ISSET) { - Z_LVAL(EX_T(opline->result.var).tmp_var) = result; + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } } else { - Z_LVAL(EX_T(opline->result.var).tmp_var) = !result; + result = ((opline->extended_value & ZEND_ISSET) == 0); } - zval_ptr_dtor_nogc(&free_op1.var); - + ZVAL_BOOL(EX_VAR(opline->result.var), result); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CV(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} - static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CV(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + zend_free_op free_op1; + zval *container; + int result; + zval *offset; + + SAVE_OPLINE(); + container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); + + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->has_property) { + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); + } else { + zend_error(E_NOTICE, "Trying to check property of non-object"); + result = 0; + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else { + result = ((opline->extended_value & ZEND_ISSET) == 0); + } + + ZVAL_BOOL(EX_VAR(opline->result.var), result); + zval_ptr_dtor_nogc(free_op1.var); + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - /* The generator object is stored in return_value_ptr_ptr */ - zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr); + /* The generator object is stored in EX(return_value) */ + zend_generator *generator = (zend_generator *) EX(return_value); if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) { zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator"); } /* Destroy the previously yielded value */ - if (generator->value) { - zval_ptr_dtor(&generator->value); - } + zval_ptr_dtor(&generator->value); /* Destroy the previously yielded key */ - if (generator->key) { - zval_ptr_dtor(&generator->key); - } + zval_ptr_dtor(&generator->key); /* Set the new yielded value */ if (IS_VAR != IS_UNUSED) { @@ -24405,75 +23479,59 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG /* Constants and temporary variables aren't yieldable by reference, * but we still allow them with a notice. */ if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) { - zval *value, *copy; + zval *value; zend_error(E_NOTICE, "Only variable references should be yielded by reference"); value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); + ZVAL_COPY_VALUE(&generator->value, value); + if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1); /* Temporary variables don't need ctor copying */ if (!0) { - zval_copy_ctor(copy); + zval_copy_ctor(&generator->value); } - - generator->value = copy; } else { - zval **value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); + zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); - if (IS_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference"); } /* If a function call result is yielded and the function did * not return by reference we throw a notice. */ - if (IS_VAR == IS_VAR && !Z_ISREF_PP(value_ptr) + if (IS_VAR == IS_VAR && !Z_ISREF_P(value_ptr) && !(opline->extended_value == ZEND_RETURNS_FUNCTION - && EX_T(opline->op1.var).var.fcall_returned_reference) - && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) { + && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); - - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } else { SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr); - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } + ZVAL_COPY(&generator->value, value_ptr); - if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}; + if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}; } } else { zval *value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC); /* Consts, temporary variables and references need copying */ - if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR - || PZVAL_IS_REF(value) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); - - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } - - generator->value = copy; - zval_ptr_dtor_nogc(&free_op1.var); + if (IS_VAR == IS_CONST) { + ZVAL_DUP(&generator->value, value); + } else if (IS_VAR == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->value, value); + } else if (Z_ISREF_P(value)) { + ZVAL_DUP(&generator->value, Z_REFVAL_P(value)); + zval_ptr_dtor_nogc(free_op1.var); } else { if (IS_VAR == IS_CV) { - Z_ADDREF_P(value); + if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value); } - generator->value = value; + ZVAL_COPY_VALUE(&generator->value, value); } } } else { /* If no value was specified yield null */ - Z_ADDREF(EG(uninitialized_zval)); - generator->value = &EG(uninitialized_zval); + ZVAL_NULL(&generator->value); } /* Set the new yielded key */ @@ -24482,45 +23540,36 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); /* Consts, temporary variables and references need copying */ - if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR - || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, key); - - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } + if (IS_CV == IS_CONST) { + ZVAL_DUP(&generator->key, key); + } else if (IS_CV == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->key, key); + } else if (Z_ISREF_P(key)) { + ZVAL_DUP(&generator->key, Z_REFVAL_P(key)); - generator->key = copy; } else { - Z_ADDREF_P(key); - generator->key = key; + if (IS_CV == IS_CV) { + if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key); + } + ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE_P(generator->key) == IS_LONG - && Z_LVAL_P(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_LONG + && Z_LVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL_P(generator->key); + generator->largest_used_integer_key = Z_LVAL(generator->key); } - } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - - ALLOC_INIT_ZVAL(generator->key); - ZVAL_LONG(generator->key, generator->largest_used_integer_key); + ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ - generator->send_target = &EX_T(opline->result.var).var.ptr; - Z_ADDREF(EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + generator->send_target = EX_VAR(opline->result.var); + ZVAL_NULL(generator->send_target); } else { generator->send_target = NULL; } @@ -24542,10 +23591,10 @@ static int ZEND_FASTCALL ZEND_POW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op1; SAVE_OPLINE(); - pow_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op1.var); + pow_function(EX_VAR(opline->result.var), + _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op1.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -24581,7 +23630,7 @@ static int ZEND_FASTCALL ZEND_CLONE_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARG clone_call = Z_OBJ_HT_P(obj)->clone_obj; if (UNEXPECTED(clone_call == NULL)) { if (ce) { - zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name); + zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name->val); } else { zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object"); } @@ -24592,29 +23641,21 @@ static int ZEND_FASTCALL ZEND_CLONE_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARG /* Ensure that if we're calling a private function, we're allowed to do so. */ if (UNEXPECTED(ce != EG(scope))) { - zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : ""); + zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name->val, EG(scope) ? EG(scope)->name->val : ""); } } else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) { /* Ensure that if we're calling a protected function, we're allowed to do so. */ if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), EG(scope)))) { - zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : ""); + zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name->val, EG(scope) ? EG(scope)->name->val : ""); } } } if (EXPECTED(EG(exception) == NULL)) { - zval *retval; - - ALLOC_ZVAL(retval); - Z_OBJVAL_P(retval) = clone_call(obj TSRMLS_CC); - Z_TYPE_P(retval) = IS_OBJECT; - Z_SET_REFCOUNT_P(retval, 1); - Z_SET_ISREF_P(retval); + ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(obj TSRMLS_CC)); if (!RETURN_VALUE_USED(opline) || UNEXPECTED(EG(exception) != NULL)) { - zval_ptr_dtor(&retval); - } else { - EX_T(opline->result.var).var.ptr = retval; + zval_ptr_dtor(EX_VAR(opline->result.var)); } } @@ -24635,7 +23676,7 @@ static int ZEND_FASTCALL ZEND_EXIT_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS if (Z_TYPE_P(ptr) == IS_LONG) { EG(exit_status) = Z_LVAL_P(ptr); } else { - zend_print_variable(ptr); + zend_print_variable(ptr TSRMLS_CC); } } @@ -24648,18 +23689,18 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(int { USE_OPLINE zend_free_op free_op_data1; - zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); - zval *object; + zval *object = _get_obj_zval_ptr_unused(TSRMLS_C); zval *property = opline->op2.zv; - zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); + zval *value; int have_get_ptr = 0; - if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - make_real_object(object_ptr TSRMLS_CC); - object = *object_ptr; + object = make_real_object(object TSRMLS_CC); + + value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { zend_error(E_WARNING, "Attempt to assign property of non-object"); @@ -24667,81 +23708,67 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(int FREE_OP(free_op_data1); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } } else { /* here we are sure we are dealing with an object */ - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - - /* here property is a string */ if (opline->extended_value == ZEND_ASSIGN_OBJ && Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); if (zptr != NULL) { /* NULL means no success in getting PTR */ SEPARATE_ZVAL_IF_NOT_REF(zptr); have_get_ptr = 1; - binary_op(*zptr, *zptr, value TSRMLS_CC); + binary_op(zptr, zptr, value TSRMLS_CC); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(*zptr); - EX_T(opline->result.var).var.ptr = *zptr; + ZVAL_COPY(EX_VAR(opline->result.var), zptr); } } } if (!have_get_ptr) { zval *z = NULL; + zval rv; if (opline->extended_value == ZEND_ASSIGN_OBJ) { if (Z_OBJ_HT_P(object)->read_property) { - z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC); } } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { if (Z_OBJ_HT_P(object)->read_dimension) { - z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC); + z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R, &rv TSRMLS_CC); } } if (z) { if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); zval_dtor(z); - FREE_ZVAL(z); } - z = value; + ZVAL_COPY_VALUE(z, value); } - Z_ADDREF_P(z); - SEPARATE_ZVAL_IF_NOT_REF(&z); +//??? if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); + SEPARATE_ZVAL_IF_NOT_REF(z); binary_op(z, z, value TSRMLS_CC); if (opline->extended_value == ZEND_ASSIGN_OBJ) { - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(z); - EX_T(opline->result.var).var.ptr = z; + ZVAL_COPY(EX_VAR(opline->result.var), z); } - zval_ptr_dtor(&z); + zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to assign property of non-object"); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } } } - if (0) { - zval_ptr_dtor(&property); - } else { - - } FREE_OP(free_op_data1); } @@ -24751,178 +23778,288 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(int ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_UNUSED_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_free_op free_op_data2, free_op_data1; - zval **var_ptr; - zval *value; + zval *var_ptr; + zval *value, *container; SAVE_OPLINE(); - switch (opline->extended_value) { - case ZEND_ASSIGN_OBJ: - return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - break; - case ZEND_ASSIGN_DIM: { - zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); - - if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); - } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) { - if (IS_UNUSED == IS_VAR && !0) { - Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */ - } - return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - } else { - zval *dim = opline->op2.zv; + container = _get_obj_zval_ptr_unused(TSRMLS_C); + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { + zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); + } else if (UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { + if (IS_UNUSED == IS_VAR && !0) { + Z_ADDREF_P(container); /* undo the effect of get_obj_zval_ptr_ptr() */ + } + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else { + zval *dim = opline->op2.zv; - zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_CONST, BP_VAR_RW TSRMLS_CC); - value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); - var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); - } - } - break; - default: - value = opline->op2.zv; - var_ptr = NULL; - /* do nothing */ - break; + zend_fetch_dimension_address_RW(EX_VAR((opline+1)->op2.var), container, dim, IS_CONST TSRMLS_CC); + value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); + var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); } - if (UNEXPECTED(var_ptr == NULL)) { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); } - if (UNEXPECTED(*var_ptr == &EG(error_zval))) { - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + if (UNEXPECTED(var_ptr == &EG(error_zval))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); } + goto assign_op_dim_exit; + } + SEPARATE_ZVAL_IF_NOT_REF(var_ptr); + ZVAL_DEREF(var_ptr); - CHECK_EXCEPTION(); - if (opline->extended_value == ZEND_ASSIGN_DIM) { - ZEND_VM_INC_OPCODE(); + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) && + UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) { + /* proxy object */ + zval rv; + zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC); + Z_ADDREF_P(objval); + binary_op(objval, objval, value TSRMLS_CC); + Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); + zval_ptr_dtor(objval); + } else { + binary_op(var_ptr, var_ptr, value TSRMLS_CC); + } + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + } + +assign_op_dim_exit: + + FREE_OP(free_op_data1); + FREE_OP_VAR_PTR(free_op_data2); + + CHECK_EXCEPTION(); + ZEND_VM_INC_OPCODE(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + + zval *var_ptr; + zval *value; + + SAVE_OPLINE(); + value = opline->op2.zv; + var_ptr = NULL; + + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { + zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); + } + + if (IS_UNUSED == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); } - ZEND_VM_NEXT_OPCODE(); + goto assign_op_exit; } SEPARATE_ZVAL_IF_NOT_REF(var_ptr); + ZVAL_DEREF(var_ptr); - if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) - && Z_OBJ_HANDLER_PP(var_ptr, get) - && Z_OBJ_HANDLER_PP(var_ptr, set)) { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) && + UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) { /* proxy object */ - zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); + zval rv; + zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC); Z_ADDREF_P(objval); binary_op(objval, objval, value TSRMLS_CC); - Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC); - zval_ptr_dtor(&objval); + Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); + zval_ptr_dtor(objval); } else { - binary_op(*var_ptr, *var_ptr, value TSRMLS_CC); + binary_op(var_ptr, var_ptr, value TSRMLS_CC); } - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(*var_ptr); - EX_T(opline->result.var).var.ptr = *var_ptr; + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } - if (opline->extended_value == ZEND_ASSIGN_DIM) { - FREE_OP(free_op_data1); - FREE_OP_VAR_PTR(free_op_data2); +assign_op_exit: - CHECK_EXCEPTION(); - ZEND_VM_INC_OPCODE(); - } else { - CHECK_EXCEPTION(); - } + CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval **object_ptr; zval *object; zval *property; - zval **retval; + zval *retval; int have_get_ptr = 0; SAVE_OPLINE(); - object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); + object = _get_obj_zval_ptr_unused(TSRMLS_C); property = opline->op2.zv; - retval = &EX_T(opline->result.var).var.ptr; + retval = EX_VAR(opline->result.var); - if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } - make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ - object = *object_ptr; + object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */ if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - *retval = &EG(uninitialized_zval); + ZVAL_NULL(retval); } CHECK_EXCEPTION(); @@ -24931,59 +24068,49 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_CONST(incde /* here we are sure we are dealing with an object */ - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); if (zptr != NULL) { /* NULL means no success in getting PTR */ SEPARATE_ZVAL_IF_NOT_REF(zptr); have_get_ptr = 1; - incdec_op(*zptr); + incdec_op(zptr); if (RETURN_VALUE_USED(opline)) { - *retval = *zptr; - PZVAL_LOCK(*retval); + ZVAL_COPY(retval, zptr); } } } if (!have_get_ptr) { + zval rv; + if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC); if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); zval_dtor(z); - FREE_ZVAL(z); } - z = value; + ZVAL_COPY_VALUE(z, value); } - Z_ADDREF_P(z); - SEPARATE_ZVAL_IF_NOT_REF(&z); + if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); + SEPARATE_ZVAL_IF_NOT_REF(z); incdec_op(z); - *retval = z; - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - SELECTIVE_PZVAL_LOCK(*retval, opline); - zval_ptr_dtor(&z); + ZVAL_COPY_VALUE(retval, z); + Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); + SELECTIVE_PZVAL_LOCK(retval, opline); + zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - *retval = &EG(uninitialized_zval); + ZVAL_NULL(retval); } } } - if (0) { - zval_ptr_dtor(&property); - } else { - - } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -25003,23 +24130,21 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_CONST(incd { USE_OPLINE - zval **object_ptr; zval *object; zval *property; zval *retval; int have_get_ptr = 0; SAVE_OPLINE(); - object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); + object = _get_obj_zval_ptr_unused(TSRMLS_C); property = opline->op2.zv; - retval = &EX_T(opline->result.var).tmp_var; + retval = EX_VAR(opline->result.var); - if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } - make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ - object = *object_ptr; + object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */ if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); @@ -25032,60 +24157,47 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_CONST(incd /* here we are sure we are dealing with an object */ - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); if (zptr != NULL) { /* NULL means no success in getting PTR */ have_get_ptr = 1; SEPARATE_ZVAL_IF_NOT_REF(zptr); - ZVAL_COPY_VALUE(retval, *zptr); - zendi_zval_copy_ctor(*retval); + ZVAL_DUP(retval, zptr); - incdec_op(*zptr); + incdec_op(zptr); } } if (!have_get_ptr) { if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - zval *z_copy; + zval rv; + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC); + zval z_copy; if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); zval_dtor(z); - FREE_ZVAL(z); } - z = value; + ZVAL_COPY_VALUE(z, value); } - ZVAL_COPY_VALUE(retval, z); - zendi_zval_copy_ctor(*retval); - ALLOC_ZVAL(z_copy); - INIT_PZVAL_COPY(z_copy, z); - zendi_zval_copy_ctor(*z_copy); - incdec_op(z_copy); - Z_ADDREF_P(z); - Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + ZVAL_DUP(retval, z); + ZVAL_DUP(&z_copy, z); + incdec_op(&z_copy); + if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); + Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); zval_ptr_dtor(&z_copy); - zval_ptr_dtor(&z); + zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); ZVAL_NULL(retval); } } - if (0) { - zval_ptr_dtor(&property); - } else { - - } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -25116,29 +24228,19 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_CON if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { zend_error(E_NOTICE, "Trying to get property of non-object"); - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - + ZVAL_NULL(EX_VAR(opline->result.var)); } else { zval *retval; - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - /* here we are sure we are dealing with an object */ - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - - PZVAL_LOCK(retval); - EX_T(opline->result.var).var.ptr = retval; - - if (0) { - zval_ptr_dtor(&offset); - } else { + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC); + if (retval != EX_VAR(opline->result.var)) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); } } + CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -25153,38 +24255,20 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE USE_OPLINE zend_free_op free_op1; zval *property; - zval **container; + zval *container; SAVE_OPLINE(); property = opline->op2.zv; - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); - if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { + container = _get_obj_zval_ptr_unused(TSRMLS_C); + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property); - } else { + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC); - } if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); - } - - /* We are going to assign the result by reference */ - if (opline->extended_value & ZEND_FETCH_MAKE_REF) { - zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; - - Z_DELREF_PP(retval_ptr); - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); - Z_ADDREF_PP(retval_ptr); - EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr; - EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } CHECK_EXCEPTION(); @@ -25196,26 +24280,19 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCOD USE_OPLINE zend_free_op free_op1; zval *property; - zval **container; + zval *container; SAVE_OPLINE(); property = opline->op2.zv; - container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); + container = _get_obj_zval_ptr_unused(TSRMLS_C); - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property); - } else { + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_RW, 0 TSRMLS_CC); - } if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } CHECK_EXCEPTION(); @@ -25236,29 +24313,19 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCOD if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - + ZVAL_NULL(EX_VAR(opline->result.var)); } else { zval *retval; - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - /* here we are sure we are dealing with an object */ - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - - PZVAL_LOCK(retval); - EX_T(opline->result.var).var.ptr = retval; - - if (0) { - zval_ptr_dtor(&offset); - } else { + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC); + if (retval != EX_VAR(opline->result.var)) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); } } + CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -25266,31 +24333,24 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCOD static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE + zval *container; if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { /* Behave like FETCH_OBJ_W */ zend_free_op free_op1; zval *property; - zval **container; SAVE_OPLINE(); property = opline->op2.zv; - container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); + container = _get_obj_zval_ptr_unused(TSRMLS_C); - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property); - } else { + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, 0 TSRMLS_CC); - } if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } CHECK_EXCEPTION(); @@ -25303,41 +24363,22 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_free_op free_op1, free_res; - zval **container; - zval *property; + zend_free_op free_op1; + zval *container, *property; SAVE_OPLINE(); - container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); + container = _get_obj_zval_ptr_unused(TSRMLS_C); property = opline->op2.zv; - if (IS_UNUSED == IS_CV) { - if (container != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(container); - } - } - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property); - } else { + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_UNSET, 0 TSRMLS_CC); - } if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res); - if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr); - } - PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr); - FREE_OP_VAR_PTR(free_res); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -25346,25 +24387,18 @@ static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_ { USE_OPLINE - zval **object_ptr; + zval *object; zval *property_name; SAVE_OPLINE(); - object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); + object = _get_obj_zval_ptr_unused(TSRMLS_C); property_name = opline->op2.zv; - if (0) { - MAKE_REAL_ZVAL_PTR(property_name); - } - if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property_name); - } else { + zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC); - } /* assign_obj has two opcodes! */ CHECK_EXCEPTION(); @@ -25375,17 +24409,13 @@ static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_ static int ZEND_FASTCALL ZEND_ADD_CHAR_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *str = &EX_T(opline->result.var).tmp_var; + zval *str = EX_VAR(opline->result.var); SAVE_OPLINE(); if (IS_UNUSED == IS_UNUSED) { /* Initialize for erealloc in add_char_to_string */ - Z_STRVAL_P(str) = NULL; - Z_STRLEN_P(str) = 0; - Z_TYPE_P(str) = IS_STRING; - - INIT_PZVAL(str); + ZVAL_EMPTY_STRING(str); } add_char_to_string(str, str, opline->op2.zv); @@ -25398,17 +24428,13 @@ static int ZEND_FASTCALL ZEND_ADD_CHAR_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HA static int ZEND_FASTCALL ZEND_ADD_STRING_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *str = &EX_T(opline->result.var).tmp_var; + zval *str = EX_VAR(opline->result.var); SAVE_OPLINE(); if (IS_UNUSED == IS_UNUSED) { /* Initialize for erealloc in add_string_to_string */ - Z_STRVAL_P(str) = NULL; - Z_STRLEN_P(str) = 0; - Z_TYPE_P(str) = IS_STRING; - - INIT_PZVAL(str); + ZVAL_EMPTY_STRING(str); } add_string_to_string(str, str, opline->op2.zv); @@ -25422,10 +24448,9 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_O { USE_OPLINE zval *function_name; - char *function_name_strval; - int function_name_strlen; call_slot *call = EX(call_slots) + opline->result.num; + zval *object; SAVE_OPLINE(); @@ -25439,33 +24464,30 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_O zend_error_noreturn(E_ERROR, "Method name must be a string"); } - function_name_strval = Z_STRVAL_P(function_name); - function_name_strlen = Z_STRLEN_P(function_name); - - call->object = _get_obj_zval_ptr_unused(TSRMLS_C); + object = _get_obj_zval_ptr_unused(TSRMLS_C); + call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL; - if (EXPECTED(call->object != NULL) && - EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) { - call->called_scope = Z_OBJCE_P(call->object); + if (EXPECTED(call->object != NULL)) { + call->called_scope = zend_get_class_entry(call->object TSRMLS_CC); if (IS_CONST != IS_CONST || - (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) { - zval *object = call->object; + (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope)) == NULL) { + zend_object *object = call->object; - if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) { + if (UNEXPECTED(object->handlers->get_method == NULL)) { zend_error_noreturn(E_ERROR, "Object does not support method calls"); } /* First, locate the function. */ - call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); + call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); if (UNEXPECTED(call->fbc == NULL)) { - zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval); + zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name)); } if (IS_CONST == IS_CONST && EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) && EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) && EXPECTED(call->object == object)) { - CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc); + CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope, call->fbc); } } } else { @@ -25473,21 +24495,13 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_O HANDLE_EXCEPTION(); } - zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval); + zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", Z_STRVAL_P(function_name)); } if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) { call->object = NULL; } else { - if (!PZVAL_IS_REF(call->object)) { - Z_ADDREF_P(call->object); /* For $this pointer */ - } else { - zval *this_ptr; - ALLOC_ZVAL(this_ptr); - INIT_PZVAL_COPY(this_ptr, call->object); - zval_copy_ctor(this_ptr); - call->object = this_ptr; - } + GC_REFCOUNT(call->object)++; /* For $this pointer */ } call->num_additional_args = 0; @@ -25508,9 +24522,9 @@ static int ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPC zend_constant *c; zval *retval; - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - c = CACHED_PTR(opline->op2.literal->cache_slot); - } else if ((c = zend_quick_get_constant(opline->op2.literal + 1, opline->extended_value TSRMLS_CC)) == NULL) { + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + c = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + } else if ((c = zend_quick_get_constant(opline->op2.zv + 1, opline->extended_value TSRMLS_CC)) == NULL) { if ((opline->extended_value & IS_CONSTANT_UNQUALIFIED) != 0) { char *actual = (char *)zend_memrchr(Z_STRVAL_P(opline->op2.zv), '\\', Z_STRLEN_P(opline->op2.zv)); if(!actual) { @@ -25520,52 +24534,52 @@ static int ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPC } /* non-qualified constant - allow text substitution */ zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'", actual, actual); - ZVAL_STRINGL(&EX_T(opline->result.var).tmp_var, actual, Z_STRLEN_P(opline->op2.zv)-(actual - Z_STRVAL_P(opline->op2.zv)), 1); + ZVAL_STRINGL(EX_VAR(opline->result.var), actual, Z_STRLEN_P(opline->op2.zv)-(actual - Z_STRVAL_P(opline->op2.zv))); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } else { zend_error_noreturn(E_ERROR, "Undefined constant '%s'", Z_STRVAL_P(opline->op2.zv)); } } else { - CACHE_PTR(opline->op2.literal->cache_slot, c); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), c); } - retval = &EX_T(opline->result.var).tmp_var; - ZVAL_COPY_VALUE(retval, &c->value); - zval_copy_ctor(retval); + retval = EX_VAR(opline->result.var); + ZVAL_DUP(retval, &c->value); } else { /* class constant */ zend_class_entry *ce; - zval **value; + zval *value; if (IS_UNUSED == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - value = CACHED_PTR(opline->op2.literal->cache_slot); - ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value); - zval_copy_ctor(&EX_T(opline->result.var).tmp_var); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + value = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + ZVAL_DUP(EX_VAR(opline->result.var), value); goto constant_fetch_end; - } else if (CACHED_PTR(opline->op1.literal->cache_slot)) { - ce = CACHED_PTR(opline->op1.literal->cache_slot); + } else if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } if (UNEXPECTED(ce == NULL)) { zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv)); } - CACHE_PTR(opline->op1.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce); } } else { - ce = EX_T(opline->op1.var).class_entry; - if ((value = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce)) != NULL) { - ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value); - zval_copy_ctor(&EX_T(opline->result.var).tmp_var); + ce = Z_CE_P(EX_VAR(opline->op1.var)); + if ((value = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce)) != NULL) { + ZVAL_DUP(EX_VAR(opline->result.var), value); goto constant_fetch_end; } } - if (EXPECTED(zend_hash_quick_find(&ce->constants_table, Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv)+1, Z_HASH_P(opline->op2.zv), (void **) &value) == SUCCESS)) { - if (IS_CONSTANT_TYPE(Z_TYPE_PP(value))) { + if (EXPECTED((value = zend_hash_find(&ce->constants_table, Z_STR_P(opline->op2.zv))) != NULL)) { + if (Z_ISREF_P(value)) { + value = Z_REFVAL_P(value); + } + if (Z_CONSTANT_P(value)) { zend_class_entry *old_scope = EG(scope); EG(scope) = ce; @@ -25573,32 +24587,46 @@ static int ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPC EG(scope) = old_scope; } if (IS_UNUSED == IS_CONST) { - CACHE_PTR(opline->op2.literal->cache_slot, value); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), value); } else { - CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, value); + CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce, value); } - ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value); - zval_copy_ctor(&EX_T(opline->result.var).tmp_var); + ZVAL_DUP(EX_VAR(opline->result.var), value); } else if (Z_STRLEN_P(opline->op2.zv) == sizeof("class")-1 && memcmp(Z_STRVAL_P(opline->op2.zv), "class", sizeof("class") - 1) == 0) { /* "class" is assigned as a case-sensitive keyword from zend_do_resolve_class_name */ - ZVAL_STRINGL(&EX_T(opline->result.var).tmp_var, ce->name, ce->name_length, 1); + ZVAL_STR(EX_VAR(opline->result.var), ce->name); + STR_ADDREF(ce->name); } else { zend_error_noreturn(E_ERROR, "Undefined class constant '%s'", Z_STRVAL_P(opline->op2.zv)); } } constant_fetch_end: - if (Z_TYPE(EX_T(opline->result.var).tmp_var) == IS_ARRAY) { - zend_error_noreturn(E_ERROR, "Arrays are not allowed in constants at run-time"); - } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { + zval *array; + zend_uint size; USE_OPLINE - array_init(&EX_T(opline->result.var).tmp_var); + array = EX_VAR(opline->result.var); + if (IS_UNUSED != IS_UNUSED) { + size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; + } else { + size = 0; + } + ZVAL_NEW_ARR(array); + zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); + + if (IS_UNUSED != IS_UNUSED) { + /* Explicitly initialize array as not-packed if flag is set */ + if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) { + zend_hash_real_init(Z_ARRVAL_P(array), 0); + } + } + if (IS_UNUSED == IS_UNUSED) { ZEND_VM_NEXT_OPCODE(); #if 0 || IS_UNUSED != IS_UNUSED @@ -25612,91 +24640,98 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_H { USE_OPLINE - zval **container; + zval *container; zval *offset; ulong hval; SAVE_OPLINE(); - container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); - if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) { + container = _get_obj_zval_ptr_unused(TSRMLS_C); + if (IS_UNUSED != IS_UNUSED) { SEPARATE_ZVAL_IF_NOT_REF(container); } offset = opline->op2.zv; - if (IS_UNUSED != IS_VAR || container) { - switch (Z_TYPE_PP(container)) { - case IS_ARRAY: { - HashTable *ht = Z_ARRVAL_PP(container); - - switch (Z_TYPE_P(offset)) { - case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); - zend_hash_index_del(ht, hval); - break; - case IS_RESOURCE: - case IS_BOOL: - case IS_LONG: - hval = Z_LVAL_P(offset); - zend_hash_index_del(ht, hval); - break; - case IS_STRING: - if (IS_CONST == IS_CV || IS_CONST == IS_VAR) { - Z_ADDREF_P(offset); - } - if (IS_CONST == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); - } - if (ht == &EG(symbol_table)) { - zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC); - } else { - zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval); - } - if (IS_CONST == IS_CV || IS_CONST == IS_VAR) { - zval_ptr_dtor(&offset); - } - break; +container_again: + switch (Z_TYPE_P(container)) { + case IS_ARRAY: { + HashTable *ht = Z_ARRVAL_P(container); +offset_again: + switch (Z_TYPE_P(offset)) { + case IS_DOUBLE: + hval = zend_dval_to_lval(Z_DVAL_P(offset)); + zend_hash_index_del(ht, hval); + break; + case IS_LONG: + hval = Z_LVAL_P(offset); num_index_dim: - zend_hash_index_del(ht, hval); - if (IS_CONST == IS_CV || IS_CONST == IS_VAR) { - zval_ptr_dtor(&offset); - } - break; - case IS_NULL: - zend_hash_del(ht, "", sizeof("")); - break; - default: - zend_error(E_WARNING, "Illegal offset type in unset"); - break; - } - - break; + zend_hash_index_del(ht, hval); + break; + case IS_STRING: + if (IS_CONST == IS_CV || IS_CONST == IS_VAR) { + if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset); + } + if (IS_CONST != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto numeric_index_dim); + } + if (ht == &EG(symbol_table).ht) { + zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC); + } else { + zend_hash_del(ht, Z_STR_P(offset)); + } + if (IS_CONST == IS_CV || IS_CONST == IS_VAR) { + zval_ptr_dtor(offset); + } + break; +numeric_index_dim: + zend_hash_index_del(ht, hval); + if (IS_CONST == IS_CV || IS_CONST == IS_VAR) { + zval_ptr_dtor(offset); + } + break; + case IS_NULL: + zend_hash_del(ht, STR_EMPTY_ALLOC()); + break; + case IS_FALSE: + hval = 0; + goto num_index_dim; + case IS_TRUE: + hval = 1; + goto num_index_dim; + case IS_RESOURCE: + hval = Z_RES_HANDLE_P(offset); + goto num_index_dim; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto offset_again; + break; + default: + zend_error(E_WARNING, "Illegal offset type in unset"); + break; } - case IS_OBJECT: - if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use object as array"); - } - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC); - if (0) { - zval_ptr_dtor(&offset); - } else { - - } - break; - case IS_STRING: - zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); - ZEND_VM_CONTINUE(); /* bailed out before */ - default: - break; + break; } - } else { + case IS_OBJECT: + if (UNEXPECTED(Z_OBJ_HT_P(container)->unset_dimension == NULL)) { + zend_error_noreturn(E_ERROR, "Cannot use object as array"); + } +//??? if (IS_CONST == IS_CONST) { +//??? zval_copy_ctor(offset); +//??? } + Z_OBJ_HT_P(container)->unset_dimension(container, offset TSRMLS_CC); + + break; + case IS_STRING: + case IS_STR_OFFSET: + zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); + ZEND_VM_CONTINUE(); /* bailed out before */ + case IS_REFERENCE: + container = Z_REFVAL_P(container); + goto container_again; + break; + default: + break; } CHECK_EXCEPTION(); @@ -25707,49 +24742,36 @@ static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_H { USE_OPLINE - zval **container; + zval *container; zval *offset; SAVE_OPLINE(); - container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); + container = _get_obj_zval_ptr_unused(TSRMLS_C); + if (IS_UNUSED == IS_VAR && Z_TYPE_P(container) == IS_STR_OFFSET) { + zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); + } offset = opline->op2.zv; - if (IS_UNUSED != IS_VAR || container) { - if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(container); - } - if (Z_TYPE_PP(container) == IS_OBJECT) { - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - if (Z_OBJ_HT_P(*container)->unset_property) { - Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to unset property of non-object"); - } - if (0) { - zval_ptr_dtor(&offset); - } else { - - } + ZVAL_DEREF(container); + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->unset_property) { + Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); } else { - + zend_error(E_NOTICE, "Trying to unset property of non-object"); } - } else { - } + CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CONST(int prop_dim, ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; - zval **value = NULL; - int result = 0; + int result; ulong hval; zval *offset; @@ -25757,40 +24779,45 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CON container = _get_obj_zval_ptr_unused(TSRMLS_C); offset = opline->op2.zv; - if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) { - HashTable *ht; - int isset = 0; - - ht = Z_ARRVAL_P(container); + if (Z_TYPE_P(container) == IS_ARRAY) { + HashTable *ht = Z_ARRVAL_P(container); + zval *value = NULL; + zend_string *str; +isset_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: hval = zend_dval_to_lval(Z_DVAL_P(offset)); goto num_index_prop; - case IS_RESOURCE: - case IS_BOOL: case IS_LONG: hval = Z_LVAL_P(offset); num_index_prop: - if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) { - isset = 1; - } + value = zend_hash_index_find(ht, hval); break; case IS_STRING: - if (IS_CONST == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); - } - if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) { - isset = 1; + str = Z_STR_P(offset); + if (IS_CONST != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index_prop); } +str_index_prop: + value = zend_hash_find_ind(ht, str); break; case IS_NULL: - if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) { - isset = 1; - } + str = STR_EMPTY_ALLOC(); + goto str_index_prop; + break; + case IS_FALSE: + hval = 0; + goto num_index_prop; + case IS_TRUE: + hval = 0; + goto num_index_prop; + case IS_RESOURCE: + hval = Z_RES_HANDLE_P(offset); + goto num_index_prop; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto isset_again; break; default: zend_error(E_WARNING, "Illegal offset type in isset or empty"); @@ -25798,116 +24825,103 @@ num_index_prop: } if (opline->extended_value & ZEND_ISSET) { - if (isset && Z_TYPE_PP(value) == IS_NULL) { - result = 0; - } else { - result = isset; - } + /* > IS_NULL means not IS_UNDEF and not IS_NULL */ + result = (value != NULL && Z_TYPE_P(value) > IS_NULL); } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { - if (!isset || !i_zend_is_true(*value TSRMLS_CC)) { - result = 0; - } else { - result = 1; - } + result = (value == NULL || !i_zend_is_true(value TSRMLS_CC)); } - } else if (Z_TYPE_P(container) == IS_OBJECT) { - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - if (prop_dim) { - if (Z_OBJ_HT_P(container)->has_property) { - result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check property of non-object"); - result = 0; - } + if (Z_OBJ_HT_P(container)->has_dimension) { + result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); } else { - if (Z_OBJ_HT_P(container)->has_dimension) { - result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check element of non-array"); - result = 0; - } + zend_error(E_NOTICE, "Trying to check element of non-array"); + result = 0; } - if (0) { - zval_ptr_dtor(&offset); - } else { - + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; } - } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */ + } else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */ zval tmp; - if (Z_TYPE_P(offset) != IS_LONG) { - if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */ + result = 0; + if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) { + if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */ || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { - ZVAL_COPY_VALUE(&tmp, offset); - zval_copy_ctor(&tmp); + ZVAL_DUP(&tmp, offset); convert_to_long(&tmp); offset = &tmp; - } else { - /* can not be converted to proper offset, return "not set" */ - result = 0; } } if (Z_TYPE_P(offset) == IS_LONG) { - if (opline->extended_value & ZEND_ISSET) { - if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { - result = 1; - } - } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { - if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') { + if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { + if ((opline->extended_value & ZEND_ISSET) || + Z_STRVAL_P(container)[offset->value.lval] != '0') { result = 1; } } } - + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } } else { - + result = ((opline->extended_value & ZEND_ISSET) == 0); } - Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; - if (opline->extended_value & ZEND_ISSET) { - Z_LVAL(EX_T(opline->result.var).tmp_var) = result; - } else { - Z_LVAL(EX_T(opline->result.var).tmp_var) = !result; - } + ZVAL_BOOL(EX_VAR(opline->result.var), result); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CONST(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} - static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CONST(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + zval *container; + int result; + zval *offset; + + SAVE_OPLINE(); + container = _get_obj_zval_ptr_unused(TSRMLS_C); + offset = opline->op2.zv; + + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->has_property) { + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); + } else { + zend_error(E_NOTICE, "Trying to check property of non-object"); + result = 0; + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else { + result = ((opline->extended_value & ZEND_ISSET) == 0); + } + + ZVAL_BOOL(EX_VAR(opline->result.var), result); + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - /* The generator object is stored in return_value_ptr_ptr */ - zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr); + /* The generator object is stored in EX(return_value) */ + zend_generator *generator = (zend_generator *) EX(return_value); if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) { zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator"); } /* Destroy the previously yielded value */ - if (generator->value) { - zval_ptr_dtor(&generator->value); - } + zval_ptr_dtor(&generator->value); /* Destroy the previously yielded key */ - if (generator->key) { - zval_ptr_dtor(&generator->key); - } + zval_ptr_dtor(&generator->key); /* Set the new yielded value */ if (IS_UNUSED != IS_UNUSED) { @@ -25917,74 +24931,58 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDL /* Constants and temporary variables aren't yieldable by reference, * but we still allow them with a notice. */ if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR) { - zval *value, *copy; + zval *value; zend_error(E_NOTICE, "Only variable references should be yielded by reference"); value = NULL; - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); + ZVAL_COPY_VALUE(&generator->value, value); + if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1); /* Temporary variables don't need ctor copying */ if (!0) { - zval_copy_ctor(copy); + zval_copy_ctor(&generator->value); } - - generator->value = copy; } else { - zval **value_ptr = NULL; + zval *value_ptr = NULL; - if (IS_UNUSED == IS_VAR && UNEXPECTED(value_ptr == NULL)) { + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference"); } /* If a function call result is yielded and the function did * not return by reference we throw a notice. */ - if (IS_UNUSED == IS_VAR && !Z_ISREF_PP(value_ptr) + if (IS_UNUSED == IS_VAR && !Z_ISREF_P(value_ptr) && !(opline->extended_value == ZEND_RETURNS_FUNCTION - && EX_T(opline->op1.var).var.fcall_returned_reference) - && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) { + && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); - - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } else { SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr); - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } + ZVAL_COPY(&generator->value, value_ptr); } } else { zval *value = NULL; /* Consts, temporary variables and references need copying */ - if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR - || PZVAL_IS_REF(value) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); - - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } - - generator->value = copy; + if (IS_UNUSED == IS_CONST) { + ZVAL_DUP(&generator->value, value); + } else if (IS_UNUSED == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->value, value); + } else if (Z_ISREF_P(value)) { + ZVAL_DUP(&generator->value, Z_REFVAL_P(value)); } else { if (IS_UNUSED == IS_CV) { - Z_ADDREF_P(value); + if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value); } - generator->value = value; + ZVAL_COPY_VALUE(&generator->value, value); } } } else { /* If no value was specified yield null */ - Z_ADDREF(EG(uninitialized_zval)); - generator->value = &EG(uninitialized_zval); + ZVAL_NULL(&generator->value); } /* Set the new yielded key */ @@ -25993,45 +24991,36 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDL zval *key = opline->op2.zv; /* Consts, temporary variables and references need copying */ - if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR - || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, key); - - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } + if (IS_CONST == IS_CONST) { + ZVAL_DUP(&generator->key, key); + } else if (IS_CONST == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->key, key); + } else if (Z_ISREF_P(key)) { + ZVAL_DUP(&generator->key, Z_REFVAL_P(key)); - generator->key = copy; } else { - Z_ADDREF_P(key); - generator->key = key; + if (IS_CONST == IS_CV) { + if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key); + } + ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE_P(generator->key) == IS_LONG - && Z_LVAL_P(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_LONG + && Z_LVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL_P(generator->key); + generator->largest_used_integer_key = Z_LVAL(generator->key); } - } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - - ALLOC_INIT_ZVAL(generator->key); - ZVAL_LONG(generator->key, generator->largest_used_integer_key); + ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ - generator->send_target = &EX_T(opline->result.var).var.ptr; - Z_ADDREF(EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + generator->send_target = EX_VAR(opline->result.var); + ZVAL_NULL(generator->send_target); } else { generator->send_target = NULL; } @@ -26056,18 +25045,18 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(int (* { USE_OPLINE zend_free_op free_op2, free_op_data1; - zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); - zval *object; + zval *object = _get_obj_zval_ptr_unused(TSRMLS_C); zval *property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); + zval *value; int have_get_ptr = 0; - if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - make_real_object(object_ptr TSRMLS_CC); - object = *object_ptr; + object = make_real_object(object TSRMLS_CC); + + value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { zend_error(E_WARNING, "Attempt to assign property of non-object"); @@ -26075,81 +25064,68 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(int (* FREE_OP(free_op_data1); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } } else { /* here we are sure we are dealing with an object */ - if (1) { - MAKE_REAL_ZVAL_PTR(property); - } - - /* here property is a string */ if (opline->extended_value == ZEND_ASSIGN_OBJ && Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); if (zptr != NULL) { /* NULL means no success in getting PTR */ SEPARATE_ZVAL_IF_NOT_REF(zptr); have_get_ptr = 1; - binary_op(*zptr, *zptr, value TSRMLS_CC); + binary_op(zptr, zptr, value TSRMLS_CC); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(*zptr); - EX_T(opline->result.var).var.ptr = *zptr; + ZVAL_COPY(EX_VAR(opline->result.var), zptr); } } } if (!have_get_ptr) { zval *z = NULL; + zval rv; if (opline->extended_value == ZEND_ASSIGN_OBJ) { if (Z_OBJ_HT_P(object)->read_property) { - z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC); } } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { if (Z_OBJ_HT_P(object)->read_dimension) { - z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC); + z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R, &rv TSRMLS_CC); } } if (z) { if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); zval_dtor(z); - FREE_ZVAL(z); } - z = value; + ZVAL_COPY_VALUE(z, value); } - Z_ADDREF_P(z); - SEPARATE_ZVAL_IF_NOT_REF(&z); +//??? if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); + SEPARATE_ZVAL_IF_NOT_REF(z); binary_op(z, z, value TSRMLS_CC); if (opline->extended_value == ZEND_ASSIGN_OBJ) { - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(z); - EX_T(opline->result.var).var.ptr = z; + ZVAL_COPY(EX_VAR(opline->result.var), z); } - zval_ptr_dtor(&z); + zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to assign property of non-object"); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } } } - if (1) { - zval_ptr_dtor(&property); - } else { - zval_dtor(free_op2.var); - } + zval_dtor(free_op2.var); FREE_OP(free_op_data1); } @@ -26159,179 +25135,288 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(int (* ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_UNUSED_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_free_op free_op2, free_op_data2, free_op_data1; - zval **var_ptr; - zval *value; + zval *var_ptr; + zval *value, *container; SAVE_OPLINE(); - switch (opline->extended_value) { - case ZEND_ASSIGN_OBJ: - return zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - break; - case ZEND_ASSIGN_DIM: { - zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); - - if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); - } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) { - if (IS_UNUSED == IS_VAR && !0) { - Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */ - } - return zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - } else { - zval *dim = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + container = _get_obj_zval_ptr_unused(TSRMLS_C); + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { + zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); + } else if (UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { + if (IS_UNUSED == IS_VAR && !0) { + Z_ADDREF_P(container); /* undo the effect of get_obj_zval_ptr_ptr() */ + } + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else { + zval *dim = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_TMP_VAR, BP_VAR_RW TSRMLS_CC); - value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); - var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); - } - } - break; - default: - value = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - var_ptr = NULL; - /* do nothing */ - break; + zend_fetch_dimension_address_RW(EX_VAR((opline+1)->op2.var), container, dim, IS_TMP_VAR TSRMLS_CC); + value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); + var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); } - if (UNEXPECTED(var_ptr == NULL)) { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); } - if (UNEXPECTED(*var_ptr == &EG(error_zval))) { - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - } - zval_dtor(free_op2.var); - - CHECK_EXCEPTION(); - if (opline->extended_value == ZEND_ASSIGN_DIM) { - ZEND_VM_INC_OPCODE(); + if (UNEXPECTED(var_ptr == &EG(error_zval))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); } - ZEND_VM_NEXT_OPCODE(); + goto assign_op_dim_exit; } SEPARATE_ZVAL_IF_NOT_REF(var_ptr); + ZVAL_DEREF(var_ptr); - if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) - && Z_OBJ_HANDLER_PP(var_ptr, get) - && Z_OBJ_HANDLER_PP(var_ptr, set)) { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) && + UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) { /* proxy object */ - zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); + zval rv; + zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC); Z_ADDREF_P(objval); binary_op(objval, objval, value TSRMLS_CC); - Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC); - zval_ptr_dtor(&objval); + Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); + zval_ptr_dtor(objval); } else { - binary_op(*var_ptr, *var_ptr, value TSRMLS_CC); + binary_op(var_ptr, var_ptr, value TSRMLS_CC); } - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(*var_ptr); - EX_T(opline->result.var).var.ptr = *var_ptr; + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } + +assign_op_dim_exit: zval_dtor(free_op2.var); + FREE_OP(free_op_data1); + FREE_OP_VAR_PTR(free_op_data2); - if (opline->extended_value == ZEND_ASSIGN_DIM) { - FREE_OP(free_op_data1); - FREE_OP_VAR_PTR(free_op_data2); + CHECK_EXCEPTION(); + ZEND_VM_INC_OPCODE(); + ZEND_VM_NEXT_OPCODE(); +} - CHECK_EXCEPTION(); - ZEND_VM_INC_OPCODE(); +static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_free_op free_op2; + zval *var_ptr; + zval *value; + + SAVE_OPLINE(); + value = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + var_ptr = NULL; + + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { + zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); + } + + if (IS_UNUSED == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } + goto assign_op_exit; + } + + SEPARATE_ZVAL_IF_NOT_REF(var_ptr); + ZVAL_DEREF(var_ptr); + + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) && + UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) { + /* proxy object */ + zval rv; + zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC); + Z_ADDREF_P(objval); + binary_op(objval, objval, value TSRMLS_CC); + Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); + zval_ptr_dtor(objval); } else { + binary_op(var_ptr, var_ptr, value TSRMLS_CC); + } - CHECK_EXCEPTION(); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } + +assign_op_exit: + zval_dtor(free_op2.var); + + CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_TMP(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_TMP(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_TMP(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_TMP(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_TMP(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_TMP(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_TMP(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_TMP(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_TMP(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_TMP(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_TMP(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_TMP(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_free_op free_op2; - zval **object_ptr; zval *object; zval *property; - zval **retval; + zval *retval; int have_get_ptr = 0; SAVE_OPLINE(); - object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); + object = _get_obj_zval_ptr_unused(TSRMLS_C); property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - retval = &EX_T(opline->result.var).var.ptr; + retval = EX_VAR(opline->result.var); - if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } - make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ - object = *object_ptr; + object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */ if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); zval_dtor(free_op2.var); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - *retval = &EG(uninitialized_zval); + ZVAL_NULL(retval); } CHECK_EXCEPTION(); @@ -26340,59 +25425,50 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_TMP(incdec_ /* here we are sure we are dealing with an object */ - if (1) { - MAKE_REAL_ZVAL_PTR(property); - } - if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); if (zptr != NULL) { /* NULL means no success in getting PTR */ SEPARATE_ZVAL_IF_NOT_REF(zptr); have_get_ptr = 1; - incdec_op(*zptr); + incdec_op(zptr); if (RETURN_VALUE_USED(opline)) { - *retval = *zptr; - PZVAL_LOCK(*retval); + ZVAL_COPY(retval, zptr); } } } if (!have_get_ptr) { + zval rv; + if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC); if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); zval_dtor(z); - FREE_ZVAL(z); } - z = value; + ZVAL_COPY_VALUE(z, value); } - Z_ADDREF_P(z); - SEPARATE_ZVAL_IF_NOT_REF(&z); + if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); + SEPARATE_ZVAL_IF_NOT_REF(z); incdec_op(z); - *retval = z; - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - SELECTIVE_PZVAL_LOCK(*retval, opline); - zval_ptr_dtor(&z); + ZVAL_COPY_VALUE(retval, z); + Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); + SELECTIVE_PZVAL_LOCK(retval, opline); + zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - *retval = &EG(uninitialized_zval); + ZVAL_NULL(retval); } } } - if (1) { - zval_ptr_dtor(&property); - } else { - zval_dtor(free_op2.var); - } + zval_dtor(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -26412,23 +25488,21 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_TMP(incdec { USE_OPLINE zend_free_op free_op2; - zval **object_ptr; zval *object; zval *property; zval *retval; int have_get_ptr = 0; SAVE_OPLINE(); - object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); + object = _get_obj_zval_ptr_unused(TSRMLS_C); property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - retval = &EX_T(opline->result.var).tmp_var; + retval = EX_VAR(opline->result.var); - if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } - make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ - object = *object_ptr; + object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */ if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); @@ -26441,60 +25515,48 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_TMP(incdec /* here we are sure we are dealing with an object */ - if (1) { - MAKE_REAL_ZVAL_PTR(property); - } - if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); if (zptr != NULL) { /* NULL means no success in getting PTR */ have_get_ptr = 1; SEPARATE_ZVAL_IF_NOT_REF(zptr); - ZVAL_COPY_VALUE(retval, *zptr); - zendi_zval_copy_ctor(*retval); + ZVAL_DUP(retval, zptr); - incdec_op(*zptr); + incdec_op(zptr); } } if (!have_get_ptr) { if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - zval *z_copy; + zval rv; + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC); + zval z_copy; if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); zval_dtor(z); - FREE_ZVAL(z); } - z = value; + ZVAL_COPY_VALUE(z, value); } - ZVAL_COPY_VALUE(retval, z); - zendi_zval_copy_ctor(*retval); - ALLOC_ZVAL(z_copy); - INIT_PZVAL_COPY(z_copy, z); - zendi_zval_copy_ctor(*z_copy); - incdec_op(z_copy); - Z_ADDREF_P(z); - Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + ZVAL_DUP(retval, z); + ZVAL_DUP(&z_copy, z); + incdec_op(&z_copy); + if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); + Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); zval_ptr_dtor(&z_copy); - zval_ptr_dtor(&z); + zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); ZVAL_NULL(retval); } } - if (1) { - zval_ptr_dtor(&property); - } else { - zval_dtor(free_op2.var); - } + zval_dtor(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -26525,29 +25587,20 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_TMP if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { zend_error(E_NOTICE, "Trying to get property of non-object"); - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - zval_dtor(free_op2.var); + ZVAL_NULL(EX_VAR(opline->result.var)); } else { zval *retval; - if (1) { - MAKE_REAL_ZVAL_PTR(offset); - } - /* here we are sure we are dealing with an object */ - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - - PZVAL_LOCK(retval); - EX_T(opline->result.var).var.ptr = retval; + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC); - if (1) { - zval_ptr_dtor(&offset); - } else { - zval_dtor(free_op2.var); + if (retval != EX_VAR(opline->result.var)) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); } } + zval_dtor(free_op2.var); + CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -26562,38 +25615,20 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_H USE_OPLINE zend_free_op free_op1, free_op2; zval *property; - zval **container; + zval *container; SAVE_OPLINE(); property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (1) { - MAKE_REAL_ZVAL_PTR(property); - } - container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); - if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { + container = _get_obj_zval_ptr_unused(TSRMLS_C); + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); - if (1) { - zval_ptr_dtor(&property); - } else { - zval_dtor(free_op2.var); - } + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC); + zval_dtor(free_op2.var); if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); - } - - /* We are going to assign the result by reference */ - if (opline->extended_value & ZEND_FETCH_MAKE_REF) { - zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; - - Z_DELREF_PP(retval_ptr); - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); - Z_ADDREF_PP(retval_ptr); - EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr; - EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } CHECK_EXCEPTION(); @@ -26605,26 +25640,19 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_ USE_OPLINE zend_free_op free_op1, free_op2; zval *property; - zval **container; + zval *container; SAVE_OPLINE(); property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); + container = _get_obj_zval_ptr_unused(TSRMLS_C); - if (1) { - MAKE_REAL_ZVAL_PTR(property); - } - if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC); - if (1) { - zval_ptr_dtor(&property); - } else { - zval_dtor(free_op2.var); - } + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_RW, 0 TSRMLS_CC); + zval_dtor(free_op2.var); if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } CHECK_EXCEPTION(); @@ -26645,29 +25673,20 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_ if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - zval_dtor(free_op2.var); + ZVAL_NULL(EX_VAR(opline->result.var)); } else { zval *retval; - if (1) { - MAKE_REAL_ZVAL_PTR(offset); - } - /* here we are sure we are dealing with an object */ - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC); - PZVAL_LOCK(retval); - EX_T(opline->result.var).var.ptr = retval; - - if (1) { - zval_ptr_dtor(&offset); - } else { - zval_dtor(free_op2.var); + if (retval != EX_VAR(opline->result.var)) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); } } + zval_dtor(free_op2.var); + CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -26675,31 +25694,24 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE + zval *container; if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { /* Behave like FETCH_OBJ_W */ zend_free_op free_op1, free_op2; zval *property; - zval **container; SAVE_OPLINE(); property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); + container = _get_obj_zval_ptr_unused(TSRMLS_C); - if (1) { - MAKE_REAL_ZVAL_PTR(property); - } - if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); - if (1) { - zval_ptr_dtor(&property); - } else { - zval_dtor(free_op2.var); - } + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, 0 TSRMLS_CC); + zval_dtor(free_op2.var); if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } CHECK_EXCEPTION(); @@ -26712,41 +25724,22 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMP_HANDLER(ZEND_O static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_free_op free_op1, free_op2, free_res; - zval **container; - zval *property; + zend_free_op free_op1, free_op2; + zval *container, *property; SAVE_OPLINE(); - container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); + container = _get_obj_zval_ptr_unused(TSRMLS_C); property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (IS_UNUSED == IS_CV) { - if (container != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(container); - } - } - if (1) { - MAKE_REAL_ZVAL_PTR(property); - } - if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC); - if (1) { - zval_ptr_dtor(&property); - } else { - zval_dtor(free_op2.var); - } + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_UNSET, 0 TSRMLS_CC); + zval_dtor(free_op2.var); if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res); - if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr); - } - PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr); - FREE_OP_VAR_PTR(free_res); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -26755,25 +25748,18 @@ static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HA { USE_OPLINE zend_free_op free_op2; - zval **object_ptr; + zval *object; zval *property_name; SAVE_OPLINE(); - object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); + object = _get_obj_zval_ptr_unused(TSRMLS_C); property_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (1) { - MAKE_REAL_ZVAL_PTR(property_name); - } - if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - if (1) { - zval_ptr_dtor(&property_name); - } else { - zval_dtor(free_op2.var); - } + zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC); + zval_dtor(free_op2.var); /* assign_obj has two opcodes! */ CHECK_EXCEPTION(); @@ -26785,7 +25771,7 @@ static int ZEND_FASTCALL ZEND_ADD_VAR_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDL { USE_OPLINE zend_free_op free_op2; - zval *str = &EX_T(opline->result.var).tmp_var; + zval *str = EX_VAR(opline->result.var); zval *var; zval var_copy; int use_copy = 0; @@ -26795,18 +25781,17 @@ static int ZEND_FASTCALL ZEND_ADD_VAR_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDL if (IS_UNUSED == IS_UNUSED) { /* Initialize for erealloc in add_string_to_string */ - Z_STRVAL_P(str) = NULL; - Z_STRLEN_P(str) = 0; - Z_TYPE_P(str) = IS_STRING; - - INIT_PZVAL(str); + ZVAL_EMPTY_STRING(str); } if (Z_TYPE_P(var) != IS_STRING) { - zend_make_printable_zval(var, &var_copy, &use_copy); + ZVAL_DEREF(var); + if (Z_TYPE_P(var) != IS_STRING) { + zend_make_printable_zval(var, &var_copy, &use_copy); - if (use_copy) { - var = &var_copy; + if (use_copy) { + var = &var_copy; + } } } add_string_to_string(str, str, var); @@ -26830,10 +25815,9 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPC { USE_OPLINE zval *function_name; - char *function_name_strval; - int function_name_strlen; zend_free_op free_op2; call_slot *call = EX(call_slots) + opline->result.num; + zval *object; SAVE_OPLINE(); @@ -26847,33 +25831,30 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPC zend_error_noreturn(E_ERROR, "Method name must be a string"); } - function_name_strval = Z_STRVAL_P(function_name); - function_name_strlen = Z_STRLEN_P(function_name); + object = _get_obj_zval_ptr_unused(TSRMLS_C); + call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL; - call->object = _get_obj_zval_ptr_unused(TSRMLS_C); - - if (EXPECTED(call->object != NULL) && - EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) { - call->called_scope = Z_OBJCE_P(call->object); + if (EXPECTED(call->object != NULL)) { + call->called_scope = zend_get_class_entry(call->object TSRMLS_CC); if (IS_TMP_VAR != IS_CONST || - (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) { - zval *object = call->object; + (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope)) == NULL) { + zend_object *object = call->object; - if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) { + if (UNEXPECTED(object->handlers->get_method == NULL)) { zend_error_noreturn(E_ERROR, "Object does not support method calls"); } /* First, locate the function. */ - call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); + call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); if (UNEXPECTED(call->fbc == NULL)) { - zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval); + zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name)); } if (IS_TMP_VAR == IS_CONST && EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) && EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) && EXPECTED(call->object == object)) { - CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc); + CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope, call->fbc); } } } else { @@ -26881,21 +25862,13 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPC zval_dtor(free_op2.var); HANDLE_EXCEPTION(); } - zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval); + zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", Z_STRVAL_P(function_name)); } if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) { call->object = NULL; } else { - if (!PZVAL_IS_REF(call->object)) { - Z_ADDREF_P(call->object); /* For $this pointer */ - } else { - zval *this_ptr; - ALLOC_ZVAL(this_ptr); - INIT_PZVAL_COPY(this_ptr, call->object); - zval_copy_ctor(this_ptr); - call->object = this_ptr; - } + GC_REFCOUNT(call->object)++; /* For $this pointer */ } call->num_additional_args = 0; @@ -26910,9 +25883,26 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPC static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { + zval *array; + zend_uint size; USE_OPLINE - array_init(&EX_T(opline->result.var).tmp_var); + array = EX_VAR(opline->result.var); + if (IS_UNUSED != IS_UNUSED) { + size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; + } else { + size = 0; + } + ZVAL_NEW_ARR(array); + zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); + + if (IS_UNUSED != IS_UNUSED) { + /* Explicitly initialize array as not-packed if flag is set */ + if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) { + zend_hash_real_init(Z_ARRVAL_P(array), 0); + } + } + if (IS_UNUSED == IS_UNUSED) { ZEND_VM_NEXT_OPCODE(); #if 0 || IS_UNUSED != IS_UNUSED @@ -26926,91 +25916,98 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HAN { USE_OPLINE zend_free_op free_op2; - zval **container; + zval *container; zval *offset; ulong hval; SAVE_OPLINE(); - container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); - if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) { + container = _get_obj_zval_ptr_unused(TSRMLS_C); + if (IS_UNUSED != IS_UNUSED) { SEPARATE_ZVAL_IF_NOT_REF(container); } offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (IS_UNUSED != IS_VAR || container) { - switch (Z_TYPE_PP(container)) { - case IS_ARRAY: { - HashTable *ht = Z_ARRVAL_PP(container); - - switch (Z_TYPE_P(offset)) { - case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); - zend_hash_index_del(ht, hval); - break; - case IS_RESOURCE: - case IS_BOOL: - case IS_LONG: - hval = Z_LVAL_P(offset); - zend_hash_index_del(ht, hval); - break; - case IS_STRING: - if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { - Z_ADDREF_P(offset); - } - if (IS_TMP_VAR == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); - } - if (ht == &EG(symbol_table)) { - zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC); - } else { - zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval); - } - if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { - zval_ptr_dtor(&offset); - } - break; +container_again: + switch (Z_TYPE_P(container)) { + case IS_ARRAY: { + HashTable *ht = Z_ARRVAL_P(container); +offset_again: + switch (Z_TYPE_P(offset)) { + case IS_DOUBLE: + hval = zend_dval_to_lval(Z_DVAL_P(offset)); + zend_hash_index_del(ht, hval); + break; + case IS_LONG: + hval = Z_LVAL_P(offset); num_index_dim: - zend_hash_index_del(ht, hval); - if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { - zval_ptr_dtor(&offset); - } - break; - case IS_NULL: - zend_hash_del(ht, "", sizeof("")); - break; - default: - zend_error(E_WARNING, "Illegal offset type in unset"); - break; - } - zval_dtor(free_op2.var); - break; + zend_hash_index_del(ht, hval); + break; + case IS_STRING: + if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { + if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset); + } + if (IS_TMP_VAR != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto numeric_index_dim); + } + if (ht == &EG(symbol_table).ht) { + zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC); + } else { + zend_hash_del(ht, Z_STR_P(offset)); + } + if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { + zval_ptr_dtor(offset); + } + break; +numeric_index_dim: + zend_hash_index_del(ht, hval); + if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { + zval_ptr_dtor(offset); + } + break; + case IS_NULL: + zend_hash_del(ht, STR_EMPTY_ALLOC()); + break; + case IS_FALSE: + hval = 0; + goto num_index_dim; + case IS_TRUE: + hval = 1; + goto num_index_dim; + case IS_RESOURCE: + hval = Z_RES_HANDLE_P(offset); + goto num_index_dim; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto offset_again; + break; + default: + zend_error(E_WARNING, "Illegal offset type in unset"); + break; } - case IS_OBJECT: - if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use object as array"); - } - if (1) { - MAKE_REAL_ZVAL_PTR(offset); - } - Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC); - if (1) { - zval_ptr_dtor(&offset); - } else { - zval_dtor(free_op2.var); - } - break; - case IS_STRING: - zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); - ZEND_VM_CONTINUE(); /* bailed out before */ - default: - zval_dtor(free_op2.var); - break; + zval_dtor(free_op2.var); + break; } - } else { - zval_dtor(free_op2.var); + case IS_OBJECT: + if (UNEXPECTED(Z_OBJ_HT_P(container)->unset_dimension == NULL)) { + zend_error_noreturn(E_ERROR, "Cannot use object as array"); + } +//??? if (IS_TMP_VAR == IS_CONST) { +//??? zval_copy_ctor(offset); +//??? } + Z_OBJ_HT_P(container)->unset_dimension(container, offset TSRMLS_CC); + zval_dtor(free_op2.var); + break; + case IS_STRING: + case IS_STR_OFFSET: + zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); + ZEND_VM_CONTINUE(); /* bailed out before */ + case IS_REFERENCE: + container = Z_REFVAL_P(container); + goto container_again; + break; + default: + zval_dtor(free_op2.var); + break; } CHECK_EXCEPTION(); @@ -27021,49 +26018,36 @@ static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HAN { USE_OPLINE zend_free_op free_op2; - zval **container; + zval *container; zval *offset; SAVE_OPLINE(); - container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); + container = _get_obj_zval_ptr_unused(TSRMLS_C); + if (IS_UNUSED == IS_VAR && Z_TYPE_P(container) == IS_STR_OFFSET) { + zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); + } offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (IS_UNUSED != IS_VAR || container) { - if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(container); - } - if (Z_TYPE_PP(container) == IS_OBJECT) { - if (1) { - MAKE_REAL_ZVAL_PTR(offset); - } - if (Z_OBJ_HT_P(*container)->unset_property) { - Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to unset property of non-object"); - } - if (1) { - zval_ptr_dtor(&offset); - } else { - zval_dtor(free_op2.var); - } + ZVAL_DEREF(container); + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->unset_property) { + Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); } else { - zval_dtor(free_op2.var); + zend_error(E_NOTICE, "Trying to unset property of non-object"); } - } else { - zval_dtor(free_op2.var); } + zval_dtor(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_TMP(int prop_dim, ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_free_op free_op2; zval *container; - zval **value = NULL; - int result = 0; + int result; ulong hval; zval *offset; @@ -27071,40 +26055,45 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_TMP container = _get_obj_zval_ptr_unused(TSRMLS_C); offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) { - HashTable *ht; - int isset = 0; - - ht = Z_ARRVAL_P(container); + if (Z_TYPE_P(container) == IS_ARRAY) { + HashTable *ht = Z_ARRVAL_P(container); + zval *value = NULL; + zend_string *str; +isset_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: hval = zend_dval_to_lval(Z_DVAL_P(offset)); goto num_index_prop; - case IS_RESOURCE: - case IS_BOOL: case IS_LONG: hval = Z_LVAL_P(offset); num_index_prop: - if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) { - isset = 1; - } + value = zend_hash_index_find(ht, hval); break; case IS_STRING: - if (IS_TMP_VAR == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); - } - if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) { - isset = 1; + str = Z_STR_P(offset); + if (IS_TMP_VAR != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index_prop); } +str_index_prop: + value = zend_hash_find_ind(ht, str); break; case IS_NULL: - if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) { - isset = 1; - } + str = STR_EMPTY_ALLOC(); + goto str_index_prop; + break; + case IS_FALSE: + hval = 0; + goto num_index_prop; + case IS_TRUE: + hval = 0; + goto num_index_prop; + case IS_RESOURCE: + hval = Z_RES_HANDLE_P(offset); + goto num_index_prop; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto isset_again; break; default: zend_error(E_WARNING, "Illegal offset type in isset or empty"); @@ -27112,116 +26101,105 @@ num_index_prop: } if (opline->extended_value & ZEND_ISSET) { - if (isset && Z_TYPE_PP(value) == IS_NULL) { - result = 0; - } else { - result = isset; - } + /* > IS_NULL means not IS_UNDEF and not IS_NULL */ + result = (value != NULL && Z_TYPE_P(value) > IS_NULL); } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { - if (!isset || !i_zend_is_true(*value TSRMLS_CC)) { - result = 0; - } else { - result = 1; - } + result = (value == NULL || !i_zend_is_true(value TSRMLS_CC)); } - zval_dtor(free_op2.var); } else if (Z_TYPE_P(container) == IS_OBJECT) { - if (1) { - MAKE_REAL_ZVAL_PTR(offset); - } - if (prop_dim) { - if (Z_OBJ_HT_P(container)->has_property) { - result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check property of non-object"); - result = 0; - } + if (Z_OBJ_HT_P(container)->has_dimension) { + result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); } else { - if (Z_OBJ_HT_P(container)->has_dimension) { - result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check element of non-array"); - result = 0; - } + zend_error(E_NOTICE, "Trying to check element of non-array"); + result = 0; } - if (1) { - zval_ptr_dtor(&offset); - } else { - zval_dtor(free_op2.var); + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; } - } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */ + } else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */ zval tmp; - if (Z_TYPE_P(offset) != IS_LONG) { - if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */ + result = 0; + if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) { + if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */ || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { - ZVAL_COPY_VALUE(&tmp, offset); - zval_copy_ctor(&tmp); + ZVAL_DUP(&tmp, offset); convert_to_long(&tmp); offset = &tmp; - } else { - /* can not be converted to proper offset, return "not set" */ - result = 0; } } if (Z_TYPE_P(offset) == IS_LONG) { - if (opline->extended_value & ZEND_ISSET) { - if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { - result = 1; - } - } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { - if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') { + if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { + if ((opline->extended_value & ZEND_ISSET) || + Z_STRVAL_P(container)[offset->value.lval] != '0') { result = 1; } } } - zval_dtor(free_op2.var); + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } } else { - zval_dtor(free_op2.var); + result = ((opline->extended_value & ZEND_ISSET) == 0); } - Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; - if (opline->extended_value & ZEND_ISSET) { - Z_LVAL(EX_T(opline->result.var).tmp_var) = result; - } else { - Z_LVAL(EX_T(opline->result.var).tmp_var) = !result; - } + zval_dtor(free_op2.var); + ZVAL_BOOL(EX_VAR(opline->result.var), result); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_TMP(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} - static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_TMP(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + zend_free_op free_op2; + zval *container; + int result; + zval *offset; + + SAVE_OPLINE(); + container = _get_obj_zval_ptr_unused(TSRMLS_C); + offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->has_property) { + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); + } else { + zend_error(E_NOTICE, "Trying to check property of non-object"); + result = 0; + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else { + result = ((opline->extended_value & ZEND_ISSET) == 0); + } + + zval_dtor(free_op2.var); + ZVAL_BOOL(EX_VAR(opline->result.var), result); + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - /* The generator object is stored in return_value_ptr_ptr */ - zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr); + /* The generator object is stored in EX(return_value) */ + zend_generator *generator = (zend_generator *) EX(return_value); if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) { zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator"); } /* Destroy the previously yielded value */ - if (generator->value) { - zval_ptr_dtor(&generator->value); - } + zval_ptr_dtor(&generator->value); /* Destroy the previously yielded key */ - if (generator->key) { - zval_ptr_dtor(&generator->key); - } + zval_ptr_dtor(&generator->key); /* Set the new yielded value */ if (IS_UNUSED != IS_UNUSED) { @@ -27231,74 +26209,58 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER /* Constants and temporary variables aren't yieldable by reference, * but we still allow them with a notice. */ if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR) { - zval *value, *copy; + zval *value; zend_error(E_NOTICE, "Only variable references should be yielded by reference"); value = NULL; - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); + ZVAL_COPY_VALUE(&generator->value, value); + if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1); /* Temporary variables don't need ctor copying */ if (!0) { - zval_copy_ctor(copy); + zval_copy_ctor(&generator->value); } - - generator->value = copy; } else { - zval **value_ptr = NULL; + zval *value_ptr = NULL; - if (IS_UNUSED == IS_VAR && UNEXPECTED(value_ptr == NULL)) { + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference"); } /* If a function call result is yielded and the function did * not return by reference we throw a notice. */ - if (IS_UNUSED == IS_VAR && !Z_ISREF_PP(value_ptr) + if (IS_UNUSED == IS_VAR && !Z_ISREF_P(value_ptr) && !(opline->extended_value == ZEND_RETURNS_FUNCTION - && EX_T(opline->op1.var).var.fcall_returned_reference) - && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) { + && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); - - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } else { SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr); - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } + ZVAL_COPY(&generator->value, value_ptr); } } else { zval *value = NULL; /* Consts, temporary variables and references need copying */ - if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR - || PZVAL_IS_REF(value) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); - - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } - - generator->value = copy; + if (IS_UNUSED == IS_CONST) { + ZVAL_DUP(&generator->value, value); + } else if (IS_UNUSED == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->value, value); + } else if (Z_ISREF_P(value)) { + ZVAL_DUP(&generator->value, Z_REFVAL_P(value)); } else { if (IS_UNUSED == IS_CV) { - Z_ADDREF_P(value); + if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value); } - generator->value = value; + ZVAL_COPY_VALUE(&generator->value, value); } } } else { /* If no value was specified yield null */ - Z_ADDREF(EG(uninitialized_zval)); - generator->value = &EG(uninitialized_zval); + ZVAL_NULL(&generator->value); } /* Set the new yielded key */ @@ -27307,45 +26269,36 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); /* Consts, temporary variables and references need copying */ - if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR - || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, key); - - /* Temporary variables don't need ctor copying */ - if (!1) { - zval_copy_ctor(copy); - } + if (IS_TMP_VAR == IS_CONST) { + ZVAL_DUP(&generator->key, key); + } else if (IS_TMP_VAR == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->key, key); + } else if (Z_ISREF_P(key)) { + ZVAL_DUP(&generator->key, Z_REFVAL_P(key)); - generator->key = copy; } else { - Z_ADDREF_P(key); - generator->key = key; + if (IS_TMP_VAR == IS_CV) { + if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key); + } + ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE_P(generator->key) == IS_LONG - && Z_LVAL_P(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_LONG + && Z_LVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL_P(generator->key); + generator->largest_used_integer_key = Z_LVAL(generator->key); } - } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - - ALLOC_INIT_ZVAL(generator->key); - ZVAL_LONG(generator->key, generator->largest_used_integer_key); + ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ - generator->send_target = &EX_T(opline->result.var).var.ptr; - Z_ADDREF(EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + generator->send_target = EX_VAR(opline->result.var); + ZVAL_NULL(generator->send_target); } else { generator->send_target = NULL; } @@ -27370,100 +26323,87 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(int (* { USE_OPLINE zend_free_op free_op2, free_op_data1; - zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); - zval *object; + zval *object = _get_obj_zval_ptr_unused(TSRMLS_C); zval *property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); + zval *value; int have_get_ptr = 0; - if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - make_real_object(object_ptr TSRMLS_CC); - object = *object_ptr; + object = make_real_object(object TSRMLS_CC); + + value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { zend_error(E_WARNING, "Attempt to assign property of non-object"); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); FREE_OP(free_op_data1); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } } else { /* here we are sure we are dealing with an object */ - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - - /* here property is a string */ if (opline->extended_value == ZEND_ASSIGN_OBJ && Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); if (zptr != NULL) { /* NULL means no success in getting PTR */ SEPARATE_ZVAL_IF_NOT_REF(zptr); have_get_ptr = 1; - binary_op(*zptr, *zptr, value TSRMLS_CC); + binary_op(zptr, zptr, value TSRMLS_CC); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(*zptr); - EX_T(opline->result.var).var.ptr = *zptr; + ZVAL_COPY(EX_VAR(opline->result.var), zptr); } } } if (!have_get_ptr) { zval *z = NULL; + zval rv; if (opline->extended_value == ZEND_ASSIGN_OBJ) { if (Z_OBJ_HT_P(object)->read_property) { - z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC); } } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { if (Z_OBJ_HT_P(object)->read_dimension) { - z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC); + z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R, &rv TSRMLS_CC); } } if (z) { if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); zval_dtor(z); - FREE_ZVAL(z); } - z = value; + ZVAL_COPY_VALUE(z, value); } - Z_ADDREF_P(z); - SEPARATE_ZVAL_IF_NOT_REF(&z); +//??? if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); + SEPARATE_ZVAL_IF_NOT_REF(z); binary_op(z, z, value TSRMLS_CC); if (opline->extended_value == ZEND_ASSIGN_OBJ) { - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(z); - EX_T(opline->result.var).var.ptr = z; + ZVAL_COPY(EX_VAR(opline->result.var), z); } - zval_ptr_dtor(&z); + zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to assign property of non-object"); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } } } - if (0) { - zval_ptr_dtor(&property); - } else { - zval_ptr_dtor_nogc(&free_op2.var); - } + zval_ptr_dtor_nogc(free_op2.var); FREE_OP(free_op_data1); } @@ -27473,179 +26413,288 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(int (* ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_UNUSED_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_free_op free_op2, free_op_data2, free_op_data1; - zval **var_ptr; - zval *value; + zval *var_ptr; + zval *value, *container; SAVE_OPLINE(); - switch (opline->extended_value) { - case ZEND_ASSIGN_OBJ: - return zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - break; - case ZEND_ASSIGN_DIM: { - zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); - - if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); - } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) { - if (IS_UNUSED == IS_VAR && !0) { - Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */ - } - return zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - } else { - zval *dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + container = _get_obj_zval_ptr_unused(TSRMLS_C); + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { + zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); + } else if (UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { + if (IS_UNUSED == IS_VAR && !0) { + Z_ADDREF_P(container); /* undo the effect of get_obj_zval_ptr_ptr() */ + } + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else { + zval *dim = _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_VAR, BP_VAR_RW TSRMLS_CC); - value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); - var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); - } - } - break; - default: - value = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - var_ptr = NULL; - /* do nothing */ - break; + zend_fetch_dimension_address_RW(EX_VAR((opline+1)->op2.var), container, dim, IS_VAR TSRMLS_CC); + value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); + var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); } - if (UNEXPECTED(var_ptr == NULL)) { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); } - if (UNEXPECTED(*var_ptr == &EG(error_zval))) { - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - } - zval_ptr_dtor_nogc(&free_op2.var); - - CHECK_EXCEPTION(); - if (opline->extended_value == ZEND_ASSIGN_DIM) { - ZEND_VM_INC_OPCODE(); + if (UNEXPECTED(var_ptr == &EG(error_zval))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); } - ZEND_VM_NEXT_OPCODE(); + goto assign_op_dim_exit; } SEPARATE_ZVAL_IF_NOT_REF(var_ptr); + ZVAL_DEREF(var_ptr); - if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) - && Z_OBJ_HANDLER_PP(var_ptr, get) - && Z_OBJ_HANDLER_PP(var_ptr, set)) { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) && + UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) { /* proxy object */ - zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); + zval rv; + zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC); Z_ADDREF_P(objval); binary_op(objval, objval, value TSRMLS_CC); - Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC); - zval_ptr_dtor(&objval); + Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); + zval_ptr_dtor(objval); } else { - binary_op(*var_ptr, *var_ptr, value TSRMLS_CC); + binary_op(var_ptr, var_ptr, value TSRMLS_CC); } - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(*var_ptr); - EX_T(opline->result.var).var.ptr = *var_ptr; + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } - zval_ptr_dtor_nogc(&free_op2.var); - if (opline->extended_value == ZEND_ASSIGN_DIM) { - FREE_OP(free_op_data1); - FREE_OP_VAR_PTR(free_op_data2); +assign_op_dim_exit: + zval_ptr_dtor_nogc(free_op2.var); + FREE_OP(free_op_data1); + FREE_OP_VAR_PTR(free_op_data2); - CHECK_EXCEPTION(); - ZEND_VM_INC_OPCODE(); + CHECK_EXCEPTION(); + ZEND_VM_INC_OPCODE(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_free_op free_op2; + zval *var_ptr; + zval *value; + + SAVE_OPLINE(); + value = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + var_ptr = NULL; + + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { + zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); + } + + if (IS_UNUSED == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } + goto assign_op_exit; + } + + SEPARATE_ZVAL_IF_NOT_REF(var_ptr); + ZVAL_DEREF(var_ptr); + + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) && + UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) { + /* proxy object */ + zval rv; + zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC); + Z_ADDREF_P(objval); + binary_op(objval, objval, value TSRMLS_CC); + Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); + zval_ptr_dtor(objval); } else { + binary_op(var_ptr, var_ptr, value TSRMLS_CC); + } - CHECK_EXCEPTION(); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } + +assign_op_exit: + zval_ptr_dtor_nogc(free_op2.var); + + CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_VAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_VAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_VAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_VAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_VAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_VAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_VAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_VAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_VAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_VAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_VAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_VAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_free_op free_op2; - zval **object_ptr; zval *object; zval *property; - zval **retval; + zval *retval; int have_get_ptr = 0; SAVE_OPLINE(); - object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); + object = _get_obj_zval_ptr_unused(TSRMLS_C); property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - retval = &EX_T(opline->result.var).var.ptr; + retval = EX_VAR(opline->result.var); - if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } - make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ - object = *object_ptr; + object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */ if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - *retval = &EG(uninitialized_zval); + ZVAL_NULL(retval); } CHECK_EXCEPTION(); @@ -27654,59 +26703,50 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_VAR(incdec_ /* here we are sure we are dealing with an object */ - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); if (zptr != NULL) { /* NULL means no success in getting PTR */ SEPARATE_ZVAL_IF_NOT_REF(zptr); have_get_ptr = 1; - incdec_op(*zptr); + incdec_op(zptr); if (RETURN_VALUE_USED(opline)) { - *retval = *zptr; - PZVAL_LOCK(*retval); + ZVAL_COPY(retval, zptr); } } } if (!have_get_ptr) { + zval rv; + if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC); if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); zval_dtor(z); - FREE_ZVAL(z); } - z = value; + ZVAL_COPY_VALUE(z, value); } - Z_ADDREF_P(z); - SEPARATE_ZVAL_IF_NOT_REF(&z); + if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); + SEPARATE_ZVAL_IF_NOT_REF(z); incdec_op(z); - *retval = z; - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - SELECTIVE_PZVAL_LOCK(*retval, opline); - zval_ptr_dtor(&z); + ZVAL_COPY_VALUE(retval, z); + Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); + SELECTIVE_PZVAL_LOCK(retval, opline); + zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - *retval = &EG(uninitialized_zval); + ZVAL_NULL(retval); } } } - if (0) { - zval_ptr_dtor(&property); - } else { - zval_ptr_dtor_nogc(&free_op2.var); - } + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -27726,27 +26766,25 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_VAR(incdec { USE_OPLINE zend_free_op free_op2; - zval **object_ptr; zval *object; zval *property; zval *retval; int have_get_ptr = 0; SAVE_OPLINE(); - object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); + object = _get_obj_zval_ptr_unused(TSRMLS_C); property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - retval = &EX_T(opline->result.var).tmp_var; + retval = EX_VAR(opline->result.var); - if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } - make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ - object = *object_ptr; + object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */ if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); ZVAL_NULL(retval); CHECK_EXCEPTION(); @@ -27755,60 +26793,48 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_VAR(incdec /* here we are sure we are dealing with an object */ - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); if (zptr != NULL) { /* NULL means no success in getting PTR */ have_get_ptr = 1; SEPARATE_ZVAL_IF_NOT_REF(zptr); - ZVAL_COPY_VALUE(retval, *zptr); - zendi_zval_copy_ctor(*retval); + ZVAL_DUP(retval, zptr); - incdec_op(*zptr); + incdec_op(zptr); } } if (!have_get_ptr) { if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - zval *z_copy; + zval rv; + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC); + zval z_copy; if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); zval_dtor(z); - FREE_ZVAL(z); } - z = value; + ZVAL_COPY_VALUE(z, value); } - ZVAL_COPY_VALUE(retval, z); - zendi_zval_copy_ctor(*retval); - ALLOC_ZVAL(z_copy); - INIT_PZVAL_COPY(z_copy, z); - zendi_zval_copy_ctor(*z_copy); - incdec_op(z_copy); - Z_ADDREF_P(z); - Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + ZVAL_DUP(retval, z); + ZVAL_DUP(&z_copy, z); + incdec_op(&z_copy); + if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); + Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); zval_ptr_dtor(&z_copy); - zval_ptr_dtor(&z); + zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); ZVAL_NULL(retval); } } - if (0) { - zval_ptr_dtor(&property); - } else { - zval_ptr_dtor_nogc(&free_op2.var); - } + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -27839,29 +26865,20 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_VAR if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { zend_error(E_NOTICE, "Trying to get property of non-object"); - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - zval_ptr_dtor_nogc(&free_op2.var); + ZVAL_NULL(EX_VAR(opline->result.var)); } else { zval *retval; - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - /* here we are sure we are dealing with an object */ - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC); - PZVAL_LOCK(retval); - EX_T(opline->result.var).var.ptr = retval; - - if (0) { - zval_ptr_dtor(&offset); - } else { - zval_ptr_dtor_nogc(&free_op2.var); + if (retval != EX_VAR(opline->result.var)) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); } } + zval_ptr_dtor_nogc(free_op2.var); + CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -27876,38 +26893,20 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_H USE_OPLINE zend_free_op free_op1, free_op2; zval *property; - zval **container; + zval *container; SAVE_OPLINE(); property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); - if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { + container = _get_obj_zval_ptr_unused(TSRMLS_C); + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property); - } else { - zval_ptr_dtor_nogc(&free_op2.var); - } + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC); + zval_ptr_dtor_nogc(free_op2.var); if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); - } - - /* We are going to assign the result by reference */ - if (opline->extended_value & ZEND_FETCH_MAKE_REF) { - zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; - - Z_DELREF_PP(retval_ptr); - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); - Z_ADDREF_PP(retval_ptr); - EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr; - EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } CHECK_EXCEPTION(); @@ -27919,26 +26918,19 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_ USE_OPLINE zend_free_op free_op1, free_op2; zval *property; - zval **container; + zval *container; SAVE_OPLINE(); property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); + container = _get_obj_zval_ptr_unused(TSRMLS_C); - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property); - } else { - zval_ptr_dtor_nogc(&free_op2.var); - } + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_RW, 0 TSRMLS_CC); + zval_ptr_dtor_nogc(free_op2.var); if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } CHECK_EXCEPTION(); @@ -27959,29 +26951,20 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_ if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - zval_ptr_dtor_nogc(&free_op2.var); + ZVAL_NULL(EX_VAR(opline->result.var)); } else { zval *retval; - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - /* here we are sure we are dealing with an object */ - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - - PZVAL_LOCK(retval); - EX_T(opline->result.var).var.ptr = retval; + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC); - if (0) { - zval_ptr_dtor(&offset); - } else { - zval_ptr_dtor_nogc(&free_op2.var); + if (retval != EX_VAR(opline->result.var)) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); } } + zval_ptr_dtor_nogc(free_op2.var); + CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -27989,31 +26972,24 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE + zval *container; if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { /* Behave like FETCH_OBJ_W */ zend_free_op free_op1, free_op2; zval *property; - zval **container; SAVE_OPLINE(); property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); + container = _get_obj_zval_ptr_unused(TSRMLS_C); - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property); - } else { - zval_ptr_dtor_nogc(&free_op2.var); - } + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, 0 TSRMLS_CC); + zval_ptr_dtor_nogc(free_op2.var); if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } CHECK_EXCEPTION(); @@ -28026,41 +27002,22 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_VAR_HANDLER(ZEND_O static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_free_op free_op1, free_op2, free_res; - zval **container; - zval *property; + zend_free_op free_op1, free_op2; + zval *container, *property; SAVE_OPLINE(); - container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); + container = _get_obj_zval_ptr_unused(TSRMLS_C); property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (IS_UNUSED == IS_CV) { - if (container != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(container); - } - } - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property); - } else { - zval_ptr_dtor_nogc(&free_op2.var); - } + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_UNSET, 0 TSRMLS_CC); + zval_ptr_dtor_nogc(free_op2.var); if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res); - if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr); - } - PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr); - FREE_OP_VAR_PTR(free_res); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -28069,25 +27026,18 @@ static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HA { USE_OPLINE zend_free_op free_op2; - zval **object_ptr; + zval *object; zval *property_name; SAVE_OPLINE(); - object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); + object = _get_obj_zval_ptr_unused(TSRMLS_C); property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (0) { - MAKE_REAL_ZVAL_PTR(property_name); - } - if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property_name); - } else { - zval_ptr_dtor_nogc(&free_op2.var); - } + zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op2.var); /* assign_obj has two opcodes! */ CHECK_EXCEPTION(); @@ -28099,7 +27049,7 @@ static int ZEND_FASTCALL ZEND_ADD_VAR_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDL { USE_OPLINE zend_free_op free_op2; - zval *str = &EX_T(opline->result.var).tmp_var; + zval *str = EX_VAR(opline->result.var); zval *var; zval var_copy; int use_copy = 0; @@ -28109,18 +27059,17 @@ static int ZEND_FASTCALL ZEND_ADD_VAR_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDL if (IS_UNUSED == IS_UNUSED) { /* Initialize for erealloc in add_string_to_string */ - Z_STRVAL_P(str) = NULL; - Z_STRLEN_P(str) = 0; - Z_TYPE_P(str) = IS_STRING; - - INIT_PZVAL(str); + ZVAL_EMPTY_STRING(str); } if (Z_TYPE_P(var) != IS_STRING) { - zend_make_printable_zval(var, &var_copy, &use_copy); + ZVAL_DEREF(var); + if (Z_TYPE_P(var) != IS_STRING) { + zend_make_printable_zval(var, &var_copy, &use_copy); - if (use_copy) { - var = &var_copy; + if (use_copy) { + var = &var_copy; + } } } add_string_to_string(str, str, var); @@ -28134,7 +27083,7 @@ static int ZEND_FASTCALL ZEND_ADD_VAR_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDL * which aren't affected by FREE_OP(Ts, )'s anyway, unless they're * string offsets or overloaded objects */ - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -28144,10 +27093,9 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_VAR_HANDLER(ZEND_OPC { USE_OPLINE zval *function_name; - char *function_name_strval; - int function_name_strlen; zend_free_op free_op2; call_slot *call = EX(call_slots) + opline->result.num; + zval *object; SAVE_OPLINE(); @@ -28161,62 +27109,51 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_VAR_HANDLER(ZEND_OPC zend_error_noreturn(E_ERROR, "Method name must be a string"); } - function_name_strval = Z_STRVAL_P(function_name); - function_name_strlen = Z_STRLEN_P(function_name); - - call->object = _get_obj_zval_ptr_unused(TSRMLS_C); + object = _get_obj_zval_ptr_unused(TSRMLS_C); + call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL; - if (EXPECTED(call->object != NULL) && - EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) { - call->called_scope = Z_OBJCE_P(call->object); + if (EXPECTED(call->object != NULL)) { + call->called_scope = zend_get_class_entry(call->object TSRMLS_CC); if (IS_VAR != IS_CONST || - (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) { - zval *object = call->object; + (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope)) == NULL) { + zend_object *object = call->object; - if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) { + if (UNEXPECTED(object->handlers->get_method == NULL)) { zend_error_noreturn(E_ERROR, "Object does not support method calls"); } /* First, locate the function. */ - call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); + call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_VAR == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); if (UNEXPECTED(call->fbc == NULL)) { - zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval); + zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name)); } if (IS_VAR == IS_CONST && EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) && EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) && EXPECTED(call->object == object)) { - CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc); + CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope, call->fbc); } } } else { if (UNEXPECTED(EG(exception) != NULL)) { - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); HANDLE_EXCEPTION(); } - zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval); + zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", Z_STRVAL_P(function_name)); } if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) { call->object = NULL; } else { - if (!PZVAL_IS_REF(call->object)) { - Z_ADDREF_P(call->object); /* For $this pointer */ - } else { - zval *this_ptr; - ALLOC_ZVAL(this_ptr); - INIT_PZVAL_COPY(this_ptr, call->object); - zval_copy_ctor(this_ptr); - call->object = this_ptr; - } + GC_REFCOUNT(call->object)++; /* For $this pointer */ } call->num_additional_args = 0; call->is_ctor_call = 0; EX(call) = call; - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -28224,9 +27161,26 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_VAR_HANDLER(ZEND_OPC static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { + zval *array; + zend_uint size; USE_OPLINE - array_init(&EX_T(opline->result.var).tmp_var); + array = EX_VAR(opline->result.var); + if (IS_UNUSED != IS_UNUSED) { + size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; + } else { + size = 0; + } + ZVAL_NEW_ARR(array); + zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); + + if (IS_UNUSED != IS_UNUSED) { + /* Explicitly initialize array as not-packed if flag is set */ + if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) { + zend_hash_real_init(Z_ARRVAL_P(array), 0); + } + } + if (IS_UNUSED == IS_UNUSED) { ZEND_VM_NEXT_OPCODE(); #if 0 || IS_UNUSED != IS_UNUSED @@ -28240,91 +27194,98 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HAN { USE_OPLINE zend_free_op free_op2; - zval **container; + zval *container; zval *offset; ulong hval; SAVE_OPLINE(); - container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); - if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) { + container = _get_obj_zval_ptr_unused(TSRMLS_C); + if (IS_UNUSED != IS_UNUSED) { SEPARATE_ZVAL_IF_NOT_REF(container); } offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (IS_UNUSED != IS_VAR || container) { - switch (Z_TYPE_PP(container)) { - case IS_ARRAY: { - HashTable *ht = Z_ARRVAL_PP(container); - - switch (Z_TYPE_P(offset)) { - case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); - zend_hash_index_del(ht, hval); - break; - case IS_RESOURCE: - case IS_BOOL: - case IS_LONG: - hval = Z_LVAL_P(offset); - zend_hash_index_del(ht, hval); - break; - case IS_STRING: - if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { - Z_ADDREF_P(offset); - } - if (IS_VAR == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); - } - if (ht == &EG(symbol_table)) { - zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC); - } else { - zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval); - } - if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { - zval_ptr_dtor(&offset); - } - break; +container_again: + switch (Z_TYPE_P(container)) { + case IS_ARRAY: { + HashTable *ht = Z_ARRVAL_P(container); +offset_again: + switch (Z_TYPE_P(offset)) { + case IS_DOUBLE: + hval = zend_dval_to_lval(Z_DVAL_P(offset)); + zend_hash_index_del(ht, hval); + break; + case IS_LONG: + hval = Z_LVAL_P(offset); num_index_dim: - zend_hash_index_del(ht, hval); - if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { - zval_ptr_dtor(&offset); - } - break; - case IS_NULL: - zend_hash_del(ht, "", sizeof("")); - break; - default: - zend_error(E_WARNING, "Illegal offset type in unset"); - break; - } - zval_ptr_dtor_nogc(&free_op2.var); - break; + zend_hash_index_del(ht, hval); + break; + case IS_STRING: + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset); + } + if (IS_VAR != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto numeric_index_dim); + } + if (ht == &EG(symbol_table).ht) { + zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC); + } else { + zend_hash_del(ht, Z_STR_P(offset)); + } + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + zval_ptr_dtor(offset); + } + break; +numeric_index_dim: + zend_hash_index_del(ht, hval); + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + zval_ptr_dtor(offset); + } + break; + case IS_NULL: + zend_hash_del(ht, STR_EMPTY_ALLOC()); + break; + case IS_FALSE: + hval = 0; + goto num_index_dim; + case IS_TRUE: + hval = 1; + goto num_index_dim; + case IS_RESOURCE: + hval = Z_RES_HANDLE_P(offset); + goto num_index_dim; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto offset_again; + break; + default: + zend_error(E_WARNING, "Illegal offset type in unset"); + break; } - case IS_OBJECT: - if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use object as array"); - } - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC); - if (0) { - zval_ptr_dtor(&offset); - } else { - zval_ptr_dtor_nogc(&free_op2.var); - } - break; - case IS_STRING: - zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); - ZEND_VM_CONTINUE(); /* bailed out before */ - default: - zval_ptr_dtor_nogc(&free_op2.var); - break; + zval_ptr_dtor_nogc(free_op2.var); + break; } - } else { - zval_ptr_dtor_nogc(&free_op2.var); + case IS_OBJECT: + if (UNEXPECTED(Z_OBJ_HT_P(container)->unset_dimension == NULL)) { + zend_error_noreturn(E_ERROR, "Cannot use object as array"); + } +//??? if (IS_VAR == IS_CONST) { +//??? zval_copy_ctor(offset); +//??? } + Z_OBJ_HT_P(container)->unset_dimension(container, offset TSRMLS_CC); + zval_ptr_dtor_nogc(free_op2.var); + break; + case IS_STRING: + case IS_STR_OFFSET: + zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); + ZEND_VM_CONTINUE(); /* bailed out before */ + case IS_REFERENCE: + container = Z_REFVAL_P(container); + goto container_again; + break; + default: + zval_ptr_dtor_nogc(free_op2.var); + break; } CHECK_EXCEPTION(); @@ -28335,49 +27296,36 @@ static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HAN { USE_OPLINE zend_free_op free_op2; - zval **container; + zval *container; zval *offset; SAVE_OPLINE(); - container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); + container = _get_obj_zval_ptr_unused(TSRMLS_C); + if (IS_UNUSED == IS_VAR && Z_TYPE_P(container) == IS_STR_OFFSET) { + zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); + } offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (IS_UNUSED != IS_VAR || container) { - if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(container); - } - if (Z_TYPE_PP(container) == IS_OBJECT) { - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - if (Z_OBJ_HT_P(*container)->unset_property) { - Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to unset property of non-object"); - } - if (0) { - zval_ptr_dtor(&offset); - } else { - zval_ptr_dtor_nogc(&free_op2.var); - } + ZVAL_DEREF(container); + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->unset_property) { + Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); } else { - zval_ptr_dtor_nogc(&free_op2.var); + zend_error(E_NOTICE, "Trying to unset property of non-object"); } - } else { - zval_ptr_dtor_nogc(&free_op2.var); } + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_VAR(int prop_dim, ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_free_op free_op2; zval *container; - zval **value = NULL; - int result = 0; + int result; ulong hval; zval *offset; @@ -28385,40 +27333,45 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_VAR container = _get_obj_zval_ptr_unused(TSRMLS_C); offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) { - HashTable *ht; - int isset = 0; - - ht = Z_ARRVAL_P(container); + if (Z_TYPE_P(container) == IS_ARRAY) { + HashTable *ht = Z_ARRVAL_P(container); + zval *value = NULL; + zend_string *str; +isset_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: hval = zend_dval_to_lval(Z_DVAL_P(offset)); goto num_index_prop; - case IS_RESOURCE: - case IS_BOOL: case IS_LONG: hval = Z_LVAL_P(offset); num_index_prop: - if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) { - isset = 1; - } + value = zend_hash_index_find(ht, hval); break; case IS_STRING: - if (IS_VAR == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); - } - if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) { - isset = 1; + str = Z_STR_P(offset); + if (IS_VAR != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index_prop); } +str_index_prop: + value = zend_hash_find_ind(ht, str); break; case IS_NULL: - if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) { - isset = 1; - } + str = STR_EMPTY_ALLOC(); + goto str_index_prop; + break; + case IS_FALSE: + hval = 0; + goto num_index_prop; + case IS_TRUE: + hval = 0; + goto num_index_prop; + case IS_RESOURCE: + hval = Z_RES_HANDLE_P(offset); + goto num_index_prop; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto isset_again; break; default: zend_error(E_WARNING, "Illegal offset type in isset or empty"); @@ -28426,116 +27379,105 @@ num_index_prop: } if (opline->extended_value & ZEND_ISSET) { - if (isset && Z_TYPE_PP(value) == IS_NULL) { - result = 0; - } else { - result = isset; - } + /* > IS_NULL means not IS_UNDEF and not IS_NULL */ + result = (value != NULL && Z_TYPE_P(value) > IS_NULL); } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { - if (!isset || !i_zend_is_true(*value TSRMLS_CC)) { - result = 0; - } else { - result = 1; - } + result = (value == NULL || !i_zend_is_true(value TSRMLS_CC)); } - zval_ptr_dtor_nogc(&free_op2.var); } else if (Z_TYPE_P(container) == IS_OBJECT) { - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - if (prop_dim) { - if (Z_OBJ_HT_P(container)->has_property) { - result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check property of non-object"); - result = 0; - } + if (Z_OBJ_HT_P(container)->has_dimension) { + result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); } else { - if (Z_OBJ_HT_P(container)->has_dimension) { - result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check element of non-array"); - result = 0; - } + zend_error(E_NOTICE, "Trying to check element of non-array"); + result = 0; } - if (0) { - zval_ptr_dtor(&offset); - } else { - zval_ptr_dtor_nogc(&free_op2.var); + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; } - } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */ + } else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */ zval tmp; - if (Z_TYPE_P(offset) != IS_LONG) { - if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */ + result = 0; + if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) { + if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */ || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { - ZVAL_COPY_VALUE(&tmp, offset); - zval_copy_ctor(&tmp); + ZVAL_DUP(&tmp, offset); convert_to_long(&tmp); offset = &tmp; - } else { - /* can not be converted to proper offset, return "not set" */ - result = 0; } } if (Z_TYPE_P(offset) == IS_LONG) { - if (opline->extended_value & ZEND_ISSET) { - if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { - result = 1; - } - } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { - if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') { + if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { + if ((opline->extended_value & ZEND_ISSET) || + Z_STRVAL_P(container)[offset->value.lval] != '0') { result = 1; } } } - zval_ptr_dtor_nogc(&free_op2.var); + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } } else { - zval_ptr_dtor_nogc(&free_op2.var); + result = ((opline->extended_value & ZEND_ISSET) == 0); } - Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; - if (opline->extended_value & ZEND_ISSET) { - Z_LVAL(EX_T(opline->result.var).tmp_var) = result; - } else { - Z_LVAL(EX_T(opline->result.var).tmp_var) = !result; - } + zval_ptr_dtor_nogc(free_op2.var); + ZVAL_BOOL(EX_VAR(opline->result.var), result); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_VAR(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} - static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_VAR(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + zend_free_op free_op2; + zval *container; + int result; + zval *offset; + + SAVE_OPLINE(); + container = _get_obj_zval_ptr_unused(TSRMLS_C); + offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->has_property) { + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); + } else { + zend_error(E_NOTICE, "Trying to check property of non-object"); + result = 0; + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else { + result = ((opline->extended_value & ZEND_ISSET) == 0); + } + + zval_ptr_dtor_nogc(free_op2.var); + ZVAL_BOOL(EX_VAR(opline->result.var), result); + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - /* The generator object is stored in return_value_ptr_ptr */ - zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr); + /* The generator object is stored in EX(return_value) */ + zend_generator *generator = (zend_generator *) EX(return_value); if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) { zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator"); } /* Destroy the previously yielded value */ - if (generator->value) { - zval_ptr_dtor(&generator->value); - } + zval_ptr_dtor(&generator->value); /* Destroy the previously yielded key */ - if (generator->key) { - zval_ptr_dtor(&generator->key); - } + zval_ptr_dtor(&generator->key); /* Set the new yielded value */ if (IS_UNUSED != IS_UNUSED) { @@ -28545,74 +27487,58 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER /* Constants and temporary variables aren't yieldable by reference, * but we still allow them with a notice. */ if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR) { - zval *value, *copy; + zval *value; zend_error(E_NOTICE, "Only variable references should be yielded by reference"); value = NULL; - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); + ZVAL_COPY_VALUE(&generator->value, value); + if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1); /* Temporary variables don't need ctor copying */ if (!0) { - zval_copy_ctor(copy); + zval_copy_ctor(&generator->value); } - - generator->value = copy; } else { - zval **value_ptr = NULL; + zval *value_ptr = NULL; - if (IS_UNUSED == IS_VAR && UNEXPECTED(value_ptr == NULL)) { + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference"); } /* If a function call result is yielded and the function did * not return by reference we throw a notice. */ - if (IS_UNUSED == IS_VAR && !Z_ISREF_PP(value_ptr) + if (IS_UNUSED == IS_VAR && !Z_ISREF_P(value_ptr) && !(opline->extended_value == ZEND_RETURNS_FUNCTION - && EX_T(opline->op1.var).var.fcall_returned_reference) - && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) { + && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); - - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } else { SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr); - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } + ZVAL_COPY(&generator->value, value_ptr); } } else { zval *value = NULL; /* Consts, temporary variables and references need copying */ - if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR - || PZVAL_IS_REF(value) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); - - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } - - generator->value = copy; + if (IS_UNUSED == IS_CONST) { + ZVAL_DUP(&generator->value, value); + } else if (IS_UNUSED == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->value, value); + } else if (Z_ISREF_P(value)) { + ZVAL_DUP(&generator->value, Z_REFVAL_P(value)); } else { if (IS_UNUSED == IS_CV) { - Z_ADDREF_P(value); + if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value); } - generator->value = value; + ZVAL_COPY_VALUE(&generator->value, value); } } } else { /* If no value was specified yield null */ - Z_ADDREF(EG(uninitialized_zval)); - generator->value = &EG(uninitialized_zval); + ZVAL_NULL(&generator->value); } /* Set the new yielded key */ @@ -28621,46 +27547,36 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); /* Consts, temporary variables and references need copying */ - if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR - || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, key); - - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } - - generator->key = copy; + if (IS_VAR == IS_CONST) { + ZVAL_DUP(&generator->key, key); + } else if (IS_VAR == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->key, key); + } else if (Z_ISREF_P(key)) { + ZVAL_DUP(&generator->key, Z_REFVAL_P(key)); + zval_ptr_dtor_nogc(free_op2.var); } else { - Z_ADDREF_P(key); - generator->key = key; + if (IS_VAR == IS_CV) { + if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key); + } + ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE_P(generator->key) == IS_LONG - && Z_LVAL_P(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_LONG + && Z_LVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL_P(generator->key); + generator->largest_used_integer_key = Z_LVAL(generator->key); } - - zval_ptr_dtor_nogc(&free_op2.var); } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - - ALLOC_INIT_ZVAL(generator->key); - ZVAL_LONG(generator->key, generator->largest_used_integer_key); + ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ - generator->send_target = &EX_T(opline->result.var).var.ptr; - Z_ADDREF(EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + generator->send_target = EX_VAR(opline->result.var); + ZVAL_NULL(generator->send_target); } else { generator->send_target = NULL; } @@ -28685,18 +27601,18 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(int { USE_OPLINE zend_free_op free_op_data1; - zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); - zval *object; + zval *object = _get_obj_zval_ptr_unused(TSRMLS_C); zval *property = NULL; - zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); + zval *value; int have_get_ptr = 0; - if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - make_real_object(object_ptr TSRMLS_CC); - object = *object_ptr; + object = make_real_object(object TSRMLS_CC); + + value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { zend_error(E_WARNING, "Attempt to assign property of non-object"); @@ -28704,81 +27620,67 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(int FREE_OP(free_op_data1); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } } else { /* here we are sure we are dealing with an object */ - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - - /* here property is a string */ if (opline->extended_value == ZEND_ASSIGN_OBJ && Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_UNUSED == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); if (zptr != NULL) { /* NULL means no success in getting PTR */ SEPARATE_ZVAL_IF_NOT_REF(zptr); have_get_ptr = 1; - binary_op(*zptr, *zptr, value TSRMLS_CC); + binary_op(zptr, zptr, value TSRMLS_CC); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(*zptr); - EX_T(opline->result.var).var.ptr = *zptr; + ZVAL_COPY(EX_VAR(opline->result.var), zptr); } } } if (!have_get_ptr) { zval *z = NULL; + zval rv; if (opline->extended_value == ZEND_ASSIGN_OBJ) { if (Z_OBJ_HT_P(object)->read_property) { - z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_UNUSED == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC); } } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { if (Z_OBJ_HT_P(object)->read_dimension) { - z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC); + z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R, &rv TSRMLS_CC); } } if (z) { if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); zval_dtor(z); - FREE_ZVAL(z); } - z = value; + ZVAL_COPY_VALUE(z, value); } - Z_ADDREF_P(z); - SEPARATE_ZVAL_IF_NOT_REF(&z); +//??? if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); + SEPARATE_ZVAL_IF_NOT_REF(z); binary_op(z, z, value TSRMLS_CC); if (opline->extended_value == ZEND_ASSIGN_OBJ) { - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_UNUSED == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(z); - EX_T(opline->result.var).var.ptr = z; + ZVAL_COPY(EX_VAR(opline->result.var), z); } - zval_ptr_dtor(&z); + zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to assign property of non-object"); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } } } - if (0) { - zval_ptr_dtor(&property); - } else { - - } FREE_OP(free_op_data1); } @@ -28788,155 +27690,285 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(int ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_free_op free_op_data2, free_op_data1; - zval **var_ptr; - zval *value; + zval *var_ptr; + zval *value, *container; SAVE_OPLINE(); - switch (opline->extended_value) { - case ZEND_ASSIGN_OBJ: - return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - break; - case ZEND_ASSIGN_DIM: { - zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); - - if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); - } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) { - if (IS_UNUSED == IS_VAR && !0) { - Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */ - } - return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - } else { - zval *dim = NULL; + container = _get_obj_zval_ptr_unused(TSRMLS_C); + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { + zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); + } else if (UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { + if (IS_UNUSED == IS_VAR && !0) { + Z_ADDREF_P(container); /* undo the effect of get_obj_zval_ptr_ptr() */ + } + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else { + zval *dim = NULL; - zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_UNUSED, BP_VAR_RW TSRMLS_CC); - value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); - var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); - } - } - break; - default: - value = NULL; - var_ptr = NULL; - /* do nothing */ - break; + zend_fetch_dimension_address_RW(EX_VAR((opline+1)->op2.var), container, dim, IS_UNUSED TSRMLS_CC); + value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); + var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); } - if (UNEXPECTED(var_ptr == NULL)) { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); } - if (UNEXPECTED(*var_ptr == &EG(error_zval))) { - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + if (UNEXPECTED(var_ptr == &EG(error_zval))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); } + goto assign_op_dim_exit; + } + SEPARATE_ZVAL_IF_NOT_REF(var_ptr); + ZVAL_DEREF(var_ptr); - CHECK_EXCEPTION(); - if (opline->extended_value == ZEND_ASSIGN_DIM) { - ZEND_VM_INC_OPCODE(); + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) && + UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) { + /* proxy object */ + zval rv; + zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC); + Z_ADDREF_P(objval); + binary_op(objval, objval, value TSRMLS_CC); + Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); + zval_ptr_dtor(objval); + } else { + binary_op(var_ptr, var_ptr, value TSRMLS_CC); + } + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + } + +assign_op_dim_exit: + + FREE_OP(free_op_data1); + FREE_OP_VAR_PTR(free_op_data2); + + CHECK_EXCEPTION(); + ZEND_VM_INC_OPCODE(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + + zval *var_ptr; + zval *value; + + SAVE_OPLINE(); + value = NULL; + var_ptr = NULL; + + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { + zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); + } + + if (IS_UNUSED == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); } - ZEND_VM_NEXT_OPCODE(); + goto assign_op_exit; } SEPARATE_ZVAL_IF_NOT_REF(var_ptr); + ZVAL_DEREF(var_ptr); - if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) - && Z_OBJ_HANDLER_PP(var_ptr, get) - && Z_OBJ_HANDLER_PP(var_ptr, set)) { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) && + UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) { /* proxy object */ - zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); + zval rv; + zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC); Z_ADDREF_P(objval); binary_op(objval, objval, value TSRMLS_CC); - Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC); - zval_ptr_dtor(&objval); + Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); + zval_ptr_dtor(objval); } else { - binary_op(*var_ptr, *var_ptr, value TSRMLS_CC); + binary_op(var_ptr, var_ptr, value TSRMLS_CC); } - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(*var_ptr); - EX_T(opline->result.var).var.ptr = *var_ptr; + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } - if (opline->extended_value == ZEND_ASSIGN_DIM) { - FREE_OP(free_op_data1); - FREE_OP_VAR_PTR(free_op_data2); +assign_op_exit: - CHECK_EXCEPTION(); - ZEND_VM_INC_OPCODE(); - } else { - CHECK_EXCEPTION(); - } + CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { + zval *array; + zend_uint size; USE_OPLINE - array_init(&EX_T(opline->result.var).tmp_var); + array = EX_VAR(opline->result.var); + if (IS_UNUSED != IS_UNUSED) { + size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; + } else { + size = 0; + } + ZVAL_NEW_ARR(array); + zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); + + if (IS_UNUSED != IS_UNUSED) { + /* Explicitly initialize array as not-packed if flag is set */ + if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) { + zend_hash_real_init(Z_ARRVAL_P(array), 0); + } + } + if (IS_UNUSED == IS_UNUSED) { ZEND_VM_NEXT_OPCODE(); #if 0 || IS_UNUSED != IS_UNUSED @@ -28950,22 +27982,18 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HAND { USE_OPLINE - /* The generator object is stored in return_value_ptr_ptr */ - zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr); + /* The generator object is stored in EX(return_value) */ + zend_generator *generator = (zend_generator *) EX(return_value); if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) { zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator"); } /* Destroy the previously yielded value */ - if (generator->value) { - zval_ptr_dtor(&generator->value); - } + zval_ptr_dtor(&generator->value); /* Destroy the previously yielded key */ - if (generator->key) { - zval_ptr_dtor(&generator->key); - } + zval_ptr_dtor(&generator->key); /* Set the new yielded value */ if (IS_UNUSED != IS_UNUSED) { @@ -28975,74 +28003,58 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HAND /* Constants and temporary variables aren't yieldable by reference, * but we still allow them with a notice. */ if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR) { - zval *value, *copy; + zval *value; zend_error(E_NOTICE, "Only variable references should be yielded by reference"); value = NULL; - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); + ZVAL_COPY_VALUE(&generator->value, value); + if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1); /* Temporary variables don't need ctor copying */ if (!0) { - zval_copy_ctor(copy); + zval_copy_ctor(&generator->value); } - - generator->value = copy; } else { - zval **value_ptr = NULL; + zval *value_ptr = NULL; - if (IS_UNUSED == IS_VAR && UNEXPECTED(value_ptr == NULL)) { + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference"); } /* If a function call result is yielded and the function did * not return by reference we throw a notice. */ - if (IS_UNUSED == IS_VAR && !Z_ISREF_PP(value_ptr) + if (IS_UNUSED == IS_VAR && !Z_ISREF_P(value_ptr) && !(opline->extended_value == ZEND_RETURNS_FUNCTION - && EX_T(opline->op1.var).var.fcall_returned_reference) - && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) { + && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); - - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } else { SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr); - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } + ZVAL_COPY(&generator->value, value_ptr); } } else { zval *value = NULL; /* Consts, temporary variables and references need copying */ - if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR - || PZVAL_IS_REF(value) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); - - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } - - generator->value = copy; + if (IS_UNUSED == IS_CONST) { + ZVAL_DUP(&generator->value, value); + } else if (IS_UNUSED == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->value, value); + } else if (Z_ISREF_P(value)) { + ZVAL_DUP(&generator->value, Z_REFVAL_P(value)); } else { if (IS_UNUSED == IS_CV) { - Z_ADDREF_P(value); + if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value); } - generator->value = value; + ZVAL_COPY_VALUE(&generator->value, value); } } } else { /* If no value was specified yield null */ - Z_ADDREF(EG(uninitialized_zval)); - generator->value = &EG(uninitialized_zval); + ZVAL_NULL(&generator->value); } /* Set the new yielded key */ @@ -29051,45 +28063,36 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HAND zval *key = NULL; /* Consts, temporary variables and references need copying */ - if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR - || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, key); - - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } + if (IS_UNUSED == IS_CONST) { + ZVAL_DUP(&generator->key, key); + } else if (IS_UNUSED == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->key, key); + } else if (Z_ISREF_P(key)) { + ZVAL_DUP(&generator->key, Z_REFVAL_P(key)); - generator->key = copy; } else { - Z_ADDREF_P(key); - generator->key = key; + if (IS_UNUSED == IS_CV) { + if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key); + } + ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE_P(generator->key) == IS_LONG - && Z_LVAL_P(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_LONG + && Z_LVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL_P(generator->key); + generator->largest_used_integer_key = Z_LVAL(generator->key); } - } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - - ALLOC_INIT_ZVAL(generator->key); - ZVAL_LONG(generator->key, generator->largest_used_integer_key); + ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ - generator->send_target = &EX_T(opline->result.var).var.ptr; - Z_ADDREF(EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + generator->send_target = EX_VAR(opline->result.var); + ZVAL_NULL(generator->send_target); } else { generator->send_target = NULL; } @@ -29114,18 +28117,18 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(int (*b { USE_OPLINE zend_free_op free_op_data1; - zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); - zval *object; + zval *object = _get_obj_zval_ptr_unused(TSRMLS_C); zval *property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); + zval *value; int have_get_ptr = 0; - if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - make_real_object(object_ptr TSRMLS_CC); - object = *object_ptr; + object = make_real_object(object TSRMLS_CC); + + value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { zend_error(E_WARNING, "Attempt to assign property of non-object"); @@ -29133,81 +28136,67 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(int (*b FREE_OP(free_op_data1); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } } else { /* here we are sure we are dealing with an object */ - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - - /* here property is a string */ if (opline->extended_value == ZEND_ASSIGN_OBJ && Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); if (zptr != NULL) { /* NULL means no success in getting PTR */ SEPARATE_ZVAL_IF_NOT_REF(zptr); have_get_ptr = 1; - binary_op(*zptr, *zptr, value TSRMLS_CC); + binary_op(zptr, zptr, value TSRMLS_CC); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(*zptr); - EX_T(opline->result.var).var.ptr = *zptr; + ZVAL_COPY(EX_VAR(opline->result.var), zptr); } } } if (!have_get_ptr) { zval *z = NULL; + zval rv; if (opline->extended_value == ZEND_ASSIGN_OBJ) { if (Z_OBJ_HT_P(object)->read_property) { - z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC); } } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { if (Z_OBJ_HT_P(object)->read_dimension) { - z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC); + z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R, &rv TSRMLS_CC); } } if (z) { if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); zval_dtor(z); - FREE_ZVAL(z); } - z = value; + ZVAL_COPY_VALUE(z, value); } - Z_ADDREF_P(z); - SEPARATE_ZVAL_IF_NOT_REF(&z); +//??? if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); + SEPARATE_ZVAL_IF_NOT_REF(z); binary_op(z, z, value TSRMLS_CC); if (opline->extended_value == ZEND_ASSIGN_OBJ) { - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(z); - EX_T(opline->result.var).var.ptr = z; + ZVAL_COPY(EX_VAR(opline->result.var), z); } - zval_ptr_dtor(&z); + zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to assign property of non-object"); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } } } - if (0) { - zval_ptr_dtor(&property); - } else { - - } FREE_OP(free_op_data1); } @@ -29217,178 +28206,288 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(int (*b ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_free_op free_op_data2, free_op_data1; - zval **var_ptr; - zval *value; + zval *var_ptr; + zval *value, *container; SAVE_OPLINE(); - switch (opline->extended_value) { - case ZEND_ASSIGN_OBJ: - return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - break; - case ZEND_ASSIGN_DIM: { - zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); - - if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); - } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) { - if (IS_UNUSED == IS_VAR && !0) { - Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */ - } - return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - } else { - zval *dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); + container = _get_obj_zval_ptr_unused(TSRMLS_C); + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { + zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); + } else if (UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { + if (IS_UNUSED == IS_VAR && !0) { + Z_ADDREF_P(container); /* undo the effect of get_obj_zval_ptr_ptr() */ + } + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else { + zval *dim = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_CV, BP_VAR_RW TSRMLS_CC); - value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); - var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); - } - } - break; - default: - value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - var_ptr = NULL; - /* do nothing */ - break; + zend_fetch_dimension_address_RW(EX_VAR((opline+1)->op2.var), container, dim, IS_CV TSRMLS_CC); + value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); + var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); } - if (UNEXPECTED(var_ptr == NULL)) { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); } - if (UNEXPECTED(*var_ptr == &EG(error_zval))) { - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + if (UNEXPECTED(var_ptr == &EG(error_zval))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); } + goto assign_op_dim_exit; + } + SEPARATE_ZVAL_IF_NOT_REF(var_ptr); + ZVAL_DEREF(var_ptr); - CHECK_EXCEPTION(); - if (opline->extended_value == ZEND_ASSIGN_DIM) { - ZEND_VM_INC_OPCODE(); + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) && + UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) { + /* proxy object */ + zval rv; + zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC); + Z_ADDREF_P(objval); + binary_op(objval, objval, value TSRMLS_CC); + Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); + zval_ptr_dtor(objval); + } else { + binary_op(var_ptr, var_ptr, value TSRMLS_CC); + } + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + } + +assign_op_dim_exit: + + FREE_OP(free_op_data1); + FREE_OP_VAR_PTR(free_op_data2); + + CHECK_EXCEPTION(); + ZEND_VM_INC_OPCODE(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + + zval *var_ptr; + zval *value; + + SAVE_OPLINE(); + value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); + var_ptr = NULL; + + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { + zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); + } + + if (IS_UNUSED == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); } - ZEND_VM_NEXT_OPCODE(); + goto assign_op_exit; } SEPARATE_ZVAL_IF_NOT_REF(var_ptr); + ZVAL_DEREF(var_ptr); - if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) - && Z_OBJ_HANDLER_PP(var_ptr, get) - && Z_OBJ_HANDLER_PP(var_ptr, set)) { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) && + UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) { /* proxy object */ - zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); + zval rv; + zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC); Z_ADDREF_P(objval); binary_op(objval, objval, value TSRMLS_CC); - Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC); - zval_ptr_dtor(&objval); + Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); + zval_ptr_dtor(objval); } else { - binary_op(*var_ptr, *var_ptr, value TSRMLS_CC); + binary_op(var_ptr, var_ptr, value TSRMLS_CC); } - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(*var_ptr); - EX_T(opline->result.var).var.ptr = *var_ptr; + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } - if (opline->extended_value == ZEND_ASSIGN_DIM) { - FREE_OP(free_op_data1); - FREE_OP_VAR_PTR(free_op_data2); +assign_op_exit: - CHECK_EXCEPTION(); - ZEND_VM_INC_OPCODE(); - } else { - CHECK_EXCEPTION(); - } + CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_UNUSED_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_UNUSED_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval **object_ptr; zval *object; zval *property; - zval **retval; + zval *retval; int have_get_ptr = 0; SAVE_OPLINE(); - object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); + object = _get_obj_zval_ptr_unused(TSRMLS_C); property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - retval = &EX_T(opline->result.var).var.ptr; + retval = EX_VAR(opline->result.var); - if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } - make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ - object = *object_ptr; + object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */ if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - *retval = &EG(uninitialized_zval); + ZVAL_NULL(retval); } CHECK_EXCEPTION(); @@ -29397,59 +28496,49 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_CV(incdec_t /* here we are sure we are dealing with an object */ - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); if (zptr != NULL) { /* NULL means no success in getting PTR */ SEPARATE_ZVAL_IF_NOT_REF(zptr); have_get_ptr = 1; - incdec_op(*zptr); + incdec_op(zptr); if (RETURN_VALUE_USED(opline)) { - *retval = *zptr; - PZVAL_LOCK(*retval); + ZVAL_COPY(retval, zptr); } } } if (!have_get_ptr) { + zval rv; + if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC); if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); zval_dtor(z); - FREE_ZVAL(z); } - z = value; + ZVAL_COPY_VALUE(z, value); } - Z_ADDREF_P(z); - SEPARATE_ZVAL_IF_NOT_REF(&z); + if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); + SEPARATE_ZVAL_IF_NOT_REF(z); incdec_op(z); - *retval = z; - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - SELECTIVE_PZVAL_LOCK(*retval, opline); - zval_ptr_dtor(&z); + ZVAL_COPY_VALUE(retval, z); + Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); + SELECTIVE_PZVAL_LOCK(retval, opline); + zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - *retval = &EG(uninitialized_zval); + ZVAL_NULL(retval); } } } - if (0) { - zval_ptr_dtor(&property); - } else { - - } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -29469,23 +28558,21 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_CV(incdec_ { USE_OPLINE - zval **object_ptr; zval *object; zval *property; zval *retval; int have_get_ptr = 0; SAVE_OPLINE(); - object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); + object = _get_obj_zval_ptr_unused(TSRMLS_C); property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - retval = &EX_T(opline->result.var).tmp_var; + retval = EX_VAR(opline->result.var); - if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } - make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ - object = *object_ptr; + object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */ if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); @@ -29498,60 +28585,47 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_CV(incdec_ /* here we are sure we are dealing with an object */ - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); if (zptr != NULL) { /* NULL means no success in getting PTR */ have_get_ptr = 1; SEPARATE_ZVAL_IF_NOT_REF(zptr); - ZVAL_COPY_VALUE(retval, *zptr); - zendi_zval_copy_ctor(*retval); + ZVAL_DUP(retval, zptr); - incdec_op(*zptr); + incdec_op(zptr); } } if (!have_get_ptr) { if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - zval *z_copy; + zval rv; + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC); + zval z_copy; if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); zval_dtor(z); - FREE_ZVAL(z); } - z = value; + ZVAL_COPY_VALUE(z, value); } - ZVAL_COPY_VALUE(retval, z); - zendi_zval_copy_ctor(*retval); - ALLOC_ZVAL(z_copy); - INIT_PZVAL_COPY(z_copy, z); - zendi_zval_copy_ctor(*z_copy); - incdec_op(z_copy); - Z_ADDREF_P(z); - Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + ZVAL_DUP(retval, z); + ZVAL_DUP(&z_copy, z); + incdec_op(&z_copy); + if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); + Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); zval_ptr_dtor(&z_copy); - zval_ptr_dtor(&z); + zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); ZVAL_NULL(retval); } } - if (0) { - zval_ptr_dtor(&property); - } else { - - } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -29582,29 +28656,19 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_CV( if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { zend_error(E_NOTICE, "Trying to get property of non-object"); - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - + ZVAL_NULL(EX_VAR(opline->result.var)); } else { zval *retval; - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - /* here we are sure we are dealing with an object */ - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - - PZVAL_LOCK(retval); - EX_T(opline->result.var).var.ptr = retval; - - if (0) { - zval_ptr_dtor(&offset); - } else { + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC); + if (retval != EX_VAR(opline->result.var)) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); } } + CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -29619,38 +28683,20 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HA USE_OPLINE zend_free_op free_op1; zval *property; - zval **container; + zval *container; SAVE_OPLINE(); property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); - if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { + container = _get_obj_zval_ptr_unused(TSRMLS_C); + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property); - } else { + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC); - } if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); - } - - /* We are going to assign the result by reference */ - if (opline->extended_value & ZEND_FETCH_MAKE_REF) { - zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; - - Z_DELREF_PP(retval_ptr); - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); - Z_ADDREF_PP(retval_ptr); - EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr; - EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } CHECK_EXCEPTION(); @@ -29662,26 +28708,19 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_H USE_OPLINE zend_free_op free_op1; zval *property; - zval **container; + zval *container; SAVE_OPLINE(); property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); + container = _get_obj_zval_ptr_unused(TSRMLS_C); - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property); - } else { + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_RW, 0 TSRMLS_CC); - } if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } CHECK_EXCEPTION(); @@ -29702,29 +28741,19 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_H if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - + ZVAL_NULL(EX_VAR(opline->result.var)); } else { zval *retval; - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - /* here we are sure we are dealing with an object */ - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - - PZVAL_LOCK(retval); - EX_T(opline->result.var).var.ptr = retval; - - if (0) { - zval_ptr_dtor(&offset); - } else { + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC); + if (retval != EX_VAR(opline->result.var)) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); } } + CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -29732,31 +28761,24 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_H static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE + zval *container; if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { /* Behave like FETCH_OBJ_W */ zend_free_op free_op1; zval *property; - zval **container; SAVE_OPLINE(); property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); + container = _get_obj_zval_ptr_unused(TSRMLS_C); - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property); - } else { + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, 0 TSRMLS_CC); - } if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } CHECK_EXCEPTION(); @@ -29769,41 +28791,22 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER(ZEND_OP static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_free_op free_op1, free_res; - zval **container; - zval *property; + zend_free_op free_op1; + zval *container, *property; SAVE_OPLINE(); - container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); + container = _get_obj_zval_ptr_unused(TSRMLS_C); property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - if (IS_UNUSED == IS_CV) { - if (container != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(container); - } - } - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property); - } else { + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_UNSET, 0 TSRMLS_CC); - } if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res); - if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr); - } - PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr); - FREE_OP_VAR_PTR(free_res); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -29812,25 +28815,18 @@ static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HAN { USE_OPLINE - zval **object_ptr; + zval *object; zval *property_name; SAVE_OPLINE(); - object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); + object = _get_obj_zval_ptr_unused(TSRMLS_C); property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - if (0) { - MAKE_REAL_ZVAL_PTR(property_name); - } - if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property_name); - } else { + zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC); - } /* assign_obj has two opcodes! */ CHECK_EXCEPTION(); @@ -29842,7 +28838,7 @@ static int ZEND_FASTCALL ZEND_ADD_VAR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLE { USE_OPLINE - zval *str = &EX_T(opline->result.var).tmp_var; + zval *str = EX_VAR(opline->result.var); zval *var; zval var_copy; int use_copy = 0; @@ -29852,18 +28848,17 @@ static int ZEND_FASTCALL ZEND_ADD_VAR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLE if (IS_UNUSED == IS_UNUSED) { /* Initialize for erealloc in add_string_to_string */ - Z_STRVAL_P(str) = NULL; - Z_STRLEN_P(str) = 0; - Z_TYPE_P(str) = IS_STRING; - - INIT_PZVAL(str); + ZVAL_EMPTY_STRING(str); } if (Z_TYPE_P(var) != IS_STRING) { - zend_make_printable_zval(var, &var_copy, &use_copy); + ZVAL_DEREF(var); + if (Z_TYPE_P(var) != IS_STRING) { + zend_make_printable_zval(var, &var_copy, &use_copy); - if (use_copy) { - var = &var_copy; + if (use_copy) { + var = &var_copy; + } } } add_string_to_string(str, str, var); @@ -29886,10 +28881,9 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCO { USE_OPLINE zval *function_name; - char *function_name_strval; - int function_name_strlen; call_slot *call = EX(call_slots) + opline->result.num; + zval *object; SAVE_OPLINE(); @@ -29903,33 +28897,30 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCO zend_error_noreturn(E_ERROR, "Method name must be a string"); } - function_name_strval = Z_STRVAL_P(function_name); - function_name_strlen = Z_STRLEN_P(function_name); - - call->object = _get_obj_zval_ptr_unused(TSRMLS_C); + object = _get_obj_zval_ptr_unused(TSRMLS_C); + call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL; - if (EXPECTED(call->object != NULL) && - EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) { - call->called_scope = Z_OBJCE_P(call->object); + if (EXPECTED(call->object != NULL)) { + call->called_scope = zend_get_class_entry(call->object TSRMLS_CC); if (IS_CV != IS_CONST || - (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) { - zval *object = call->object; + (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope)) == NULL) { + zend_object *object = call->object; - if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) { + if (UNEXPECTED(object->handlers->get_method == NULL)) { zend_error_noreturn(E_ERROR, "Object does not support method calls"); } /* First, locate the function. */ - call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); + call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); if (UNEXPECTED(call->fbc == NULL)) { - zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval); + zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name)); } if (IS_CV == IS_CONST && EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) && EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) && EXPECTED(call->object == object)) { - CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc); + CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope, call->fbc); } } } else { @@ -29937,21 +28928,13 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCO HANDLE_EXCEPTION(); } - zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval); + zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", Z_STRVAL_P(function_name)); } if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) { call->object = NULL; } else { - if (!PZVAL_IS_REF(call->object)) { - Z_ADDREF_P(call->object); /* For $this pointer */ - } else { - zval *this_ptr; - ALLOC_ZVAL(this_ptr); - INIT_PZVAL_COPY(this_ptr, call->object); - zval_copy_ctor(this_ptr); - call->object = this_ptr; - } + GC_REFCOUNT(call->object)++; /* For $this pointer */ } call->num_additional_args = 0; @@ -29965,9 +28948,26 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCO static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { + zval *array; + zend_uint size; USE_OPLINE - array_init(&EX_T(opline->result.var).tmp_var); + array = EX_VAR(opline->result.var); + if (IS_UNUSED != IS_UNUSED) { + size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; + } else { + size = 0; + } + ZVAL_NEW_ARR(array); + zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); + + if (IS_UNUSED != IS_UNUSED) { + /* Explicitly initialize array as not-packed if flag is set */ + if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) { + zend_hash_real_init(Z_ARRVAL_P(array), 0); + } + } + if (IS_UNUSED == IS_UNUSED) { ZEND_VM_NEXT_OPCODE(); #if 0 || IS_UNUSED != IS_UNUSED @@ -29981,91 +28981,98 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HAND { USE_OPLINE - zval **container; + zval *container; zval *offset; ulong hval; SAVE_OPLINE(); - container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); - if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) { + container = _get_obj_zval_ptr_unused(TSRMLS_C); + if (IS_UNUSED != IS_UNUSED) { SEPARATE_ZVAL_IF_NOT_REF(container); } offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - if (IS_UNUSED != IS_VAR || container) { - switch (Z_TYPE_PP(container)) { - case IS_ARRAY: { - HashTable *ht = Z_ARRVAL_PP(container); - - switch (Z_TYPE_P(offset)) { - case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); - zend_hash_index_del(ht, hval); - break; - case IS_RESOURCE: - case IS_BOOL: - case IS_LONG: - hval = Z_LVAL_P(offset); - zend_hash_index_del(ht, hval); - break; - case IS_STRING: - if (IS_CV == IS_CV || IS_CV == IS_VAR) { - Z_ADDREF_P(offset); - } - if (IS_CV == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); - } - if (ht == &EG(symbol_table)) { - zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC); - } else { - zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval); - } - if (IS_CV == IS_CV || IS_CV == IS_VAR) { - zval_ptr_dtor(&offset); - } - break; +container_again: + switch (Z_TYPE_P(container)) { + case IS_ARRAY: { + HashTable *ht = Z_ARRVAL_P(container); +offset_again: + switch (Z_TYPE_P(offset)) { + case IS_DOUBLE: + hval = zend_dval_to_lval(Z_DVAL_P(offset)); + zend_hash_index_del(ht, hval); + break; + case IS_LONG: + hval = Z_LVAL_P(offset); num_index_dim: - zend_hash_index_del(ht, hval); - if (IS_CV == IS_CV || IS_CV == IS_VAR) { - zval_ptr_dtor(&offset); - } - break; - case IS_NULL: - zend_hash_del(ht, "", sizeof("")); - break; - default: - zend_error(E_WARNING, "Illegal offset type in unset"); - break; - } - - break; + zend_hash_index_del(ht, hval); + break; + case IS_STRING: + if (IS_CV == IS_CV || IS_CV == IS_VAR) { + if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset); + } + if (IS_CV != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto numeric_index_dim); + } + if (ht == &EG(symbol_table).ht) { + zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC); + } else { + zend_hash_del(ht, Z_STR_P(offset)); + } + if (IS_CV == IS_CV || IS_CV == IS_VAR) { + zval_ptr_dtor(offset); + } + break; +numeric_index_dim: + zend_hash_index_del(ht, hval); + if (IS_CV == IS_CV || IS_CV == IS_VAR) { + zval_ptr_dtor(offset); + } + break; + case IS_NULL: + zend_hash_del(ht, STR_EMPTY_ALLOC()); + break; + case IS_FALSE: + hval = 0; + goto num_index_dim; + case IS_TRUE: + hval = 1; + goto num_index_dim; + case IS_RESOURCE: + hval = Z_RES_HANDLE_P(offset); + goto num_index_dim; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto offset_again; + break; + default: + zend_error(E_WARNING, "Illegal offset type in unset"); + break; } - case IS_OBJECT: - if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use object as array"); - } - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC); - if (0) { - zval_ptr_dtor(&offset); - } else { - - } - break; - case IS_STRING: - zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); - ZEND_VM_CONTINUE(); /* bailed out before */ - default: - break; + break; } - } else { + case IS_OBJECT: + if (UNEXPECTED(Z_OBJ_HT_P(container)->unset_dimension == NULL)) { + zend_error_noreturn(E_ERROR, "Cannot use object as array"); + } +//??? if (IS_CV == IS_CONST) { +//??? zval_copy_ctor(offset); +//??? } + Z_OBJ_HT_P(container)->unset_dimension(container, offset TSRMLS_CC); + break; + case IS_STRING: + case IS_STR_OFFSET: + zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); + ZEND_VM_CONTINUE(); /* bailed out before */ + case IS_REFERENCE: + container = Z_REFVAL_P(container); + goto container_again; + break; + default: + + break; } CHECK_EXCEPTION(); @@ -30076,49 +29083,36 @@ static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HAND { USE_OPLINE - zval **container; + zval *container; zval *offset; SAVE_OPLINE(); - container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C); + container = _get_obj_zval_ptr_unused(TSRMLS_C); + if (IS_UNUSED == IS_VAR && Z_TYPE_P(container) == IS_STR_OFFSET) { + zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); + } offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - if (IS_UNUSED != IS_VAR || container) { - if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(container); - } - if (Z_TYPE_PP(container) == IS_OBJECT) { - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - if (Z_OBJ_HT_P(*container)->unset_property) { - Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to unset property of non-object"); - } - if (0) { - zval_ptr_dtor(&offset); - } else { - - } + ZVAL_DEREF(container); + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->unset_property) { + Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); } else { - + zend_error(E_NOTICE, "Trying to unset property of non-object"); } - } else { - } + CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CV(int prop_dim, ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; - zval **value = NULL; - int result = 0; + int result; ulong hval; zval *offset; @@ -30126,40 +29120,45 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CV( container = _get_obj_zval_ptr_unused(TSRMLS_C); offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) { - HashTable *ht; - int isset = 0; - - ht = Z_ARRVAL_P(container); + if (Z_TYPE_P(container) == IS_ARRAY) { + HashTable *ht = Z_ARRVAL_P(container); + zval *value = NULL; + zend_string *str; +isset_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: hval = zend_dval_to_lval(Z_DVAL_P(offset)); goto num_index_prop; - case IS_RESOURCE: - case IS_BOOL: case IS_LONG: hval = Z_LVAL_P(offset); num_index_prop: - if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) { - isset = 1; - } + value = zend_hash_index_find(ht, hval); break; case IS_STRING: - if (IS_CV == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); - } - if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) { - isset = 1; + str = Z_STR_P(offset); + if (IS_CV != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index_prop); } +str_index_prop: + value = zend_hash_find_ind(ht, str); break; case IS_NULL: - if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) { - isset = 1; - } + str = STR_EMPTY_ALLOC(); + goto str_index_prop; + break; + case IS_FALSE: + hval = 0; + goto num_index_prop; + case IS_TRUE: + hval = 0; + goto num_index_prop; + case IS_RESOURCE: + hval = Z_RES_HANDLE_P(offset); + goto num_index_prop; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto isset_again; break; default: zend_error(E_WARNING, "Illegal offset type in isset or empty"); @@ -30167,116 +29166,103 @@ num_index_prop: } if (opline->extended_value & ZEND_ISSET) { - if (isset && Z_TYPE_PP(value) == IS_NULL) { - result = 0; - } else { - result = isset; - } + /* > IS_NULL means not IS_UNDEF and not IS_NULL */ + result = (value != NULL && Z_TYPE_P(value) > IS_NULL); } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { - if (!isset || !i_zend_is_true(*value TSRMLS_CC)) { - result = 0; - } else { - result = 1; - } + result = (value == NULL || !i_zend_is_true(value TSRMLS_CC)); } - } else if (Z_TYPE_P(container) == IS_OBJECT) { - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - if (prop_dim) { - if (Z_OBJ_HT_P(container)->has_property) { - result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check property of non-object"); - result = 0; - } + if (Z_OBJ_HT_P(container)->has_dimension) { + result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); } else { - if (Z_OBJ_HT_P(container)->has_dimension) { - result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check element of non-array"); - result = 0; - } + zend_error(E_NOTICE, "Trying to check element of non-array"); + result = 0; } - if (0) { - zval_ptr_dtor(&offset); - } else { - + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; } - } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */ + } else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */ zval tmp; - if (Z_TYPE_P(offset) != IS_LONG) { - if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */ + result = 0; + if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) { + if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */ || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { - ZVAL_COPY_VALUE(&tmp, offset); - zval_copy_ctor(&tmp); + ZVAL_DUP(&tmp, offset); convert_to_long(&tmp); offset = &tmp; - } else { - /* can not be converted to proper offset, return "not set" */ - result = 0; } } if (Z_TYPE_P(offset) == IS_LONG) { - if (opline->extended_value & ZEND_ISSET) { - if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { - result = 1; - } - } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { - if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') { + if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { + if ((opline->extended_value & ZEND_ISSET) || + Z_STRVAL_P(container)[offset->value.lval] != '0') { result = 1; } } } - + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } } else { - + result = ((opline->extended_value & ZEND_ISSET) == 0); } - Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; - if (opline->extended_value & ZEND_ISSET) { - Z_LVAL(EX_T(opline->result.var).tmp_var) = result; - } else { - Z_LVAL(EX_T(opline->result.var).tmp_var) = !result; - } + ZVAL_BOOL(EX_VAR(opline->result.var), result); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CV(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} - static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CV(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + zval *container; + int result; + zval *offset; + + SAVE_OPLINE(); + container = _get_obj_zval_ptr_unused(TSRMLS_C); + offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); + + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->has_property) { + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); + } else { + zend_error(E_NOTICE, "Trying to check property of non-object"); + result = 0; + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else { + result = ((opline->extended_value & ZEND_ISSET) == 0); + } + + ZVAL_BOOL(EX_VAR(opline->result.var), result); + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - /* The generator object is stored in return_value_ptr_ptr */ - zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr); + /* The generator object is stored in EX(return_value) */ + zend_generator *generator = (zend_generator *) EX(return_value); if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) { zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator"); } /* Destroy the previously yielded value */ - if (generator->value) { - zval_ptr_dtor(&generator->value); - } + zval_ptr_dtor(&generator->value); /* Destroy the previously yielded key */ - if (generator->key) { - zval_ptr_dtor(&generator->key); - } + zval_ptr_dtor(&generator->key); /* Set the new yielded value */ if (IS_UNUSED != IS_UNUSED) { @@ -30286,74 +29272,58 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ /* Constants and temporary variables aren't yieldable by reference, * but we still allow them with a notice. */ if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR) { - zval *value, *copy; + zval *value; zend_error(E_NOTICE, "Only variable references should be yielded by reference"); value = NULL; - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); + ZVAL_COPY_VALUE(&generator->value, value); + if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1); /* Temporary variables don't need ctor copying */ if (!0) { - zval_copy_ctor(copy); + zval_copy_ctor(&generator->value); } - - generator->value = copy; } else { - zval **value_ptr = NULL; + zval *value_ptr = NULL; - if (IS_UNUSED == IS_VAR && UNEXPECTED(value_ptr == NULL)) { + if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference"); } /* If a function call result is yielded and the function did * not return by reference we throw a notice. */ - if (IS_UNUSED == IS_VAR && !Z_ISREF_PP(value_ptr) + if (IS_UNUSED == IS_VAR && !Z_ISREF_P(value_ptr) && !(opline->extended_value == ZEND_RETURNS_FUNCTION - && EX_T(opline->op1.var).var.fcall_returned_reference) - && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) { + && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); - - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } else { SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr); - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } + ZVAL_COPY(&generator->value, value_ptr); } } else { zval *value = NULL; /* Consts, temporary variables and references need copying */ - if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR - || PZVAL_IS_REF(value) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); - - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } - - generator->value = copy; + if (IS_UNUSED == IS_CONST) { + ZVAL_DUP(&generator->value, value); + } else if (IS_UNUSED == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->value, value); + } else if (Z_ISREF_P(value)) { + ZVAL_DUP(&generator->value, Z_REFVAL_P(value)); } else { if (IS_UNUSED == IS_CV) { - Z_ADDREF_P(value); + if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value); } - generator->value = value; + ZVAL_COPY_VALUE(&generator->value, value); } } } else { /* If no value was specified yield null */ - Z_ADDREF(EG(uninitialized_zval)); - generator->value = &EG(uninitialized_zval); + ZVAL_NULL(&generator->value); } /* Set the new yielded key */ @@ -30362,45 +29332,36 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); /* Consts, temporary variables and references need copying */ - if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR - || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, key); - - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } + if (IS_CV == IS_CONST) { + ZVAL_DUP(&generator->key, key); + } else if (IS_CV == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->key, key); + } else if (Z_ISREF_P(key)) { + ZVAL_DUP(&generator->key, Z_REFVAL_P(key)); - generator->key = copy; } else { - Z_ADDREF_P(key); - generator->key = key; + if (IS_CV == IS_CV) { + if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key); + } + ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE_P(generator->key) == IS_LONG - && Z_LVAL_P(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_LONG + && Z_LVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL_P(generator->key); + generator->largest_used_integer_key = Z_LVAL(generator->key); } - } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - - ALLOC_INIT_ZVAL(generator->key); - ZVAL_LONG(generator->key, generator->largest_used_integer_key); + ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ - generator->send_target = &EX_T(opline->result.var).var.ptr; - Z_ADDREF(EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + generator->send_target = EX_VAR(opline->result.var); + ZVAL_NULL(generator->send_target); } else { generator->send_target = NULL; } @@ -30427,8 +29388,8 @@ static int ZEND_FASTCALL ZEND_BW_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) SAVE_OPLINE(); - bitwise_not_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC) TSRMLS_CC); + bitwise_not_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC) TSRMLS_CC); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -30440,8 +29401,8 @@ static int ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS SAVE_OPLINE(); - boolean_not_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC) TSRMLS_CC); + boolean_not_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC) TSRMLS_CC); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -30451,42 +29412,53 @@ static int ZEND_FASTCALL ZEND_PRE_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval **var_ptr; + zval *var_ptr; SAVE_OPLINE(); - var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); + var_ptr = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); + + if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) { + fast_increment_function(var_ptr); + if (RETURN_VALUE_USED(opline)) { + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr); + } + ZEND_VM_NEXT_OPCODE(); + } - if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } - if (IS_CV == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) { + if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) { if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - SEPARATE_ZVAL_IF_NOT_REF(var_ptr); + if (UNEXPECTED(Z_ISREF_P(var_ptr))) { + var_ptr = Z_REFVAL_P(var_ptr); + } else { + SEPARATE_ZVAL(var_ptr); + } - if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) - && Z_OBJ_HANDLER_PP(var_ptr, get) - && Z_OBJ_HANDLER_PP(var_ptr, set)) { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) + && Z_OBJ_HANDLER_P(var_ptr, get) + && Z_OBJ_HANDLER_P(var_ptr, set)) { /* proxy object */ - zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); + zval rv; + zval *val = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC); Z_ADDREF_P(val); fast_increment_function(val); - Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC); - zval_ptr_dtor(&val); + Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC); + zval_ptr_dtor(val); } else { - fast_increment_function(*var_ptr); + increment_function(var_ptr); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(*var_ptr); - EX_T(opline->result.var).var.ptr = *var_ptr; + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } CHECK_EXCEPTION(); @@ -30497,42 +29469,53 @@ static int ZEND_FASTCALL ZEND_PRE_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval **var_ptr; + zval *var_ptr; SAVE_OPLINE(); - var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); + var_ptr = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); - if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == NULL)) { + if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) { + fast_decrement_function(var_ptr); + if (RETURN_VALUE_USED(opline)) { + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr); + } + ZEND_VM_NEXT_OPCODE(); + } + + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } - if (IS_CV == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) { + if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) { if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - SEPARATE_ZVAL_IF_NOT_REF(var_ptr); + if (UNEXPECTED(Z_ISREF_P(var_ptr))) { + var_ptr = Z_REFVAL_P(var_ptr); + } else { + SEPARATE_ZVAL(var_ptr); + } - if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) - && Z_OBJ_HANDLER_PP(var_ptr, get) - && Z_OBJ_HANDLER_PP(var_ptr, set)) { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) + && Z_OBJ_HANDLER_P(var_ptr, get) + && Z_OBJ_HANDLER_P(var_ptr, set)) { /* proxy object */ - zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); + zval rv; + zval *val = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC); Z_ADDREF_P(val); fast_decrement_function(val); - Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC); - zval_ptr_dtor(&val); + Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC); + zval_ptr_dtor(val); } else { - fast_decrement_function(*var_ptr); + decrement_function(var_ptr); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(*var_ptr); - EX_T(opline->result.var).var.ptr = *var_ptr; + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } CHECK_EXCEPTION(); @@ -30543,38 +29526,49 @@ static int ZEND_FASTCALL ZEND_POST_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS { USE_OPLINE - zval **var_ptr, *retval; + zval *var_ptr, *retval; SAVE_OPLINE(); - var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); + var_ptr = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); + + if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) { + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr); + fast_increment_function(var_ptr); + ZEND_VM_NEXT_OPCODE(); + } - if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } - if (IS_CV == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) { - ZVAL_NULL(&EX_T(opline->result.var).tmp_var); + if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) { + ZVAL_NULL(EX_VAR(opline->result.var)); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - retval = &EX_T(opline->result.var).tmp_var; - ZVAL_COPY_VALUE(retval, *var_ptr); - zendi_zval_copy_ctor(*retval); + retval = EX_VAR(opline->result.var); - SEPARATE_ZVAL_IF_NOT_REF(var_ptr); + if (UNEXPECTED(Z_ISREF_P(var_ptr))) { + var_ptr = Z_REFVAL_P(var_ptr); + ZVAL_DUP(retval, var_ptr); + } else { + ZVAL_DUP(retval, var_ptr); + SEPARATE_ZVAL(var_ptr); + } - if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) - && Z_OBJ_HANDLER_PP(var_ptr, get) - && Z_OBJ_HANDLER_PP(var_ptr, set)) { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) + && Z_OBJ_HANDLER_P(var_ptr, get) + && Z_OBJ_HANDLER_P(var_ptr, set)) { /* proxy object */ - zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); + zval rv; + zval *val = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC); Z_ADDREF_P(val); fast_increment_function(val); - Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC); - zval_ptr_dtor(&val); + Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC); + zval_ptr_dtor(val); } else { - fast_increment_function(*var_ptr); + increment_function(var_ptr); } CHECK_EXCEPTION(); @@ -30585,38 +29579,49 @@ static int ZEND_FASTCALL ZEND_POST_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS { USE_OPLINE - zval **var_ptr, *retval; + zval *var_ptr, *retval; SAVE_OPLINE(); - var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); + var_ptr = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); - if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == NULL)) { + if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) { + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr); + fast_decrement_function(var_ptr); + ZEND_VM_NEXT_OPCODE(); + } + + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } - if (IS_CV == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) { - ZVAL_NULL(&EX_T(opline->result.var).tmp_var); + if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) { + ZVAL_NULL(EX_VAR(opline->result.var)); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - retval = &EX_T(opline->result.var).tmp_var; - ZVAL_COPY_VALUE(retval, *var_ptr); - zendi_zval_copy_ctor(*retval); + retval = EX_VAR(opline->result.var); - SEPARATE_ZVAL_IF_NOT_REF(var_ptr); + if (UNEXPECTED(Z_ISREF_P(var_ptr))) { + var_ptr = Z_REFVAL_P(var_ptr); + ZVAL_DUP(retval, var_ptr); + } else { + ZVAL_DUP(retval, var_ptr); + SEPARATE_ZVAL(var_ptr); + } - if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) - && Z_OBJ_HANDLER_PP(var_ptr, get) - && Z_OBJ_HANDLER_PP(var_ptr, set)) { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) + && Z_OBJ_HANDLER_P(var_ptr, get) + && Z_OBJ_HANDLER_P(var_ptr, set)) { /* proxy object */ - zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); + zval rv; + zval *val = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC); Z_ADDREF_P(val); fast_decrement_function(val); - Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC); - zval_ptr_dtor(&val); + Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC); + zval_ptr_dtor(val); } else { - fast_decrement_function(*var_ptr); + decrement_function(var_ptr); } CHECK_EXCEPTION(); @@ -30630,12 +29635,9 @@ static int ZEND_FASTCALL ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zval *z; SAVE_OPLINE(); - z = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); + z = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); - if (IS_CV == IS_TMP_VAR && Z_TYPE_P(z) == IS_OBJECT) { - INIT_PZVAL(z); - } - zend_print_variable(z); + zend_print_variable(z TSRMLS_CC); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -30645,7 +29647,7 @@ static int ZEND_FASTCALL ZEND_PRINT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - ZVAL_LONG(&EX_T(opline->result.var).tmp_var, 1); + ZVAL_LONG(EX_VAR(opline->result.var), 1); return ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } @@ -30654,29 +29656,30 @@ static int ZEND_FASTCALL ZEND_JMPZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) USE_OPLINE zval *val; - int ret; SAVE_OPLINE(); - val = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); + val = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); - if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { - ret = Z_LVAL_P(val); - } else { - ret = i_zend_is_true(val TSRMLS_CC); - - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); + if (IS_CV == IS_TMP_VAR) { + if (Z_TYPE_P(val) == IS_TRUE) { + ZEND_VM_SET_OPCODE(opline + 1); + ZEND_VM_CONTINUE(); + } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { + ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); + ZEND_VM_CONTINUE(); } } - if (!ret) { -#if DEBUG_ZEND>=2 - printf("Conditional jmp to %d\n", opline->op2.opline_num); -#endif - ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); - ZEND_VM_CONTINUE(); + + if (i_zend_is_true(val TSRMLS_CC)) { + opline++; + } else { + opline = opline->op2.jmp_addr; } - ZEND_VM_NEXT_OPCODE(); + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } + ZEND_VM_JMP(opline); } static int ZEND_FASTCALL ZEND_JMPNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -30684,29 +29687,30 @@ static int ZEND_FASTCALL ZEND_JMPNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) USE_OPLINE zval *val; - int ret; SAVE_OPLINE(); - val = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); - - if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { - ret = Z_LVAL_P(val); - } else { - ret = i_zend_is_true(val TSRMLS_CC); + val = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); + if (IS_CV == IS_TMP_VAR) { + if (Z_TYPE_P(val) == IS_TRUE) { + ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); + ZEND_VM_CONTINUE(); + } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { + ZEND_VM_SET_OPCODE(opline + 1); + ZEND_VM_CONTINUE(); } } - if (ret) { -#if DEBUG_ZEND>=2 - printf("Conditional jmp to %d\n", opline->op2.opline_num); -#endif - ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); - ZEND_VM_CONTINUE(); + + if (i_zend_is_true(val TSRMLS_CC)) { + opline = opline->op2.jmp_addr; + } else { + opline++; } - ZEND_VM_NEXT_OPCODE(); + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } + ZEND_VM_JMP(opline); } static int ZEND_FASTCALL ZEND_JMPZNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -30714,33 +29718,30 @@ static int ZEND_FASTCALL ZEND_JMPZNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) USE_OPLINE zval *val; - int retval; SAVE_OPLINE(); - val = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); - - if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { - retval = Z_LVAL_P(val); - } else { - retval = i_zend_is_true(val TSRMLS_CC); + val = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); + if (IS_CV == IS_TMP_VAR) { + if (EXPECTED(Z_TYPE_P(val) == IS_TRUE)) { + ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value); + ZEND_VM_CONTINUE(); + } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { + ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); + ZEND_VM_CONTINUE(); } } - if (EXPECTED(retval != 0)) { -#if DEBUG_ZEND>=2 - printf("Conditional jmp on true to %d\n", opline->extended_value); -#endif - ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]); - ZEND_VM_CONTINUE(); /* CHECK_ME */ + + if (i_zend_is_true(val TSRMLS_CC)) { + opline = (zend_op*)(((char*)opline) + opline->extended_value); } else { -#if DEBUG_ZEND>=2 - printf("Conditional jmp on false to %d\n", opline->op2.opline_num); -#endif - ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->op2.opline_num]); - ZEND_VM_CONTINUE(); /* CHECK_ME */ + opline = opline->op2.jmp_addr; } + + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } + ZEND_VM_JMP(opline); } static int ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -30748,30 +29749,34 @@ static int ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) USE_OPLINE zval *val; - int retval; SAVE_OPLINE(); - val = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); + val = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); - if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { - retval = Z_LVAL_P(val); - } else { - retval = i_zend_is_true(val TSRMLS_CC); - - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); + if (IS_CV == IS_TMP_VAR) { + if (Z_TYPE_P(val) == IS_TRUE) { + ZVAL_TRUE(EX_VAR(opline->result.var)); + ZEND_VM_SET_OPCODE(opline + 1); + ZEND_VM_CONTINUE(); + } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { + ZVAL_FALSE(EX_VAR(opline->result.var)); + ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); + ZEND_VM_CONTINUE(); } } - Z_LVAL(EX_T(opline->result.var).tmp_var) = retval; - Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; - if (!retval) { -#if DEBUG_ZEND>=2 - printf("Conditional jmp to %d\n", opline->op2.opline_num); -#endif - ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); - ZEND_VM_CONTINUE(); + + if (i_zend_is_true(val TSRMLS_CC)) { + ZVAL_TRUE(EX_VAR(opline->result.var)); + opline++; + } else { + ZVAL_FALSE(EX_VAR(opline->result.var)); + opline = opline->op2.jmp_addr; } - ZEND_VM_NEXT_OPCODE(); + + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } + ZEND_VM_JMP(opline); } static int ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -30779,30 +29784,33 @@ static int ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS USE_OPLINE zval *val; - int retval; SAVE_OPLINE(); - val = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); - - if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) { - retval = Z_LVAL_P(val); - } else { - retval = i_zend_is_true(val TSRMLS_CC); + val = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); + if (IS_CV == IS_TMP_VAR) { + if (Z_TYPE_P(val) == IS_TRUE) { + ZVAL_TRUE(EX_VAR(opline->result.var)); + ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); + ZEND_VM_CONTINUE(); + } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { + ZVAL_FALSE(EX_VAR(opline->result.var)); + ZEND_VM_SET_OPCODE(opline + 1); + ZEND_VM_CONTINUE(); } } - Z_LVAL(EX_T(opline->result.var).tmp_var) = retval; - Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; - if (retval) { -#if DEBUG_ZEND>=2 - printf("Conditional jmp to %d\n", opline->op2.opline_num); -#endif - ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); - ZEND_VM_CONTINUE(); + if (i_zend_is_true(val TSRMLS_CC)) { + ZVAL_TRUE(EX_VAR(opline->result.var)); + opline = opline->op2.jmp_addr; + } else { + ZVAL_FALSE(EX_VAR(opline->result.var)); + opline++; } - ZEND_VM_NEXT_OPCODE(); + + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } + ZEND_VM_JMP(opline); } static int ZEND_FASTCALL ZEND_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -30814,34 +29822,21 @@ static int ZEND_FASTCALL ZEND_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) SAVE_OPLINE(); retval_ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); - if (!EG(return_value_ptr_ptr)) { + if (!EX(return_value)) { } else { - if (IS_CV == IS_CONST || - IS_CV == IS_TMP_VAR || - PZVAL_IS_REF(retval_ptr)) { - zval *ret; - - ALLOC_ZVAL(ret); - INIT_PZVAL_COPY(ret, retval_ptr); + if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) { + ZVAL_COPY_VALUE(EX(return_value), retval_ptr); if (IS_CV != IS_TMP_VAR) { - zval_copy_ctor(ret); + zval_opt_copy_ctor(EX(return_value)); } - *EG(return_value_ptr_ptr) = ret; + } else if (Z_ISREF_P(retval_ptr)) { + ZVAL_DUP(EX(return_value), Z_REFVAL_P(retval_ptr)); - } else if ((IS_CV == IS_CV || IS_CV == IS_VAR) && - retval_ptr == &EG(uninitialized_zval)) { - zval *ret; - - if (IS_CV == IS_VAR) { - Z_DELREF_P(retval_ptr); - } - ALLOC_INIT_ZVAL(ret); - *EG(return_value_ptr_ptr) = ret; } else { - *EG(return_value_ptr_ptr) = retval_ptr; + ZVAL_COPY_VALUE(EX(return_value), retval_ptr); if (IS_CV == IS_CV) { - Z_ADDREF_P(retval_ptr); + if (Z_OPT_REFCOUNTED_P(retval_ptr)) Z_ADDREF_P(retval_ptr); } } } @@ -30852,7 +29847,6 @@ static int ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER { USE_OPLINE zval *retval_ptr; - zval **retval_ptr_ptr; SAVE_OPLINE(); @@ -30864,55 +29858,41 @@ static int ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER zend_error(E_NOTICE, "Only variable references should be returned by reference"); retval_ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); - if (!EG(return_value_ptr_ptr)) { + if (!EX(return_value)) { if (IS_CV == IS_TMP_VAR) { } } else if (!0) { /* Not a temp var */ - zval *ret; - - ALLOC_ZVAL(ret); - INIT_PZVAL_COPY(ret, retval_ptr); - zval_copy_ctor(ret); - *EG(return_value_ptr_ptr) = ret; + ZVAL_DUP(EX(return_value), retval_ptr); } else { - zval *ret; - - ALLOC_ZVAL(ret); - INIT_PZVAL_COPY(ret, retval_ptr); - *EG(return_value_ptr_ptr) = ret; + ZVAL_COPY_VALUE(EX(return_value), retval_ptr); } break; } - retval_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + retval_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); - if (IS_CV == IS_VAR && UNEXPECTED(retval_ptr_ptr == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(retval_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference"); } - if (IS_CV == IS_VAR && !Z_ISREF_PP(retval_ptr_ptr)) { + if (IS_CV == IS_VAR && !Z_ISREF_P(retval_ptr)) { if (opline->extended_value == ZEND_RETURNS_FUNCTION && - EX_T(opline->op1.var).var.fcall_returned_reference) { - } else if (EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) { + (Z_VAR_FLAGS_P(retval_ptr) & IS_VAR_RET_REF)) { + } else { zend_error(E_NOTICE, "Only variable references should be returned by reference"); - if (EG(return_value_ptr_ptr)) { - zval *ret; - - ALLOC_ZVAL(ret); - INIT_PZVAL_COPY(ret, *retval_ptr_ptr); - zval_copy_ctor(ret); - *EG(return_value_ptr_ptr) = ret; + if (EX(return_value)) { + zval tmp; + ZVAL_DUP(&tmp, retval_ptr); + ZVAL_NEW_REF(EX(return_value), &tmp); } break; } } - if (EG(return_value_ptr_ptr)) { - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr); - Z_ADDREF_PP(retval_ptr_ptr); - - *EG(return_value_ptr_ptr) = *retval_ptr_ptr; + if (EX(return_value)) { + SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); + ZVAL_COPY(EX(return_value), retval_ptr); } } while (0); @@ -30923,7 +29903,7 @@ static int ZEND_FASTCALL ZEND_THROW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *value; - zval *exception; + zval exception; SAVE_OPLINE(); @@ -30937,14 +29917,14 @@ static int ZEND_FASTCALL ZEND_THROW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) } zend_exception_save(TSRMLS_C); - /* Not sure if a complete copy is what we want here */ - ALLOC_ZVAL(exception); - INIT_PZVAL_COPY(exception, value); - if (!0) { - zval_copy_ctor(exception); + if (IS_CV == IS_CONST) { + ZVAL_DUP(&exception, value); + value = &exception; + } else if (IS_CV != IS_TMP_VAR) { + if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value); } - zend_throw_exception_object(exception TSRMLS_CC); + zend_throw_exception_object(value TSRMLS_CC); zend_exception_restore(TSRMLS_C); HANDLE_EXCEPTION(); @@ -30953,33 +29933,20 @@ static int ZEND_FASTCALL ZEND_THROW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) static int ZEND_FASTCALL zend_send_by_var_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *varptr; + zval *varptr, *top; - varptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); - if (varptr == &EG(uninitialized_zval)) { - if (IS_CV == IS_VAR) { - Z_DELREF_P(varptr); - } - ALLOC_INIT_ZVAL(varptr); - } else if (PZVAL_IS_REF(varptr)) { - if (IS_CV == IS_CV || - (IS_CV == IS_VAR && Z_REFCOUNT_P(varptr) > 2)) { - zval *original_var = varptr; - - ALLOC_ZVAL(varptr); - INIT_PZVAL_COPY(varptr, original_var); - zval_copy_ctor(varptr); + varptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); + top = zend_vm_stack_top_inc(TSRMLS_C); + if (Z_ISREF_P(varptr)) { + ZVAL_DUP(top, Z_REFVAL_P(varptr)); - } else { - Z_UNSET_ISREF_P(varptr); + } else { + ZVAL_COPY_VALUE(top, varptr); + if (IS_CV == IS_CV) { + if (Z_OPT_REFCOUNTED_P(varptr)) Z_ADDREF_P(varptr); } - } else if (IS_CV == IS_CV) { - Z_ADDREF_P(varptr); } - zend_vm_stack_push(varptr TSRMLS_CC); - - CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -30987,7 +29954,7 @@ static int ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDL { USE_OPLINE - zval *varptr; + zval *varptr, *top; SAVE_OPLINE(); if (opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) { /* Had function_ptr at compile_time */ @@ -31002,29 +29969,29 @@ static int ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDL varptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); if ((!(opline->extended_value & ZEND_ARG_SEND_FUNCTION) || - EX_T(opline->op1.var).var.fcall_returned_reference) && - varptr != &EG(uninitialized_zval) && - (PZVAL_IS_REF(varptr) || Z_REFCOUNT_P(varptr) == 1)) { - Z_SET_ISREF_P(varptr); + (Z_VAR_FLAGS_P(varptr) & IS_VAR_RET_REF)) && + ((!Z_REFCOUNTED_P(varptr) && Z_TYPE_P(varptr) != IS_STRING) || + Z_ISREF_P(varptr) || + Z_TYPE_P(varptr) == IS_OBJECT || + (Z_REFCOUNTED_P(varptr) && Z_REFCOUNT_P(varptr) == 1))) { + + if (!Z_ISREF_P(varptr)) { + ZVAL_NEW_REF(varptr, varptr); + } if (IS_CV == IS_CV) { Z_ADDREF_P(varptr); } zend_vm_stack_push(varptr TSRMLS_CC); } else { - zval *valptr; - if ((opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) ? !(opline->extended_value & ZEND_ARG_SEND_SILENT) : !ARG_MAY_BE_SENT_BY_REF(EX(call)->fbc, opline->op2.num)) { zend_error(E_STRICT, "Only variables should be passed by reference"); } - ALLOC_ZVAL(valptr); - INIT_PZVAL_COPY(valptr, varptr); - if (!0) { - zval_copy_ctor(valptr); - } + top = zend_vm_stack_top_inc(TSRMLS_C); + ZVAL_COPY_VALUE(top, varptr); + zval_opt_copy_ctor(top); - zend_vm_stack_push(valptr TSRMLS_CC); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -31034,57 +30001,68 @@ static int ZEND_FASTCALL ZEND_SEND_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS { USE_OPLINE - zval **varptr_ptr; - zval *varptr; + zval *varptr, *top; SAVE_OPLINE(); - varptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + varptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); - if (IS_CV == IS_VAR && UNEXPECTED(varptr_ptr == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(varptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Only variables can be passed by reference"); } - if (IS_CV == IS_VAR && UNEXPECTED(*varptr_ptr == &EG(error_zval))) { - ALLOC_INIT_ZVAL(varptr); - zend_vm_stack_push(varptr TSRMLS_CC); - CHECK_EXCEPTION(); + top = zend_vm_stack_top_inc(TSRMLS_C); + if (IS_CV == IS_VAR && UNEXPECTED(varptr == &EG(error_zval))) { + ZVAL_NEW_REF(top, &EG(uninitialized_zval)); ZEND_VM_NEXT_OPCODE(); } - if (opline->extended_value == ZEND_DO_FCALL_BY_NAME && - EX(function_state).function->type == ZEND_INTERNAL_FUNCTION) { - if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->fbc, opline->op2.num)) { - return zend_send_by_var_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - } + if (Z_ISREF_P(varptr)) { + Z_ADDREF_P(varptr); + ZVAL_COPY_VALUE(top, varptr); + } else if (IS_CV == IS_VAR && + UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) { + ZVAL_COPY_VALUE(top, varptr); + SEPARATE_ZVAL_TO_MAKE_IS_REF(top); + } else { + SEPARATE_ZVAL_TO_MAKE_IS_REF(varptr); + Z_ADDREF_P(varptr); + ZVAL_COPY_VALUE(top, varptr); } - SEPARATE_ZVAL_TO_MAKE_IS_REF(varptr_ptr); - varptr = *varptr_ptr; - Z_ADDREF_P(varptr); - zend_vm_stack_push(varptr TSRMLS_CC); - - CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_SEND_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE + zval *varptr, *top; + if (opline->extended_value == ZEND_DO_FCALL_BY_NAME) { if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->fbc, opline->op2.num)) { return ZEND_SEND_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } } - SAVE_OPLINE(); - return zend_send_by_var_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + + varptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); + top = zend_vm_stack_top_inc(TSRMLS_C); + if (Z_ISREF_P(varptr)) { + ZVAL_DUP(top, Z_REFVAL_P(varptr)); + + } else { + ZVAL_COPY_VALUE(top, varptr); + if (IS_CV == IS_CV) { + if (Z_OPT_REFCOUNTED_P(varptr)) Z_ADDREF_P(varptr); + } + } + ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_BOOL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *retval = &EX_T(opline->result.var).tmp_var; + zval *retval = EX_VAR(opline->result.var); SAVE_OPLINE(); /* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */ @@ -31119,7 +30097,7 @@ static int ZEND_FASTCALL ZEND_CLONE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) clone_call = Z_OBJ_HT_P(obj)->clone_obj; if (UNEXPECTED(clone_call == NULL)) { if (ce) { - zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name); + zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name->val); } else { zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object"); } @@ -31130,29 +30108,21 @@ static int ZEND_FASTCALL ZEND_CLONE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) /* Ensure that if we're calling a private function, we're allowed to do so. */ if (UNEXPECTED(ce != EG(scope))) { - zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : ""); + zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name->val, EG(scope) ? EG(scope)->name->val : ""); } } else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) { /* Ensure that if we're calling a protected function, we're allowed to do so. */ if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), EG(scope)))) { - zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : ""); + zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name->val, EG(scope) ? EG(scope)->name->val : ""); } } } if (EXPECTED(EG(exception) == NULL)) { - zval *retval; - - ALLOC_ZVAL(retval); - Z_OBJVAL_P(retval) = clone_call(obj TSRMLS_CC); - Z_TYPE_P(retval) = IS_OBJECT; - Z_SET_REFCOUNT_P(retval, 1); - Z_SET_ISREF_P(retval); + ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(obj TSRMLS_CC)); if (!RETURN_VALUE_USED(opline) || UNEXPECTED(EG(exception) != NULL)) { - zval_ptr_dtor(&retval); - } else { - EX_T(opline->result.var).var.ptr = retval; + zval_ptr_dtor(EX_VAR(opline->result.var)); } } @@ -31165,54 +30135,71 @@ static int ZEND_FASTCALL ZEND_CAST_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) USE_OPLINE zval *expr; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); expr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); - if (opline->extended_value != IS_STRING) { - ZVAL_COPY_VALUE(result, expr); - if (!0) { - zendi_zval_copy_ctor(*result); - } - } switch (opline->extended_value) { case IS_NULL: - convert_to_null(result); + /* This code is taken from convert_to_null. However, it does not seems very useful, + * because a conversion to null always results in the same value. This could only + * be relevant if a cast_object handler for IS_NULL has some kind of side-effect. */ +#if 0 + if (IS_CV == IS_VAR || IS_CV == IS_CV) { + ZVAL_DEREF(expr); + } + if (Z_TYPE_P(expr) == IS_OBJECT && Z_OBJ_HT_P(expr)->cast_object) { + if (Z_OBJ_HT_P(expr)->cast_object(expr, result, IS_NULL TSRMLS_CC) == SUCCESS) { + break; + } + } +#endif + + ZVAL_NULL(result); break; - case IS_BOOL: - convert_to_boolean(result); + case _IS_BOOL: + ZVAL_BOOL(result, zend_is_true(expr TSRMLS_CC)); break; case IS_LONG: - convert_to_long(result); + ZVAL_LONG(result, zval_get_long(expr)); break; case IS_DOUBLE: - convert_to_double(result); + ZVAL_DOUBLE(result, zval_get_double(expr)); + break; + case IS_STRING: + ZVAL_STR(result, zval_get_string(expr)); break; - case IS_STRING: { - zval var_copy; - int use_copy; + default: + /* If value is already of correct type, return it directly */ + if (Z_TYPE_P(expr) == opline->extended_value) { + ZVAL_COPY_VALUE(result, expr); + if (IS_CV == IS_CONST) { + zval_opt_copy_ctor(result); + } else if (IS_CV == IS_CV) { + if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr); + } - zend_make_printable_zval(expr, &var_copy, &use_copy); - if (use_copy) { - ZVAL_COPY_VALUE(result, &var_copy); - if (0) { + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); + } - } + if (IS_CV == IS_VAR || IS_CV == IS_CV) { + ZVAL_DEREF(expr); + } + ZVAL_COPY_VALUE(result, expr); + if (!0) { + zval_opt_copy_ctor(result); + } + + if (opline->extended_value == IS_ARRAY) { + convert_to_array(result); } else { - ZVAL_COPY_VALUE(result, expr); - if (!0) { - zendi_zval_copy_ctor(*result); - } + convert_to_object(result); } - break; - } - case IS_ARRAY: - convert_to_array(result); - break; - case IS_OBJECT: - convert_to_object(result); - break; + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } CHECK_EXCEPTION(); @@ -31225,18 +30212,17 @@ static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDL zend_op_array *new_op_array=NULL; zval *inc_filename; - zval *tmp_inc_filename = NULL; + zval tmp_inc_filename; zend_bool failure_retval=0; SAVE_OPLINE(); inc_filename = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); - if (inc_filename->type!=IS_STRING) { - MAKE_STD_ZVAL(tmp_inc_filename); - ZVAL_COPY_VALUE(tmp_inc_filename, inc_filename); - zval_copy_ctor(tmp_inc_filename); - convert_to_string(tmp_inc_filename); - inc_filename = tmp_inc_filename; + ZVAL_UNDEF(&tmp_inc_filename); + if (Z_TYPE_P(inc_filename) != IS_STRING) { + ZVAL_DUP(&tmp_inc_filename, inc_filename); + convert_to_string(&tmp_inc_filename); + inc_filename = &tmp_inc_filename; } if (opline->extended_value != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRLEN_P(inc_filename)) { @@ -31254,7 +30240,7 @@ static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDL resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename) TSRMLS_CC); if (resolved_path) { - failure_retval = zend_hash_exists(&EG(included_files), resolved_path, strlen(resolved_path)+1); + failure_retval = zend_hash_str_exists(&EG(included_files), resolved_path, strlen(resolved_path)); } else { resolved_path = Z_STRVAL_P(inc_filename); } @@ -31267,7 +30253,7 @@ static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDL file_handle.opened_path = estrdup(resolved_path); } - if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1)==SUCCESS) { + if (zend_hash_str_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path))) { new_op_array = zend_compile_file(&file_handle, (opline->extended_value==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) TSRMLS_CC); zend_destroy_file_handle(&file_handle TSRMLS_CC); } else { @@ -31300,40 +30286,37 @@ static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDL EMPTY_SWITCH_DEFAULT_CASE() } } - if (tmp_inc_filename) { + if (Z_TYPE(tmp_inc_filename) != IS_UNDEF) { zval_ptr_dtor(&tmp_inc_filename); } if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } else if (EXPECTED(new_op_array != NULL)) { - EX(original_return_value) = EG(return_value_ptr_ptr); + zval *return_value = NULL; + EG(active_op_array) = new_op_array; if (RETURN_VALUE_USED(opline)) { - EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; - EG(return_value_ptr_ptr) = EX_T(opline->result.var).var.ptr_ptr; - } else { - EG(return_value_ptr_ptr) = NULL; + return_value = EX_VAR(opline->result.var); } EX(function_state).function = (zend_function *) new_op_array; - EX(object) = NULL; if (!EG(active_symbol_table)) { zend_rebuild_symbol_table(TSRMLS_C); } if (EXPECTED(zend_execute_ex == execute_ex)) { + i_create_execute_data_from_op_array(new_op_array, return_value, VM_FRAME_NESTED_CODE TSRMLS_CC); ZEND_VM_ENTER(); } else { - zend_execute(new_op_array TSRMLS_CC); + zend_execute(new_op_array, return_value TSRMLS_CC); } EX(function_state).function = (zend_function *) EX(op_array); EG(opline_ptr) = &EX(opline); EG(active_op_array) = EX(op_array); - EG(return_value_ptr_ptr) = EX(original_return_value); destroy_op_array(new_op_array TSRMLS_CC); efree(new_op_array); if (UNEXPECTED(EG(exception) != NULL)) { @@ -31342,12 +30325,7 @@ static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDL } } else if (RETURN_VALUE_USED(opline)) { - zval *retval; - - ALLOC_ZVAL(retval); - ZVAL_BOOL(retval, failure_retval); - INIT_PZVAL(retval); - EX_T(opline->result.var).var.ptr = retval; + ZVAL_BOOL(EX_VAR(opline->result.var), failure_retval); } ZEND_VM_NEXT_OPCODE(); } @@ -31356,7 +30334,7 @@ static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS { USE_OPLINE - zval *array_ptr, **array_ptr_ptr; + zval *array_ptr, *array_ref, iterator; HashTable *fe_ht; zend_object_iterator *iter = NULL; zend_class_entry *ce = NULL; @@ -31366,71 +30344,79 @@ static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS if ((IS_CV == IS_CV || IS_CV == IS_VAR) && (opline->extended_value & ZEND_FE_RESET_VARIABLE)) { - array_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); - if (array_ptr_ptr == NULL || array_ptr_ptr == &EG(uninitialized_zval_ptr)) { - MAKE_STD_ZVAL(array_ptr); - ZVAL_NULL(array_ptr); - } else if (Z_TYPE_PP(array_ptr_ptr) == IS_OBJECT) { - if(Z_OBJ_HT_PP(array_ptr_ptr)->get_class_entry == NULL) { + array_ptr = array_ref = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); + ZVAL_DEREF(array_ptr); + if (Z_TYPE_P(array_ptr) == IS_ARRAY) { + if (!Z_ISREF_P(array_ref)) { + SEPARATE_ZVAL(array_ptr); + array_ref = array_ptr; + if (opline->extended_value & ZEND_FE_FETCH_BYREF) { + ZVAL_NEW_REF(array_ptr, array_ptr); + array_ref = array_ptr; + array_ptr = Z_REFVAL_P(array_ptr); + } + } + if (Z_REFCOUNTED_P(array_ref)) Z_ADDREF_P(array_ref); + } else if (Z_TYPE_P(array_ptr) == IS_OBJECT) { + if(Z_OBJ_HT_P(array_ptr)->get_class_entry == NULL) { zend_error(E_WARNING, "foreach() cannot iterate over objects without PHP class"); ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num); } - ce = Z_OBJCE_PP(array_ptr_ptr); + ce = Z_OBJCE_P(array_ptr); if (!ce || ce->get_iterator == NULL) { - SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr); - Z_ADDREF_PP(array_ptr_ptr); - } - array_ptr = *array_ptr_ptr; - } else { - if (Z_TYPE_PP(array_ptr_ptr) == IS_ARRAY) { - SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr); - if (opline->extended_value & ZEND_FE_FETCH_BYREF) { - Z_SET_ISREF_PP(array_ptr_ptr); + if (!Z_ISREF_P(array_ref)) { + SEPARATE_ZVAL(array_ptr); } + Z_ADDREF_P(array_ptr); } - array_ptr = *array_ptr_ptr; - Z_ADDREF_P(array_ptr); + array_ref = array_ptr; + } else { + if (Z_REFCOUNTED_P(array_ref)) Z_ADDREF_P(array_ref); } } else { - array_ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); + array_ptr = array_ref = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); + ZVAL_DEREF(array_ptr); if (0) { /* IS_TMP_VAR */ - zval *tmp; + zval tmp; - ALLOC_ZVAL(tmp); - INIT_PZVAL_COPY(tmp, array_ptr); - array_ptr = tmp; + ZVAL_COPY_VALUE(&tmp, array_ptr); + array_ptr = &tmp; if (Z_TYPE_P(array_ptr) == IS_OBJECT) { ce = Z_OBJCE_P(array_ptr); if (ce && ce->get_iterator) { - Z_DELREF_P(array_ptr); + Z_DELREF_P(array_ref); } } } else if (Z_TYPE_P(array_ptr) == IS_OBJECT) { ce = Z_OBJCE_P(array_ptr); if (!ce || !ce->get_iterator) { if (IS_CV == IS_CV) { - Z_ADDREF_P(array_ptr); + Z_ADDREF_P(array_ref); } } - } else if (IS_CV == IS_CONST || - (IS_CV == IS_CV && - !Z_ISREF_P(array_ptr) && - Z_REFCOUNT_P(array_ptr) > 1) || - (IS_CV == IS_VAR && - !Z_ISREF_P(array_ptr) && - Z_REFCOUNT_P(array_ptr) > 2)) { - zval *tmp; + } else if (Z_REFCOUNTED_P(array_ref)) { + if (IS_CV == IS_CONST || + (IS_CV == IS_CV && + !Z_ISREF_P(array_ref) && + Z_REFCOUNT_P(array_ref) > 1) || + (IS_CV == IS_VAR && + !Z_ISREF_P(array_ref) && + Z_REFCOUNT_P(array_ref) > 2)) { + zval tmp; - if (IS_CV == IS_VAR) { - Z_DELREF_P(array_ptr); + if (IS_CV == IS_VAR) { + Z_DELREF_P(array_ref); + } + ZVAL_DUP(&tmp, array_ref); + array_ptr = array_ref = &tmp; + } else if (IS_CV == IS_CV) { + if (Z_ISREF_P(array_ref) && Z_REFCOUNT_P(array_ref) == 1) { + ZVAL_UNREF(array_ref); + array_ptr = array_ref; + } + Z_ADDREF_P(array_ref); } - ALLOC_ZVAL(tmp); - INIT_PZVAL_COPY(tmp, array_ptr); - zval_copy_ctor(tmp); - array_ptr = tmp; - } else if (IS_CV == IS_CV) { - Z_ADDREF_P(array_ptr); } } @@ -31441,27 +30427,28 @@ static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS } if (iter && EXPECTED(EG(exception) == NULL)) { - array_ptr = zend_iterator_wrap(iter TSRMLS_CC); + ZVAL_OBJ(&iterator, &iter->std); + array_ptr = array_ref = &iterator; } else { if (IS_CV == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) { } if (!EG(exception)) { - zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name); + zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name->val); } zend_throw_exception_internal(NULL TSRMLS_CC); HANDLE_EXCEPTION(); } } - EX_T(opline->result.var).fe.ptr = array_ptr; + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref); if (iter) { iter->index = 0; if (iter->funcs->rewind) { iter->funcs->rewind(iter TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { - zval_ptr_dtor(&array_ptr); + zval_ptr_dtor(array_ref); if (IS_CV == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) { } @@ -31470,7 +30457,7 @@ static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS } is_empty = iter->funcs->valid(iter TSRMLS_CC) != SUCCESS; if (UNEXPECTED(EG(exception) != NULL)) { - zval_ptr_dtor(&array_ptr); + zval_ptr_dtor(array_ref); if (IS_CV == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) { } @@ -31480,24 +30467,23 @@ static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS } else if ((fe_ht = HASH_OF(array_ptr)) != NULL) { zend_hash_internal_pointer_reset(fe_ht); if (ce) { - zend_object *zobj = zend_objects_get_address(array_ptr TSRMLS_CC); + zend_object *zobj = Z_OBJ_P(array_ptr); while (zend_hash_has_more_elements(fe_ht) == SUCCESS) { - char *str_key; - uint str_key_len; + zend_string *str_key; ulong int_key; zend_uchar key_type; - key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL); + key_type = zend_hash_get_current_key(fe_ht, &str_key, &int_key, 0); if (key_type != HASH_KEY_NON_EXISTENT && (key_type == HASH_KEY_IS_LONG || - zend_check_property_access(zobj, str_key, str_key_len-1 TSRMLS_CC) == SUCCESS)) { + zend_check_property_access(zobj, str_key TSRMLS_CC) == SUCCESS)) { break; } zend_hash_move_forward(fe_ht); } } is_empty = zend_hash_has_more_elements(fe_ht) != SUCCESS; - zend_hash_get_pointer(fe_ht, &EX_T(opline->result.var).fe.fe_pos); + zend_hash_get_pointer(fe_ht, (HashPointer*)EX_VAR((opline+2)->op1.var)); } else { zend_error(E_WARNING, "Invalid argument supplied for foreach()"); is_empty = 1; @@ -31527,7 +30513,7 @@ static int ZEND_FASTCALL ZEND_EXIT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) if (Z_TYPE_P(ptr) == IS_LONG) { EG(exit_status) = Z_LVAL_P(ptr); } else { - zend_print_variable(ptr); + zend_print_variable(ptr TSRMLS_CC); } } @@ -31546,14 +30532,11 @@ static int ZEND_FASTCALL ZEND_JMP_SET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); if (i_zend_is_true(value TSRMLS_CC)) { - ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value); + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value); if (!0) { - zendi_zval_copy_ctor(EX_T(opline->result.var).tmp_var); + zval_opt_copy_ctor(EX_VAR(opline->result.var)); } -#if DEBUG_ZEND>=2 - printf("Conditional jmp to %d\n", opline->op2.opline_num); -#endif ZEND_VM_JMP(opline->op2.jmp_addr); } @@ -31565,29 +30548,21 @@ static int ZEND_FASTCALL ZEND_JMP_SET_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_A { USE_OPLINE - zval *value, *ret; + zval *value; SAVE_OPLINE(); value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); if (i_zend_is_true(value TSRMLS_CC)) { if (IS_CV == IS_VAR || IS_CV == IS_CV) { - Z_ADDREF_P(value); - EX_T(opline->result.var).var.ptr = value; - EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; - } else { - ALLOC_ZVAL(ret); - INIT_PZVAL_COPY(ret, value); - EX_T(opline->result.var).var.ptr = ret; - EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; + ZVAL_COPY(EX_VAR(opline->result.var), value); + } else { + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value); if (!0) { - zval_copy_ctor(EX_T(opline->result.var).var.ptr); + zval_opt_copy_ctor(EX_VAR(opline->result.var)); } } -#if DEBUG_ZEND>=2 - printf("Conditional jmp to %d\n", opline->op2.opline_num); -#endif ZEND_VM_JMP(opline->op2.jmp_addr); } @@ -31604,9 +30579,9 @@ static int ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG SAVE_OPLINE(); value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); - ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value); + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value); if (!0) { - zval_copy_ctor(&EX_T(opline->result.var).tmp_var); + zval_opt_copy_ctor(EX_VAR(opline->result.var)); } CHECK_EXCEPTION(); @@ -31617,22 +30592,17 @@ static int ZEND_FASTCALL ZEND_QM_ASSIGN_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER { USE_OPLINE - zval *value, *ret; + zval *value; SAVE_OPLINE(); value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); if (IS_CV == IS_VAR || IS_CV == IS_CV) { - Z_ADDREF_P(value); - EX_T(opline->result.var).var.ptr = value; - EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; - } else { - ALLOC_ZVAL(ret); - INIT_PZVAL_COPY(ret, value); - EX_T(opline->result.var).var.ptr = ret; - EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; + ZVAL_COPY(EX_VAR(opline->result.var), value); + } else { + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value); if (!0) { - zval_copy_ctor(EX_T(opline->result.var).var.ptr); + zval_opt_copy_ctor(EX_VAR(opline->result.var)); } } @@ -31648,14 +30618,14 @@ static int ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_AR zend_bool result; SAVE_OPLINE(); - expr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); + expr = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); if (Z_TYPE_P(expr) == IS_OBJECT && Z_OBJ_HT_P(expr)->get_class_entry) { - result = instanceof_function(Z_OBJCE_P(expr), EX_T(opline->op2.var).class_entry TSRMLS_CC); + result = instanceof_function(Z_OBJCE_P(expr), Z_CE_P(EX_VAR(opline->op2.var)) TSRMLS_CC); } else { result = 0; } - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, result); + ZVAL_BOOL(EX_VAR(opline->result.var), result); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -31667,7 +30637,7 @@ static int ZEND_FASTCALL ZEND_ADD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG SAVE_OPLINE(); - fast_add_function(&EX_T(opline->result.var).tmp_var, + fast_add_function(EX_VAR(opline->result.var), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), opline->op2.zv TSRMLS_CC); @@ -31682,7 +30652,7 @@ static int ZEND_FASTCALL ZEND_SUB_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG SAVE_OPLINE(); - fast_sub_function(&EX_T(opline->result.var).tmp_var, + fast_sub_function(EX_VAR(opline->result.var), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), opline->op2.zv TSRMLS_CC); @@ -31697,7 +30667,7 @@ static int ZEND_FASTCALL ZEND_MUL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG SAVE_OPLINE(); - fast_mul_function(&EX_T(opline->result.var).tmp_var, + fast_mul_function(EX_VAR(opline->result.var), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), opline->op2.zv TSRMLS_CC); @@ -31712,7 +30682,7 @@ static int ZEND_FASTCALL ZEND_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG SAVE_OPLINE(); - fast_div_function(&EX_T(opline->result.var).tmp_var, + fast_div_function(EX_VAR(opline->result.var), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), opline->op2.zv TSRMLS_CC); @@ -31727,8 +30697,8 @@ static int ZEND_FASTCALL ZEND_MOD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG SAVE_OPLINE(); - fast_mod_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + fast_mod_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), opline->op2.zv TSRMLS_CC); @@ -31742,8 +30712,8 @@ static int ZEND_FASTCALL ZEND_SL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS SAVE_OPLINE(); - shift_left_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + shift_left_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), opline->op2.zv TSRMLS_CC); @@ -31757,8 +30727,8 @@ static int ZEND_FASTCALL ZEND_SR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS SAVE_OPLINE(); - shift_right_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + shift_right_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), opline->op2.zv TSRMLS_CC); @@ -31772,8 +30742,8 @@ static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ SAVE_OPLINE(); - concat_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + concat_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), opline->op2.zv TSRMLS_CC); @@ -31787,8 +30757,8 @@ static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA SAVE_OPLINE(); - is_identical_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + fast_is_identical_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), opline->op2.zv TSRMLS_CC); @@ -31800,13 +30770,12 @@ static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCOD { USE_OPLINE - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - is_identical_function(result, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + fast_is_not_identical_function(result, + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), opline->op2.zv TSRMLS_CC); - Z_LVAL_P(result) = !Z_LVAL_P(result); CHECK_EXCEPTION(); @@ -31817,12 +30786,12 @@ static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLE { USE_OPLINE - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_equal_function(result, + fast_equal_function(result, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - opline->op2.zv TSRMLS_CC)); + opline->op2.zv TSRMLS_CC); CHECK_EXCEPTION(); @@ -31833,12 +30802,12 @@ static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA { USE_OPLINE - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_not_equal_function(result, + fast_not_equal_function(result, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - opline->op2.zv TSRMLS_CC)); + opline->op2.zv TSRMLS_CC); CHECK_EXCEPTION(); @@ -31849,12 +30818,12 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAND { USE_OPLINE - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_is_smaller_function(result, + fast_is_smaller_function(result, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - opline->op2.zv TSRMLS_CC)); + opline->op2.zv TSRMLS_CC); CHECK_EXCEPTION(); @@ -31865,12 +30834,12 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OP { USE_OPLINE - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, + fast_is_smaller_or_equal_function(result, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - opline->op2.zv TSRMLS_CC)); + opline->op2.zv TSRMLS_CC); CHECK_EXCEPTION(); @@ -31883,8 +30852,8 @@ static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_A SAVE_OPLINE(); - bitwise_or_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + bitwise_or_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), opline->op2.zv TSRMLS_CC); @@ -31898,8 +30867,8 @@ static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ SAVE_OPLINE(); - bitwise_and_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + bitwise_and_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), opline->op2.zv TSRMLS_CC); @@ -31913,8 +30882,8 @@ static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ SAVE_OPLINE(); - bitwise_xor_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + bitwise_xor_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), opline->op2.zv TSRMLS_CC); @@ -31928,8 +30897,8 @@ static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLE SAVE_OPLINE(); - boolean_xor_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + boolean_xor_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), opline->op2.zv TSRMLS_CC); @@ -31941,18 +30910,18 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CONST(int (*bi { USE_OPLINE zend_free_op free_op_data1; - zval **object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); - zval *object; + zval *object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); zval *property = opline->op2.zv; - zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); + zval *value; int have_get_ptr = 0; - if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - make_real_object(object_ptr TSRMLS_CC); - object = *object_ptr; + object = make_real_object(object TSRMLS_CC); + + value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { zend_error(E_WARNING, "Attempt to assign property of non-object"); @@ -31960,81 +30929,67 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CONST(int (*bi FREE_OP(free_op_data1); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } } else { /* here we are sure we are dealing with an object */ - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - - /* here property is a string */ if (opline->extended_value == ZEND_ASSIGN_OBJ && Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); if (zptr != NULL) { /* NULL means no success in getting PTR */ SEPARATE_ZVAL_IF_NOT_REF(zptr); have_get_ptr = 1; - binary_op(*zptr, *zptr, value TSRMLS_CC); + binary_op(zptr, zptr, value TSRMLS_CC); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(*zptr); - EX_T(opline->result.var).var.ptr = *zptr; + ZVAL_COPY(EX_VAR(opline->result.var), zptr); } } } if (!have_get_ptr) { zval *z = NULL; + zval rv; if (opline->extended_value == ZEND_ASSIGN_OBJ) { if (Z_OBJ_HT_P(object)->read_property) { - z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC); } } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { if (Z_OBJ_HT_P(object)->read_dimension) { - z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC); + z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R, &rv TSRMLS_CC); } } if (z) { if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); zval_dtor(z); - FREE_ZVAL(z); } - z = value; + ZVAL_COPY_VALUE(z, value); } - Z_ADDREF_P(z); - SEPARATE_ZVAL_IF_NOT_REF(&z); +//??? if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); + SEPARATE_ZVAL_IF_NOT_REF(z); binary_op(z, z, value TSRMLS_CC); if (opline->extended_value == ZEND_ASSIGN_OBJ) { - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(z); - EX_T(opline->result.var).var.ptr = z; + ZVAL_COPY(EX_VAR(opline->result.var), z); } - zval_ptr_dtor(&z); + zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to assign property of non-object"); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } } } - if (0) { - zval_ptr_dtor(&property); - } else { - - } FREE_OP(free_op_data1); } @@ -32044,178 +30999,288 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CONST(int (*bi ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_CV_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_free_op free_op_data2, free_op_data1; - zval **var_ptr; - zval *value; + zval *var_ptr; + zval *value, *container; SAVE_OPLINE(); - switch (opline->extended_value) { - case ZEND_ASSIGN_OBJ: - return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - break; - case ZEND_ASSIGN_DIM: { - zval **container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); - - if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); - } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) { - if (IS_CV == IS_VAR && !0) { - Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */ - } - return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - } else { - zval *dim = opline->op2.zv; + container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { + zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); + } else if (UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { + if (IS_CV == IS_VAR && !0) { + Z_ADDREF_P(container); /* undo the effect of get_obj_zval_ptr_ptr() */ + } + return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else { + zval *dim = opline->op2.zv; - zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_CONST, BP_VAR_RW TSRMLS_CC); - value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); - var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); - } - } - break; - default: - value = opline->op2.zv; - var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); - /* do nothing */ - break; + zend_fetch_dimension_address_RW(EX_VAR((opline+1)->op2.var), container, dim, IS_CONST TSRMLS_CC); + value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); + var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); } - if (UNEXPECTED(var_ptr == NULL)) { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); } - if (UNEXPECTED(*var_ptr == &EG(error_zval))) { - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + if (UNEXPECTED(var_ptr == &EG(error_zval))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); } + goto assign_op_dim_exit; + } + SEPARATE_ZVAL_IF_NOT_REF(var_ptr); + ZVAL_DEREF(var_ptr); - CHECK_EXCEPTION(); - if (opline->extended_value == ZEND_ASSIGN_DIM) { - ZEND_VM_INC_OPCODE(); + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) && + UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) { + /* proxy object */ + zval rv; + zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC); + Z_ADDREF_P(objval); + binary_op(objval, objval, value TSRMLS_CC); + Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); + zval_ptr_dtor(objval); + } else { + binary_op(var_ptr, var_ptr, value TSRMLS_CC); + } + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + } + +assign_op_dim_exit: + + FREE_OP(free_op_data1); + FREE_OP_VAR_PTR(free_op_data2); + + CHECK_EXCEPTION(); + ZEND_VM_INC_OPCODE(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + + zval *var_ptr; + zval *value; + + SAVE_OPLINE(); + value = opline->op2.zv; + var_ptr = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); + + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { + zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); + } + + if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); } - ZEND_VM_NEXT_OPCODE(); + goto assign_op_exit; } SEPARATE_ZVAL_IF_NOT_REF(var_ptr); + ZVAL_DEREF(var_ptr); - if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) - && Z_OBJ_HANDLER_PP(var_ptr, get) - && Z_OBJ_HANDLER_PP(var_ptr, set)) { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) && + UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) { /* proxy object */ - zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); + zval rv; + zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC); Z_ADDREF_P(objval); binary_op(objval, objval, value TSRMLS_CC); - Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC); - zval_ptr_dtor(&objval); + Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); + zval_ptr_dtor(objval); } else { - binary_op(*var_ptr, *var_ptr, value TSRMLS_CC); + binary_op(var_ptr, var_ptr, value TSRMLS_CC); } - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(*var_ptr); - EX_T(opline->result.var).var.ptr = *var_ptr; + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } - if (opline->extended_value == ZEND_ASSIGN_DIM) { - FREE_OP(free_op_data1); - FREE_OP_VAR_PTR(free_op_data2); +assign_op_exit: - CHECK_EXCEPTION(); - ZEND_VM_INC_OPCODE(); - } else { - CHECK_EXCEPTION(); - } + CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval **object_ptr; zval *object; zval *property; - zval **retval; + zval *retval; int have_get_ptr = 0; SAVE_OPLINE(); - object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); + object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); property = opline->op2.zv; - retval = &EX_T(opline->result.var).var.ptr; + retval = EX_VAR(opline->result.var); - if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } - make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ - object = *object_ptr; + object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */ if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - *retval = &EG(uninitialized_zval); + ZVAL_NULL(retval); } CHECK_EXCEPTION(); @@ -32224,59 +31289,49 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_CONST(incdec_t /* here we are sure we are dealing with an object */ - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); if (zptr != NULL) { /* NULL means no success in getting PTR */ SEPARATE_ZVAL_IF_NOT_REF(zptr); have_get_ptr = 1; - incdec_op(*zptr); + incdec_op(zptr); if (RETURN_VALUE_USED(opline)) { - *retval = *zptr; - PZVAL_LOCK(*retval); + ZVAL_COPY(retval, zptr); } } } if (!have_get_ptr) { + zval rv; + if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC); if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); zval_dtor(z); - FREE_ZVAL(z); } - z = value; + ZVAL_COPY_VALUE(z, value); } - Z_ADDREF_P(z); - SEPARATE_ZVAL_IF_NOT_REF(&z); + if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); + SEPARATE_ZVAL_IF_NOT_REF(z); incdec_op(z); - *retval = z; - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - SELECTIVE_PZVAL_LOCK(*retval, opline); - zval_ptr_dtor(&z); + ZVAL_COPY_VALUE(retval, z); + Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); + SELECTIVE_PZVAL_LOCK(retval, opline); + zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - *retval = &EG(uninitialized_zval); + ZVAL_NULL(retval); } } } - if (0) { - zval_ptr_dtor(&property); - } else { - - } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -32296,23 +31351,21 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_CONST(incdec_t { USE_OPLINE - zval **object_ptr; zval *object; zval *property; zval *retval; int have_get_ptr = 0; SAVE_OPLINE(); - object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); + object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); property = opline->op2.zv; - retval = &EX_T(opline->result.var).tmp_var; + retval = EX_VAR(opline->result.var); - if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } - make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ - object = *object_ptr; + object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */ if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); @@ -32325,60 +31378,47 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_CONST(incdec_t /* here we are sure we are dealing with an object */ - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); if (zptr != NULL) { /* NULL means no success in getting PTR */ have_get_ptr = 1; SEPARATE_ZVAL_IF_NOT_REF(zptr); - ZVAL_COPY_VALUE(retval, *zptr); - zendi_zval_copy_ctor(*retval); + ZVAL_DUP(retval, zptr); - incdec_op(*zptr); + incdec_op(zptr); } } if (!have_get_ptr) { if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - zval *z_copy; + zval rv; + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC); + zval z_copy; if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); zval_dtor(z); - FREE_ZVAL(z); } - z = value; + ZVAL_COPY_VALUE(z, value); } - ZVAL_COPY_VALUE(retval, z); - zendi_zval_copy_ctor(*retval); - ALLOC_ZVAL(z_copy); - INIT_PZVAL_COPY(z_copy, z); - zendi_zval_copy_ctor(*z_copy); - incdec_op(z_copy); - Z_ADDREF_P(z); - Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + ZVAL_DUP(retval, z); + ZVAL_DUP(&z_copy, z); + incdec_op(&z_copy); + if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); + Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); zval_ptr_dtor(&z_copy); - zval_ptr_dtor(&z); + zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); ZVAL_NULL(retval); } } - if (0) { - zval_ptr_dtor(&property); - } else { - - } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -32397,21 +31437,18 @@ static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_CONST(int type, ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_free_op free_op1; + zval *varname; - zval **retval; + zval *retval; zval tmp_varname; HashTable *target_symbol_table; - ulong hash_value; SAVE_OPLINE(); varname = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); + ZVAL_UNDEF(&tmp_varname); if (IS_CV != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) { - ZVAL_COPY_VALUE(&tmp_varname, varname); - zval_copy_ctor(&tmp_varname); - Z_SET_REFCOUNT(tmp_varname, 1); - Z_UNSET_ISREF(tmp_varname); + ZVAL_DUP_DEREF(&tmp_varname, varname); convert_to_string(&tmp_varname); varname = &tmp_varname; } @@ -32420,105 +31457,88 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_CONST(int type, Z zend_class_entry *ce; if (IS_CONST == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { - if (IS_CV != IS_CONST && varname == &tmp_varname) { + if (IS_CV != IS_CONST) { zval_dtor(&tmp_varname); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(opline->op2.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); } } else { - ce = EX_T(opline->op2.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op2.var)); } - retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); + retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC); } else { target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); -/* - if (!target_symbol_table) { - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); - } -*/ - if (IS_CV == IS_CONST) { - hash_value = Z_HASH_P(varname); - } else { - hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname)); - } - - if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) { + retval = zend_hash_find(target_symbol_table, Z_STR_P(varname)); + if (retval == NULL) { switch (type) { case BP_VAR_R: case BP_VAR_UNSET: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); /* break missing intentionally */ case BP_VAR_IS: - retval = &EG(uninitialized_zval_ptr); + retval = EX_VAR(opline->result.var); + ZVAL_NULL(retval); break; case BP_VAR_RW: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); /* break missing intentionally */ case BP_VAR_W: - Z_ADDREF_P(&EG(uninitialized_zval)); - zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval); + retval = zend_hash_update(target_symbol_table, Z_STR_P(varname), &EG(uninitialized_zval)); break; EMPTY_SWITCH_DEFAULT_CASE() } - } - switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) { - case ZEND_FETCH_GLOBAL: - if (IS_CV != IS_TMP_VAR) { - + /* GLOBAL or $$name variable may be an INDIRECT pointer to CV */ + } else if (Z_TYPE_P(retval) == IS_INDIRECT) { + retval = Z_INDIRECT_P(retval); + if (Z_TYPE_P(retval) == IS_UNDEF) { + switch (type) { + case BP_VAR_R: + case BP_VAR_UNSET: + zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); + /* break missing intentionally */ + case BP_VAR_IS: + retval = EX_VAR(opline->result.var); + ZVAL_NULL(retval); + break; + case BP_VAR_RW: + zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); + /* break missing intentionally */ + case BP_VAR_W: + ZVAL_NULL(retval); + break; + EMPTY_SWITCH_DEFAULT_CASE() } - break; - case ZEND_FETCH_LOCAL: + } + } + if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC) { + zval_update_constant(retval, 1 TSRMLS_CC); + } else if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) != ZEND_FETCH_GLOBAL_LOCK) { - break; - case ZEND_FETCH_STATIC: - zval_update_constant(retval, 1 TSRMLS_CC); - break; - case ZEND_FETCH_GLOBAL_LOCK: - if (IS_CV == IS_VAR && !free_op1.var) { - PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); - } - break; } } - - if (IS_CV != IS_CONST && varname == &tmp_varname) { + if (IS_CV != IS_CONST) { zval_dtor(&tmp_varname); } - if (opline->extended_value & ZEND_FETCH_MAKE_REF) { - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval); - } - PZVAL_LOCK(*retval); - switch (type) { - case BP_VAR_R: - case BP_VAR_IS: - EX_T(opline->result.var).var.ptr = *retval; - break; - case BP_VAR_UNSET: { - zend_free_op free_res; - PZVAL_UNLOCK(*retval, &free_res); - if (retval != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(retval); - } - PZVAL_LOCK(*retval); - FREE_OP_VAR_PTR(free_res); + ZEND_ASSERT(retval != NULL); + if (type == BP_VAR_R || type == BP_VAR_IS) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); + } else { + if (/*type == BP_VAR_W &&*/ (opline->extended_value & ZEND_FETCH_MAKE_REF)) { + SEPARATE_ZVAL_TO_MAKE_IS_REF(retval); } - /* break missing intentionally */ - default: - EX_T(opline->result.var).var.ptr_ptr = retval; - break; + ZVAL_INDIRECT(EX_VAR(opline->result.var), retval); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -32543,7 +31563,11 @@ static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_ { USE_OPLINE - return zend_fetch_var_address_helper_SPEC_CV_CONST(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { + return zend_fetch_var_address_helper_SPEC_CV_CONST(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else { + return zend_fetch_var_address_helper_SPEC_CV_CONST(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -32564,7 +31588,7 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAN SAVE_OPLINE(); container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); - zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); if (IS_CV != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) { @@ -32577,29 +31601,22 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAN { USE_OPLINE zend_free_op free_op1; - zval **container; + zval *container; SAVE_OPLINE(); - container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); - if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_W TSRMLS_CC); - - if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + if (EXPECTED(opline->extended_value == 0)) { + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); + } else { + zend_fetch_dimension_address_W_ref(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); } - /* We are going to assign the result by reference */ - if (UNEXPECTED(opline->extended_value != 0)) { - zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; - - if (retval_ptr) { - Z_DELREF_PP(retval_ptr); - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); - Z_ADDREF_PP(retval_ptr); - } + if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } CHECK_EXCEPTION(); @@ -32610,18 +31627,18 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA { USE_OPLINE zend_free_op free_op1; - zval **container; + zval *container; SAVE_OPLINE(); - container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); - if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_RW TSRMLS_CC); + zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } CHECK_EXCEPTION(); @@ -32636,7 +31653,7 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA SAVE_OPLINE(); container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC); - zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_IS TSRMLS_CC); + zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); CHECK_EXCEPTION(); @@ -32646,29 +31663,28 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE + zval *container; zend_free_op free_op1; SAVE_OPLINE(); if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { - zval **container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_W TSRMLS_CC); + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } } else { - zval *container; - if (IS_CONST == IS_UNUSED) { zend_error_noreturn(E_ERROR, "Cannot use [] for reading"); } container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); - zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); } @@ -32680,41 +31696,22 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE { USE_OPLINE zend_free_op free_op1; - zval **container; + zval *container; SAVE_OPLINE(); - container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC); - if (IS_CV == IS_CV) { - if (container != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(container); - } - } - if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_UNSET TSRMLS_CC); + zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); - ZEND_VM_NEXT_OPCODE(); - } else { - zend_free_op free_res; - zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; - - PZVAL_UNLOCK(*retval_ptr, &free_res); - if (retval_ptr != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(retval_ptr); - } - PZVAL_LOCK(*retval_ptr); - FREE_OP_VAR_PTR(free_res); - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); - } + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_CONST(ZEND_OPCODE_HANDLER_ARGS) @@ -32726,35 +31723,25 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_CONST(Z zval *offset; SAVE_OPLINE(); - container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); offset = opline->op2.zv; if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { zend_error(E_NOTICE, "Trying to get property of non-object"); - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - + ZVAL_NULL(EX_VAR(opline->result.var)); } else { zval *retval; - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - /* here we are sure we are dealing with an object */ - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - - PZVAL_LOCK(retval); - EX_T(opline->result.var).var.ptr = retval; - - if (0) { - zval_ptr_dtor(&offset); - } else { + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC); + if (retval != EX_VAR(opline->result.var)) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); } } + CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -32769,38 +31756,20 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAN USE_OPLINE zend_free_op free_op1; zval *property; - zval **container; + zval *container; SAVE_OPLINE(); property = opline->op2.zv; - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); - if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { + container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property); - } else { + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC); - } if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); - } - - /* We are going to assign the result by reference */ - if (opline->extended_value & ZEND_FETCH_MAKE_REF) { - zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; - - Z_DELREF_PP(retval_ptr); - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); - Z_ADDREF_PP(retval_ptr); - EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr; - EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } CHECK_EXCEPTION(); @@ -32812,26 +31781,19 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA USE_OPLINE zend_free_op free_op1; zval *property; - zval **container; + zval *container; SAVE_OPLINE(); property = opline->op2.zv; - container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property); - } else { + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_RW, 0 TSRMLS_CC); - } if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } CHECK_EXCEPTION(); @@ -32847,34 +31809,24 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA zval *offset; SAVE_OPLINE(); - container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_deref_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC); offset = opline->op2.zv; if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - + ZVAL_NULL(EX_VAR(opline->result.var)); } else { zval *retval; - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - /* here we are sure we are dealing with an object */ - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - - PZVAL_LOCK(retval); - EX_T(opline->result.var).var.ptr = retval; - - if (0) { - zval_ptr_dtor(&offset); - } else { + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC); + if (retval != EX_VAR(opline->result.var)) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); } } + CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -32882,31 +31834,24 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE + zval *container; if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { /* Behave like FETCH_OBJ_W */ zend_free_op free_op1; zval *property; - zval **container; SAVE_OPLINE(); property = opline->op2.zv; - container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property); - } else { + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, 0 TSRMLS_CC); - } if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } CHECK_EXCEPTION(); @@ -32919,41 +31864,22 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPC static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_free_op free_op1, free_res; - zval **container; - zval *property; + zend_free_op free_op1; + zval *container, *property; SAVE_OPLINE(); - container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC); property = opline->op2.zv; - if (IS_CV == IS_CV) { - if (container != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(container); - } - } - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property); - } else { + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_UNSET, 0 TSRMLS_CC); - } if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res); - if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr); - } - PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr); - FREE_OP_VAR_PTR(free_res); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -32962,25 +31888,18 @@ static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAND { USE_OPLINE - zval **object_ptr; + zval *object; zval *property_name; SAVE_OPLINE(); - object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + object = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); property_name = opline->op2.zv; - if (0) { - MAKE_REAL_ZVAL_PTR(property_name); - } - if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property_name); - } else { + zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC); - } /* assign_obj has two opcodes! */ CHECK_EXCEPTION(); @@ -32992,73 +31911,56 @@ static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAND { USE_OPLINE - zval **object_ptr; + zval *object_ptr; SAVE_OPLINE(); - object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + object_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); - if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - if (Z_TYPE_PP(object_ptr) == IS_OBJECT) { + if (UNEXPECTED(Z_ISREF_P(object_ptr)) && Z_TYPE_P(Z_REFVAL_P(object_ptr)) == IS_OBJECT) { + object_ptr = Z_REFVAL_P(object_ptr); + } + if (Z_TYPE_P(object_ptr) == IS_OBJECT) { zval *property_name = opline->op2.zv; - if (0) { - MAKE_REAL_ZVAL_PTR(property_name); - } - zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property_name); - } else { + zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC); - } } else { zend_free_op free_op_data1, free_op_data2; zval *value; zval *dim = opline->op2.zv; - zval **variable_ptr_ptr; + zval *variable_ptr; - zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_CONST, BP_VAR_W TSRMLS_CC); + zend_fetch_dimension_address_W(EX_VAR((opline+1)->op2.var), object_ptr, dim, IS_CONST TSRMLS_CC); value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); - variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); - if (UNEXPECTED(variable_ptr_ptr == NULL)) { - if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) { - if (RETURN_VALUE_USED(opline)) { - zval *retval; - - ALLOC_ZVAL(retval); - ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1); - INIT_PZVAL(retval); - EX_T(opline->result.var).var.ptr = retval; - } - } else if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - } - } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) { + variable_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); + if (UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) { + zend_assign_to_string_offset(variable_ptr, value, (opline+1)->op1_type, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC); + } else if (UNEXPECTED(variable_ptr == &EG(error_zval))) { if (IS_TMP_FREE(free_op_data1)) { zval_dtor(value); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } + FREE_OP_VAR_PTR(free_op_data2); } else { if ((opline+1)->op1_type == IS_TMP_VAR) { - value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_tmp_to_variable(variable_ptr, value TSRMLS_CC); } else if ((opline+1)->op1_type == IS_CONST) { - value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_const_to_variable(variable_ptr, value TSRMLS_CC); } else { - value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_to_variable(variable_ptr, value TSRMLS_CC); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(value); - EX_T(opline->result.var).var.ptr = value; + ZVAL_COPY(EX_VAR(opline->result.var), value); } + FREE_OP_VAR_PTR(free_op_data2); } - FREE_OP_VAR_PTR(free_op_data2); FREE_OP_IF_VAR(free_op_data1); } @@ -33073,46 +31975,33 @@ static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ USE_OPLINE zval *value; - zval **variable_ptr_ptr; + zval *variable_ptr; SAVE_OPLINE(); value = opline->op2.zv; - variable_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); - if (IS_CV == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) { - if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_CONST TSRMLS_CC)) { - if (RETURN_VALUE_USED(opline)) { - zval *retval; - - ALLOC_ZVAL(retval); - ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1); - INIT_PZVAL(retval); - EX_T(opline->result.var).var.ptr = retval; - } - } else if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - } - } else if (IS_CV == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) { + zend_assign_to_string_offset(variable_ptr, value, IS_CONST, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC); + } else if (IS_CV == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) { if (0) { zval_dtor(value); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } } else { if (IS_CONST == IS_TMP_VAR) { - value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_tmp_to_variable(variable_ptr, value TSRMLS_CC); } else if (IS_CONST == IS_CONST) { - value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_const_to_variable(variable_ptr, value TSRMLS_CC); } else { - value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_to_variable(variable_ptr, value TSRMLS_CC); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(value); - EX_T(opline->result.var).var.ptr = value; + ZVAL_COPY(EX_VAR(opline->result.var), value); } + } /* zend_assign_to_variable() always takes care of op2, never free it! */ @@ -33125,10 +32014,9 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER(ZEND_OPCOD { USE_OPLINE zval *function_name; - char *function_name_strval; - int function_name_strlen; call_slot *call = EX(call_slots) + opline->result.num; + zval *object; SAVE_OPLINE(); @@ -33142,33 +32030,30 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER(ZEND_OPCOD zend_error_noreturn(E_ERROR, "Method name must be a string"); } - function_name_strval = Z_STRVAL_P(function_name); - function_name_strlen = Z_STRLEN_P(function_name); + object = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); + call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL; - call->object = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); - - if (EXPECTED(call->object != NULL) && - EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) { - call->called_scope = Z_OBJCE_P(call->object); + if (EXPECTED(call->object != NULL)) { + call->called_scope = zend_get_class_entry(call->object TSRMLS_CC); if (IS_CONST != IS_CONST || - (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) { - zval *object = call->object; + (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope)) == NULL) { + zend_object *object = call->object; - if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) { + if (UNEXPECTED(object->handlers->get_method == NULL)) { zend_error_noreturn(E_ERROR, "Object does not support method calls"); } /* First, locate the function. */ - call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); + call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); if (UNEXPECTED(call->fbc == NULL)) { - zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval); + zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name)); } if (IS_CONST == IS_CONST && EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) && EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) && EXPECTED(call->object == object)) { - CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc); + CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope, call->fbc); } } } else { @@ -33176,21 +32061,13 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER(ZEND_OPCOD HANDLE_EXCEPTION(); } - zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval); + zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", Z_STRVAL_P(function_name)); } if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) { call->object = NULL; } else { - if (!PZVAL_IS_REF(call->object)) { - Z_ADDREF_P(call->object); /* For $this pointer */ - } else { - zval *this_ptr; - ALLOC_ZVAL(this_ptr); - INIT_PZVAL_COPY(this_ptr, call->object); - zval_copy_ctor(this_ptr); - call->object = this_ptr; - } + GC_REFCOUNT(call->object)++; /* For $this pointer */ } call->num_additional_args = 0; @@ -33206,11 +32083,12 @@ static int ZEND_FASTCALL ZEND_CASE_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR { USE_OPLINE + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - is_equal_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - opline->op2.zv TSRMLS_CC); + fast_equal_function(result, + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + opline->op2.zv TSRMLS_CC); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -33220,35 +32098,31 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCO { USE_OPLINE - zval *expr_ptr; + zval *expr_ptr, new_expr; SAVE_OPLINE(); - if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) { - zval **expr_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); - - if (IS_CV == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) { + if ((IS_CV == IS_VAR || IS_CV == IS_CV) && + (opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) { + expr_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets"); } - SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); - expr_ptr = *expr_ptr_ptr; + SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr); Z_ADDREF_P(expr_ptr); + } else { - expr_ptr=_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); + expr_ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); if (0) { /* temporary variable */ - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - } else if (IS_CV == IS_CONST || PZVAL_IS_REF(expr_ptr)) { - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - zendi_zval_copy_ctor(*expr_ptr); + ZVAL_COPY_VALUE(&new_expr, expr_ptr); + expr_ptr = &new_expr; + } else if (IS_CV == IS_CONST) { + ZVAL_DUP(&new_expr, expr_ptr); + expr_ptr = &new_expr; + } else if (Z_ISREF_P(expr_ptr)) { + ZVAL_DUP(&new_expr, Z_REFVAL_P(expr_ptr)); + expr_ptr = &new_expr; - } else if (IS_CV == IS_CV) { + } else if (IS_CV == IS_CV && Z_REFCOUNTED_P(expr_ptr)) { Z_ADDREF_P(expr_ptr); } } @@ -33256,42 +32130,49 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCO if (IS_CONST != IS_UNUSED) { zval *offset = opline->op2.zv; + zend_string *str; ulong hval; +add_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: hval = zend_dval_to_lval(Z_DVAL_P(offset)); goto num_index; case IS_LONG: - case IS_BOOL: hval = Z_LVAL_P(offset); num_index: - zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL); + zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); break; case IS_STRING: - if (IS_CONST == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); + str = Z_STR_P(offset); + if (IS_CONST != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index); } - zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL); +str_index: + zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); break; case IS_NULL: - zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); + str = STR_EMPTY_ALLOC(); + goto str_index; + case IS_FALSE: + hval = 0; + goto num_index; + case IS_TRUE: + hval = 1; + goto num_index; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto add_again; break; default: zend_error(E_WARNING, "Illegal offset type"); - zval_ptr_dtor(&expr_ptr); + zval_ptr_dtor(expr_ptr); /* do nothing */ break; } } else { - zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL); - } - if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) { - + zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -33299,9 +32180,26 @@ num_index: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { + zval *array; + zend_uint size; USE_OPLINE - array_init(&EX_T(opline->result.var).tmp_var); + array = EX_VAR(opline->result.var); + if (IS_CV != IS_UNUSED) { + size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; + } else { + size = 0; + } + ZVAL_NEW_ARR(array); + zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); + + if (IS_CV != IS_UNUSED) { + /* Explicitly initialize array as not-packed if flag is set */ + if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) { + zend_hash_real_init(Z_ARRVAL_P(array), 0); + } + } + if (IS_CV == IS_UNUSED) { ZEND_VM_NEXT_OPCODE(); #if 0 || IS_CV != IS_UNUSED @@ -33317,20 +32215,15 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDL zval tmp, *varname; HashTable *target_symbol_table; + zend_bool tmp_is_dup = 0; SAVE_OPLINE(); if (IS_CV == IS_CV && IS_CONST == IS_UNUSED && (opline->extended_value & ZEND_QUICK_SET)) { - if (EG(active_symbol_table)) { - zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); - - zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC); - EX_CV(opline->op1.var) = NULL; - } else if (EX_CV(opline->op1.var)) { - zval_ptr_dtor(EX_CV(opline->op1.var)); - EX_CV(opline->op1.var) = NULL; - } + ZVAL_COPY_VALUE(&tmp, EX_VAR(opline->op1.var)); + ZVAL_UNDEF(EX_VAR(opline->op1.var)); + zval_ptr_dtor(&tmp); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -33338,27 +32231,28 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDL varname = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { - ZVAL_COPY_VALUE(&tmp, varname); - zval_copy_ctor(&tmp); + ZVAL_DUP(&tmp, varname); convert_to_string(&tmp); varname = &tmp; + tmp_is_dup = 1; } else if (IS_CV == IS_VAR || IS_CV == IS_CV) { - Z_ADDREF_P(varname); + ZVAL_COPY(&tmp, varname); + varname = &tmp; } if (IS_CONST != IS_UNUSED) { zend_class_entry *ce; if (IS_CONST == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { - if (IS_CV != IS_CONST && varname == &tmp) { + if (IS_CV != IS_CONST && tmp_is_dup) { zval_dtor(&tmp); } else if (IS_CV == IS_VAR || IS_CV == IS_CV) { - zval_ptr_dtor(&varname); + zval_ptr_dtor(&tmp); } HANDLE_EXCEPTION(); @@ -33366,23 +32260,21 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDL if (UNEXPECTED(ce == NULL)) { zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv)); } - CACHE_PTR(opline->op2.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); } } else { - ce = EX_T(opline->op2.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op2.var)); } - zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); + zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC); } else { - ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1); - target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); - zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC); + zend_hash_del_ind(target_symbol_table, Z_STR_P(varname)); } - if (IS_CV != IS_CONST && varname == &tmp) { + if (IS_CV != IS_CONST && tmp_is_dup) { zval_dtor(&tmp); } else if (IS_CV == IS_VAR || IS_CV == IS_CV) { - zval_ptr_dtor(&varname); + zval_ptr_dtor(&tmp); } CHECK_EXCEPTION(); @@ -33393,91 +32285,98 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDL { USE_OPLINE - zval **container; + zval *container; zval *offset; ulong hval; SAVE_OPLINE(); - container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC); - if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) { + container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC); + if (IS_CV != IS_UNUSED) { SEPARATE_ZVAL_IF_NOT_REF(container); } offset = opline->op2.zv; - if (IS_CV != IS_VAR || container) { - switch (Z_TYPE_PP(container)) { - case IS_ARRAY: { - HashTable *ht = Z_ARRVAL_PP(container); - - switch (Z_TYPE_P(offset)) { - case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); - zend_hash_index_del(ht, hval); - break; - case IS_RESOURCE: - case IS_BOOL: - case IS_LONG: - hval = Z_LVAL_P(offset); - zend_hash_index_del(ht, hval); - break; - case IS_STRING: - if (IS_CONST == IS_CV || IS_CONST == IS_VAR) { - Z_ADDREF_P(offset); - } - if (IS_CONST == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); - } - if (ht == &EG(symbol_table)) { - zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC); - } else { - zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval); - } - if (IS_CONST == IS_CV || IS_CONST == IS_VAR) { - zval_ptr_dtor(&offset); - } - break; +container_again: + switch (Z_TYPE_P(container)) { + case IS_ARRAY: { + HashTable *ht = Z_ARRVAL_P(container); +offset_again: + switch (Z_TYPE_P(offset)) { + case IS_DOUBLE: + hval = zend_dval_to_lval(Z_DVAL_P(offset)); + zend_hash_index_del(ht, hval); + break; + case IS_LONG: + hval = Z_LVAL_P(offset); num_index_dim: - zend_hash_index_del(ht, hval); - if (IS_CONST == IS_CV || IS_CONST == IS_VAR) { - zval_ptr_dtor(&offset); - } - break; - case IS_NULL: - zend_hash_del(ht, "", sizeof("")); - break; - default: - zend_error(E_WARNING, "Illegal offset type in unset"); - break; - } - - break; + zend_hash_index_del(ht, hval); + break; + case IS_STRING: + if (IS_CONST == IS_CV || IS_CONST == IS_VAR) { + if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset); + } + if (IS_CONST != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto numeric_index_dim); + } + if (ht == &EG(symbol_table).ht) { + zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC); + } else { + zend_hash_del(ht, Z_STR_P(offset)); + } + if (IS_CONST == IS_CV || IS_CONST == IS_VAR) { + zval_ptr_dtor(offset); + } + break; +numeric_index_dim: + zend_hash_index_del(ht, hval); + if (IS_CONST == IS_CV || IS_CONST == IS_VAR) { + zval_ptr_dtor(offset); + } + break; + case IS_NULL: + zend_hash_del(ht, STR_EMPTY_ALLOC()); + break; + case IS_FALSE: + hval = 0; + goto num_index_dim; + case IS_TRUE: + hval = 1; + goto num_index_dim; + case IS_RESOURCE: + hval = Z_RES_HANDLE_P(offset); + goto num_index_dim; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto offset_again; + break; + default: + zend_error(E_WARNING, "Illegal offset type in unset"); + break; } - case IS_OBJECT: - if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use object as array"); - } - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC); - if (0) { - zval_ptr_dtor(&offset); - } else { - } - break; - case IS_STRING: - zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); - ZEND_VM_CONTINUE(); /* bailed out before */ - default: - - break; + break; } - } else { + case IS_OBJECT: + if (UNEXPECTED(Z_OBJ_HT_P(container)->unset_dimension == NULL)) { + zend_error_noreturn(E_ERROR, "Cannot use object as array"); + } +//??? if (IS_CONST == IS_CONST) { +//??? zval_copy_ctor(offset); +//??? } + Z_OBJ_HT_P(container)->unset_dimension(container, offset TSRMLS_CC); + break; + case IS_STRING: + case IS_STR_OFFSET: + zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); + ZEND_VM_CONTINUE(); /* bailed out before */ + case IS_REFERENCE: + container = Z_REFVAL_P(container); + goto container_again; + break; + default: + + break; } CHECK_EXCEPTION(); @@ -33488,38 +32387,26 @@ static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDL { USE_OPLINE - zval **container; + zval *container; zval *offset; SAVE_OPLINE(); - container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC); + if (IS_CV == IS_VAR && Z_TYPE_P(container) == IS_STR_OFFSET) { + zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); + } offset = opline->op2.zv; - if (IS_CV != IS_VAR || container) { - if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(container); - } - if (Z_TYPE_PP(container) == IS_OBJECT) { - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - if (Z_OBJ_HT_P(*container)->unset_property) { - Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to unset property of non-object"); - } - if (0) { - zval_ptr_dtor(&offset); - } else { - - } + ZVAL_DEREF(container); + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->unset_property) { + Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); } else { - + zend_error(E_NOTICE, "Trying to unset property of non-object"); } - } else { - } + CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -33527,21 +32414,16 @@ static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDL static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval **value; + zval *value; zend_bool isset = 1; SAVE_OPLINE(); if (IS_CV == IS_CV && IS_CONST == IS_UNUSED && (opline->extended_value & ZEND_QUICK_SET)) { - if (EX_CV(opline->op1.var)) { - value = EX_CV(opline->op1.var); - } else if (EG(active_symbol_table)) { - zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); - - if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) { - isset = 0; - } + if (Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_UNDEF) { + value = EX_VAR(opline->op1.var); + ZVAL_DEREF(value); } else { isset = 0; } @@ -33551,8 +32433,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCO zval tmp, *varname = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC); if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { - ZVAL_COPY_VALUE(&tmp, varname); - zval_copy_ctor(&tmp); + ZVAL_DUP(&tmp, varname); convert_to_string(&tmp); varname = &tmp; } @@ -33561,26 +32442,26 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCO zend_class_entry *ce; if (IS_CONST == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(opline->op2.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); } } else { - ce = EX_T(opline->op2.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op2.var)); } - value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); + value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC); if (!value) { isset = 0; } } else { target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); - if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) { + if ((value = zend_hash_find(target_symbol_table, Z_STR_P(varname))) == NULL) { isset = 0; } } @@ -33592,16 +32473,16 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCO } if (opline->extended_value & ZEND_ISSET) { - if (isset && Z_TYPE_PP(value) != IS_NULL) { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); + if (isset && Z_TYPE_P(value) != IS_NULL) { + ZVAL_BOOL(EX_VAR(opline->result.var), 1); } else { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); + ZVAL_BOOL(EX_VAR(opline->result.var), 0); } } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { - if (!isset || !i_zend_is_true(*value TSRMLS_CC)) { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); + if (!isset || !i_zend_is_true(value TSRMLS_CC)) { + ZVAL_BOOL(EX_VAR(opline->result.var), 1); } else { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); + ZVAL_BOOL(EX_VAR(opline->result.var), 0); } } @@ -33609,54 +32490,58 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCO ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(int prop_dim, ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; - zval **value = NULL; - int result = 0; + int result; ulong hval; zval *offset; SAVE_OPLINE(); - container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_deref_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC); offset = opline->op2.zv; - if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) { - HashTable *ht; - int isset = 0; - - ht = Z_ARRVAL_P(container); + if (Z_TYPE_P(container) == IS_ARRAY) { + HashTable *ht = Z_ARRVAL_P(container); + zval *value = NULL; + zend_string *str; +isset_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: hval = zend_dval_to_lval(Z_DVAL_P(offset)); goto num_index_prop; - case IS_RESOURCE: - case IS_BOOL: case IS_LONG: hval = Z_LVAL_P(offset); num_index_prop: - if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) { - isset = 1; - } + value = zend_hash_index_find(ht, hval); break; case IS_STRING: - if (IS_CONST == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); - } - if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) { - isset = 1; + str = Z_STR_P(offset); + if (IS_CONST != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index_prop); } +str_index_prop: + value = zend_hash_find_ind(ht, str); break; case IS_NULL: - if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) { - isset = 1; - } + str = STR_EMPTY_ALLOC(); + goto str_index_prop; + break; + case IS_FALSE: + hval = 0; + goto num_index_prop; + case IS_TRUE: + hval = 0; + goto num_index_prop; + case IS_RESOURCE: + hval = Z_RES_HANDLE_P(offset); + goto num_index_prop; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto isset_again; break; default: zend_error(E_WARNING, "Illegal offset type in isset or empty"); @@ -33664,116 +32549,103 @@ num_index_prop: } if (opline->extended_value & ZEND_ISSET) { - if (isset && Z_TYPE_PP(value) == IS_NULL) { - result = 0; - } else { - result = isset; - } + /* > IS_NULL means not IS_UNDEF and not IS_NULL */ + result = (value != NULL && Z_TYPE_P(value) > IS_NULL); } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { - if (!isset || !i_zend_is_true(*value TSRMLS_CC)) { - result = 0; - } else { - result = 1; - } + result = (value == NULL || !i_zend_is_true(value TSRMLS_CC)); } - } else if (Z_TYPE_P(container) == IS_OBJECT) { - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - if (prop_dim) { - if (Z_OBJ_HT_P(container)->has_property) { - result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check property of non-object"); - result = 0; - } + if (Z_OBJ_HT_P(container)->has_dimension) { + result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); } else { - if (Z_OBJ_HT_P(container)->has_dimension) { - result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check element of non-array"); - result = 0; - } + zend_error(E_NOTICE, "Trying to check element of non-array"); + result = 0; } - if (0) { - zval_ptr_dtor(&offset); - } else { - + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; } - } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */ + } else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */ zval tmp; - if (Z_TYPE_P(offset) != IS_LONG) { - if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */ + result = 0; + if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) { + if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */ || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { - ZVAL_COPY_VALUE(&tmp, offset); - zval_copy_ctor(&tmp); + ZVAL_DUP(&tmp, offset); convert_to_long(&tmp); offset = &tmp; - } else { - /* can not be converted to proper offset, return "not set" */ - result = 0; } } if (Z_TYPE_P(offset) == IS_LONG) { - if (opline->extended_value & ZEND_ISSET) { - if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { - result = 1; - } - } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { - if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') { + if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { + if ((opline->extended_value & ZEND_ISSET) || + Z_STRVAL_P(container)[offset->value.lval] != '0') { result = 1; } } } - + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } } else { - + result = ((opline->extended_value & ZEND_ISSET) == 0); } - Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; - if (opline->extended_value & ZEND_ISSET) { - Z_LVAL(EX_T(opline->result.var).tmp_var) = result; - } else { - Z_LVAL(EX_T(opline->result.var).tmp_var) = !result; - } + ZVAL_BOOL(EX_VAR(opline->result.var), result); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} - static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + zval *container; + int result; + zval *offset; + + SAVE_OPLINE(); + container = _get_zval_ptr_cv_deref_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC); + offset = opline->op2.zv; + + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->has_property) { + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); + } else { + zend_error(E_NOTICE, "Trying to check property of non-object"); + result = 0; + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else { + result = ((opline->extended_value & ZEND_ISSET) == 0); + } + + ZVAL_BOOL(EX_VAR(opline->result.var), result); + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - /* The generator object is stored in return_value_ptr_ptr */ - zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr); + /* The generator object is stored in EX(return_value) */ + zend_generator *generator = (zend_generator *) EX(return_value); if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) { zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator"); } /* Destroy the previously yielded value */ - if (generator->value) { - zval_ptr_dtor(&generator->value); - } + zval_ptr_dtor(&generator->value); /* Destroy the previously yielded key */ - if (generator->key) { - zval_ptr_dtor(&generator->key); - } + zval_ptr_dtor(&generator->key); /* Set the new yielded value */ if (IS_CV != IS_UNUSED) { @@ -33783,74 +32655,58 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_A /* Constants and temporary variables aren't yieldable by reference, * but we still allow them with a notice. */ if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) { - zval *value, *copy; + zval *value; zend_error(E_NOTICE, "Only variable references should be yielded by reference"); value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); + ZVAL_COPY_VALUE(&generator->value, value); + if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1); /* Temporary variables don't need ctor copying */ if (!0) { - zval_copy_ctor(copy); + zval_copy_ctor(&generator->value); } - - generator->value = copy; } else { - zval **value_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); - if (IS_CV == IS_VAR && UNEXPECTED(value_ptr == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference"); } /* If a function call result is yielded and the function did * not return by reference we throw a notice. */ - if (IS_CV == IS_VAR && !Z_ISREF_PP(value_ptr) + if (IS_CV == IS_VAR && !Z_ISREF_P(value_ptr) && !(opline->extended_value == ZEND_RETURNS_FUNCTION - && EX_T(opline->op1.var).var.fcall_returned_reference) - && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) { + && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); - - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } else { SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr); - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } + ZVAL_COPY(&generator->value, value_ptr); } } else { zval *value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); /* Consts, temporary variables and references need copying */ - if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR - || PZVAL_IS_REF(value) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); - - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } - - generator->value = copy; + if (IS_CV == IS_CONST) { + ZVAL_DUP(&generator->value, value); + } else if (IS_CV == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->value, value); + } else if (Z_ISREF_P(value)) { + ZVAL_DUP(&generator->value, Z_REFVAL_P(value)); } else { if (IS_CV == IS_CV) { - Z_ADDREF_P(value); + if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value); } - generator->value = value; + ZVAL_COPY_VALUE(&generator->value, value); } } } else { /* If no value was specified yield null */ - Z_ADDREF(EG(uninitialized_zval)); - generator->value = &EG(uninitialized_zval); + ZVAL_NULL(&generator->value); } /* Set the new yielded key */ @@ -33859,45 +32715,36 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_A zval *key = opline->op2.zv; /* Consts, temporary variables and references need copying */ - if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR - || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, key); - - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } + if (IS_CONST == IS_CONST) { + ZVAL_DUP(&generator->key, key); + } else if (IS_CONST == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->key, key); + } else if (Z_ISREF_P(key)) { + ZVAL_DUP(&generator->key, Z_REFVAL_P(key)); - generator->key = copy; } else { - Z_ADDREF_P(key); - generator->key = key; + if (IS_CONST == IS_CV) { + if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key); + } + ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE_P(generator->key) == IS_LONG - && Z_LVAL_P(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_LONG + && Z_LVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL_P(generator->key); + generator->largest_used_integer_key = Z_LVAL(generator->key); } - } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - - ALLOC_INIT_ZVAL(generator->key); - ZVAL_LONG(generator->key, generator->largest_used_integer_key); + ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ - generator->send_target = &EX_T(opline->result.var).var.ptr; - Z_ADDREF(EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + generator->send_target = EX_VAR(opline->result.var); + ZVAL_NULL(generator->send_target); } else { generator->send_target = NULL; } @@ -33919,8 +32766,8 @@ static int ZEND_FASTCALL ZEND_POW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG SAVE_OPLINE(); - pow_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + pow_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), opline->op2.zv TSRMLS_CC); @@ -33939,7 +32786,7 @@ static int ZEND_FASTCALL ZEND_ADD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op2; SAVE_OPLINE(); - fast_add_function(&EX_T(opline->result.var).tmp_var, + fast_add_function(EX_VAR(opline->result.var), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); @@ -33954,7 +32801,7 @@ static int ZEND_FASTCALL ZEND_SUB_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op2; SAVE_OPLINE(); - fast_sub_function(&EX_T(opline->result.var).tmp_var, + fast_sub_function(EX_VAR(opline->result.var), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); @@ -33969,7 +32816,7 @@ static int ZEND_FASTCALL ZEND_MUL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op2; SAVE_OPLINE(); - fast_mul_function(&EX_T(opline->result.var).tmp_var, + fast_mul_function(EX_VAR(opline->result.var), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); @@ -33984,7 +32831,7 @@ static int ZEND_FASTCALL ZEND_DIV_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op2; SAVE_OPLINE(); - fast_div_function(&EX_T(opline->result.var).tmp_var, + fast_div_function(EX_VAR(opline->result.var), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); @@ -33999,8 +32846,8 @@ static int ZEND_FASTCALL ZEND_MOD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op2; SAVE_OPLINE(); - fast_mod_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + fast_mod_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op2.var); @@ -34014,8 +32861,8 @@ static int ZEND_FASTCALL ZEND_SL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op2; SAVE_OPLINE(); - shift_left_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + shift_left_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op2.var); @@ -34029,8 +32876,8 @@ static int ZEND_FASTCALL ZEND_SR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op2; SAVE_OPLINE(); - shift_right_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + shift_right_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op2.var); @@ -34044,8 +32891,8 @@ static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR zend_free_op free_op2; SAVE_OPLINE(); - concat_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + concat_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op2.var); @@ -34059,8 +32906,8 @@ static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HAND zend_free_op free_op2; SAVE_OPLINE(); - is_identical_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + fast_is_identical_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op2.var); @@ -34072,13 +32919,12 @@ static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_ { USE_OPLINE zend_free_op free_op2; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - is_identical_function(result, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + fast_is_not_identical_function(result, + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - Z_LVAL_P(result) = !Z_LVAL_P(result); zval_dtor(free_op2.var); CHECK_EXCEPTION(); @@ -34089,12 +32935,12 @@ static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ { USE_OPLINE zend_free_op free_op2; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_equal_function(result, + fast_equal_function(result, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op2.var); CHECK_EXCEPTION(); @@ -34105,12 +32951,12 @@ static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HAND { USE_OPLINE zend_free_op free_op2; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_not_equal_function(result, + fast_not_equal_function(result, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op2.var); CHECK_EXCEPTION(); @@ -34121,12 +32967,12 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLE { USE_OPLINE zend_free_op free_op2; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_is_smaller_function(result, + fast_is_smaller_function(result, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op2.var); CHECK_EXCEPTION(); @@ -34137,12 +32983,12 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_TMP_HANDLER(ZEND_OPCO { USE_OPLINE zend_free_op free_op2; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, + fast_is_smaller_or_equal_function(result, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op2.var); CHECK_EXCEPTION(); @@ -34155,8 +33001,8 @@ static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG zend_free_op free_op2; SAVE_OPLINE(); - bitwise_or_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + bitwise_or_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op2.var); @@ -34170,8 +33016,8 @@ static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR zend_free_op free_op2; SAVE_OPLINE(); - bitwise_and_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + bitwise_and_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op2.var); @@ -34185,8 +33031,8 @@ static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR zend_free_op free_op2; SAVE_OPLINE(); - bitwise_xor_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + bitwise_xor_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op2.var); @@ -34200,8 +33046,8 @@ static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ zend_free_op free_op2; SAVE_OPLINE(); - boolean_xor_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + boolean_xor_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op2.var); @@ -34213,18 +33059,18 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_TMP(int (*bina { USE_OPLINE zend_free_op free_op2, free_op_data1; - zval **object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); - zval *object; + zval *object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); zval *property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); + zval *value; int have_get_ptr = 0; - if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - make_real_object(object_ptr TSRMLS_CC); - object = *object_ptr; + object = make_real_object(object TSRMLS_CC); + + value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { zend_error(E_WARNING, "Attempt to assign property of non-object"); @@ -34232,81 +33078,68 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_TMP(int (*bina FREE_OP(free_op_data1); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } } else { /* here we are sure we are dealing with an object */ - if (1) { - MAKE_REAL_ZVAL_PTR(property); - } - - /* here property is a string */ if (opline->extended_value == ZEND_ASSIGN_OBJ && Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); if (zptr != NULL) { /* NULL means no success in getting PTR */ SEPARATE_ZVAL_IF_NOT_REF(zptr); have_get_ptr = 1; - binary_op(*zptr, *zptr, value TSRMLS_CC); + binary_op(zptr, zptr, value TSRMLS_CC); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(*zptr); - EX_T(opline->result.var).var.ptr = *zptr; + ZVAL_COPY(EX_VAR(opline->result.var), zptr); } } } if (!have_get_ptr) { zval *z = NULL; + zval rv; if (opline->extended_value == ZEND_ASSIGN_OBJ) { if (Z_OBJ_HT_P(object)->read_property) { - z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC); } } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { if (Z_OBJ_HT_P(object)->read_dimension) { - z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC); + z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R, &rv TSRMLS_CC); } } if (z) { if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); zval_dtor(z); - FREE_ZVAL(z); } - z = value; + ZVAL_COPY_VALUE(z, value); } - Z_ADDREF_P(z); - SEPARATE_ZVAL_IF_NOT_REF(&z); +//??? if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); + SEPARATE_ZVAL_IF_NOT_REF(z); binary_op(z, z, value TSRMLS_CC); if (opline->extended_value == ZEND_ASSIGN_OBJ) { - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(z); - EX_T(opline->result.var).var.ptr = z; + ZVAL_COPY(EX_VAR(opline->result.var), z); } - zval_ptr_dtor(&z); + zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to assign property of non-object"); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } } } - if (1) { - zval_ptr_dtor(&property); - } else { - zval_dtor(free_op2.var); - } + zval_dtor(free_op2.var); FREE_OP(free_op_data1); } @@ -34316,179 +33149,288 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_TMP(int (*bina ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_CV_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_free_op free_op2, free_op_data2, free_op_data1; - zval **var_ptr; - zval *value; + zval *var_ptr; + zval *value, *container; SAVE_OPLINE(); - switch (opline->extended_value) { - case ZEND_ASSIGN_OBJ: - return zend_binary_assign_op_obj_helper_SPEC_CV_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - break; - case ZEND_ASSIGN_DIM: { - zval **container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); - - if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); - } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) { - if (IS_CV == IS_VAR && !0) { - Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */ - } - return zend_binary_assign_op_obj_helper_SPEC_CV_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - } else { - zval *dim = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { + zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); + } else if (UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { + if (IS_CV == IS_VAR && !0) { + Z_ADDREF_P(container); /* undo the effect of get_obj_zval_ptr_ptr() */ + } + return zend_binary_assign_op_obj_helper_SPEC_CV_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else { + zval *dim = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_TMP_VAR, BP_VAR_RW TSRMLS_CC); - value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); - var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); - } - } - break; - default: - value = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); - /* do nothing */ - break; + zend_fetch_dimension_address_RW(EX_VAR((opline+1)->op2.var), container, dim, IS_TMP_VAR TSRMLS_CC); + value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); + var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); } - if (UNEXPECTED(var_ptr == NULL)) { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); } - if (UNEXPECTED(*var_ptr == &EG(error_zval))) { - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - } - zval_dtor(free_op2.var); - - CHECK_EXCEPTION(); - if (opline->extended_value == ZEND_ASSIGN_DIM) { - ZEND_VM_INC_OPCODE(); + if (UNEXPECTED(var_ptr == &EG(error_zval))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); } - ZEND_VM_NEXT_OPCODE(); + goto assign_op_dim_exit; } SEPARATE_ZVAL_IF_NOT_REF(var_ptr); + ZVAL_DEREF(var_ptr); - if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) - && Z_OBJ_HANDLER_PP(var_ptr, get) - && Z_OBJ_HANDLER_PP(var_ptr, set)) { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) && + UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) { /* proxy object */ - zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); + zval rv; + zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC); Z_ADDREF_P(objval); binary_op(objval, objval, value TSRMLS_CC); - Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC); - zval_ptr_dtor(&objval); + Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); + zval_ptr_dtor(objval); } else { - binary_op(*var_ptr, *var_ptr, value TSRMLS_CC); + binary_op(var_ptr, var_ptr, value TSRMLS_CC); } - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(*var_ptr); - EX_T(opline->result.var).var.ptr = *var_ptr; + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } + +assign_op_dim_exit: zval_dtor(free_op2.var); + FREE_OP(free_op_data1); + FREE_OP_VAR_PTR(free_op_data2); - if (opline->extended_value == ZEND_ASSIGN_DIM) { - FREE_OP(free_op_data1); - FREE_OP_VAR_PTR(free_op_data2); + CHECK_EXCEPTION(); + ZEND_VM_INC_OPCODE(); + ZEND_VM_NEXT_OPCODE(); +} - CHECK_EXCEPTION(); - ZEND_VM_INC_OPCODE(); +static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_free_op free_op2; + zval *var_ptr; + zval *value; + + SAVE_OPLINE(); + value = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + var_ptr = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); + + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { + zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); + } + + if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } + goto assign_op_exit; + } + + SEPARATE_ZVAL_IF_NOT_REF(var_ptr); + ZVAL_DEREF(var_ptr); + + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) && + UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) { + /* proxy object */ + zval rv; + zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC); + Z_ADDREF_P(objval); + binary_op(objval, objval, value TSRMLS_CC); + Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); + zval_ptr_dtor(objval); } else { + binary_op(var_ptr, var_ptr, value TSRMLS_CC); + } - CHECK_EXCEPTION(); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } + +assign_op_exit: + zval_dtor(free_op2.var); + + CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_TMP(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_TMP(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_TMP(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_TMP(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_TMP(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_TMP(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_TMP(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_TMP(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_TMP(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_TMP(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_TMP(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_TMP(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_TMP(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_TMP(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_TMP(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_TMP(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_TMP(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_TMP(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_TMP(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_TMP(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_TMP(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_TMP(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_TMP(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_TMP(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_TMP(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_TMP(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_TMP(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_TMP(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_TMP(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_TMP(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_TMP(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_TMP(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_TMP(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_TMP(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_TMP(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_TMP(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_TMP(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_TMP(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_TMP(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_TMP(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_TMP(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_TMP(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_TMP(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_TMP(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_TMP(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_free_op free_op2; - zval **object_ptr; zval *object; zval *property; - zval **retval; + zval *retval; int have_get_ptr = 0; SAVE_OPLINE(); - object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); + object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - retval = &EX_T(opline->result.var).var.ptr; + retval = EX_VAR(opline->result.var); - if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } - make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ - object = *object_ptr; + object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */ if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); zval_dtor(free_op2.var); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - *retval = &EG(uninitialized_zval); + ZVAL_NULL(retval); } CHECK_EXCEPTION(); @@ -34497,59 +33439,50 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_TMP(incdec_t in /* here we are sure we are dealing with an object */ - if (1) { - MAKE_REAL_ZVAL_PTR(property); - } - if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); if (zptr != NULL) { /* NULL means no success in getting PTR */ SEPARATE_ZVAL_IF_NOT_REF(zptr); have_get_ptr = 1; - incdec_op(*zptr); + incdec_op(zptr); if (RETURN_VALUE_USED(opline)) { - *retval = *zptr; - PZVAL_LOCK(*retval); + ZVAL_COPY(retval, zptr); } } } if (!have_get_ptr) { + zval rv; + if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC); if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); zval_dtor(z); - FREE_ZVAL(z); } - z = value; + ZVAL_COPY_VALUE(z, value); } - Z_ADDREF_P(z); - SEPARATE_ZVAL_IF_NOT_REF(&z); + if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); + SEPARATE_ZVAL_IF_NOT_REF(z); incdec_op(z); - *retval = z; - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - SELECTIVE_PZVAL_LOCK(*retval, opline); - zval_ptr_dtor(&z); + ZVAL_COPY_VALUE(retval, z); + Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); + SELECTIVE_PZVAL_LOCK(retval, opline); + zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - *retval = &EG(uninitialized_zval); + ZVAL_NULL(retval); } } } - if (1) { - zval_ptr_dtor(&property); - } else { - zval_dtor(free_op2.var); - } + zval_dtor(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -34569,23 +33502,21 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_TMP(incdec_t i { USE_OPLINE zend_free_op free_op2; - zval **object_ptr; zval *object; zval *property; zval *retval; int have_get_ptr = 0; SAVE_OPLINE(); - object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); + object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - retval = &EX_T(opline->result.var).tmp_var; + retval = EX_VAR(opline->result.var); - if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } - make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ - object = *object_ptr; + object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */ if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); @@ -34598,60 +33529,48 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_TMP(incdec_t i /* here we are sure we are dealing with an object */ - if (1) { - MAKE_REAL_ZVAL_PTR(property); - } - if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); if (zptr != NULL) { /* NULL means no success in getting PTR */ have_get_ptr = 1; SEPARATE_ZVAL_IF_NOT_REF(zptr); - ZVAL_COPY_VALUE(retval, *zptr); - zendi_zval_copy_ctor(*retval); + ZVAL_DUP(retval, zptr); - incdec_op(*zptr); + incdec_op(zptr); } } if (!have_get_ptr) { if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - zval *z_copy; + zval rv; + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC); + zval z_copy; if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); zval_dtor(z); - FREE_ZVAL(z); } - z = value; + ZVAL_COPY_VALUE(z, value); } - ZVAL_COPY_VALUE(retval, z); - zendi_zval_copy_ctor(*retval); - ALLOC_ZVAL(z_copy); - INIT_PZVAL_COPY(z_copy, z); - zendi_zval_copy_ctor(*z_copy); - incdec_op(z_copy); - Z_ADDREF_P(z); - Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + ZVAL_DUP(retval, z); + ZVAL_DUP(&z_copy, z); + incdec_op(&z_copy); + if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); + Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); zval_ptr_dtor(&z_copy); - zval_ptr_dtor(&z); + zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); ZVAL_NULL(retval); } } - if (1) { - zval_ptr_dtor(&property); - } else { - zval_dtor(free_op2.var); - } + zval_dtor(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -34675,7 +33594,7 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDL SAVE_OPLINE(); container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); - zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC); zval_dtor(free_op2.var); if (IS_CV != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) { @@ -34688,29 +33607,22 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDL { USE_OPLINE zend_free_op free_op1, free_op2; - zval **container; + zval *container; SAVE_OPLINE(); - container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); - if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_W TSRMLS_CC); + if (EXPECTED(opline->extended_value == 0)) { + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC); + } else { + zend_fetch_dimension_address_W_ref(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC); + } zval_dtor(free_op2.var); if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); - } - - /* We are going to assign the result by reference */ - if (UNEXPECTED(opline->extended_value != 0)) { - zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; - - if (retval_ptr) { - Z_DELREF_PP(retval_ptr); - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); - Z_ADDREF_PP(retval_ptr); - } + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } CHECK_EXCEPTION(); @@ -34721,18 +33633,18 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HAND { USE_OPLINE zend_free_op free_op1, free_op2; - zval **container; + zval *container; SAVE_OPLINE(); - container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); - if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_RW TSRMLS_CC); + zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC); zval_dtor(free_op2.var); if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } CHECK_EXCEPTION(); @@ -34747,7 +33659,7 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HAND SAVE_OPLINE(); container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC); - zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_IS TSRMLS_CC); + zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC); zval_dtor(free_op2.var); CHECK_EXCEPTION(); @@ -34757,29 +33669,28 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HAND static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE + zval *container; zend_free_op free_op1, free_op2; SAVE_OPLINE(); if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { - zval **container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_W TSRMLS_CC); + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC); if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } zval_dtor(free_op2.var); } else { - zval *container; - if (IS_TMP_VAR == IS_UNUSED) { zend_error_noreturn(E_ERROR, "Cannot use [] for reading"); } container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); - zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC); zval_dtor(free_op2.var); } @@ -34791,41 +33702,22 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_H { USE_OPLINE zend_free_op free_op1, free_op2; - zval **container; + zval *container; SAVE_OPLINE(); - container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC); - if (IS_CV == IS_CV) { - if (container != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(container); - } - } - if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_UNSET TSRMLS_CC); + zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC); zval_dtor(free_op2.var); if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); - ZEND_VM_NEXT_OPCODE(); - } else { - zend_free_op free_res; - zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; - - PZVAL_UNLOCK(*retval_ptr, &free_res); - if (retval_ptr != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(retval_ptr); - } - PZVAL_LOCK(*retval_ptr); - FREE_OP_VAR_PTR(free_res); - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); - } + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_TMP(ZEND_OPCODE_HANDLER_ARGS) @@ -34837,35 +33729,26 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_TMP(ZEN zval *offset; SAVE_OPLINE(); - container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { zend_error(E_NOTICE, "Trying to get property of non-object"); - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - zval_dtor(free_op2.var); + ZVAL_NULL(EX_VAR(opline->result.var)); } else { zval *retval; - if (1) { - MAKE_REAL_ZVAL_PTR(offset); - } - /* here we are sure we are dealing with an object */ - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC); - PZVAL_LOCK(retval); - EX_T(opline->result.var).var.ptr = retval; - - if (1) { - zval_ptr_dtor(&offset); - } else { - zval_dtor(free_op2.var); + if (retval != EX_VAR(opline->result.var)) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); } } + zval_dtor(free_op2.var); + CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -34880,38 +33763,20 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDL USE_OPLINE zend_free_op free_op1, free_op2; zval *property; - zval **container; + zval *container; SAVE_OPLINE(); property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (1) { - MAKE_REAL_ZVAL_PTR(property); - } - container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); - if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { + container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); - if (1) { - zval_ptr_dtor(&property); - } else { - zval_dtor(free_op2.var); - } + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC); + zval_dtor(free_op2.var); if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); - } - - /* We are going to assign the result by reference */ - if (opline->extended_value & ZEND_FETCH_MAKE_REF) { - zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; - - Z_DELREF_PP(retval_ptr); - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); - Z_ADDREF_PP(retval_ptr); - EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr; - EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } CHECK_EXCEPTION(); @@ -34923,26 +33788,19 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HAND USE_OPLINE zend_free_op free_op1, free_op2; zval *property; - zval **container; + zval *container; SAVE_OPLINE(); property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); - if (1) { - MAKE_REAL_ZVAL_PTR(property); - } - if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC); - if (1) { - zval_ptr_dtor(&property); - } else { - zval_dtor(free_op2.var); - } + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_RW, 0 TSRMLS_CC); + zval_dtor(free_op2.var); if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } CHECK_EXCEPTION(); @@ -34958,34 +33816,25 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HAND zval *offset; SAVE_OPLINE(); - container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_deref_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC); offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - zval_dtor(free_op2.var); + ZVAL_NULL(EX_VAR(opline->result.var)); } else { zval *retval; - if (1) { - MAKE_REAL_ZVAL_PTR(offset); - } - /* here we are sure we are dealing with an object */ - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC); - PZVAL_LOCK(retval); - EX_T(opline->result.var).var.ptr = retval; - - if (1) { - zval_ptr_dtor(&offset); - } else { - zval_dtor(free_op2.var); + if (retval != EX_VAR(opline->result.var)) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); } } + zval_dtor(free_op2.var); + CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -34993,31 +33842,24 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HAND static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE + zval *container; if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { /* Behave like FETCH_OBJ_W */ zend_free_op free_op1, free_op2; zval *property; - zval **container; SAVE_OPLINE(); property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); - if (1) { - MAKE_REAL_ZVAL_PTR(property); - } - if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); - if (1) { - zval_ptr_dtor(&property); - } else { - zval_dtor(free_op2.var); - } + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, 0 TSRMLS_CC); + zval_dtor(free_op2.var); if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } CHECK_EXCEPTION(); @@ -35030,41 +33872,22 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMP_HANDLER(ZEND_OPCOD static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_free_op free_op1, free_op2, free_res; - zval **container; - zval *property; + zend_free_op free_op1, free_op2; + zval *container, *property; SAVE_OPLINE(); - container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC); property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (IS_CV == IS_CV) { - if (container != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(container); - } - } - if (1) { - MAKE_REAL_ZVAL_PTR(property); - } - if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC); - if (1) { - zval_ptr_dtor(&property); - } else { - zval_dtor(free_op2.var); - } + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_UNSET, 0 TSRMLS_CC); + zval_dtor(free_op2.var); if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res); - if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr); - } - PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr); - FREE_OP_VAR_PTR(free_res); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -35073,25 +33896,18 @@ static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLE { USE_OPLINE zend_free_op free_op2; - zval **object_ptr; + zval *object; zval *property_name; SAVE_OPLINE(); - object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + object = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); property_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (1) { - MAKE_REAL_ZVAL_PTR(property_name); - } - if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - if (1) { - zval_ptr_dtor(&property_name); - } else { - zval_dtor(free_op2.var); - } + zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC); + zval_dtor(free_op2.var); /* assign_obj has two opcodes! */ CHECK_EXCEPTION(); @@ -35103,74 +33919,57 @@ static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLE { USE_OPLINE - zval **object_ptr; + zval *object_ptr; SAVE_OPLINE(); - object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + object_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); - if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - if (Z_TYPE_PP(object_ptr) == IS_OBJECT) { + if (UNEXPECTED(Z_ISREF_P(object_ptr)) && Z_TYPE_P(Z_REFVAL_P(object_ptr)) == IS_OBJECT) { + object_ptr = Z_REFVAL_P(object_ptr); + } + if (Z_TYPE_P(object_ptr) == IS_OBJECT) { zend_free_op free_op2; zval *property_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (1) { - MAKE_REAL_ZVAL_PTR(property_name); - } - zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - if (1) { - zval_ptr_dtor(&property_name); - } else { - zval_dtor(free_op2.var); - } + zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC); + zval_dtor(free_op2.var); } else { zend_free_op free_op2, free_op_data1, free_op_data2; zval *value; zval *dim = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - zval **variable_ptr_ptr; + zval *variable_ptr; - zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_TMP_VAR, BP_VAR_W TSRMLS_CC); + zend_fetch_dimension_address_W(EX_VAR((opline+1)->op2.var), object_ptr, dim, IS_TMP_VAR TSRMLS_CC); zval_dtor(free_op2.var); value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); - variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); - if (UNEXPECTED(variable_ptr_ptr == NULL)) { - if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) { - if (RETURN_VALUE_USED(opline)) { - zval *retval; - - ALLOC_ZVAL(retval); - ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1); - INIT_PZVAL(retval); - EX_T(opline->result.var).var.ptr = retval; - } - } else if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - } - } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) { + variable_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); + if (UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) { + zend_assign_to_string_offset(variable_ptr, value, (opline+1)->op1_type, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC); + } else if (UNEXPECTED(variable_ptr == &EG(error_zval))) { if (IS_TMP_FREE(free_op_data1)) { zval_dtor(value); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } + FREE_OP_VAR_PTR(free_op_data2); } else { if ((opline+1)->op1_type == IS_TMP_VAR) { - value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_tmp_to_variable(variable_ptr, value TSRMLS_CC); } else if ((opline+1)->op1_type == IS_CONST) { - value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_const_to_variable(variable_ptr, value TSRMLS_CC); } else { - value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_to_variable(variable_ptr, value TSRMLS_CC); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(value); - EX_T(opline->result.var).var.ptr = value; + ZVAL_COPY(EX_VAR(opline->result.var), value); } + FREE_OP_VAR_PTR(free_op_data2); } - FREE_OP_VAR_PTR(free_op_data2); FREE_OP_IF_VAR(free_op_data1); } @@ -35185,46 +33984,33 @@ static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR USE_OPLINE zend_free_op free_op2; zval *value; - zval **variable_ptr_ptr; + zval *variable_ptr; SAVE_OPLINE(); value = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - variable_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); - - if (IS_CV == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) { - if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_TMP_VAR TSRMLS_CC)) { - if (RETURN_VALUE_USED(opline)) { - zval *retval; + variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); - ALLOC_ZVAL(retval); - ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1); - INIT_PZVAL(retval); - EX_T(opline->result.var).var.ptr = retval; - } - } else if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - } - } else if (IS_CV == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) { + zend_assign_to_string_offset(variable_ptr, value, IS_TMP_VAR, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC); + } else if (IS_CV == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) { if (1) { zval_dtor(value); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } } else { if (IS_TMP_VAR == IS_TMP_VAR) { - value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_tmp_to_variable(variable_ptr, value TSRMLS_CC); } else if (IS_TMP_VAR == IS_CONST) { - value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_const_to_variable(variable_ptr, value TSRMLS_CC); } else { - value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_to_variable(variable_ptr, value TSRMLS_CC); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(value); - EX_T(opline->result.var).var.ptr = value; + ZVAL_COPY(EX_VAR(opline->result.var), value); } + } /* zend_assign_to_variable() always takes care of op2, never free it! */ @@ -35237,10 +34023,9 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_ { USE_OPLINE zval *function_name; - char *function_name_strval; - int function_name_strlen; zend_free_op free_op2; call_slot *call = EX(call_slots) + opline->result.num; + zval *object; SAVE_OPLINE(); @@ -35254,33 +34039,30 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_ zend_error_noreturn(E_ERROR, "Method name must be a string"); } - function_name_strval = Z_STRVAL_P(function_name); - function_name_strlen = Z_STRLEN_P(function_name); - - call->object = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); + object = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); + call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL; - if (EXPECTED(call->object != NULL) && - EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) { - call->called_scope = Z_OBJCE_P(call->object); + if (EXPECTED(call->object != NULL)) { + call->called_scope = zend_get_class_entry(call->object TSRMLS_CC); if (IS_TMP_VAR != IS_CONST || - (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) { - zval *object = call->object; + (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope)) == NULL) { + zend_object *object = call->object; - if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) { + if (UNEXPECTED(object->handlers->get_method == NULL)) { zend_error_noreturn(E_ERROR, "Object does not support method calls"); } /* First, locate the function. */ - call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); + call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); if (UNEXPECTED(call->fbc == NULL)) { - zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval); + zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name)); } if (IS_TMP_VAR == IS_CONST && EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) && EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) && EXPECTED(call->object == object)) { - CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc); + CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope, call->fbc); } } } else { @@ -35288,21 +34070,13 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_ zval_dtor(free_op2.var); HANDLE_EXCEPTION(); } - zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval); + zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", Z_STRVAL_P(function_name)); } if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) { call->object = NULL; } else { - if (!PZVAL_IS_REF(call->object)) { - Z_ADDREF_P(call->object); /* For $this pointer */ - } else { - zval *this_ptr; - ALLOC_ZVAL(this_ptr); - INIT_PZVAL_COPY(this_ptr, call->object); - zval_copy_ctor(this_ptr); - call->object = this_ptr; - } + GC_REFCOUNT(call->object)++; /* For $this pointer */ } call->num_additional_args = 0; @@ -35319,11 +34093,12 @@ static int ZEND_FASTCALL ZEND_CASE_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS { USE_OPLINE zend_free_op free_op2; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - is_equal_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + fast_equal_function(result, + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op2.var); CHECK_EXCEPTION(); @@ -35334,35 +34109,31 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE { USE_OPLINE - zval *expr_ptr; + zval *expr_ptr, new_expr; SAVE_OPLINE(); - if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) { - zval **expr_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); - - if (IS_CV == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) { + if ((IS_CV == IS_VAR || IS_CV == IS_CV) && + (opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) { + expr_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets"); } - SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); - expr_ptr = *expr_ptr_ptr; + SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr); Z_ADDREF_P(expr_ptr); + } else { - expr_ptr=_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); + expr_ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); if (0) { /* temporary variable */ - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - } else if (IS_CV == IS_CONST || PZVAL_IS_REF(expr_ptr)) { - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - zendi_zval_copy_ctor(*expr_ptr); + ZVAL_COPY_VALUE(&new_expr, expr_ptr); + expr_ptr = &new_expr; + } else if (IS_CV == IS_CONST) { + ZVAL_DUP(&new_expr, expr_ptr); + expr_ptr = &new_expr; + } else if (Z_ISREF_P(expr_ptr)) { + ZVAL_DUP(&new_expr, Z_REFVAL_P(expr_ptr)); + expr_ptr = &new_expr; - } else if (IS_CV == IS_CV) { + } else if (IS_CV == IS_CV && Z_REFCOUNTED_P(expr_ptr)) { Z_ADDREF_P(expr_ptr); } } @@ -35370,42 +34141,49 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE if (IS_TMP_VAR != IS_UNUSED) { zend_free_op free_op2; zval *offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + zend_string *str; ulong hval; +add_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: hval = zend_dval_to_lval(Z_DVAL_P(offset)); goto num_index; case IS_LONG: - case IS_BOOL: hval = Z_LVAL_P(offset); num_index: - zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL); + zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); break; case IS_STRING: - if (IS_TMP_VAR == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); + str = Z_STR_P(offset); + if (IS_TMP_VAR != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index); } - zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL); +str_index: + zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); break; case IS_NULL: - zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); + str = STR_EMPTY_ALLOC(); + goto str_index; + case IS_FALSE: + hval = 0; + goto num_index; + case IS_TRUE: + hval = 1; + goto num_index; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto add_again; break; default: zend_error(E_WARNING, "Illegal offset type"); - zval_ptr_dtor(&expr_ptr); + zval_ptr_dtor(expr_ptr); /* do nothing */ break; } zval_dtor(free_op2.var); } else { - zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL); - } - if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) { - + zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -35413,9 +34191,26 @@ num_index: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { + zval *array; + zend_uint size; USE_OPLINE - array_init(&EX_T(opline->result.var).tmp_var); + array = EX_VAR(opline->result.var); + if (IS_CV != IS_UNUSED) { + size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; + } else { + size = 0; + } + ZVAL_NEW_ARR(array); + zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); + + if (IS_CV != IS_UNUSED) { + /* Explicitly initialize array as not-packed if flag is set */ + if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) { + zend_hash_real_init(Z_ARRVAL_P(array), 0); + } + } + if (IS_CV == IS_UNUSED) { ZEND_VM_NEXT_OPCODE(); #if 0 || IS_CV != IS_UNUSED @@ -35429,91 +34224,98 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER { USE_OPLINE zend_free_op free_op2; - zval **container; + zval *container; zval *offset; ulong hval; SAVE_OPLINE(); - container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC); - if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) { + container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC); + if (IS_CV != IS_UNUSED) { SEPARATE_ZVAL_IF_NOT_REF(container); } offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (IS_CV != IS_VAR || container) { - switch (Z_TYPE_PP(container)) { - case IS_ARRAY: { - HashTable *ht = Z_ARRVAL_PP(container); - - switch (Z_TYPE_P(offset)) { - case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); - zend_hash_index_del(ht, hval); - break; - case IS_RESOURCE: - case IS_BOOL: - case IS_LONG: - hval = Z_LVAL_P(offset); - zend_hash_index_del(ht, hval); - break; - case IS_STRING: - if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { - Z_ADDREF_P(offset); - } - if (IS_TMP_VAR == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); - } - if (ht == &EG(symbol_table)) { - zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC); - } else { - zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval); - } - if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { - zval_ptr_dtor(&offset); - } - break; +container_again: + switch (Z_TYPE_P(container)) { + case IS_ARRAY: { + HashTable *ht = Z_ARRVAL_P(container); +offset_again: + switch (Z_TYPE_P(offset)) { + case IS_DOUBLE: + hval = zend_dval_to_lval(Z_DVAL_P(offset)); + zend_hash_index_del(ht, hval); + break; + case IS_LONG: + hval = Z_LVAL_P(offset); num_index_dim: - zend_hash_index_del(ht, hval); - if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { - zval_ptr_dtor(&offset); - } - break; - case IS_NULL: - zend_hash_del(ht, "", sizeof("")); - break; - default: - zend_error(E_WARNING, "Illegal offset type in unset"); - break; - } - zval_dtor(free_op2.var); - break; + zend_hash_index_del(ht, hval); + break; + case IS_STRING: + if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { + if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset); + } + if (IS_TMP_VAR != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto numeric_index_dim); + } + if (ht == &EG(symbol_table).ht) { + zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC); + } else { + zend_hash_del(ht, Z_STR_P(offset)); + } + if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { + zval_ptr_dtor(offset); + } + break; +numeric_index_dim: + zend_hash_index_del(ht, hval); + if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { + zval_ptr_dtor(offset); + } + break; + case IS_NULL: + zend_hash_del(ht, STR_EMPTY_ALLOC()); + break; + case IS_FALSE: + hval = 0; + goto num_index_dim; + case IS_TRUE: + hval = 1; + goto num_index_dim; + case IS_RESOURCE: + hval = Z_RES_HANDLE_P(offset); + goto num_index_dim; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto offset_again; + break; + default: + zend_error(E_WARNING, "Illegal offset type in unset"); + break; } - case IS_OBJECT: - if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use object as array"); - } - if (1) { - MAKE_REAL_ZVAL_PTR(offset); - } - Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC); - if (1) { - zval_ptr_dtor(&offset); - } else { - zval_dtor(free_op2.var); - } - break; - case IS_STRING: - zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); - ZEND_VM_CONTINUE(); /* bailed out before */ - default: - zval_dtor(free_op2.var); - break; + zval_dtor(free_op2.var); + break; } - } else { - zval_dtor(free_op2.var); + case IS_OBJECT: + if (UNEXPECTED(Z_OBJ_HT_P(container)->unset_dimension == NULL)) { + zend_error_noreturn(E_ERROR, "Cannot use object as array"); + } +//??? if (IS_TMP_VAR == IS_CONST) { +//??? zval_copy_ctor(offset); +//??? } + Z_OBJ_HT_P(container)->unset_dimension(container, offset TSRMLS_CC); + zval_dtor(free_op2.var); + break; + case IS_STRING: + case IS_STR_OFFSET: + zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); + ZEND_VM_CONTINUE(); /* bailed out before */ + case IS_REFERENCE: + container = Z_REFVAL_P(container); + goto container_again; + break; + default: + zval_dtor(free_op2.var); + break; } CHECK_EXCEPTION(); @@ -35524,90 +34326,82 @@ static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER { USE_OPLINE zend_free_op free_op2; - zval **container; + zval *container; zval *offset; SAVE_OPLINE(); - container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC); + if (IS_CV == IS_VAR && Z_TYPE_P(container) == IS_STR_OFFSET) { + zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); + } offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (IS_CV != IS_VAR || container) { - if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(container); - } - if (Z_TYPE_PP(container) == IS_OBJECT) { - if (1) { - MAKE_REAL_ZVAL_PTR(offset); - } - if (Z_OBJ_HT_P(*container)->unset_property) { - Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to unset property of non-object"); - } - if (1) { - zval_ptr_dtor(&offset); - } else { - zval_dtor(free_op2.var); - } + ZVAL_DEREF(container); + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->unset_property) { + Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); } else { - zval_dtor(free_op2.var); + zend_error(E_NOTICE, "Trying to unset property of non-object"); } - } else { - zval_dtor(free_op2.var); } + zval_dtor(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_TMP(int prop_dim, ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_free_op free_op2; zval *container; - zval **value = NULL; - int result = 0; + int result; ulong hval; zval *offset; SAVE_OPLINE(); - container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_deref_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC); offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) { - HashTable *ht; - int isset = 0; - - ht = Z_ARRVAL_P(container); + if (Z_TYPE_P(container) == IS_ARRAY) { + HashTable *ht = Z_ARRVAL_P(container); + zval *value = NULL; + zend_string *str; +isset_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: hval = zend_dval_to_lval(Z_DVAL_P(offset)); goto num_index_prop; - case IS_RESOURCE: - case IS_BOOL: case IS_LONG: hval = Z_LVAL_P(offset); num_index_prop: - if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) { - isset = 1; - } + value = zend_hash_index_find(ht, hval); break; case IS_STRING: - if (IS_TMP_VAR == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); - } - if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) { - isset = 1; + str = Z_STR_P(offset); + if (IS_TMP_VAR != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index_prop); } +str_index_prop: + value = zend_hash_find_ind(ht, str); break; case IS_NULL: - if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) { - isset = 1; - } + str = STR_EMPTY_ALLOC(); + goto str_index_prop; + break; + case IS_FALSE: + hval = 0; + goto num_index_prop; + case IS_TRUE: + hval = 0; + goto num_index_prop; + case IS_RESOURCE: + hval = Z_RES_HANDLE_P(offset); + goto num_index_prop; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto isset_again; break; default: zend_error(E_WARNING, "Illegal offset type in isset or empty"); @@ -35615,116 +34409,105 @@ num_index_prop: } if (opline->extended_value & ZEND_ISSET) { - if (isset && Z_TYPE_PP(value) == IS_NULL) { - result = 0; - } else { - result = isset; - } + /* > IS_NULL means not IS_UNDEF and not IS_NULL */ + result = (value != NULL && Z_TYPE_P(value) > IS_NULL); } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { - if (!isset || !i_zend_is_true(*value TSRMLS_CC)) { - result = 0; - } else { - result = 1; - } + result = (value == NULL || !i_zend_is_true(value TSRMLS_CC)); } - zval_dtor(free_op2.var); } else if (Z_TYPE_P(container) == IS_OBJECT) { - if (1) { - MAKE_REAL_ZVAL_PTR(offset); - } - if (prop_dim) { - if (Z_OBJ_HT_P(container)->has_property) { - result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check property of non-object"); - result = 0; - } + if (Z_OBJ_HT_P(container)->has_dimension) { + result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); } else { - if (Z_OBJ_HT_P(container)->has_dimension) { - result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check element of non-array"); - result = 0; - } + zend_error(E_NOTICE, "Trying to check element of non-array"); + result = 0; } - if (1) { - zval_ptr_dtor(&offset); - } else { - zval_dtor(free_op2.var); + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; } - } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */ + } else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */ zval tmp; - if (Z_TYPE_P(offset) != IS_LONG) { - if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */ + result = 0; + if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) { + if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */ || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { - ZVAL_COPY_VALUE(&tmp, offset); - zval_copy_ctor(&tmp); + ZVAL_DUP(&tmp, offset); convert_to_long(&tmp); offset = &tmp; - } else { - /* can not be converted to proper offset, return "not set" */ - result = 0; } } if (Z_TYPE_P(offset) == IS_LONG) { - if (opline->extended_value & ZEND_ISSET) { - if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { - result = 1; - } - } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { - if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') { + if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { + if ((opline->extended_value & ZEND_ISSET) || + Z_STRVAL_P(container)[offset->value.lval] != '0') { result = 1; } } } - zval_dtor(free_op2.var); + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } } else { - zval_dtor(free_op2.var); + result = ((opline->extended_value & ZEND_ISSET) == 0); } - Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; - if (opline->extended_value & ZEND_ISSET) { - Z_LVAL(EX_T(opline->result.var).tmp_var) = result; - } else { - Z_LVAL(EX_T(opline->result.var).tmp_var) = !result; - } + zval_dtor(free_op2.var); + ZVAL_BOOL(EX_VAR(opline->result.var), result); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_TMP(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} - static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_TMP(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + zend_free_op free_op2; + zval *container; + int result; + zval *offset; + + SAVE_OPLINE(); + container = _get_zval_ptr_cv_deref_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC); + offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->has_property) { + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); + } else { + zend_error(E_NOTICE, "Trying to check property of non-object"); + result = 0; + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else { + result = ((opline->extended_value & ZEND_ISSET) == 0); + } + + zval_dtor(free_op2.var); + ZVAL_BOOL(EX_VAR(opline->result.var), result); + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_YIELD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - /* The generator object is stored in return_value_ptr_ptr */ - zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr); + /* The generator object is stored in EX(return_value) */ + zend_generator *generator = (zend_generator *) EX(return_value); if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) { zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator"); } /* Destroy the previously yielded value */ - if (generator->value) { - zval_ptr_dtor(&generator->value); - } + zval_ptr_dtor(&generator->value); /* Destroy the previously yielded key */ - if (generator->key) { - zval_ptr_dtor(&generator->key); - } + zval_ptr_dtor(&generator->key); /* Set the new yielded value */ if (IS_CV != IS_UNUSED) { @@ -35734,74 +34517,58 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG /* Constants and temporary variables aren't yieldable by reference, * but we still allow them with a notice. */ if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) { - zval *value, *copy; + zval *value; zend_error(E_NOTICE, "Only variable references should be yielded by reference"); value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); + ZVAL_COPY_VALUE(&generator->value, value); + if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1); /* Temporary variables don't need ctor copying */ if (!0) { - zval_copy_ctor(copy); + zval_copy_ctor(&generator->value); } - - generator->value = copy; } else { - zval **value_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); - if (IS_CV == IS_VAR && UNEXPECTED(value_ptr == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference"); } /* If a function call result is yielded and the function did * not return by reference we throw a notice. */ - if (IS_CV == IS_VAR && !Z_ISREF_PP(value_ptr) + if (IS_CV == IS_VAR && !Z_ISREF_P(value_ptr) && !(opline->extended_value == ZEND_RETURNS_FUNCTION - && EX_T(opline->op1.var).var.fcall_returned_reference) - && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) { + && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); - - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } else { SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr); - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } + ZVAL_COPY(&generator->value, value_ptr); } } else { zval *value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); /* Consts, temporary variables and references need copying */ - if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR - || PZVAL_IS_REF(value) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); - - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } - - generator->value = copy; + if (IS_CV == IS_CONST) { + ZVAL_DUP(&generator->value, value); + } else if (IS_CV == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->value, value); + } else if (Z_ISREF_P(value)) { + ZVAL_DUP(&generator->value, Z_REFVAL_P(value)); } else { if (IS_CV == IS_CV) { - Z_ADDREF_P(value); + if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value); } - generator->value = value; + ZVAL_COPY_VALUE(&generator->value, value); } } } else { /* If no value was specified yield null */ - Z_ADDREF(EG(uninitialized_zval)); - generator->value = &EG(uninitialized_zval); + ZVAL_NULL(&generator->value); } /* Set the new yielded key */ @@ -35810,45 +34577,36 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); /* Consts, temporary variables and references need copying */ - if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR - || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, key); - - /* Temporary variables don't need ctor copying */ - if (!1) { - zval_copy_ctor(copy); - } + if (IS_TMP_VAR == IS_CONST) { + ZVAL_DUP(&generator->key, key); + } else if (IS_TMP_VAR == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->key, key); + } else if (Z_ISREF_P(key)) { + ZVAL_DUP(&generator->key, Z_REFVAL_P(key)); - generator->key = copy; } else { - Z_ADDREF_P(key); - generator->key = key; + if (IS_TMP_VAR == IS_CV) { + if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key); + } + ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE_P(generator->key) == IS_LONG - && Z_LVAL_P(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_LONG + && Z_LVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL_P(generator->key); + generator->largest_used_integer_key = Z_LVAL(generator->key); } - } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - - ALLOC_INIT_ZVAL(generator->key); - ZVAL_LONG(generator->key, generator->largest_used_integer_key); + ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ - generator->send_target = &EX_T(opline->result.var).var.ptr; - Z_ADDREF(EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + generator->send_target = EX_VAR(opline->result.var); + ZVAL_NULL(generator->send_target); } else { generator->send_target = NULL; } @@ -35870,8 +34628,8 @@ static int ZEND_FASTCALL ZEND_POW_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op2; SAVE_OPLINE(); - pow_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + pow_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); zval_dtor(free_op2.var); @@ -35890,11 +34648,11 @@ static int ZEND_FASTCALL ZEND_ADD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op2; SAVE_OPLINE(); - fast_add_function(&EX_T(opline->result.var).tmp_var, + fast_add_function(EX_VAR(opline->result.var), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -35905,11 +34663,11 @@ static int ZEND_FASTCALL ZEND_SUB_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op2; SAVE_OPLINE(); - fast_sub_function(&EX_T(opline->result.var).tmp_var, + fast_sub_function(EX_VAR(opline->result.var), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -35920,11 +34678,11 @@ static int ZEND_FASTCALL ZEND_MUL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op2; SAVE_OPLINE(); - fast_mul_function(&EX_T(opline->result.var).tmp_var, + fast_mul_function(EX_VAR(opline->result.var), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -35935,11 +34693,11 @@ static int ZEND_FASTCALL ZEND_DIV_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op2; SAVE_OPLINE(); - fast_div_function(&EX_T(opline->result.var).tmp_var, + fast_div_function(EX_VAR(opline->result.var), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -35950,11 +34708,11 @@ static int ZEND_FASTCALL ZEND_MOD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op2; SAVE_OPLINE(); - fast_mod_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + fast_mod_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -35965,11 +34723,11 @@ static int ZEND_FASTCALL ZEND_SL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op2; SAVE_OPLINE(); - shift_left_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + shift_left_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -35980,11 +34738,11 @@ static int ZEND_FASTCALL ZEND_SR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op2; SAVE_OPLINE(); - shift_right_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + shift_right_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -35995,11 +34753,11 @@ static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR zend_free_op free_op2; SAVE_OPLINE(); - concat_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + concat_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -36010,11 +34768,11 @@ static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HAND zend_free_op free_op2; SAVE_OPLINE(); - is_identical_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + fast_is_identical_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -36023,15 +34781,14 @@ static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_ { USE_OPLINE zend_free_op free_op2; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - is_identical_function(result, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - Z_LVAL_P(result) = !Z_LVAL_P(result); + fast_is_not_identical_function(result, + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -36040,14 +34797,14 @@ static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ { USE_OPLINE zend_free_op free_op2; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_equal_function(result, + fast_equal_function(result, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -36056,14 +34813,14 @@ static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HAND { USE_OPLINE zend_free_op free_op2; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_not_equal_function(result, + fast_not_equal_function(result, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -36072,14 +34829,14 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLE { USE_OPLINE zend_free_op free_op2; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_is_smaller_function(result, + fast_is_smaller_function(result, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -36088,14 +34845,14 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_VAR_HANDLER(ZEND_OPCO { USE_OPLINE zend_free_op free_op2; - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, + fast_is_smaller_or_equal_function(result, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -36106,11 +34863,11 @@ static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG zend_free_op free_op2; SAVE_OPLINE(); - bitwise_or_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + bitwise_or_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -36121,11 +34878,11 @@ static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR zend_free_op free_op2; SAVE_OPLINE(); - bitwise_and_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + bitwise_and_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -36136,11 +34893,11 @@ static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR zend_free_op free_op2; SAVE_OPLINE(); - bitwise_xor_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + bitwise_xor_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -36151,11 +34908,11 @@ static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ zend_free_op free_op2; SAVE_OPLINE(); - boolean_xor_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + boolean_xor_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -36164,100 +34921,87 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_VAR(int (*bina { USE_OPLINE zend_free_op free_op2, free_op_data1; - zval **object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); - zval *object; + zval *object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); zval *property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); + zval *value; int have_get_ptr = 0; - if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - make_real_object(object_ptr TSRMLS_CC); - object = *object_ptr; + object = make_real_object(object TSRMLS_CC); + + value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { zend_error(E_WARNING, "Attempt to assign property of non-object"); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); FREE_OP(free_op_data1); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } } else { /* here we are sure we are dealing with an object */ - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - - /* here property is a string */ if (opline->extended_value == ZEND_ASSIGN_OBJ && Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); if (zptr != NULL) { /* NULL means no success in getting PTR */ SEPARATE_ZVAL_IF_NOT_REF(zptr); have_get_ptr = 1; - binary_op(*zptr, *zptr, value TSRMLS_CC); + binary_op(zptr, zptr, value TSRMLS_CC); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(*zptr); - EX_T(opline->result.var).var.ptr = *zptr; + ZVAL_COPY(EX_VAR(opline->result.var), zptr); } } } if (!have_get_ptr) { zval *z = NULL; + zval rv; if (opline->extended_value == ZEND_ASSIGN_OBJ) { if (Z_OBJ_HT_P(object)->read_property) { - z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC); } } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { if (Z_OBJ_HT_P(object)->read_dimension) { - z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC); + z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R, &rv TSRMLS_CC); } } if (z) { if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); zval_dtor(z); - FREE_ZVAL(z); } - z = value; + ZVAL_COPY_VALUE(z, value); } - Z_ADDREF_P(z); - SEPARATE_ZVAL_IF_NOT_REF(&z); +//??? if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); + SEPARATE_ZVAL_IF_NOT_REF(z); binary_op(z, z, value TSRMLS_CC); if (opline->extended_value == ZEND_ASSIGN_OBJ) { - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(z); - EX_T(opline->result.var).var.ptr = z; + ZVAL_COPY(EX_VAR(opline->result.var), z); } - zval_ptr_dtor(&z); + zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to assign property of non-object"); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } } } - if (0) { - zval_ptr_dtor(&property); - } else { - zval_ptr_dtor_nogc(&free_op2.var); - } + zval_ptr_dtor_nogc(free_op2.var); FREE_OP(free_op_data1); } @@ -36267,179 +35011,288 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_VAR(int (*bina ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_CV_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_free_op free_op2, free_op_data2, free_op_data1; - zval **var_ptr; - zval *value; + zval *var_ptr; + zval *value, *container; SAVE_OPLINE(); - switch (opline->extended_value) { - case ZEND_ASSIGN_OBJ: - return zend_binary_assign_op_obj_helper_SPEC_CV_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - break; - case ZEND_ASSIGN_DIM: { - zval **container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); - - if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); - } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) { - if (IS_CV == IS_VAR && !0) { - Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */ - } - return zend_binary_assign_op_obj_helper_SPEC_CV_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - } else { - zval *dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { + zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); + } else if (UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { + if (IS_CV == IS_VAR && !0) { + Z_ADDREF_P(container); /* undo the effect of get_obj_zval_ptr_ptr() */ + } + return zend_binary_assign_op_obj_helper_SPEC_CV_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else { + zval *dim = _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_VAR, BP_VAR_RW TSRMLS_CC); - value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); - var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); - } - } - break; - default: - value = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); - /* do nothing */ - break; + zend_fetch_dimension_address_RW(EX_VAR((opline+1)->op2.var), container, dim, IS_VAR TSRMLS_CC); + value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); + var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); } - if (UNEXPECTED(var_ptr == NULL)) { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); } - if (UNEXPECTED(*var_ptr == &EG(error_zval))) { - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + if (UNEXPECTED(var_ptr == &EG(error_zval))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); } - zval_ptr_dtor_nogc(&free_op2.var); - - CHECK_EXCEPTION(); - if (opline->extended_value == ZEND_ASSIGN_DIM) { - ZEND_VM_INC_OPCODE(); - } - ZEND_VM_NEXT_OPCODE(); + goto assign_op_dim_exit; } SEPARATE_ZVAL_IF_NOT_REF(var_ptr); + ZVAL_DEREF(var_ptr); - if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) - && Z_OBJ_HANDLER_PP(var_ptr, get) - && Z_OBJ_HANDLER_PP(var_ptr, set)) { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) && + UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) { /* proxy object */ - zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); + zval rv; + zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC); Z_ADDREF_P(objval); binary_op(objval, objval, value TSRMLS_CC); - Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC); - zval_ptr_dtor(&objval); + Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); + zval_ptr_dtor(objval); } else { - binary_op(*var_ptr, *var_ptr, value TSRMLS_CC); + binary_op(var_ptr, var_ptr, value TSRMLS_CC); } - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(*var_ptr); - EX_T(opline->result.var).var.ptr = *var_ptr; + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } - zval_ptr_dtor_nogc(&free_op2.var); - if (opline->extended_value == ZEND_ASSIGN_DIM) { - FREE_OP(free_op_data1); - FREE_OP_VAR_PTR(free_op_data2); +assign_op_dim_exit: + zval_ptr_dtor_nogc(free_op2.var); + FREE_OP(free_op_data1); + FREE_OP_VAR_PTR(free_op_data2); - CHECK_EXCEPTION(); - ZEND_VM_INC_OPCODE(); + CHECK_EXCEPTION(); + ZEND_VM_INC_OPCODE(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_free_op free_op2; + zval *var_ptr; + zval *value; + + SAVE_OPLINE(); + value = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + var_ptr = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); + + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { + zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); + } + + if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } + goto assign_op_exit; + } + + SEPARATE_ZVAL_IF_NOT_REF(var_ptr); + ZVAL_DEREF(var_ptr); + + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) && + UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) { + /* proxy object */ + zval rv; + zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC); + Z_ADDREF_P(objval); + binary_op(objval, objval, value TSRMLS_CC); + Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); + zval_ptr_dtor(objval); } else { + binary_op(var_ptr, var_ptr, value TSRMLS_CC); + } - CHECK_EXCEPTION(); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } + +assign_op_exit: + zval_ptr_dtor_nogc(free_op2.var); + + CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_VAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_VAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_VAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_VAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_VAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_VAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_VAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_VAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_VAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_VAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_VAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_VAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_VAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_VAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_VAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_VAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_VAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_VAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_VAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_VAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_VAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_VAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_VAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_VAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_VAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_VAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_VAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_VAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_VAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_VAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_VAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_VAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_VAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_VAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_VAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_VAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_VAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_VAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_VAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_VAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_VAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_VAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_VAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_VAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_VAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_free_op free_op2; - zval **object_ptr; zval *object; zval *property; - zval **retval; + zval *retval; int have_get_ptr = 0; SAVE_OPLINE(); - object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); + object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - retval = &EX_T(opline->result.var).var.ptr; + retval = EX_VAR(opline->result.var); - if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } - make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ - object = *object_ptr; + object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */ if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - *retval = &EG(uninitialized_zval); + ZVAL_NULL(retval); } CHECK_EXCEPTION(); @@ -36448,59 +35301,50 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_VAR(incdec_t in /* here we are sure we are dealing with an object */ - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); if (zptr != NULL) { /* NULL means no success in getting PTR */ SEPARATE_ZVAL_IF_NOT_REF(zptr); have_get_ptr = 1; - incdec_op(*zptr); + incdec_op(zptr); if (RETURN_VALUE_USED(opline)) { - *retval = *zptr; - PZVAL_LOCK(*retval); + ZVAL_COPY(retval, zptr); } } } if (!have_get_ptr) { + zval rv; + if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC); if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); zval_dtor(z); - FREE_ZVAL(z); } - z = value; + ZVAL_COPY_VALUE(z, value); } - Z_ADDREF_P(z); - SEPARATE_ZVAL_IF_NOT_REF(&z); + if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); + SEPARATE_ZVAL_IF_NOT_REF(z); incdec_op(z); - *retval = z; - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - SELECTIVE_PZVAL_LOCK(*retval, opline); - zval_ptr_dtor(&z); + ZVAL_COPY_VALUE(retval, z); + Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); + SELECTIVE_PZVAL_LOCK(retval, opline); + zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - *retval = &EG(uninitialized_zval); + ZVAL_NULL(retval); } } } - if (0) { - zval_ptr_dtor(&property); - } else { - zval_ptr_dtor_nogc(&free_op2.var); - } + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -36520,27 +35364,25 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_VAR(incdec_t i { USE_OPLINE zend_free_op free_op2; - zval **object_ptr; zval *object; zval *property; zval *retval; int have_get_ptr = 0; SAVE_OPLINE(); - object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); + object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - retval = &EX_T(opline->result.var).tmp_var; + retval = EX_VAR(opline->result.var); - if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } - make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ - object = *object_ptr; + object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */ if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); ZVAL_NULL(retval); CHECK_EXCEPTION(); @@ -36549,60 +35391,48 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_VAR(incdec_t i /* here we are sure we are dealing with an object */ - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); if (zptr != NULL) { /* NULL means no success in getting PTR */ have_get_ptr = 1; SEPARATE_ZVAL_IF_NOT_REF(zptr); - ZVAL_COPY_VALUE(retval, *zptr); - zendi_zval_copy_ctor(*retval); + ZVAL_DUP(retval, zptr); - incdec_op(*zptr); + incdec_op(zptr); } } if (!have_get_ptr) { if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - zval *z_copy; + zval rv; + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC); + zval z_copy; if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); zval_dtor(z); - FREE_ZVAL(z); } - z = value; + ZVAL_COPY_VALUE(z, value); } - ZVAL_COPY_VALUE(retval, z); - zendi_zval_copy_ctor(*retval); - ALLOC_ZVAL(z_copy); - INIT_PZVAL_COPY(z_copy, z); - zendi_zval_copy_ctor(*z_copy); - incdec_op(z_copy); - Z_ADDREF_P(z); - Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + ZVAL_DUP(retval, z); + ZVAL_DUP(&z_copy, z); + incdec_op(&z_copy); + if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); + Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); zval_ptr_dtor(&z_copy); - zval_ptr_dtor(&z); + zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); ZVAL_NULL(retval); } } - if (0) { - zval_ptr_dtor(&property); - } else { - zval_ptr_dtor_nogc(&free_op2.var); - } + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -36621,21 +35451,18 @@ static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HAND static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_VAR(int type, ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_free_op free_op1; + zval *varname; - zval **retval; + zval *retval; zval tmp_varname; HashTable *target_symbol_table; - ulong hash_value; SAVE_OPLINE(); varname = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); + ZVAL_UNDEF(&tmp_varname); if (IS_CV != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) { - ZVAL_COPY_VALUE(&tmp_varname, varname); - zval_copy_ctor(&tmp_varname); - Z_SET_REFCOUNT(tmp_varname, 1); - Z_UNSET_ISREF(tmp_varname); + ZVAL_DUP_DEREF(&tmp_varname, varname); convert_to_string(&tmp_varname); varname = &tmp_varname; } @@ -36644,105 +35471,88 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_VAR(int type, ZEN zend_class_entry *ce; if (IS_VAR == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { - if (IS_CV != IS_CONST && varname == &tmp_varname) { + if (IS_CV != IS_CONST) { zval_dtor(&tmp_varname); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(opline->op2.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); } } else { - ce = EX_T(opline->op2.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op2.var)); } - retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); + retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC); } else { target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); -/* - if (!target_symbol_table) { - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); - } -*/ - if (IS_CV == IS_CONST) { - hash_value = Z_HASH_P(varname); - } else { - hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname)); - } - - if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) { + retval = zend_hash_find(target_symbol_table, Z_STR_P(varname)); + if (retval == NULL) { switch (type) { case BP_VAR_R: case BP_VAR_UNSET: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); /* break missing intentionally */ case BP_VAR_IS: - retval = &EG(uninitialized_zval_ptr); + retval = EX_VAR(opline->result.var); + ZVAL_NULL(retval); break; case BP_VAR_RW: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); /* break missing intentionally */ case BP_VAR_W: - Z_ADDREF_P(&EG(uninitialized_zval)); - zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval); + retval = zend_hash_update(target_symbol_table, Z_STR_P(varname), &EG(uninitialized_zval)); break; EMPTY_SWITCH_DEFAULT_CASE() } - } - switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) { - case ZEND_FETCH_GLOBAL: - if (IS_CV != IS_TMP_VAR) { - + /* GLOBAL or $$name variable may be an INDIRECT pointer to CV */ + } else if (Z_TYPE_P(retval) == IS_INDIRECT) { + retval = Z_INDIRECT_P(retval); + if (Z_TYPE_P(retval) == IS_UNDEF) { + switch (type) { + case BP_VAR_R: + case BP_VAR_UNSET: + zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); + /* break missing intentionally */ + case BP_VAR_IS: + retval = EX_VAR(opline->result.var); + ZVAL_NULL(retval); + break; + case BP_VAR_RW: + zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); + /* break missing intentionally */ + case BP_VAR_W: + ZVAL_NULL(retval); + break; + EMPTY_SWITCH_DEFAULT_CASE() } - break; - case ZEND_FETCH_LOCAL: + } + } + if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC) { + zval_update_constant(retval, 1 TSRMLS_CC); + } else if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) != ZEND_FETCH_GLOBAL_LOCK) { - break; - case ZEND_FETCH_STATIC: - zval_update_constant(retval, 1 TSRMLS_CC); - break; - case ZEND_FETCH_GLOBAL_LOCK: - if (IS_CV == IS_VAR && !free_op1.var) { - PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); - } - break; } } - - if (IS_CV != IS_CONST && varname == &tmp_varname) { + if (IS_CV != IS_CONST) { zval_dtor(&tmp_varname); } - if (opline->extended_value & ZEND_FETCH_MAKE_REF) { - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval); - } - PZVAL_LOCK(*retval); - switch (type) { - case BP_VAR_R: - case BP_VAR_IS: - EX_T(opline->result.var).var.ptr = *retval; - break; - case BP_VAR_UNSET: { - zend_free_op free_res; - PZVAL_UNLOCK(*retval, &free_res); - if (retval != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(retval); - } - PZVAL_LOCK(*retval); - FREE_OP_VAR_PTR(free_res); + ZEND_ASSERT(retval != NULL); + if (type == BP_VAR_R || type == BP_VAR_IS) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); + } else { + if (/*type == BP_VAR_W &&*/ (opline->extended_value & ZEND_FETCH_MAKE_REF)) { + SEPARATE_ZVAL_TO_MAKE_IS_REF(retval); } - /* break missing intentionally */ - default: - EX_T(opline->result.var).var.ptr_ptr = retval; - break; + ZVAL_INDIRECT(EX_VAR(opline->result.var), retval); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -36767,7 +35577,11 @@ static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HA { USE_OPLINE - return zend_fetch_var_address_helper_SPEC_CV_VAR(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { + return zend_fetch_var_address_helper_SPEC_CV_VAR(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else { + return zend_fetch_var_address_helper_SPEC_CV_VAR(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -36788,8 +35602,8 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDL SAVE_OPLINE(); container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); - zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC); + zval_ptr_dtor_nogc(free_op2.var); if (IS_CV != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) { } @@ -36801,29 +35615,22 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDL { USE_OPLINE zend_free_op free_op1, free_op2; - zval **container; + zval *container; SAVE_OPLINE(); - container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); - if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_W TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); - if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + if (EXPECTED(opline->extended_value == 0)) { + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC); + } else { + zend_fetch_dimension_address_W_ref(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC); } - - /* We are going to assign the result by reference */ - if (UNEXPECTED(opline->extended_value != 0)) { - zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; - - if (retval_ptr) { - Z_DELREF_PP(retval_ptr); - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); - Z_ADDREF_PP(retval_ptr); - } + zval_ptr_dtor_nogc(free_op2.var); + if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } CHECK_EXCEPTION(); @@ -36834,18 +35641,18 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HAND { USE_OPLINE zend_free_op free_op1, free_op2; - zval **container; + zval *container; SAVE_OPLINE(); - container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); - if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_RW TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC); + zval_ptr_dtor_nogc(free_op2.var); if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } CHECK_EXCEPTION(); @@ -36860,8 +35667,8 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HAND SAVE_OPLINE(); container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC); - zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_IS TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -36870,30 +35677,29 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HAND static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE + zval *container; zend_free_op free_op1, free_op2; SAVE_OPLINE(); if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { - zval **container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_W TSRMLS_CC); + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC); if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); } else { - zval *container; - if (IS_VAR == IS_UNUSED) { zend_error_noreturn(E_ERROR, "Cannot use [] for reading"); } container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); - zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC); + zval_ptr_dtor_nogc(free_op2.var); } CHECK_EXCEPTION(); @@ -36904,41 +35710,22 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_H { USE_OPLINE zend_free_op free_op1, free_op2; - zval **container; + zval *container; SAVE_OPLINE(); - container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC); - if (IS_CV == IS_CV) { - if (container != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(container); - } - } - if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_UNSET TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC); + zval_ptr_dtor_nogc(free_op2.var); if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); - ZEND_VM_NEXT_OPCODE(); - } else { - zend_free_op free_res; - zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; - - PZVAL_UNLOCK(*retval_ptr, &free_res); - if (retval_ptr != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(retval_ptr); - } - PZVAL_LOCK(*retval_ptr); - FREE_OP_VAR_PTR(free_res); - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); - } + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_VAR(ZEND_OPCODE_HANDLER_ARGS) @@ -36950,35 +35737,26 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_VAR(ZEN zval *offset; SAVE_OPLINE(); - container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { zend_error(E_NOTICE, "Trying to get property of non-object"); - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - zval_ptr_dtor_nogc(&free_op2.var); + ZVAL_NULL(EX_VAR(opline->result.var)); } else { zval *retval; - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - /* here we are sure we are dealing with an object */ - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - - PZVAL_LOCK(retval); - EX_T(opline->result.var).var.ptr = retval; + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC); - if (0) { - zval_ptr_dtor(&offset); - } else { - zval_ptr_dtor_nogc(&free_op2.var); + if (retval != EX_VAR(opline->result.var)) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); } } + zval_ptr_dtor_nogc(free_op2.var); + CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -36993,38 +35771,20 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDL USE_OPLINE zend_free_op free_op1, free_op2; zval *property; - zval **container; + zval *container; SAVE_OPLINE(); property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); - if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { + container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property); - } else { - zval_ptr_dtor_nogc(&free_op2.var); - } + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC); + zval_ptr_dtor_nogc(free_op2.var); if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); - } - - /* We are going to assign the result by reference */ - if (opline->extended_value & ZEND_FETCH_MAKE_REF) { - zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; - - Z_DELREF_PP(retval_ptr); - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); - Z_ADDREF_PP(retval_ptr); - EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr; - EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } CHECK_EXCEPTION(); @@ -37036,26 +35796,19 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HAND USE_OPLINE zend_free_op free_op1, free_op2; zval *property; - zval **container; + zval *container; SAVE_OPLINE(); property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property); - } else { - zval_ptr_dtor_nogc(&free_op2.var); - } + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_RW, 0 TSRMLS_CC); + zval_ptr_dtor_nogc(free_op2.var); if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } CHECK_EXCEPTION(); @@ -37071,34 +35824,25 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HAND zval *offset; SAVE_OPLINE(); - container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_deref_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC); offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - zval_ptr_dtor_nogc(&free_op2.var); + ZVAL_NULL(EX_VAR(opline->result.var)); } else { zval *retval; - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - /* here we are sure we are dealing with an object */ - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - - PZVAL_LOCK(retval); - EX_T(opline->result.var).var.ptr = retval; + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC); - if (0) { - zval_ptr_dtor(&offset); - } else { - zval_ptr_dtor_nogc(&free_op2.var); + if (retval != EX_VAR(opline->result.var)) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); } } + zval_ptr_dtor_nogc(free_op2.var); + CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -37106,31 +35850,24 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HAND static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE + zval *container; if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { /* Behave like FETCH_OBJ_W */ zend_free_op free_op1, free_op2; zval *property; - zval **container; SAVE_OPLINE(); property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property); - } else { - zval_ptr_dtor_nogc(&free_op2.var); - } + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, 0 TSRMLS_CC); + zval_ptr_dtor_nogc(free_op2.var); if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } CHECK_EXCEPTION(); @@ -37143,41 +35880,22 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_VAR_HANDLER(ZEND_OPCOD static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_free_op free_op1, free_op2, free_res; - zval **container; - zval *property; + zend_free_op free_op1, free_op2; + zval *container, *property; SAVE_OPLINE(); - container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC); property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (IS_CV == IS_CV) { - if (container != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(container); - } - } - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property); - } else { - zval_ptr_dtor_nogc(&free_op2.var); - } + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_UNSET, 0 TSRMLS_CC); + zval_ptr_dtor_nogc(free_op2.var); if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res); - if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr); - } - PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr); - FREE_OP_VAR_PTR(free_res); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -37186,25 +35904,18 @@ static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLE { USE_OPLINE zend_free_op free_op2; - zval **object_ptr; + zval *object; zval *property_name; SAVE_OPLINE(); - object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + object = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (0) { - MAKE_REAL_ZVAL_PTR(property_name); - } - if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property_name); - } else { - zval_ptr_dtor_nogc(&free_op2.var); - } + zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op2.var); /* assign_obj has two opcodes! */ CHECK_EXCEPTION(); @@ -37216,74 +35927,57 @@ static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLE { USE_OPLINE - zval **object_ptr; + zval *object_ptr; SAVE_OPLINE(); - object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + object_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); - if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - if (Z_TYPE_PP(object_ptr) == IS_OBJECT) { + if (UNEXPECTED(Z_ISREF_P(object_ptr)) && Z_TYPE_P(Z_REFVAL_P(object_ptr)) == IS_OBJECT) { + object_ptr = Z_REFVAL_P(object_ptr); + } + if (Z_TYPE_P(object_ptr) == IS_OBJECT) { zend_free_op free_op2; zval *property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (0) { - MAKE_REAL_ZVAL_PTR(property_name); - } - zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property_name); - } else { - zval_ptr_dtor_nogc(&free_op2.var); - } + zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC); + zval_ptr_dtor_nogc(free_op2.var); } else { zend_free_op free_op2, free_op_data1, free_op_data2; zval *value; - zval *dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - zval **variable_ptr_ptr; + zval *dim = _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + zval *variable_ptr; - zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_VAR, BP_VAR_W TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zend_fetch_dimension_address_W(EX_VAR((opline+1)->op2.var), object_ptr, dim, IS_VAR TSRMLS_CC); + zval_ptr_dtor_nogc(free_op2.var); value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); - variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); - if (UNEXPECTED(variable_ptr_ptr == NULL)) { - if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) { - if (RETURN_VALUE_USED(opline)) { - zval *retval; - - ALLOC_ZVAL(retval); - ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1); - INIT_PZVAL(retval); - EX_T(opline->result.var).var.ptr = retval; - } - } else if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - } - } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) { + variable_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); + if (UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) { + zend_assign_to_string_offset(variable_ptr, value, (opline+1)->op1_type, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC); + } else if (UNEXPECTED(variable_ptr == &EG(error_zval))) { if (IS_TMP_FREE(free_op_data1)) { zval_dtor(value); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } + FREE_OP_VAR_PTR(free_op_data2); } else { if ((opline+1)->op1_type == IS_TMP_VAR) { - value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_tmp_to_variable(variable_ptr, value TSRMLS_CC); } else if ((opline+1)->op1_type == IS_CONST) { - value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_const_to_variable(variable_ptr, value TSRMLS_CC); } else { - value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_to_variable(variable_ptr, value TSRMLS_CC); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(value); - EX_T(opline->result.var).var.ptr = value; + ZVAL_COPY(EX_VAR(opline->result.var), value); } + FREE_OP_VAR_PTR(free_op_data2); } - FREE_OP_VAR_PTR(free_op_data2); FREE_OP_IF_VAR(free_op_data1); } @@ -37298,50 +35992,37 @@ static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR USE_OPLINE zend_free_op free_op2; zval *value; - zval **variable_ptr_ptr; + zval *variable_ptr; SAVE_OPLINE(); value = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - variable_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); - if (IS_CV == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) { - if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_VAR TSRMLS_CC)) { - if (RETURN_VALUE_USED(opline)) { - zval *retval; - - ALLOC_ZVAL(retval); - ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1); - INIT_PZVAL(retval); - EX_T(opline->result.var).var.ptr = retval; - } - } else if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - } - } else if (IS_CV == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) { + zend_assign_to_string_offset(variable_ptr, value, IS_VAR, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC); + } else if (IS_CV == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) { if (0) { zval_dtor(value); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } } else { if (IS_VAR == IS_TMP_VAR) { - value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_tmp_to_variable(variable_ptr, value TSRMLS_CC); } else if (IS_VAR == IS_CONST) { - value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_const_to_variable(variable_ptr, value TSRMLS_CC); } else { - value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_to_variable(variable_ptr, value TSRMLS_CC); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(value); - EX_T(opline->result.var).var.ptr = value; + ZVAL_COPY(EX_VAR(opline->result.var), value); } + } /* zend_assign_to_variable() always takes care of op2, never free it! */ - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -37351,50 +36032,59 @@ static int ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLE { USE_OPLINE zend_free_op free_op2; - zval **variable_ptr_ptr; - zval **value_ptr_ptr; + zval *variable_ptr; + zval *value_ptr; SAVE_OPLINE(); - value_ptr_ptr = _get_zval_ptr_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + value_ptr = _get_zval_ptr_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); if (IS_VAR == IS_VAR && - value_ptr_ptr && - !Z_ISREF_PP(value_ptr_ptr) && opline->extended_value == ZEND_RETURNS_FUNCTION && - !EX_T(opline->op2.var).var.fcall_returned_reference) { - if (free_op2.var == NULL) { - PZVAL_LOCK(*value_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */ + !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF) && + !Z_ISREF_P(value_ptr)) { + if (!(free_op2.var != NULL)) { + PZVAL_LOCK(value_ptr); /* undo the effect of get_zval_ptr_ptr() */ } zend_error(E_STRICT, "Only variables should be assigned by reference"); if (UNEXPECTED(EG(exception) != NULL)) { - if (free_op2.var) {zval_ptr_dtor_nogc(&free_op2.var);}; + if (free_op2.var) {zval_ptr_dtor_nogc(free_op2.var);}; HANDLE_EXCEPTION(); } return ZEND_ASSIGN_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } else if (IS_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) { - PZVAL_LOCK(*value_ptr_ptr); + if (!(free_op2.var != NULL)) { + PZVAL_LOCK(value_ptr); + } } - if (IS_CV == IS_VAR && UNEXPECTED(EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr)) { + + variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + if (IS_CV == IS_VAR && + UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT) && + UNEXPECTED(!Z_ISREF_P(variable_ptr))) { zend_error_noreturn(E_ERROR, "Cannot assign by reference to overloaded object"); } - - variable_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); - if ((IS_VAR == IS_VAR && UNEXPECTED(value_ptr_ptr == NULL)) || - (IS_CV == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL))) { + if ((IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) || + (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET))) { zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets nor overloaded objects"); } - zend_assign_to_variable_reference(variable_ptr_ptr, value_ptr_ptr TSRMLS_CC); + if ((IS_CV == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) || + (IS_VAR == IS_VAR && UNEXPECTED(value_ptr == &EG(error_zval)))) { + variable_ptr = &EG(uninitialized_zval); + } else { + zend_assign_to_variable_reference(variable_ptr, value_ptr TSRMLS_CC); + } if (IS_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) { - Z_DELREF_PP(variable_ptr_ptr); + if (!(free_op2.var != NULL)) { + Z_DELREF_P(variable_ptr); + } } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(*variable_ptr_ptr); - EX_T(opline->result.var).var.ptr = *variable_ptr_ptr; + ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr); } - if (free_op2.var) {zval_ptr_dtor_nogc(&free_op2.var);}; + if (free_op2.var) {zval_ptr_dtor_nogc(free_op2.var);}; CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -37404,10 +36094,9 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_ { USE_OPLINE zval *function_name; - char *function_name_strval; - int function_name_strlen; zend_free_op free_op2; call_slot *call = EX(call_slots) + opline->result.num; + zval *object; SAVE_OPLINE(); @@ -37421,62 +36110,51 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_ zend_error_noreturn(E_ERROR, "Method name must be a string"); } - function_name_strval = Z_STRVAL_P(function_name); - function_name_strlen = Z_STRLEN_P(function_name); - - call->object = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); + object = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); + call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL; - if (EXPECTED(call->object != NULL) && - EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) { - call->called_scope = Z_OBJCE_P(call->object); + if (EXPECTED(call->object != NULL)) { + call->called_scope = zend_get_class_entry(call->object TSRMLS_CC); if (IS_VAR != IS_CONST || - (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) { - zval *object = call->object; + (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope)) == NULL) { + zend_object *object = call->object; - if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) { + if (UNEXPECTED(object->handlers->get_method == NULL)) { zend_error_noreturn(E_ERROR, "Object does not support method calls"); } /* First, locate the function. */ - call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); + call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_VAR == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); if (UNEXPECTED(call->fbc == NULL)) { - zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval); + zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name)); } if (IS_VAR == IS_CONST && EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) && EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) && EXPECTED(call->object == object)) { - CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc); + CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope, call->fbc); } } } else { if (UNEXPECTED(EG(exception) != NULL)) { - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); HANDLE_EXCEPTION(); } - zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval); + zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", Z_STRVAL_P(function_name)); } if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) { call->object = NULL; } else { - if (!PZVAL_IS_REF(call->object)) { - Z_ADDREF_P(call->object); /* For $this pointer */ - } else { - zval *this_ptr; - ALLOC_ZVAL(this_ptr); - INIT_PZVAL_COPY(this_ptr, call->object); - zval_copy_ctor(this_ptr); - call->object = this_ptr; - } + GC_REFCOUNT(call->object)++; /* For $this pointer */ } call->num_additional_args = 0; call->is_ctor_call = 0; EX(call) = call; - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -37486,13 +36164,14 @@ static int ZEND_FASTCALL ZEND_CASE_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS { USE_OPLINE zend_free_op free_op2; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - is_equal_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + fast_equal_function(result, + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -37501,35 +36180,31 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE { USE_OPLINE - zval *expr_ptr; + zval *expr_ptr, new_expr; SAVE_OPLINE(); - if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) { - zval **expr_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); - - if (IS_CV == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) { + if ((IS_CV == IS_VAR || IS_CV == IS_CV) && + (opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) { + expr_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets"); } - SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); - expr_ptr = *expr_ptr_ptr; + SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr); Z_ADDREF_P(expr_ptr); + } else { - expr_ptr=_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); + expr_ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); if (0) { /* temporary variable */ - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - } else if (IS_CV == IS_CONST || PZVAL_IS_REF(expr_ptr)) { - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - zendi_zval_copy_ctor(*expr_ptr); + ZVAL_COPY_VALUE(&new_expr, expr_ptr); + expr_ptr = &new_expr; + } else if (IS_CV == IS_CONST) { + ZVAL_DUP(&new_expr, expr_ptr); + expr_ptr = &new_expr; + } else if (Z_ISREF_P(expr_ptr)) { + ZVAL_DUP(&new_expr, Z_REFVAL_P(expr_ptr)); + expr_ptr = &new_expr; - } else if (IS_CV == IS_CV) { + } else if (IS_CV == IS_CV && Z_REFCOUNTED_P(expr_ptr)) { Z_ADDREF_P(expr_ptr); } } @@ -37537,42 +36212,49 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE if (IS_VAR != IS_UNUSED) { zend_free_op free_op2; zval *offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + zend_string *str; ulong hval; +add_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: hval = zend_dval_to_lval(Z_DVAL_P(offset)); goto num_index; case IS_LONG: - case IS_BOOL: hval = Z_LVAL_P(offset); num_index: - zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL); + zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); break; case IS_STRING: - if (IS_VAR == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); + str = Z_STR_P(offset); + if (IS_VAR != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index); } - zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL); +str_index: + zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); break; case IS_NULL: - zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); + str = STR_EMPTY_ALLOC(); + goto str_index; + case IS_FALSE: + hval = 0; + goto num_index; + case IS_TRUE: + hval = 1; + goto num_index; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto add_again; break; default: zend_error(E_WARNING, "Illegal offset type"); - zval_ptr_dtor(&expr_ptr); + zval_ptr_dtor(expr_ptr); /* do nothing */ break; } - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); } else { - zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL); - } - if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) { - + zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -37580,9 +36262,26 @@ num_index: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { + zval *array; + zend_uint size; USE_OPLINE - array_init(&EX_T(opline->result.var).tmp_var); + array = EX_VAR(opline->result.var); + if (IS_CV != IS_UNUSED) { + size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; + } else { + size = 0; + } + ZVAL_NEW_ARR(array); + zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); + + if (IS_CV != IS_UNUSED) { + /* Explicitly initialize array as not-packed if flag is set */ + if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) { + zend_hash_real_init(Z_ARRVAL_P(array), 0); + } + } + if (IS_CV == IS_UNUSED) { ZEND_VM_NEXT_OPCODE(); #if 0 || IS_CV != IS_UNUSED @@ -37598,20 +36297,15 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER zval tmp, *varname; HashTable *target_symbol_table; + zend_bool tmp_is_dup = 0; SAVE_OPLINE(); if (IS_CV == IS_CV && IS_VAR == IS_UNUSED && (opline->extended_value & ZEND_QUICK_SET)) { - if (EG(active_symbol_table)) { - zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); - - zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC); - EX_CV(opline->op1.var) = NULL; - } else if (EX_CV(opline->op1.var)) { - zval_ptr_dtor(EX_CV(opline->op1.var)); - EX_CV(opline->op1.var) = NULL; - } + ZVAL_COPY_VALUE(&tmp, EX_VAR(opline->op1.var)); + ZVAL_UNDEF(EX_VAR(opline->op1.var)); + zval_ptr_dtor(&tmp); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -37619,27 +36313,28 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER varname = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { - ZVAL_COPY_VALUE(&tmp, varname); - zval_copy_ctor(&tmp); + ZVAL_DUP(&tmp, varname); convert_to_string(&tmp); varname = &tmp; + tmp_is_dup = 1; } else if (IS_CV == IS_VAR || IS_CV == IS_CV) { - Z_ADDREF_P(varname); + ZVAL_COPY(&tmp, varname); + varname = &tmp; } if (IS_VAR != IS_UNUSED) { zend_class_entry *ce; if (IS_VAR == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { - if (IS_CV != IS_CONST && varname == &tmp) { + if (IS_CV != IS_CONST && tmp_is_dup) { zval_dtor(&tmp); } else if (IS_CV == IS_VAR || IS_CV == IS_CV) { - zval_ptr_dtor(&varname); + zval_ptr_dtor(&tmp); } HANDLE_EXCEPTION(); @@ -37647,23 +36342,21 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER if (UNEXPECTED(ce == NULL)) { zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv)); } - CACHE_PTR(opline->op2.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); } } else { - ce = EX_T(opline->op2.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op2.var)); } - zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); + zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC); } else { - ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1); - target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); - zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC); + zend_hash_del_ind(target_symbol_table, Z_STR_P(varname)); } - if (IS_CV != IS_CONST && varname == &tmp) { + if (IS_CV != IS_CONST && tmp_is_dup) { zval_dtor(&tmp); } else if (IS_CV == IS_VAR || IS_CV == IS_CV) { - zval_ptr_dtor(&varname); + zval_ptr_dtor(&tmp); } CHECK_EXCEPTION(); @@ -37674,91 +36367,98 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER { USE_OPLINE zend_free_op free_op2; - zval **container; + zval *container; zval *offset; ulong hval; SAVE_OPLINE(); - container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC); - if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) { + container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC); + if (IS_CV != IS_UNUSED) { SEPARATE_ZVAL_IF_NOT_REF(container); } offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (IS_CV != IS_VAR || container) { - switch (Z_TYPE_PP(container)) { - case IS_ARRAY: { - HashTable *ht = Z_ARRVAL_PP(container); - - switch (Z_TYPE_P(offset)) { - case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); - zend_hash_index_del(ht, hval); - break; - case IS_RESOURCE: - case IS_BOOL: - case IS_LONG: - hval = Z_LVAL_P(offset); - zend_hash_index_del(ht, hval); - break; - case IS_STRING: - if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { - Z_ADDREF_P(offset); - } - if (IS_VAR == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); - } - if (ht == &EG(symbol_table)) { - zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC); - } else { - zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval); - } - if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { - zval_ptr_dtor(&offset); - } - break; +container_again: + switch (Z_TYPE_P(container)) { + case IS_ARRAY: { + HashTable *ht = Z_ARRVAL_P(container); +offset_again: + switch (Z_TYPE_P(offset)) { + case IS_DOUBLE: + hval = zend_dval_to_lval(Z_DVAL_P(offset)); + zend_hash_index_del(ht, hval); + break; + case IS_LONG: + hval = Z_LVAL_P(offset); num_index_dim: - zend_hash_index_del(ht, hval); - if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { - zval_ptr_dtor(&offset); - } - break; - case IS_NULL: - zend_hash_del(ht, "", sizeof("")); - break; - default: - zend_error(E_WARNING, "Illegal offset type in unset"); - break; - } - zval_ptr_dtor_nogc(&free_op2.var); - break; + zend_hash_index_del(ht, hval); + break; + case IS_STRING: + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset); + } + if (IS_VAR != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto numeric_index_dim); + } + if (ht == &EG(symbol_table).ht) { + zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC); + } else { + zend_hash_del(ht, Z_STR_P(offset)); + } + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + zval_ptr_dtor(offset); + } + break; +numeric_index_dim: + zend_hash_index_del(ht, hval); + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + zval_ptr_dtor(offset); + } + break; + case IS_NULL: + zend_hash_del(ht, STR_EMPTY_ALLOC()); + break; + case IS_FALSE: + hval = 0; + goto num_index_dim; + case IS_TRUE: + hval = 1; + goto num_index_dim; + case IS_RESOURCE: + hval = Z_RES_HANDLE_P(offset); + goto num_index_dim; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto offset_again; + break; + default: + zend_error(E_WARNING, "Illegal offset type in unset"); + break; } - case IS_OBJECT: - if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use object as array"); - } - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC); - if (0) { - zval_ptr_dtor(&offset); - } else { - zval_ptr_dtor_nogc(&free_op2.var); - } - break; - case IS_STRING: - zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); - ZEND_VM_CONTINUE(); /* bailed out before */ - default: - zval_ptr_dtor_nogc(&free_op2.var); - break; + zval_ptr_dtor_nogc(free_op2.var); + break; } - } else { - zval_ptr_dtor_nogc(&free_op2.var); + case IS_OBJECT: + if (UNEXPECTED(Z_OBJ_HT_P(container)->unset_dimension == NULL)) { + zend_error_noreturn(E_ERROR, "Cannot use object as array"); + } +//??? if (IS_VAR == IS_CONST) { +//??? zval_copy_ctor(offset); +//??? } + Z_OBJ_HT_P(container)->unset_dimension(container, offset TSRMLS_CC); + zval_ptr_dtor_nogc(free_op2.var); + break; + case IS_STRING: + case IS_STR_OFFSET: + zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); + ZEND_VM_CONTINUE(); /* bailed out before */ + case IS_REFERENCE: + container = Z_REFVAL_P(container); + goto container_again; + break; + default: + zval_ptr_dtor_nogc(free_op2.var); + break; } CHECK_EXCEPTION(); @@ -37769,37 +36469,25 @@ static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER { USE_OPLINE zend_free_op free_op2; - zval **container; + zval *container; zval *offset; SAVE_OPLINE(); - container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC); + if (IS_CV == IS_VAR && Z_TYPE_P(container) == IS_STR_OFFSET) { + zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); + } offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (IS_CV != IS_VAR || container) { - if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(container); - } - if (Z_TYPE_PP(container) == IS_OBJECT) { - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - if (Z_OBJ_HT_P(*container)->unset_property) { - Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to unset property of non-object"); - } - if (0) { - zval_ptr_dtor(&offset); - } else { - zval_ptr_dtor_nogc(&free_op2.var); - } + ZVAL_DEREF(container); + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->unset_property) { + Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); } else { - zval_ptr_dtor_nogc(&free_op2.var); + zend_error(E_NOTICE, "Trying to unset property of non-object"); } - } else { - zval_ptr_dtor_nogc(&free_op2.var); } + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -37808,21 +36496,16 @@ static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval **value; + zval *value; zend_bool isset = 1; SAVE_OPLINE(); if (IS_CV == IS_CV && IS_VAR == IS_UNUSED && (opline->extended_value & ZEND_QUICK_SET)) { - if (EX_CV(opline->op1.var)) { - value = EX_CV(opline->op1.var); - } else if (EG(active_symbol_table)) { - zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); - - if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) { - isset = 0; - } + if (Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_UNDEF) { + value = EX_VAR(opline->op1.var); + ZVAL_DEREF(value); } else { isset = 0; } @@ -37832,8 +36515,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE zval tmp, *varname = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC); if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { - ZVAL_COPY_VALUE(&tmp, varname); - zval_copy_ctor(&tmp); + ZVAL_DUP(&tmp, varname); convert_to_string(&tmp); varname = &tmp; } @@ -37842,26 +36524,26 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE zend_class_entry *ce; if (IS_VAR == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(opline->op2.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); } } else { - ce = EX_T(opline->op2.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op2.var)); } - value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); + value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC); if (!value) { isset = 0; } } else { target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); - if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) { + if ((value = zend_hash_find(target_symbol_table, Z_STR_P(varname))) == NULL) { isset = 0; } } @@ -37873,16 +36555,16 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE } if (opline->extended_value & ZEND_ISSET) { - if (isset && Z_TYPE_PP(value) != IS_NULL) { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); + if (isset && Z_TYPE_P(value) != IS_NULL) { + ZVAL_BOOL(EX_VAR(opline->result.var), 1); } else { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); + ZVAL_BOOL(EX_VAR(opline->result.var), 0); } } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { - if (!isset || !i_zend_is_true(*value TSRMLS_CC)) { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); + if (!isset || !i_zend_is_true(value TSRMLS_CC)) { + ZVAL_BOOL(EX_VAR(opline->result.var), 1); } else { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); + ZVAL_BOOL(EX_VAR(opline->result.var), 0); } } @@ -37890,54 +36572,58 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_VAR(int prop_dim, ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_free_op free_op2; zval *container; - zval **value = NULL; - int result = 0; + int result; ulong hval; zval *offset; SAVE_OPLINE(); - container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_deref_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC); offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); - if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) { - HashTable *ht; - int isset = 0; - - ht = Z_ARRVAL_P(container); + if (Z_TYPE_P(container) == IS_ARRAY) { + HashTable *ht = Z_ARRVAL_P(container); + zval *value = NULL; + zend_string *str; +isset_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: hval = zend_dval_to_lval(Z_DVAL_P(offset)); goto num_index_prop; - case IS_RESOURCE: - case IS_BOOL: case IS_LONG: hval = Z_LVAL_P(offset); num_index_prop: - if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) { - isset = 1; - } + value = zend_hash_index_find(ht, hval); break; case IS_STRING: - if (IS_VAR == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); - } - if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) { - isset = 1; + str = Z_STR_P(offset); + if (IS_VAR != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index_prop); } +str_index_prop: + value = zend_hash_find_ind(ht, str); break; case IS_NULL: - if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) { - isset = 1; - } + str = STR_EMPTY_ALLOC(); + goto str_index_prop; + break; + case IS_FALSE: + hval = 0; + goto num_index_prop; + case IS_TRUE: + hval = 0; + goto num_index_prop; + case IS_RESOURCE: + hval = Z_RES_HANDLE_P(offset); + goto num_index_prop; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto isset_again; break; default: zend_error(E_WARNING, "Illegal offset type in isset or empty"); @@ -37945,116 +36631,105 @@ num_index_prop: } if (opline->extended_value & ZEND_ISSET) { - if (isset && Z_TYPE_PP(value) == IS_NULL) { - result = 0; - } else { - result = isset; - } + /* > IS_NULL means not IS_UNDEF and not IS_NULL */ + result = (value != NULL && Z_TYPE_P(value) > IS_NULL); } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { - if (!isset || !i_zend_is_true(*value TSRMLS_CC)) { - result = 0; - } else { - result = 1; - } + result = (value == NULL || !i_zend_is_true(value TSRMLS_CC)); } - zval_ptr_dtor_nogc(&free_op2.var); } else if (Z_TYPE_P(container) == IS_OBJECT) { - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - if (prop_dim) { - if (Z_OBJ_HT_P(container)->has_property) { - result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check property of non-object"); - result = 0; - } + if (Z_OBJ_HT_P(container)->has_dimension) { + result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); } else { - if (Z_OBJ_HT_P(container)->has_dimension) { - result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check element of non-array"); - result = 0; - } + zend_error(E_NOTICE, "Trying to check element of non-array"); + result = 0; } - if (0) { - zval_ptr_dtor(&offset); - } else { - zval_ptr_dtor_nogc(&free_op2.var); + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; } - } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */ + } else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */ zval tmp; - if (Z_TYPE_P(offset) != IS_LONG) { - if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */ + result = 0; + if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) { + if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */ || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { - ZVAL_COPY_VALUE(&tmp, offset); - zval_copy_ctor(&tmp); + ZVAL_DUP(&tmp, offset); convert_to_long(&tmp); offset = &tmp; - } else { - /* can not be converted to proper offset, return "not set" */ - result = 0; } } if (Z_TYPE_P(offset) == IS_LONG) { - if (opline->extended_value & ZEND_ISSET) { - if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { - result = 1; - } - } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { - if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') { + if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { + if ((opline->extended_value & ZEND_ISSET) || + Z_STRVAL_P(container)[offset->value.lval] != '0') { result = 1; } } } - zval_ptr_dtor_nogc(&free_op2.var); + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } } else { - zval_ptr_dtor_nogc(&free_op2.var); + result = ((opline->extended_value & ZEND_ISSET) == 0); } - Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; - if (opline->extended_value & ZEND_ISSET) { - Z_LVAL(EX_T(opline->result.var).tmp_var) = result; - } else { - Z_LVAL(EX_T(opline->result.var).tmp_var) = !result; - } + zval_ptr_dtor_nogc(free_op2.var); + ZVAL_BOOL(EX_VAR(opline->result.var), result); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_VAR(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} - static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_VAR(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + zend_free_op free_op2; + zval *container; + int result; + zval *offset; + + SAVE_OPLINE(); + container = _get_zval_ptr_cv_deref_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC); + offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); + + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->has_property) { + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); + } else { + zend_error(E_NOTICE, "Trying to check property of non-object"); + result = 0; + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else { + result = ((opline->extended_value & ZEND_ISSET) == 0); + } + + zval_ptr_dtor_nogc(free_op2.var); + ZVAL_BOOL(EX_VAR(opline->result.var), result); + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_YIELD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - /* The generator object is stored in return_value_ptr_ptr */ - zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr); + /* The generator object is stored in EX(return_value) */ + zend_generator *generator = (zend_generator *) EX(return_value); if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) { zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator"); } /* Destroy the previously yielded value */ - if (generator->value) { - zval_ptr_dtor(&generator->value); - } + zval_ptr_dtor(&generator->value); /* Destroy the previously yielded key */ - if (generator->key) { - zval_ptr_dtor(&generator->key); - } + zval_ptr_dtor(&generator->key); /* Set the new yielded value */ if (IS_CV != IS_UNUSED) { @@ -38064,74 +36739,58 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG /* Constants and temporary variables aren't yieldable by reference, * but we still allow them with a notice. */ if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) { - zval *value, *copy; + zval *value; zend_error(E_NOTICE, "Only variable references should be yielded by reference"); value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); + ZVAL_COPY_VALUE(&generator->value, value); + if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1); /* Temporary variables don't need ctor copying */ if (!0) { - zval_copy_ctor(copy); + zval_copy_ctor(&generator->value); } - - generator->value = copy; } else { - zval **value_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); - if (IS_CV == IS_VAR && UNEXPECTED(value_ptr == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference"); } /* If a function call result is yielded and the function did * not return by reference we throw a notice. */ - if (IS_CV == IS_VAR && !Z_ISREF_PP(value_ptr) + if (IS_CV == IS_VAR && !Z_ISREF_P(value_ptr) && !(opline->extended_value == ZEND_RETURNS_FUNCTION - && EX_T(opline->op1.var).var.fcall_returned_reference) - && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) { + && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); - - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } else { SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr); - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } + ZVAL_COPY(&generator->value, value_ptr); } } else { zval *value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); /* Consts, temporary variables and references need copying */ - if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR - || PZVAL_IS_REF(value) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); - - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } - - generator->value = copy; + if (IS_CV == IS_CONST) { + ZVAL_DUP(&generator->value, value); + } else if (IS_CV == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->value, value); + } else if (Z_ISREF_P(value)) { + ZVAL_DUP(&generator->value, Z_REFVAL_P(value)); } else { if (IS_CV == IS_CV) { - Z_ADDREF_P(value); + if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value); } - generator->value = value; + ZVAL_COPY_VALUE(&generator->value, value); } } } else { /* If no value was specified yield null */ - Z_ADDREF(EG(uninitialized_zval)); - generator->value = &EG(uninitialized_zval); + ZVAL_NULL(&generator->value); } /* Set the new yielded key */ @@ -38140,46 +36799,36 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC); /* Consts, temporary variables and references need copying */ - if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR - || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, key); - - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } - - generator->key = copy; + if (IS_VAR == IS_CONST) { + ZVAL_DUP(&generator->key, key); + } else if (IS_VAR == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->key, key); + } else if (Z_ISREF_P(key)) { + ZVAL_DUP(&generator->key, Z_REFVAL_P(key)); + zval_ptr_dtor_nogc(free_op2.var); } else { - Z_ADDREF_P(key); - generator->key = key; + if (IS_VAR == IS_CV) { + if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key); + } + ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE_P(generator->key) == IS_LONG - && Z_LVAL_P(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_LONG + && Z_LVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL_P(generator->key); + generator->largest_used_integer_key = Z_LVAL(generator->key); } - - zval_ptr_dtor_nogc(&free_op2.var); } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - - ALLOC_INIT_ZVAL(generator->key); - ZVAL_LONG(generator->key, generator->largest_used_integer_key); + ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ - generator->send_target = &EX_T(opline->result.var).var.ptr; - Z_ADDREF(EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + generator->send_target = EX_VAR(opline->result.var); + ZVAL_NULL(generator->send_target); } else { generator->send_target = NULL; } @@ -38201,11 +36850,11 @@ static int ZEND_FASTCALL ZEND_POW_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_free_op free_op2; SAVE_OPLINE(); - pow_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); + pow_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC); - zval_ptr_dtor_nogc(&free_op2.var); + zval_ptr_dtor_nogc(free_op2.var); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -38219,18 +36868,18 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(int (*b { USE_OPLINE zend_free_op free_op_data1; - zval **object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); - zval *object; + zval *object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); zval *property = NULL; - zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); + zval *value; int have_get_ptr = 0; - if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - make_real_object(object_ptr TSRMLS_CC); - object = *object_ptr; + object = make_real_object(object TSRMLS_CC); + + value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { zend_error(E_WARNING, "Attempt to assign property of non-object"); @@ -38238,81 +36887,67 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(int (*b FREE_OP(free_op_data1); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } } else { /* here we are sure we are dealing with an object */ - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - - /* here property is a string */ if (opline->extended_value == ZEND_ASSIGN_OBJ && Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_UNUSED == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); if (zptr != NULL) { /* NULL means no success in getting PTR */ SEPARATE_ZVAL_IF_NOT_REF(zptr); have_get_ptr = 1; - binary_op(*zptr, *zptr, value TSRMLS_CC); + binary_op(zptr, zptr, value TSRMLS_CC); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(*zptr); - EX_T(opline->result.var).var.ptr = *zptr; + ZVAL_COPY(EX_VAR(opline->result.var), zptr); } } } if (!have_get_ptr) { zval *z = NULL; + zval rv; if (opline->extended_value == ZEND_ASSIGN_OBJ) { if (Z_OBJ_HT_P(object)->read_property) { - z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_UNUSED == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC); } } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { if (Z_OBJ_HT_P(object)->read_dimension) { - z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC); + z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R, &rv TSRMLS_CC); } } if (z) { if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); zval_dtor(z); - FREE_ZVAL(z); } - z = value; + ZVAL_COPY_VALUE(z, value); } - Z_ADDREF_P(z); - SEPARATE_ZVAL_IF_NOT_REF(&z); +//??? if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); + SEPARATE_ZVAL_IF_NOT_REF(z); binary_op(z, z, value TSRMLS_CC); if (opline->extended_value == ZEND_ASSIGN_OBJ) { - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_UNUSED == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(z); - EX_T(opline->result.var).var.ptr = z; + ZVAL_COPY(EX_VAR(opline->result.var), z); } - zval_ptr_dtor(&z); + zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to assign property of non-object"); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } } } - if (0) { - zval_ptr_dtor(&property); - } else { - - } FREE_OP(free_op_data1); } @@ -38322,168 +36957,278 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(int (*b ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_CV_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_free_op free_op_data2, free_op_data1; - zval **var_ptr; - zval *value; + zval *var_ptr; + zval *value, *container; SAVE_OPLINE(); - switch (opline->extended_value) { - case ZEND_ASSIGN_OBJ: - return zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - break; - case ZEND_ASSIGN_DIM: { - zval **container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); - - if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); - } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) { - if (IS_CV == IS_VAR && !0) { - Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */ - } - return zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - } else { - zval *dim = NULL; + container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { + zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); + } else if (UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { + if (IS_CV == IS_VAR && !0) { + Z_ADDREF_P(container); /* undo the effect of get_obj_zval_ptr_ptr() */ + } + return zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else { + zval *dim = NULL; - zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_UNUSED, BP_VAR_RW TSRMLS_CC); - value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); - var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); - } - } - break; - default: - value = NULL; - var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); - /* do nothing */ - break; + zend_fetch_dimension_address_RW(EX_VAR((opline+1)->op2.var), container, dim, IS_UNUSED TSRMLS_CC); + value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); + var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); } - if (UNEXPECTED(var_ptr == NULL)) { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); } - if (UNEXPECTED(*var_ptr == &EG(error_zval))) { - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + if (UNEXPECTED(var_ptr == &EG(error_zval))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); } + goto assign_op_dim_exit; + } + SEPARATE_ZVAL_IF_NOT_REF(var_ptr); + ZVAL_DEREF(var_ptr); - CHECK_EXCEPTION(); - if (opline->extended_value == ZEND_ASSIGN_DIM) { - ZEND_VM_INC_OPCODE(); + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) && + UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) { + /* proxy object */ + zval rv; + zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC); + Z_ADDREF_P(objval); + binary_op(objval, objval, value TSRMLS_CC); + Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); + zval_ptr_dtor(objval); + } else { + binary_op(var_ptr, var_ptr, value TSRMLS_CC); + } + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + } + +assign_op_dim_exit: + + FREE_OP(free_op_data1); + FREE_OP_VAR_PTR(free_op_data2); + + CHECK_EXCEPTION(); + ZEND_VM_INC_OPCODE(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + + zval *var_ptr; + zval *value; + + SAVE_OPLINE(); + value = NULL; + var_ptr = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); + + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { + zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); + } + + if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); } - ZEND_VM_NEXT_OPCODE(); + goto assign_op_exit; } SEPARATE_ZVAL_IF_NOT_REF(var_ptr); + ZVAL_DEREF(var_ptr); - if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) - && Z_OBJ_HANDLER_PP(var_ptr, get) - && Z_OBJ_HANDLER_PP(var_ptr, set)) { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) && + UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) { /* proxy object */ - zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); + zval rv; + zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC); Z_ADDREF_P(objval); binary_op(objval, objval, value TSRMLS_CC); - Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC); - zval_ptr_dtor(&objval); + Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); + zval_ptr_dtor(objval); } else { - binary_op(*var_ptr, *var_ptr, value TSRMLS_CC); + binary_op(var_ptr, var_ptr, value TSRMLS_CC); } - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(*var_ptr); - EX_T(opline->result.var).var.ptr = *var_ptr; + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } - if (opline->extended_value == ZEND_ASSIGN_DIM) { - FREE_OP(free_op_data1); - FREE_OP_VAR_PTR(free_op_data2); +assign_op_exit: - CHECK_EXCEPTION(); - ZEND_VM_INC_OPCODE(); - } else { - CHECK_EXCEPTION(); - } + CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_UNUSED(int type, ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_free_op free_op1; + zval *varname; - zval **retval; + zval *retval; zval tmp_varname; HashTable *target_symbol_table; - ulong hash_value; SAVE_OPLINE(); varname = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); + ZVAL_UNDEF(&tmp_varname); if (IS_CV != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) { - ZVAL_COPY_VALUE(&tmp_varname, varname); - zval_copy_ctor(&tmp_varname); - Z_SET_REFCOUNT(tmp_varname, 1); - Z_UNSET_ISREF(tmp_varname); + ZVAL_DUP_DEREF(&tmp_varname, varname); convert_to_string(&tmp_varname); varname = &tmp_varname; } @@ -38492,105 +37237,88 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_UNUSED(int type, zend_class_entry *ce; if (IS_UNUSED == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { - if (IS_CV != IS_CONST && varname == &tmp_varname) { + if (IS_CV != IS_CONST) { zval_dtor(&tmp_varname); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(opline->op2.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); } } else { - ce = EX_T(opline->op2.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op2.var)); } - retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); + retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC); } else { target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); -/* - if (!target_symbol_table) { - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); - } -*/ - if (IS_CV == IS_CONST) { - hash_value = Z_HASH_P(varname); - } else { - hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname)); - } - - if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) { + retval = zend_hash_find(target_symbol_table, Z_STR_P(varname)); + if (retval == NULL) { switch (type) { case BP_VAR_R: case BP_VAR_UNSET: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); /* break missing intentionally */ case BP_VAR_IS: - retval = &EG(uninitialized_zval_ptr); + retval = EX_VAR(opline->result.var); + ZVAL_NULL(retval); break; case BP_VAR_RW: zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); /* break missing intentionally */ case BP_VAR_W: - Z_ADDREF_P(&EG(uninitialized_zval)); - zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval); + retval = zend_hash_update(target_symbol_table, Z_STR_P(varname), &EG(uninitialized_zval)); break; EMPTY_SWITCH_DEFAULT_CASE() } - } - switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) { - case ZEND_FETCH_GLOBAL: - if (IS_CV != IS_TMP_VAR) { - + /* GLOBAL or $$name variable may be an INDIRECT pointer to CV */ + } else if (Z_TYPE_P(retval) == IS_INDIRECT) { + retval = Z_INDIRECT_P(retval); + if (Z_TYPE_P(retval) == IS_UNDEF) { + switch (type) { + case BP_VAR_R: + case BP_VAR_UNSET: + zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); + /* break missing intentionally */ + case BP_VAR_IS: + retval = EX_VAR(opline->result.var); + ZVAL_NULL(retval); + break; + case BP_VAR_RW: + zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname)); + /* break missing intentionally */ + case BP_VAR_W: + ZVAL_NULL(retval); + break; + EMPTY_SWITCH_DEFAULT_CASE() } - break; - case ZEND_FETCH_LOCAL: + } + } + if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC) { + zval_update_constant(retval, 1 TSRMLS_CC); + } else if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) != ZEND_FETCH_GLOBAL_LOCK) { - break; - case ZEND_FETCH_STATIC: - zval_update_constant(retval, 1 TSRMLS_CC); - break; - case ZEND_FETCH_GLOBAL_LOCK: - if (IS_CV == IS_VAR && !free_op1.var) { - PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr); - } - break; } } - - if (IS_CV != IS_CONST && varname == &tmp_varname) { + if (IS_CV != IS_CONST) { zval_dtor(&tmp_varname); } - if (opline->extended_value & ZEND_FETCH_MAKE_REF) { - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval); - } - PZVAL_LOCK(*retval); - switch (type) { - case BP_VAR_R: - case BP_VAR_IS: - EX_T(opline->result.var).var.ptr = *retval; - break; - case BP_VAR_UNSET: { - zend_free_op free_res; - PZVAL_UNLOCK(*retval, &free_res); - if (retval != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(retval); - } - PZVAL_LOCK(*retval); - FREE_OP_VAR_PTR(free_res); + ZEND_ASSERT(retval != NULL); + if (type == BP_VAR_R || type == BP_VAR_IS) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); + } else { + if (/*type == BP_VAR_W &&*/ (opline->extended_value & ZEND_FETCH_MAKE_REF)) { + SEPARATE_ZVAL_TO_MAKE_IS_REF(retval); } - /* break missing intentionally */ - default: - EX_T(opline->result.var).var.ptr_ptr = retval; - break; + ZVAL_INDIRECT(EX_VAR(opline->result.var), retval); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -38615,7 +37343,11 @@ static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE { USE_OPLINE - return zend_fetch_var_address_helper_SPEC_CV_UNUSED(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { + return zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else { + return zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -38632,29 +37364,22 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HA { USE_OPLINE zend_free_op free_op1; - zval **container; + zval *container; SAVE_OPLINE(); - container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); - if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_W TSRMLS_CC); - - if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + if (EXPECTED(opline->extended_value == 0)) { + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, NULL, IS_UNUSED TSRMLS_CC); + } else { + zend_fetch_dimension_address_W_ref(EX_VAR(opline->result.var), container, NULL, IS_UNUSED TSRMLS_CC); } - /* We are going to assign the result by reference */ - if (UNEXPECTED(opline->extended_value != 0)) { - zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; - - if (retval_ptr) { - Z_DELREF_PP(retval_ptr); - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); - Z_ADDREF_PP(retval_ptr); - } + if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } CHECK_EXCEPTION(); @@ -38665,18 +37390,18 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_H { USE_OPLINE zend_free_op free_op1; - zval **container; + zval *container; SAVE_OPLINE(); - container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); - if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_RW TSRMLS_CC); + zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, NULL, IS_UNUSED TSRMLS_CC); if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } CHECK_EXCEPTION(); @@ -38686,29 +37411,28 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_H static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE + zval *container; zend_free_op free_op1; SAVE_OPLINE(); if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { - zval **container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_W TSRMLS_CC); + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, NULL, IS_UNUSED TSRMLS_CC); if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } } else { - zval *container; - if (IS_UNUSED == IS_UNUSED) { zend_error_noreturn(E_ERROR, "Cannot use [] for reading"); } container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); - zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_R TSRMLS_CC); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, NULL, IS_UNUSED TSRMLS_CC); } @@ -38720,73 +37444,56 @@ static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HAN { USE_OPLINE - zval **object_ptr; + zval *object_ptr; SAVE_OPLINE(); - object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + object_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); - if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - if (Z_TYPE_PP(object_ptr) == IS_OBJECT) { + if (UNEXPECTED(Z_ISREF_P(object_ptr)) && Z_TYPE_P(Z_REFVAL_P(object_ptr)) == IS_OBJECT) { + object_ptr = Z_REFVAL_P(object_ptr); + } + if (Z_TYPE_P(object_ptr) == IS_OBJECT) { zval *property_name = NULL; - if (0) { - MAKE_REAL_ZVAL_PTR(property_name); - } - zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property_name); - } else { + zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_UNUSED == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC); - } } else { zend_free_op free_op_data1, free_op_data2; zval *value; zval *dim = NULL; - zval **variable_ptr_ptr; + zval *variable_ptr; - zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_UNUSED, BP_VAR_W TSRMLS_CC); + zend_fetch_dimension_address_W(EX_VAR((opline+1)->op2.var), object_ptr, dim, IS_UNUSED TSRMLS_CC); value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); - variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); - if (UNEXPECTED(variable_ptr_ptr == NULL)) { - if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) { - if (RETURN_VALUE_USED(opline)) { - zval *retval; - - ALLOC_ZVAL(retval); - ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1); - INIT_PZVAL(retval); - EX_T(opline->result.var).var.ptr = retval; - } - } else if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - } - } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) { + variable_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); + if (UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) { + zend_assign_to_string_offset(variable_ptr, value, (opline+1)->op1_type, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC); + } else if (UNEXPECTED(variable_ptr == &EG(error_zval))) { if (IS_TMP_FREE(free_op_data1)) { zval_dtor(value); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } + FREE_OP_VAR_PTR(free_op_data2); } else { if ((opline+1)->op1_type == IS_TMP_VAR) { - value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_tmp_to_variable(variable_ptr, value TSRMLS_CC); } else if ((opline+1)->op1_type == IS_CONST) { - value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_const_to_variable(variable_ptr, value TSRMLS_CC); } else { - value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_to_variable(variable_ptr, value TSRMLS_CC); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(value); - EX_T(opline->result.var).var.ptr = value; + ZVAL_COPY(EX_VAR(opline->result.var), value); } + FREE_OP_VAR_PTR(free_op_data2); } - FREE_OP_VAR_PTR(free_op_data2); FREE_OP_IF_VAR(free_op_data1); } @@ -38800,35 +37507,31 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPC { USE_OPLINE - zval *expr_ptr; + zval *expr_ptr, new_expr; SAVE_OPLINE(); - if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) { - zval **expr_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); - - if (IS_CV == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) { + if ((IS_CV == IS_VAR || IS_CV == IS_CV) && + (opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) { + expr_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets"); } - SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); - expr_ptr = *expr_ptr_ptr; + SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr); Z_ADDREF_P(expr_ptr); + } else { - expr_ptr=_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); + expr_ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); if (0) { /* temporary variable */ - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - } else if (IS_CV == IS_CONST || PZVAL_IS_REF(expr_ptr)) { - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - zendi_zval_copy_ctor(*expr_ptr); + ZVAL_COPY_VALUE(&new_expr, expr_ptr); + expr_ptr = &new_expr; + } else if (IS_CV == IS_CONST) { + ZVAL_DUP(&new_expr, expr_ptr); + expr_ptr = &new_expr; + } else if (Z_ISREF_P(expr_ptr)) { + ZVAL_DUP(&new_expr, Z_REFVAL_P(expr_ptr)); + expr_ptr = &new_expr; - } else if (IS_CV == IS_CV) { + } else if (IS_CV == IS_CV && Z_REFCOUNTED_P(expr_ptr)) { Z_ADDREF_P(expr_ptr); } } @@ -38836,42 +37539,49 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPC if (IS_UNUSED != IS_UNUSED) { zval *offset = NULL; + zend_string *str; ulong hval; +add_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: hval = zend_dval_to_lval(Z_DVAL_P(offset)); goto num_index; case IS_LONG: - case IS_BOOL: hval = Z_LVAL_P(offset); num_index: - zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL); + zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); break; case IS_STRING: - if (IS_UNUSED == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); + str = Z_STR_P(offset); + if (IS_UNUSED != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index); } - zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL); +str_index: + zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); break; case IS_NULL: - zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); + str = STR_EMPTY_ALLOC(); + goto str_index; + case IS_FALSE: + hval = 0; + goto num_index; + case IS_TRUE: + hval = 1; + goto num_index; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto add_again; break; default: zend_error(E_WARNING, "Illegal offset type"); - zval_ptr_dtor(&expr_ptr); + zval_ptr_dtor(expr_ptr); /* do nothing */ break; } } else { - zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL); - } - if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) { - + zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -38879,9 +37589,26 @@ num_index: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { + zval *array; + zend_uint size; USE_OPLINE - array_init(&EX_T(opline->result.var).tmp_var); + array = EX_VAR(opline->result.var); + if (IS_CV != IS_UNUSED) { + size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; + } else { + size = 0; + } + ZVAL_NEW_ARR(array); + zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); + + if (IS_CV != IS_UNUSED) { + /* Explicitly initialize array as not-packed if flag is set */ + if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) { + zend_hash_real_init(Z_ARRVAL_P(array), 0); + } + } + if (IS_CV == IS_UNUSED) { ZEND_VM_NEXT_OPCODE(); #if 0 || IS_CV != IS_UNUSED @@ -38897,20 +37624,15 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HAND zval tmp, *varname; HashTable *target_symbol_table; + zend_bool tmp_is_dup = 0; SAVE_OPLINE(); if (IS_CV == IS_CV && IS_UNUSED == IS_UNUSED && (opline->extended_value & ZEND_QUICK_SET)) { - if (EG(active_symbol_table)) { - zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); - - zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC); - EX_CV(opline->op1.var) = NULL; - } else if (EX_CV(opline->op1.var)) { - zval_ptr_dtor(EX_CV(opline->op1.var)); - EX_CV(opline->op1.var) = NULL; - } + ZVAL_COPY_VALUE(&tmp, EX_VAR(opline->op1.var)); + ZVAL_UNDEF(EX_VAR(opline->op1.var)); + zval_ptr_dtor(&tmp); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -38918,27 +37640,28 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HAND varname = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { - ZVAL_COPY_VALUE(&tmp, varname); - zval_copy_ctor(&tmp); + ZVAL_DUP(&tmp, varname); convert_to_string(&tmp); varname = &tmp; + tmp_is_dup = 1; } else if (IS_CV == IS_VAR || IS_CV == IS_CV) { - Z_ADDREF_P(varname); + ZVAL_COPY(&tmp, varname); + varname = &tmp; } if (IS_UNUSED != IS_UNUSED) { zend_class_entry *ce; if (IS_UNUSED == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { - if (IS_CV != IS_CONST && varname == &tmp) { + if (IS_CV != IS_CONST && tmp_is_dup) { zval_dtor(&tmp); } else if (IS_CV == IS_VAR || IS_CV == IS_CV) { - zval_ptr_dtor(&varname); + zval_ptr_dtor(&tmp); } HANDLE_EXCEPTION(); @@ -38946,23 +37669,21 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HAND if (UNEXPECTED(ce == NULL)) { zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv)); } - CACHE_PTR(opline->op2.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); } } else { - ce = EX_T(opline->op2.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op2.var)); } - zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); + zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC); } else { - ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1); - target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); - zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC); + zend_hash_del_ind(target_symbol_table, Z_STR_P(varname)); } - if (IS_CV != IS_CONST && varname == &tmp) { + if (IS_CV != IS_CONST && tmp_is_dup) { zval_dtor(&tmp); } else if (IS_CV == IS_VAR || IS_CV == IS_CV) { - zval_ptr_dtor(&varname); + zval_ptr_dtor(&tmp); } CHECK_EXCEPTION(); @@ -38972,21 +37693,16 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HAND static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval **value; + zval *value; zend_bool isset = 1; SAVE_OPLINE(); if (IS_CV == IS_CV && IS_UNUSED == IS_UNUSED && (opline->extended_value & ZEND_QUICK_SET)) { - if (EX_CV(opline->op1.var)) { - value = EX_CV(opline->op1.var); - } else if (EG(active_symbol_table)) { - zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var); - - if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) { - isset = 0; - } + if (Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_UNDEF) { + value = EX_VAR(opline->op1.var); + ZVAL_DEREF(value); } else { isset = 0; } @@ -38996,8 +37712,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPC zval tmp, *varname = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC); if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { - ZVAL_COPY_VALUE(&tmp, varname); - zval_copy_ctor(&tmp); + ZVAL_DUP(&tmp, varname); convert_to_string(&tmp); varname = &tmp; } @@ -39006,26 +37721,26 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPC zend_class_entry *ce; if (IS_UNUSED == IS_CONST) { - if (CACHED_PTR(opline->op2.literal->cache_slot)) { - ce = CACHED_PTR(opline->op2.literal->cache_slot); + if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); } else { - ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(opline->op2.literal->cache_slot, ce); + CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); } } else { - ce = EX_T(opline->op2.var).class_entry; + ce = Z_CE_P(EX_VAR(opline->op2.var)); } - value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC); + value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC); if (!value) { isset = 0; } } else { target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); - if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) { + if ((value = zend_hash_find(target_symbol_table, Z_STR_P(varname))) == NULL) { isset = 0; } } @@ -39037,16 +37752,16 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPC } if (opline->extended_value & ZEND_ISSET) { - if (isset && Z_TYPE_PP(value) != IS_NULL) { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); + if (isset && Z_TYPE_P(value) != IS_NULL) { + ZVAL_BOOL(EX_VAR(opline->result.var), 1); } else { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); + ZVAL_BOOL(EX_VAR(opline->result.var), 0); } } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { - if (!isset || !i_zend_is_true(*value TSRMLS_CC)) { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1); + if (!isset || !i_zend_is_true(value TSRMLS_CC)) { + ZVAL_BOOL(EX_VAR(opline->result.var), 1); } else { - ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0); + ZVAL_BOOL(EX_VAR(opline->result.var), 0); } } @@ -39058,22 +37773,18 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ { USE_OPLINE - /* The generator object is stored in return_value_ptr_ptr */ - zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr); + /* The generator object is stored in EX(return_value) */ + zend_generator *generator = (zend_generator *) EX(return_value); if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) { zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator"); } /* Destroy the previously yielded value */ - if (generator->value) { - zval_ptr_dtor(&generator->value); - } + zval_ptr_dtor(&generator->value); /* Destroy the previously yielded key */ - if (generator->key) { - zval_ptr_dtor(&generator->key); - } + zval_ptr_dtor(&generator->key); /* Set the new yielded value */ if (IS_CV != IS_UNUSED) { @@ -39083,74 +37794,58 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ /* Constants and temporary variables aren't yieldable by reference, * but we still allow them with a notice. */ if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) { - zval *value, *copy; + zval *value; zend_error(E_NOTICE, "Only variable references should be yielded by reference"); value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); + ZVAL_COPY_VALUE(&generator->value, value); + if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1); /* Temporary variables don't need ctor copying */ if (!0) { - zval_copy_ctor(copy); + zval_copy_ctor(&generator->value); } - - generator->value = copy; } else { - zval **value_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); - if (IS_CV == IS_VAR && UNEXPECTED(value_ptr == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference"); } /* If a function call result is yielded and the function did * not return by reference we throw a notice. */ - if (IS_CV == IS_VAR && !Z_ISREF_PP(value_ptr) + if (IS_CV == IS_VAR && !Z_ISREF_P(value_ptr) && !(opline->extended_value == ZEND_RETURNS_FUNCTION - && EX_T(opline->op1.var).var.fcall_returned_reference) - && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) { + && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); - - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } else { SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr); - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } + ZVAL_COPY(&generator->value, value_ptr); } } else { zval *value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); /* Consts, temporary variables and references need copying */ - if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR - || PZVAL_IS_REF(value) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); - - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } - - generator->value = copy; + if (IS_CV == IS_CONST) { + ZVAL_DUP(&generator->value, value); + } else if (IS_CV == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->value, value); + } else if (Z_ISREF_P(value)) { + ZVAL_DUP(&generator->value, Z_REFVAL_P(value)); } else { if (IS_CV == IS_CV) { - Z_ADDREF_P(value); + if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value); } - generator->value = value; + ZVAL_COPY_VALUE(&generator->value, value); } } } else { /* If no value was specified yield null */ - Z_ADDREF(EG(uninitialized_zval)); - generator->value = &EG(uninitialized_zval); + ZVAL_NULL(&generator->value); } /* Set the new yielded key */ @@ -39159,45 +37854,36 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ zval *key = NULL; /* Consts, temporary variables and references need copying */ - if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR - || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, key); - - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } + if (IS_UNUSED == IS_CONST) { + ZVAL_DUP(&generator->key, key); + } else if (IS_UNUSED == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->key, key); + } else if (Z_ISREF_P(key)) { + ZVAL_DUP(&generator->key, Z_REFVAL_P(key)); - generator->key = copy; } else { - Z_ADDREF_P(key); - generator->key = key; + if (IS_UNUSED == IS_CV) { + if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key); + } + ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE_P(generator->key) == IS_LONG - && Z_LVAL_P(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_LONG + && Z_LVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL_P(generator->key); + generator->largest_used_integer_key = Z_LVAL(generator->key); } - } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - - ALLOC_INIT_ZVAL(generator->key); - ZVAL_LONG(generator->key, generator->largest_used_integer_key); + ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ - generator->send_target = &EX_T(opline->result.var).var.ptr; - Z_ADDREF(EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + generator->send_target = EX_VAR(opline->result.var); + ZVAL_NULL(generator->send_target); } else { generator->send_target = NULL; } @@ -39224,7 +37910,7 @@ static int ZEND_FASTCALL ZEND_ADD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) SAVE_OPLINE(); - fast_add_function(&EX_T(opline->result.var).tmp_var, + fast_add_function(EX_VAR(opline->result.var), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); @@ -39239,7 +37925,7 @@ static int ZEND_FASTCALL ZEND_SUB_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) SAVE_OPLINE(); - fast_sub_function(&EX_T(opline->result.var).tmp_var, + fast_sub_function(EX_VAR(opline->result.var), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); @@ -39254,7 +37940,7 @@ static int ZEND_FASTCALL ZEND_MUL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) SAVE_OPLINE(); - fast_mul_function(&EX_T(opline->result.var).tmp_var, + fast_mul_function(EX_VAR(opline->result.var), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); @@ -39269,7 +37955,7 @@ static int ZEND_FASTCALL ZEND_DIV_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) SAVE_OPLINE(); - fast_div_function(&EX_T(opline->result.var).tmp_var, + fast_div_function(EX_VAR(opline->result.var), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); @@ -39284,9 +37970,9 @@ static int ZEND_FASTCALL ZEND_MOD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) SAVE_OPLINE(); - fast_mod_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + fast_mod_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); CHECK_EXCEPTION(); @@ -39299,9 +37985,9 @@ static int ZEND_FASTCALL ZEND_SL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) SAVE_OPLINE(); - shift_left_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + shift_left_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); CHECK_EXCEPTION(); @@ -39314,9 +38000,9 @@ static int ZEND_FASTCALL ZEND_SR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) SAVE_OPLINE(); - shift_right_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + shift_right_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); CHECK_EXCEPTION(); @@ -39329,9 +38015,9 @@ static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG SAVE_OPLINE(); - concat_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + concat_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); CHECK_EXCEPTION(); @@ -39344,9 +38030,9 @@ static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDL SAVE_OPLINE(); - is_identical_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + fast_is_identical_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); CHECK_EXCEPTION(); @@ -39357,13 +38043,12 @@ static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_H { USE_OPLINE - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - is_identical_function(result, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); - Z_LVAL_P(result) = !Z_LVAL_P(result); + fast_is_not_identical_function(result, + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); CHECK_EXCEPTION(); @@ -39374,12 +38059,12 @@ static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_A { USE_OPLINE - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_equal_function(result, + fast_equal_function(result, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); CHECK_EXCEPTION(); @@ -39390,12 +38075,12 @@ static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDL { USE_OPLINE - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_not_equal_function(result, + fast_not_equal_function(result, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); CHECK_EXCEPTION(); @@ -39406,12 +38091,12 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER { USE_OPLINE - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_is_smaller_function(result, + fast_is_smaller_function(result, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); CHECK_EXCEPTION(); @@ -39422,12 +38107,12 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCOD { USE_OPLINE - zval *result = &EX_T(opline->result.var).tmp_var; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result, + fast_is_smaller_or_equal_function(result, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC)); + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); CHECK_EXCEPTION(); @@ -39440,9 +38125,9 @@ static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS SAVE_OPLINE(); - bitwise_or_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + bitwise_or_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); CHECK_EXCEPTION(); @@ -39455,9 +38140,9 @@ static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG SAVE_OPLINE(); - bitwise_and_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + bitwise_and_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); CHECK_EXCEPTION(); @@ -39470,9 +38155,9 @@ static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG SAVE_OPLINE(); - bitwise_xor_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + bitwise_xor_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); CHECK_EXCEPTION(); @@ -39485,9 +38170,9 @@ static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_A SAVE_OPLINE(); - boolean_xor_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + boolean_xor_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); CHECK_EXCEPTION(); @@ -39498,18 +38183,18 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CV(int (*binar { USE_OPLINE zend_free_op free_op_data1; - zval **object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); - zval *object; + zval *object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); zval *property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); + zval *value; int have_get_ptr = 0; - if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - make_real_object(object_ptr TSRMLS_CC); - object = *object_ptr; + object = make_real_object(object TSRMLS_CC); + + value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { zend_error(E_WARNING, "Attempt to assign property of non-object"); @@ -39517,81 +38202,67 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CV(int (*binar FREE_OP(free_op_data1); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } } else { /* here we are sure we are dealing with an object */ - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - - /* here property is a string */ if (opline->extended_value == ZEND_ASSIGN_OBJ && Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); if (zptr != NULL) { /* NULL means no success in getting PTR */ SEPARATE_ZVAL_IF_NOT_REF(zptr); have_get_ptr = 1; - binary_op(*zptr, *zptr, value TSRMLS_CC); + binary_op(zptr, zptr, value TSRMLS_CC); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(*zptr); - EX_T(opline->result.var).var.ptr = *zptr; + ZVAL_COPY(EX_VAR(opline->result.var), zptr); } } } if (!have_get_ptr) { zval *z = NULL; + zval rv; if (opline->extended_value == ZEND_ASSIGN_OBJ) { if (Z_OBJ_HT_P(object)->read_property) { - z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC); } } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { if (Z_OBJ_HT_P(object)->read_dimension) { - z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC); + z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R, &rv TSRMLS_CC); } } if (z) { if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); zval_dtor(z); - FREE_ZVAL(z); } - z = value; + ZVAL_COPY_VALUE(z, value); } - Z_ADDREF_P(z); - SEPARATE_ZVAL_IF_NOT_REF(&z); +//??? if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); + SEPARATE_ZVAL_IF_NOT_REF(z); binary_op(z, z, value TSRMLS_CC); if (opline->extended_value == ZEND_ASSIGN_OBJ) { - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ { Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(z); - EX_T(opline->result.var).var.ptr = z; + ZVAL_COPY(EX_VAR(opline->result.var), z); } - zval_ptr_dtor(&z); + zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to assign property of non-object"); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } } } - if (0) { - zval_ptr_dtor(&property); - } else { - - } FREE_OP(free_op_data1); } @@ -39601,178 +38272,288 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CV(int (*binar ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_CV_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_free_op free_op_data2, free_op_data1; - zval **var_ptr; - zval *value; + zval *var_ptr; + zval *value, *container; SAVE_OPLINE(); - switch (opline->extended_value) { - case ZEND_ASSIGN_OBJ: - return zend_binary_assign_op_obj_helper_SPEC_CV_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - break; - case ZEND_ASSIGN_DIM: { - zval **container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); - - if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); - } else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) { - if (IS_CV == IS_VAR && !0) { - Z_ADDREF_PP(container); /* undo the effect of get_obj_zval_ptr_ptr() */ - } - return zend_binary_assign_op_obj_helper_SPEC_CV_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - } else { - zval *dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); + container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { + zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); + } else if (UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { + if (IS_CV == IS_VAR && !0) { + Z_ADDREF_P(container); /* undo the effect of get_obj_zval_ptr_ptr() */ + } + return zend_binary_assign_op_obj_helper_SPEC_CV_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else { + zval *dim = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_CV, BP_VAR_RW TSRMLS_CC); - value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); - var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); - } - } - break; - default: - value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); - /* do nothing */ - break; + zend_fetch_dimension_address_RW(EX_VAR((opline+1)->op2.var), container, dim, IS_CV TSRMLS_CC); + value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); + var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); } - if (UNEXPECTED(var_ptr == NULL)) { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); } - if (UNEXPECTED(*var_ptr == &EG(error_zval))) { - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + if (UNEXPECTED(var_ptr == &EG(error_zval))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); } + goto assign_op_dim_exit; + } + SEPARATE_ZVAL_IF_NOT_REF(var_ptr); + ZVAL_DEREF(var_ptr); - CHECK_EXCEPTION(); - if (opline->extended_value == ZEND_ASSIGN_DIM) { - ZEND_VM_INC_OPCODE(); + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) && + UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) { + /* proxy object */ + zval rv; + zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC); + Z_ADDREF_P(objval); + binary_op(objval, objval, value TSRMLS_CC); + Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); + zval_ptr_dtor(objval); + } else { + binary_op(var_ptr, var_ptr, value TSRMLS_CC); + } + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + } + +assign_op_dim_exit: + + FREE_OP(free_op_data1); + FREE_OP_VAR_PTR(free_op_data2); + + CHECK_EXCEPTION(); + ZEND_VM_INC_OPCODE(); + ZEND_VM_NEXT_OPCODE(); +} + +static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + + zval *var_ptr; + zval *value; + + SAVE_OPLINE(); + value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); + var_ptr = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); + + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) { + zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); + } + + if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); } - ZEND_VM_NEXT_OPCODE(); + goto assign_op_exit; } SEPARATE_ZVAL_IF_NOT_REF(var_ptr); + ZVAL_DEREF(var_ptr); - if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT) - && Z_OBJ_HANDLER_PP(var_ptr, get) - && Z_OBJ_HANDLER_PP(var_ptr, set)) { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) && + UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) { /* proxy object */ - zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC); + zval rv; + zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC); Z_ADDREF_P(objval); binary_op(objval, objval, value TSRMLS_CC); - Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC); - zval_ptr_dtor(&objval); + Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC); + zval_ptr_dtor(objval); } else { - binary_op(*var_ptr, *var_ptr, value TSRMLS_CC); + binary_op(var_ptr, var_ptr, value TSRMLS_CC); } - if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(*var_ptr); - EX_T(opline->result.var).var.ptr = *var_ptr; + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } - if (opline->extended_value == ZEND_ASSIGN_DIM) { - FREE_OP(free_op_data1); - FREE_OP_VAR_PTR(free_op_data2); +assign_op_exit: - CHECK_EXCEPTION(); - ZEND_VM_INC_OPCODE(); - } else { - CHECK_EXCEPTION(); - } + CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_binary_assign_op_helper_SPEC_CV_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + if (EXPECTED(opline->extended_value == 0)) { + return zend_binary_assign_op_helper_SPEC_CV_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) { + return zend_binary_assign_op_dim_helper_SPEC_CV_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ { + return zend_binary_assign_op_obj_helper_SPEC_CV_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + } } static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval **object_ptr; zval *object; zval *property; - zval **retval; + zval *retval; int have_get_ptr = 0; SAVE_OPLINE(); - object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); + object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - retval = &EX_T(opline->result.var).var.ptr; + retval = EX_VAR(opline->result.var); - if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } - make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ - object = *object_ptr; + object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */ if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - *retval = &EG(uninitialized_zval); + ZVAL_NULL(retval); } CHECK_EXCEPTION(); @@ -39781,59 +38562,49 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_CV(incdec_t inc /* here we are sure we are dealing with an object */ - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); if (zptr != NULL) { /* NULL means no success in getting PTR */ SEPARATE_ZVAL_IF_NOT_REF(zptr); have_get_ptr = 1; - incdec_op(*zptr); + incdec_op(zptr); if (RETURN_VALUE_USED(opline)) { - *retval = *zptr; - PZVAL_LOCK(*retval); + ZVAL_COPY(retval, zptr); } } } if (!have_get_ptr) { + zval rv; + if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC); if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); zval_dtor(z); - FREE_ZVAL(z); } - z = value; + ZVAL_COPY_VALUE(z, value); } - Z_ADDREF_P(z); - SEPARATE_ZVAL_IF_NOT_REF(&z); + if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); + SEPARATE_ZVAL_IF_NOT_REF(z); incdec_op(z); - *retval = z; - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - SELECTIVE_PZVAL_LOCK(*retval, opline); - zval_ptr_dtor(&z); + ZVAL_COPY_VALUE(retval, z); + Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); + SELECTIVE_PZVAL_LOCK(retval, opline); + zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - *retval = &EG(uninitialized_zval); + ZVAL_NULL(retval); } } } - if (0) { - zval_ptr_dtor(&property); - } else { - - } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -39853,23 +38624,21 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_CV(incdec_t in { USE_OPLINE - zval **object_ptr; zval *object; zval *property; zval *retval; int have_get_ptr = 0; SAVE_OPLINE(); - object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); + object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - retval = &EX_T(opline->result.var).tmp_var; + retval = EX_VAR(opline->result.var); - if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } - make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */ - object = *object_ptr; + object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */ if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); @@ -39882,60 +38651,47 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_CV(incdec_t in /* here we are sure we are dealing with an object */ - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) { - zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); if (zptr != NULL) { /* NULL means no success in getting PTR */ have_get_ptr = 1; SEPARATE_ZVAL_IF_NOT_REF(zptr); - ZVAL_COPY_VALUE(retval, *zptr); - zendi_zval_copy_ctor(*retval); + ZVAL_DUP(retval, zptr); - incdec_op(*zptr); + incdec_op(zptr); } } if (!have_get_ptr) { if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - zval *z_copy; + zval rv; + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC); + zval z_copy; if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { - zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC); + zval rv; + zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); if (Z_REFCOUNT_P(z) == 0) { - GC_REMOVE_ZVAL_FROM_BUFFER(z); zval_dtor(z); - FREE_ZVAL(z); } - z = value; + ZVAL_COPY_VALUE(z, value); } - ZVAL_COPY_VALUE(retval, z); - zendi_zval_copy_ctor(*retval); - ALLOC_ZVAL(z_copy); - INIT_PZVAL_COPY(z_copy, z); - zendi_zval_copy_ctor(*z_copy); - incdec_op(z_copy); - Z_ADDREF_P(z); - Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); + ZVAL_DUP(retval, z); + ZVAL_DUP(&z_copy, z); + incdec_op(&z_copy); + if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); + Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC); zval_ptr_dtor(&z_copy); - zval_ptr_dtor(&z); + zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); ZVAL_NULL(retval); } } - if (0) { - zval_ptr_dtor(&property); - } else { - - } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -39959,7 +38715,7 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLE SAVE_OPLINE(); container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); - zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC); if (IS_CV != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) { @@ -39972,29 +38728,22 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLE { USE_OPLINE zend_free_op free_op1; - zval **container; + zval *container; SAVE_OPLINE(); - container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); - if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_W TSRMLS_CC); - - if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + if (EXPECTED(opline->extended_value == 0)) { + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC); + } else { + zend_fetch_dimension_address_W_ref(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC); } - /* We are going to assign the result by reference */ - if (UNEXPECTED(opline->extended_value != 0)) { - zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; - - if (retval_ptr) { - Z_DELREF_PP(retval_ptr); - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); - Z_ADDREF_PP(retval_ptr); - } + if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } CHECK_EXCEPTION(); @@ -40005,18 +38754,18 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDL { USE_OPLINE zend_free_op free_op1; - zval **container; + zval *container; SAVE_OPLINE(); - container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); - if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_RW TSRMLS_CC); + zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC); if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } CHECK_EXCEPTION(); @@ -40031,7 +38780,7 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDL SAVE_OPLINE(); container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC); - zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_IS TSRMLS_CC); + zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC); CHECK_EXCEPTION(); @@ -40041,29 +38790,28 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDL static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE + zval *container; zend_free_op free_op1; SAVE_OPLINE(); if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { - zval **container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_W TSRMLS_CC); + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC); if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } } else { - zval *container; - if (IS_CV == IS_UNUSED) { zend_error_noreturn(E_ERROR, "Cannot use [] for reading"); } container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); - zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC); } @@ -40075,41 +38823,22 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HA { USE_OPLINE zend_free_op free_op1; - zval **container; + zval *container; SAVE_OPLINE(); - container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC); - if (IS_CV == IS_CV) { - if (container != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(container); - } - } - if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_UNSET TSRMLS_CC); + zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC); if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); - ZEND_VM_NEXT_OPCODE(); - } else { - zend_free_op free_res; - zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; - - PZVAL_UNLOCK(*retval_ptr, &free_res); - if (retval_ptr != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(retval_ptr); - } - PZVAL_LOCK(*retval_ptr); - FREE_OP_VAR_PTR(free_res); - CHECK_EXCEPTION(); - ZEND_VM_NEXT_OPCODE(); - } + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_CV(ZEND_OPCODE_HANDLER_ARGS) @@ -40121,35 +38850,25 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_CV(ZEND zval *offset; SAVE_OPLINE(); - container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { zend_error(E_NOTICE, "Trying to get property of non-object"); - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - + ZVAL_NULL(EX_VAR(opline->result.var)); } else { zval *retval; - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - /* here we are sure we are dealing with an object */ - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - - PZVAL_LOCK(retval); - EX_T(opline->result.var).var.ptr = retval; - - if (0) { - zval_ptr_dtor(&offset); - } else { + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC); + if (retval != EX_VAR(opline->result.var)) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); } } + CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -40164,38 +38883,20 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLE USE_OPLINE zend_free_op free_op1; zval *property; - zval **container; + zval *container; SAVE_OPLINE(); property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); - if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { + container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property); - } else { + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC); - } if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); - } - - /* We are going to assign the result by reference */ - if (opline->extended_value & ZEND_FETCH_MAKE_REF) { - zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr; - - Z_DELREF_PP(retval_ptr); - SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr); - Z_ADDREF_PP(retval_ptr); - EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr; - EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr; + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } CHECK_EXCEPTION(); @@ -40207,26 +38908,19 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDL USE_OPLINE zend_free_op free_op1; zval *property; - zval **container; + zval *container; SAVE_OPLINE(); property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property); - } else { + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_RW, 0 TSRMLS_CC); - } if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } CHECK_EXCEPTION(); @@ -40242,34 +38936,24 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDL zval *offset; SAVE_OPLINE(); - container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_deref_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC); offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) || UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - + ZVAL_NULL(EX_VAR(opline->result.var)); } else { zval *retval; - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - /* here we are sure we are dealing with an object */ - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - - PZVAL_LOCK(retval); - EX_T(opline->result.var).var.ptr = retval; - - if (0) { - zval_ptr_dtor(&offset); - } else { + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC); + if (retval != EX_VAR(opline->result.var)) { + ZVAL_COPY(EX_VAR(opline->result.var), retval); } } + CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -40277,31 +38961,24 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDL static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE + zval *container; if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) { /* Behave like FETCH_OBJ_W */ zend_free_op free_op1; zval *property; - zval **container; SAVE_OPLINE(); property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property); - } else { + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, 0 TSRMLS_CC); - } if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } CHECK_EXCEPTION(); @@ -40314,41 +38991,22 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_free_op free_op1, free_res; - zval **container; - zval *property; + zend_free_op free_op1; + zval *container, *property; SAVE_OPLINE(); - container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC); property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - if (IS_CV == IS_CV) { - if (container != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(container); - } - } - if (0) { - MAKE_REAL_ZVAL_PTR(property); - } - if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property); - } else { + zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_UNSET, 0 TSRMLS_CC); - } if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) { - EXTRACT_ZVAL_PTR(&EX_T(opline->result.var)); + EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } - PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res); - if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr); - } - PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr); - FREE_OP_VAR_PTR(free_res); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } @@ -40357,25 +39015,18 @@ static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER { USE_OPLINE - zval **object_ptr; + zval *object; zval *property_name; SAVE_OPLINE(); - object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + object = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - if (0) { - MAKE_REAL_ZVAL_PTR(property_name); - } - if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property_name); - } else { + zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC); - } /* assign_obj has two opcodes! */ CHECK_EXCEPTION(); @@ -40387,73 +39038,56 @@ static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER { USE_OPLINE - zval **object_ptr; + zval *object_ptr; SAVE_OPLINE(); - object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + object_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); - if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - if (Z_TYPE_PP(object_ptr) == IS_OBJECT) { + if (UNEXPECTED(Z_ISREF_P(object_ptr)) && Z_TYPE_P(Z_REFVAL_P(object_ptr)) == IS_OBJECT) { + object_ptr = Z_REFVAL_P(object_ptr); + } + if (Z_TYPE_P(object_ptr) == IS_OBJECT) { zval *property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - if (0) { - MAKE_REAL_ZVAL_PTR(property_name); - } - zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - if (0) { - zval_ptr_dtor(&property_name); - } else { + zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC); - } } else { zend_free_op free_op_data1, free_op_data2; zval *value; - zval *dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - zval **variable_ptr_ptr; + zval *dim = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); + zval *variable_ptr; - zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_CV, BP_VAR_W TSRMLS_CC); + zend_fetch_dimension_address_W(EX_VAR((opline+1)->op2.var), object_ptr, dim, IS_CV TSRMLS_CC); value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); - variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); - if (UNEXPECTED(variable_ptr_ptr == NULL)) { - if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) { - if (RETURN_VALUE_USED(opline)) { - zval *retval; - - ALLOC_ZVAL(retval); - ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1); - INIT_PZVAL(retval); - EX_T(opline->result.var).var.ptr = retval; - } - } else if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - } - } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) { + variable_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC); + if (UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) { + zend_assign_to_string_offset(variable_ptr, value, (opline+1)->op1_type, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC); + } else if (UNEXPECTED(variable_ptr == &EG(error_zval))) { if (IS_TMP_FREE(free_op_data1)) { zval_dtor(value); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } + FREE_OP_VAR_PTR(free_op_data2); } else { if ((opline+1)->op1_type == IS_TMP_VAR) { - value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_tmp_to_variable(variable_ptr, value TSRMLS_CC); } else if ((opline+1)->op1_type == IS_CONST) { - value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_const_to_variable(variable_ptr, value TSRMLS_CC); } else { - value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_to_variable(variable_ptr, value TSRMLS_CC); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(value); - EX_T(opline->result.var).var.ptr = value; + ZVAL_COPY(EX_VAR(opline->result.var), value); } + FREE_OP_VAR_PTR(free_op_data2); } - FREE_OP_VAR_PTR(free_op_data2); FREE_OP_IF_VAR(free_op_data1); } @@ -40468,46 +39102,33 @@ static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG USE_OPLINE zval *value; - zval **variable_ptr_ptr; + zval *variable_ptr; SAVE_OPLINE(); value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - variable_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); - - if (IS_CV == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) { - if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_CV TSRMLS_CC)) { - if (RETURN_VALUE_USED(opline)) { - zval *retval; + variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); - ALLOC_ZVAL(retval); - ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1); - INIT_PZVAL(retval); - EX_T(opline->result.var).var.ptr = retval; - } - } else if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); - } - } else if (IS_CV == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) { + zend_assign_to_string_offset(variable_ptr, value, IS_CV, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC); + } else if (IS_CV == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) { if (0) { zval_dtor(value); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(&EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + ZVAL_NULL(EX_VAR(opline->result.var)); } } else { if (IS_CV == IS_TMP_VAR) { - value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_tmp_to_variable(variable_ptr, value TSRMLS_CC); } else if (IS_CV == IS_CONST) { - value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_const_to_variable(variable_ptr, value TSRMLS_CC); } else { - value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC); + value = zend_assign_to_variable(variable_ptr, value TSRMLS_CC); } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(value); - EX_T(opline->result.var).var.ptr = value; + ZVAL_COPY(EX_VAR(opline->result.var), value); } + } /* zend_assign_to_variable() always takes care of op2, never free it! */ @@ -40519,20 +39140,19 @@ static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG static int ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_free_op free_op2; - zval **variable_ptr_ptr; - zval **value_ptr_ptr; + + zval *variable_ptr; + zval *value_ptr; SAVE_OPLINE(); - value_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op2.var TSRMLS_CC); + value_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op2.var TSRMLS_CC); if (IS_CV == IS_VAR && - value_ptr_ptr && - !Z_ISREF_PP(value_ptr_ptr) && opline->extended_value == ZEND_RETURNS_FUNCTION && - !EX_T(opline->op2.var).var.fcall_returned_reference) { - if (free_op2.var == NULL) { - PZVAL_LOCK(*value_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */ + !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF) && + !Z_ISREF_P(value_ptr)) { + if (!0) { + PZVAL_LOCK(value_ptr); /* undo the effect of get_zval_ptr_ptr() */ } zend_error(E_STRICT, "Only variables should be assigned by reference"); if (UNEXPECTED(EG(exception) != NULL)) { @@ -40541,26 +39161,36 @@ static int ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER } return ZEND_ASSIGN_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); } else if (IS_CV == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) { - PZVAL_LOCK(*value_ptr_ptr); + if (!0) { + PZVAL_LOCK(value_ptr); + } } - if (IS_CV == IS_VAR && UNEXPECTED(EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr)) { + + variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + if (IS_CV == IS_VAR && + UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT) && + UNEXPECTED(!Z_ISREF_P(variable_ptr))) { zend_error_noreturn(E_ERROR, "Cannot assign by reference to overloaded object"); } - - variable_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); - if ((IS_CV == IS_VAR && UNEXPECTED(value_ptr_ptr == NULL)) || - (IS_CV == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL))) { + if ((IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) || + (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET))) { zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets nor overloaded objects"); } - zend_assign_to_variable_reference(variable_ptr_ptr, value_ptr_ptr TSRMLS_CC); + if ((IS_CV == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) || + (IS_CV == IS_VAR && UNEXPECTED(value_ptr == &EG(error_zval)))) { + variable_ptr = &EG(uninitialized_zval); + } else { + zend_assign_to_variable_reference(variable_ptr, value_ptr TSRMLS_CC); + } if (IS_CV == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) { - Z_DELREF_PP(variable_ptr_ptr); + if (!0) { + Z_DELREF_P(variable_ptr); + } } if (RETURN_VALUE_USED(opline)) { - PZVAL_LOCK(*variable_ptr_ptr); - EX_T(opline->result.var).var.ptr = *variable_ptr_ptr; + ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr); } @@ -40572,10 +39202,9 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_H { USE_OPLINE zval *function_name; - char *function_name_strval; - int function_name_strlen; call_slot *call = EX(call_slots) + opline->result.num; + zval *object; SAVE_OPLINE(); @@ -40589,33 +39218,30 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_H zend_error_noreturn(E_ERROR, "Method name must be a string"); } - function_name_strval = Z_STRVAL_P(function_name); - function_name_strlen = Z_STRLEN_P(function_name); - - call->object = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); + object = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); + call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL; - if (EXPECTED(call->object != NULL) && - EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) { - call->called_scope = Z_OBJCE_P(call->object); + if (EXPECTED(call->object != NULL)) { + call->called_scope = zend_get_class_entry(call->object TSRMLS_CC); if (IS_CV != IS_CONST || - (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) { - zval *object = call->object; + (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope)) == NULL) { + zend_object *object = call->object; - if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) { + if (UNEXPECTED(object->handlers->get_method == NULL)) { zend_error_noreturn(E_ERROR, "Object does not support method calls"); } /* First, locate the function. */ - call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC); + call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); if (UNEXPECTED(call->fbc == NULL)) { - zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval); + zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name)); } if (IS_CV == IS_CONST && EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) && EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) && EXPECTED(call->object == object)) { - CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc); + CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope, call->fbc); } } } else { @@ -40623,21 +39249,13 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_H HANDLE_EXCEPTION(); } - zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval); + zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", Z_STRVAL_P(function_name)); } if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) { call->object = NULL; } else { - if (!PZVAL_IS_REF(call->object)) { - Z_ADDREF_P(call->object); /* For $this pointer */ - } else { - zval *this_ptr; - ALLOC_ZVAL(this_ptr); - INIT_PZVAL_COPY(this_ptr, call->object); - zval_copy_ctor(this_ptr); - call->object = this_ptr; - } + GC_REFCOUNT(call->object)++; /* For $this pointer */ } call->num_additional_args = 0; @@ -40653,11 +39271,12 @@ static int ZEND_FASTCALL ZEND_CASE_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - is_equal_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + fast_equal_function(result, + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -40667,35 +39286,31 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_ { USE_OPLINE - zval *expr_ptr; + zval *expr_ptr, new_expr; SAVE_OPLINE(); - if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) { - zval **expr_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); - - if (IS_CV == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) { + if ((IS_CV == IS_VAR || IS_CV == IS_CV) && + (opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) { + expr_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets"); } - SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); - expr_ptr = *expr_ptr_ptr; + SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr); Z_ADDREF_P(expr_ptr); + } else { - expr_ptr=_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); + expr_ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); if (0) { /* temporary variable */ - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - } else if (IS_CV == IS_CONST || PZVAL_IS_REF(expr_ptr)) { - zval *new_expr; - - ALLOC_ZVAL(new_expr); - INIT_PZVAL_COPY(new_expr, expr_ptr); - expr_ptr = new_expr; - zendi_zval_copy_ctor(*expr_ptr); + ZVAL_COPY_VALUE(&new_expr, expr_ptr); + expr_ptr = &new_expr; + } else if (IS_CV == IS_CONST) { + ZVAL_DUP(&new_expr, expr_ptr); + expr_ptr = &new_expr; + } else if (Z_ISREF_P(expr_ptr)) { + ZVAL_DUP(&new_expr, Z_REFVAL_P(expr_ptr)); + expr_ptr = &new_expr; - } else if (IS_CV == IS_CV) { + } else if (IS_CV == IS_CV && Z_REFCOUNTED_P(expr_ptr)) { Z_ADDREF_P(expr_ptr); } } @@ -40703,42 +39318,49 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_ if (IS_CV != IS_UNUSED) { zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); + zend_string *str; ulong hval; +add_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: hval = zend_dval_to_lval(Z_DVAL_P(offset)); goto num_index; case IS_LONG: - case IS_BOOL: hval = Z_LVAL_P(offset); num_index: - zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL); + zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); break; case IS_STRING: - if (IS_CV == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); + str = Z_STR_P(offset); + if (IS_CV != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index); } - zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL); +str_index: + zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); break; case IS_NULL: - zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL); + str = STR_EMPTY_ALLOC(); + goto str_index; + case IS_FALSE: + hval = 0; + goto num_index; + case IS_TRUE: + hval = 1; + goto num_index; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto add_again; break; default: zend_error(E_WARNING, "Illegal offset type"); - zval_ptr_dtor(&expr_ptr); + zval_ptr_dtor(expr_ptr); /* do nothing */ break; } } else { - zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL); - } - if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) { - + zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr); } CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -40746,9 +39368,26 @@ num_index: static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { + zval *array; + zend_uint size; USE_OPLINE - array_init(&EX_T(opline->result.var).tmp_var); + array = EX_VAR(opline->result.var); + if (IS_CV != IS_UNUSED) { + size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; + } else { + size = 0; + } + ZVAL_NEW_ARR(array); + zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0); + + if (IS_CV != IS_UNUSED) { + /* Explicitly initialize array as not-packed if flag is set */ + if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) { + zend_hash_real_init(Z_ARRVAL_P(array), 0); + } + } + if (IS_CV == IS_UNUSED) { ZEND_VM_NEXT_OPCODE(); #if 0 || IS_CV != IS_UNUSED @@ -40762,91 +39401,98 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ { USE_OPLINE - zval **container; + zval *container; zval *offset; ulong hval; SAVE_OPLINE(); - container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC); - if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) { + container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC); + if (IS_CV != IS_UNUSED) { SEPARATE_ZVAL_IF_NOT_REF(container); } offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - if (IS_CV != IS_VAR || container) { - switch (Z_TYPE_PP(container)) { - case IS_ARRAY: { - HashTable *ht = Z_ARRVAL_PP(container); - - switch (Z_TYPE_P(offset)) { - case IS_DOUBLE: - hval = zend_dval_to_lval(Z_DVAL_P(offset)); - zend_hash_index_del(ht, hval); - break; - case IS_RESOURCE: - case IS_BOOL: - case IS_LONG: - hval = Z_LVAL_P(offset); - zend_hash_index_del(ht, hval); - break; - case IS_STRING: - if (IS_CV == IS_CV || IS_CV == IS_VAR) { - Z_ADDREF_P(offset); - } - if (IS_CV == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); - } - if (ht == &EG(symbol_table)) { - zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC); - } else { - zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval); - } - if (IS_CV == IS_CV || IS_CV == IS_VAR) { - zval_ptr_dtor(&offset); - } - break; +container_again: + switch (Z_TYPE_P(container)) { + case IS_ARRAY: { + HashTable *ht = Z_ARRVAL_P(container); +offset_again: + switch (Z_TYPE_P(offset)) { + case IS_DOUBLE: + hval = zend_dval_to_lval(Z_DVAL_P(offset)); + zend_hash_index_del(ht, hval); + break; + case IS_LONG: + hval = Z_LVAL_P(offset); num_index_dim: - zend_hash_index_del(ht, hval); - if (IS_CV == IS_CV || IS_CV == IS_VAR) { - zval_ptr_dtor(&offset); - } - break; - case IS_NULL: - zend_hash_del(ht, "", sizeof("")); - break; - default: - zend_error(E_WARNING, "Illegal offset type in unset"); - break; - } - - break; + zend_hash_index_del(ht, hval); + break; + case IS_STRING: + if (IS_CV == IS_CV || IS_CV == IS_VAR) { + if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset); + } + if (IS_CV != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto numeric_index_dim); + } + if (ht == &EG(symbol_table).ht) { + zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC); + } else { + zend_hash_del(ht, Z_STR_P(offset)); + } + if (IS_CV == IS_CV || IS_CV == IS_VAR) { + zval_ptr_dtor(offset); + } + break; +numeric_index_dim: + zend_hash_index_del(ht, hval); + if (IS_CV == IS_CV || IS_CV == IS_VAR) { + zval_ptr_dtor(offset); + } + break; + case IS_NULL: + zend_hash_del(ht, STR_EMPTY_ALLOC()); + break; + case IS_FALSE: + hval = 0; + goto num_index_dim; + case IS_TRUE: + hval = 1; + goto num_index_dim; + case IS_RESOURCE: + hval = Z_RES_HANDLE_P(offset); + goto num_index_dim; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto offset_again; + break; + default: + zend_error(E_WARNING, "Illegal offset type in unset"); + break; } - case IS_OBJECT: - if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) { - zend_error_noreturn(E_ERROR, "Cannot use object as array"); - } - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC); - if (0) { - zval_ptr_dtor(&offset); - } else { - } - break; - case IS_STRING: - zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); - ZEND_VM_CONTINUE(); /* bailed out before */ - default: - - break; + break; } - } else { + case IS_OBJECT: + if (UNEXPECTED(Z_OBJ_HT_P(container)->unset_dimension == NULL)) { + zend_error_noreturn(E_ERROR, "Cannot use object as array"); + } +//??? if (IS_CV == IS_CONST) { +//??? zval_copy_ctor(offset); +//??? } + Z_OBJ_HT_P(container)->unset_dimension(container, offset TSRMLS_CC); + + break; + case IS_STRING: + case IS_STR_OFFSET: + zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); + ZEND_VM_CONTINUE(); /* bailed out before */ + case IS_REFERENCE: + container = Z_REFVAL_P(container); + goto container_again; + break; + default: + break; } CHECK_EXCEPTION(); @@ -40857,90 +39503,82 @@ static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ { USE_OPLINE - zval **container; + zval *container; zval *offset; SAVE_OPLINE(); - container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC); + if (IS_CV == IS_VAR && Z_TYPE_P(container) == IS_STR_OFFSET) { + zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); + } offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - if (IS_CV != IS_VAR || container) { - if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(container); - } - if (Z_TYPE_PP(container) == IS_OBJECT) { - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - if (Z_OBJ_HT_P(*container)->unset_property) { - Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to unset property of non-object"); - } - if (0) { - zval_ptr_dtor(&offset); - } else { - - } + ZVAL_DEREF(container); + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->unset_property) { + Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); } else { - + zend_error(E_NOTICE, "Trying to unset property of non-object"); } - } else { - } + CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CV(int prop_dim, ZEND_OPCODE_HANDLER_ARGS) +static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; - zval **value = NULL; - int result = 0; + int result; ulong hval; zval *offset; SAVE_OPLINE(); - container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC); + container = _get_zval_ptr_cv_deref_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC); offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); - if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) { - HashTable *ht; - int isset = 0; - - ht = Z_ARRVAL_P(container); + if (Z_TYPE_P(container) == IS_ARRAY) { + HashTable *ht = Z_ARRVAL_P(container); + zval *value = NULL; + zend_string *str; +isset_again: switch (Z_TYPE_P(offset)) { case IS_DOUBLE: hval = zend_dval_to_lval(Z_DVAL_P(offset)); goto num_index_prop; - case IS_RESOURCE: - case IS_BOOL: case IS_LONG: hval = Z_LVAL_P(offset); num_index_prop: - if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) { - isset = 1; - } + value = zend_hash_index_find(ht, hval); break; case IS_STRING: - if (IS_CV == IS_CONST) { - hval = Z_HASH_P(offset); - } else { - ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop); - hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset)); - } - if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) { - isset = 1; + str = Z_STR_P(offset); + if (IS_CV != IS_CONST) { + ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index_prop); } +str_index_prop: + value = zend_hash_find_ind(ht, str); break; case IS_NULL: - if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) { - isset = 1; - } + str = STR_EMPTY_ALLOC(); + goto str_index_prop; + break; + case IS_FALSE: + hval = 0; + goto num_index_prop; + case IS_TRUE: + hval = 0; + goto num_index_prop; + case IS_RESOURCE: + hval = Z_RES_HANDLE_P(offset); + goto num_index_prop; + case IS_REFERENCE: + offset = Z_REFVAL_P(offset); + goto isset_again; break; default: zend_error(E_WARNING, "Illegal offset type in isset or empty"); @@ -40948,116 +39586,103 @@ num_index_prop: } if (opline->extended_value & ZEND_ISSET) { - if (isset && Z_TYPE_PP(value) == IS_NULL) { - result = 0; - } else { - result = isset; - } + /* > IS_NULL means not IS_UNDEF and not IS_NULL */ + result = (value != NULL && Z_TYPE_P(value) > IS_NULL); } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { - if (!isset || !i_zend_is_true(*value TSRMLS_CC)) { - result = 0; - } else { - result = 1; - } + result = (value == NULL || !i_zend_is_true(value TSRMLS_CC)); } - } else if (Z_TYPE_P(container) == IS_OBJECT) { - if (0) { - MAKE_REAL_ZVAL_PTR(offset); - } - if (prop_dim) { - if (Z_OBJ_HT_P(container)->has_property) { - result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check property of non-object"); - result = 0; - } + if (Z_OBJ_HT_P(container)->has_dimension) { + result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC); } else { - if (Z_OBJ_HT_P(container)->has_dimension) { - result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC); - } else { - zend_error(E_NOTICE, "Trying to check element of non-array"); - result = 0; - } + zend_error(E_NOTICE, "Trying to check element of non-array"); + result = 0; } - if (0) { - zval_ptr_dtor(&offset); - } else { - + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; } - } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */ + } else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */ zval tmp; - if (Z_TYPE_P(offset) != IS_LONG) { - if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */ + result = 0; + if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) { + if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */ || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */ && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) { - ZVAL_COPY_VALUE(&tmp, offset); - zval_copy_ctor(&tmp); + ZVAL_DUP(&tmp, offset); convert_to_long(&tmp); offset = &tmp; - } else { - /* can not be converted to proper offset, return "not set" */ - result = 0; } } if (Z_TYPE_P(offset) == IS_LONG) { - if (opline->extended_value & ZEND_ISSET) { - if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { - result = 1; - } - } else /* if (opline->extended_value & ZEND_ISEMPTY) */ { - if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') { + if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) { + if ((opline->extended_value & ZEND_ISSET) || + Z_STRVAL_P(container)[offset->value.lval] != '0') { result = 1; } } } - + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } } else { - + result = ((opline->extended_value & ZEND_ISSET) == 0); } - Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL; - if (opline->extended_value & ZEND_ISSET) { - Z_LVAL(EX_T(opline->result.var).tmp_var) = result; - } else { - Z_LVAL(EX_T(opline->result.var).tmp_var) = !result; - } + ZVAL_BOOL(EX_VAR(opline->result.var), result); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } -static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CV(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -} - static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CV(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + USE_OPLINE + + zval *container; + int result; + zval *offset; + + SAVE_OPLINE(); + container = _get_zval_ptr_cv_deref_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC); + offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); + + if (Z_TYPE_P(container) == IS_OBJECT) { + if (Z_OBJ_HT_P(container)->has_property) { + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC); + } else { + zend_error(E_NOTICE, "Trying to check property of non-object"); + result = 0; + } + if ((opline->extended_value & ZEND_ISSET) == 0) { + result = !result; + } + } else { + result = ((opline->extended_value & ZEND_ISSET) == 0); + } + + ZVAL_BOOL(EX_VAR(opline->result.var), result); + + CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } static int ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - /* The generator object is stored in return_value_ptr_ptr */ - zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr); + /* The generator object is stored in EX(return_value) */ + zend_generator *generator = (zend_generator *) EX(return_value); if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) { zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator"); } /* Destroy the previously yielded value */ - if (generator->value) { - zval_ptr_dtor(&generator->value); - } + zval_ptr_dtor(&generator->value); /* Destroy the previously yielded key */ - if (generator->key) { - zval_ptr_dtor(&generator->key); - } + zval_ptr_dtor(&generator->key); /* Set the new yielded value */ if (IS_CV != IS_UNUSED) { @@ -41067,74 +39692,58 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS /* Constants and temporary variables aren't yieldable by reference, * but we still allow them with a notice. */ if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) { - zval *value, *copy; + zval *value; zend_error(E_NOTICE, "Only variable references should be yielded by reference"); value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); + ZVAL_COPY_VALUE(&generator->value, value); + if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1); /* Temporary variables don't need ctor copying */ if (!0) { - zval_copy_ctor(copy); + zval_copy_ctor(&generator->value); } - - generator->value = copy; } else { - zval **value_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); + zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); - if (IS_CV == IS_VAR && UNEXPECTED(value_ptr == NULL)) { + if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) { zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference"); } /* If a function call result is yielded and the function did * not return by reference we throw a notice. */ - if (IS_CV == IS_VAR && !Z_ISREF_PP(value_ptr) + if (IS_CV == IS_VAR && !Z_ISREF_P(value_ptr) && !(opline->extended_value == ZEND_RETURNS_FUNCTION - && EX_T(opline->op1.var).var.fcall_returned_reference) - && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) { + && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) { zend_error(E_NOTICE, "Only variable references should be yielded by reference"); - - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } else { SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr); - Z_ADDREF_PP(value_ptr); - generator->value = *value_ptr; } + ZVAL_COPY(&generator->value, value_ptr); } } else { zval *value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); /* Consts, temporary variables and references need copying */ - if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR - || PZVAL_IS_REF(value) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, value); - - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } - - generator->value = copy; + if (IS_CV == IS_CONST) { + ZVAL_DUP(&generator->value, value); + } else if (IS_CV == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->value, value); + } else if (Z_ISREF_P(value)) { + ZVAL_DUP(&generator->value, Z_REFVAL_P(value)); } else { if (IS_CV == IS_CV) { - Z_ADDREF_P(value); + if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value); } - generator->value = value; + ZVAL_COPY_VALUE(&generator->value, value); } } } else { /* If no value was specified yield null */ - Z_ADDREF(EG(uninitialized_zval)); - generator->value = &EG(uninitialized_zval); + ZVAL_NULL(&generator->value); } /* Set the new yielded key */ @@ -41143,45 +39752,36 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); /* Consts, temporary variables and references need copying */ - if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR - || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0) - ) { - zval *copy; - - ALLOC_ZVAL(copy); - INIT_PZVAL_COPY(copy, key); - - /* Temporary variables don't need ctor copying */ - if (!0) { - zval_copy_ctor(copy); - } + if (IS_CV == IS_CONST) { + ZVAL_DUP(&generator->key, key); + } else if (IS_CV == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->key, key); + } else if (Z_ISREF_P(key)) { + ZVAL_DUP(&generator->key, Z_REFVAL_P(key)); - generator->key = copy; } else { - Z_ADDREF_P(key); - generator->key = key; + if (IS_CV == IS_CV) { + if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key); + } + ZVAL_COPY_VALUE(&generator->key, key); } - if (Z_TYPE_P(generator->key) == IS_LONG - && Z_LVAL_P(generator->key) > generator->largest_used_integer_key + if (Z_TYPE(generator->key) == IS_LONG + && Z_LVAL(generator->key) > generator->largest_used_integer_key ) { - generator->largest_used_integer_key = Z_LVAL_P(generator->key); + generator->largest_used_integer_key = Z_LVAL(generator->key); } - } else { /* If no key was specified we use auto-increment keys */ generator->largest_used_integer_key++; - - ALLOC_INIT_ZVAL(generator->key); - ZVAL_LONG(generator->key, generator->largest_used_integer_key); + ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } if (RETURN_VALUE_USED(opline)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ - generator->send_target = &EX_T(opline->result.var).var.ptr; - Z_ADDREF(EG(uninitialized_zval)); - EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval); + generator->send_target = EX_VAR(opline->result.var); + ZVAL_NULL(generator->send_target); } else { generator->send_target = NULL; } @@ -41203,9 +39803,9 @@ static int ZEND_FASTCALL ZEND_POW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) SAVE_OPLINE(); - pow_function(&EX_T(opline->result.var).tmp_var, - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); + pow_function(EX_VAR(opline->result.var), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), + _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); CHECK_EXCEPTION(); |