ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
- zval *container;
+ zval *val;
zend_free_op free_op1;
- SAVE_OPLINE();
-
- if (zend_is_by_ref_func_arg_fetch(opline, EX(call))) {
- if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
- zend_throw_error(NULL, "Cannot use temporary expression in write context");
-
- zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
- ZVAL_UNDEF(EX_VAR(opline->result.var));
- HANDLE_EXCEPTION();
- }
- container = NULL;
- zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST EXECUTE_DATA_CC);
- if (IS_TMP_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
- EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
+ val = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+ if (Z_TYPE_INFO_P(val) == IS_TRUE) {
+ ZVAL_FALSE(EX_VAR(opline->result.var));
+ } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
++ /* The result and op1 can be the same cv zval */
++ const uint32_t orig_val_type = Z_TYPE_INFO_P(val);
+ ZVAL_TRUE(EX_VAR(opline->result.var));
- if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
++ if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) {
+ SAVE_OPLINE();
+ GET_OP1_UNDEF_CV(val, BP_VAR_R);
+ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
-
-
} else {
- if (IS_CONST == IS_UNUSED) {
- zend_throw_error(NULL, "Cannot use [] for reading");
-
- zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
- ZVAL_UNDEF(EX_VAR(opline->result.var));
- HANDLE_EXCEPTION();
- }
- container = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
- zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST EXECUTE_DATA_CC);
-
+ SAVE_OPLINE();
+ ZVAL_BOOL(EX_VAR(opline->result.var), !i_zend_is_true(val));
zval_ptr_dtor_nogc(free_op1);
+ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+ ZEND_VM_NEXT_OPCODE();
}
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ECHO_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
zend_free_op free_op1;
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
- zval *array;
- uint32_t size;
USE_OPLINE
+ zval *value, *arg;
+ zend_free_op free_op1;
- array = EX_VAR(opline->result.var);
- if (IS_TMP_VAR != IS_UNUSED) {
- size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
- } else {
- size = 0;
+ value = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+ arg = ZEND_CALL_VAR(EX(call), opline->result.var);
+ ZVAL_COPY_VALUE(arg, value);
+ if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+ if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
+ Z_ADDREF_P(arg);
+ }
}
- ZVAL_NEW_ARR(array);
- zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0);
+ ZEND_VM_NEXT_OPCODE();
+}
- 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);
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+ USE_OPLINE
+ zval *val;
+ zend_free_op free_op1;
+
+ val = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+ if (Z_TYPE_INFO_P(val) == IS_TRUE) {
+ ZVAL_TRUE(EX_VAR(opline->result.var));
+ } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
++ /* The result and op1 can be the same cv zval */
++ const uint32_t orig_val_type = Z_TYPE_INFO_P(val);
+ ZVAL_FALSE(EX_VAR(opline->result.var));
- if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
++ if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) {
+ SAVE_OPLINE();
+ GET_OP1_UNDEF_CV(val, BP_VAR_R);
+ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
+ } else {
+ SAVE_OPLINE();
+ ZVAL_BOOL(EX_VAR(opline->result.var), i_zend_is_true(val));
+ zval_ptr_dtor_nogc(free_op1);
+ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
-
- ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+ ZEND_VM_NEXT_OPCODE();
}
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
- zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
+ zend_free_op free_op1;
+ zval *obj;
+ zend_class_entry *ce, *scope;
+ zend_function *clone;
+ zend_object_clone_obj_t clone_call;
SAVE_OPLINE();
- if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
- zend_throw_error(NULL, "Cannot yield from finally in a force-closed generator");
+ obj = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
- zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
- UNDEF_RESULT();
- HANDLE_EXCEPTION();
+ if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) == IS_UNDEF)) {
+ ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
}
- /* Destroy the previously yielded value */
- zval_ptr_dtor(&generator->value);
-
- /* Destroy the previously yielded key */
- zval_ptr_dtor(&generator->key);
-
- /* Set the new yielded value */
- if (IS_TMP_VAR != IS_UNUSED) {
- zend_free_op free_op1;
-
- if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
- /* Constants and temporary variables aren't yieldable by reference,
- * but we still allow them with a notice. */
- if (IS_TMP_VAR & (IS_CONST|IS_TMP_VAR)) {
- zval *value;
-
- zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-
- value = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
- ZVAL_COPY_VALUE(&generator->value, value);
- if (IS_TMP_VAR == IS_CONST) {
- if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
- Z_ADDREF(generator->value);
- }
+ do {
+ if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
+ ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT))) {
+ if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) {
+ obj = Z_REFVAL_P(obj);
+ if (EXPECTED(Z_TYPE_P(obj) == IS_OBJECT)) {
+ break;
}
- } else {
- zval *value_ptr = NULL;
-
- /* 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 &&
- (value_ptr == &EG(uninitialized_zval) ||
- (opline->extended_value == ZEND_RETURNS_FUNCTION &&
- !Z_ISREF_P(value_ptr)))) {
- zend_error(E_NOTICE, "Only variable references should be yielded by reference");
- } else {
- ZVAL_MAKE_REF(value_ptr);
+ }
+ ZVAL_UNDEF(EX_VAR(opline->result.var));
+ if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(obj) == IS_UNDEF)) {
+ GET_OP1_UNDEF_CV(obj, BP_VAR_R);
+ if (UNEXPECTED(EG(exception) != NULL)) {
+ HANDLE_EXCEPTION();
}
- ZVAL_COPY(&generator->value, value_ptr);
-
}
- } else {
- zval *value = _get_zval_ptr_tmp(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+ zend_throw_error(NULL, "__clone method called on non-object");
+ zval_ptr_dtor_nogc(free_op1);
+ HANDLE_EXCEPTION();
+ }
+ } while (0);
- /* Consts, temporary variables and references need copying */
- if (IS_TMP_VAR == IS_CONST) {
- ZVAL_COPY_VALUE(&generator->value, value);
- if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
- Z_ADDREF(generator->value);
- }
- } else if (IS_TMP_VAR == IS_TMP_VAR) {
- ZVAL_COPY_VALUE(&generator->value, value);
- } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
- ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
+ ce = Z_OBJCE_P(obj);
+ clone = ce->clone;
+ clone_call = Z_OBJ_HT_P(obj)->clone_obj;
+ if (UNEXPECTED(clone_call == NULL)) {
+ zend_throw_error(NULL, "Trying to clone an uncloneable object of class %s", ZSTR_VAL(ce->name));
+ zval_ptr_dtor_nogc(free_op1);
+ ZVAL_UNDEF(EX_VAR(opline->result.var));
+ HANDLE_EXCEPTION();
+ }
- } else {
- ZVAL_COPY_VALUE(&generator->value, value);
- if (IS_TMP_VAR == IS_CV) {
- if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
- }
+ if (clone) {
+ if (clone->op_array.fn_flags & ZEND_ACC_PRIVATE) {
+ /* Ensure that if we're calling a private function, we're allowed to do so.
+ */
+ scope = EX(func)->op_array.scope;
+ if (!zend_check_private(clone, scope, clone->common.function_name)) {
+ zend_throw_error(NULL, "Call to private %s::__clone() from context '%s'", ZSTR_VAL(clone->common.scope->name), scope ? ZSTR_VAL(scope->name) : "");
+ zval_ptr_dtor_nogc(free_op1);
+ ZVAL_UNDEF(EX_VAR(opline->result.var));
+ HANDLE_EXCEPTION();
+ }
+ } else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) {
+ /* Ensure that if we're calling a protected function, we're allowed to do so.
+ */
+ scope = EX(func)->op_array.scope;
+ if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), scope))) {
+ zend_throw_error(NULL, "Call to protected %s::__clone() from context '%s'", ZSTR_VAL(clone->common.scope->name), scope ? ZSTR_VAL(scope->name) : "");
+ zval_ptr_dtor_nogc(free_op1);
+ ZVAL_UNDEF(EX_VAR(opline->result.var));
+ HANDLE_EXCEPTION();
}
}
- } else {
- /* If no value was specified yield null */
- ZVAL_NULL(&generator->value);
}
- /* Set the new yielded key */
- if (IS_CONST != IS_UNUSED) {
+ ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(obj));
- zval *key = EX_CONSTANT(opline->op2);
+ zval_ptr_dtor_nogc(free_op1);
+ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
- /* Consts, temporary variables and references need copying */
- if (IS_CONST == IS_CONST) {
- ZVAL_COPY_VALUE(&generator->key, key);
- if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->key))) {
- Z_ADDREF(generator->key);
- }
- } else if (IS_CONST == IS_TMP_VAR) {
- ZVAL_COPY_VALUE(&generator->key, key);
- } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(key)) {
- ZVAL_COPY(&generator->key, Z_REFVAL_P(key));
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+ USE_OPLINE
+ zend_op_array *new_op_array;
+ zend_free_op free_op1;
+ zval *inc_filename;
+ SAVE_OPLINE();
+ inc_filename = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+ new_op_array = zend_include_or_eval(inc_filename, opline->extended_value);
+ zval_ptr_dtor_nogc(free_op1);
+ if (UNEXPECTED(EG(exception) != NULL)) {
+ if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) {
+ destroy_op_array(new_op_array);
+ efree_size(new_op_array, sizeof(zend_op_array));
+ }
+ UNDEF_RESULT();
+ HANDLE_EXCEPTION();
+ } else if (new_op_array == ZEND_FAKE_OP_ARRAY) {
+ if (RETURN_VALUE_USED(opline)) {
+ ZVAL_TRUE(EX_VAR(opline->result.var));
+ }
+ } else if (EXPECTED(new_op_array != NULL)) {
+ zval *return_value = NULL;
+ zend_execute_data *call;
+
+ if (RETURN_VALUE_USED(opline)) {
+ return_value = EX_VAR(opline->result.var);
+ ZVAL_NULL(return_value);
+ }
+
+ new_op_array->scope = EX(func)->op_array.scope;
+
+ call = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
+ (zend_function*)new_op_array, 0,
+ Z_TYPE(EX(This)) != IS_OBJECT ? Z_CE(EX(This)) : NULL,
+ Z_TYPE(EX(This)) == IS_OBJECT ? Z_OBJ(EX(This)) : NULL);
+
+ if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) {
+ call->symbol_table = EX(symbol_table);
} else {
- ZVAL_COPY_VALUE(&generator->key, key);
- if (IS_CONST == IS_CV) {
- if (Z_OPT_REFCOUNTED_P(key)) Z_ADDREF_P(key);
- }
+ call->symbol_table = zend_rebuild_symbol_table();
}
- if (Z_TYPE(generator->key) == IS_LONG
- && Z_LVAL(generator->key) > generator->largest_used_integer_key
- ) {
- generator->largest_used_integer_key = Z_LVAL(generator->key);
+ call->prev_execute_data = execute_data;
+ i_init_code_execute_data(call, new_op_array, return_value);
+ if (EXPECTED(zend_execute_ex == execute_ex)) {
+ ZEND_VM_ENTER();
+ } else {
+ ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
+ zend_execute_ex(call);
+ zend_vm_stack_free_call_frame(call);
}
- } else {
- /* If no key was specified we use auto-increment keys */
- generator->largest_used_integer_key++;
- ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
- }
- if (RETURN_VALUE_USED(opline)) {
- /* If the return value of yield is used set the send
- * target and initialize it to NULL */
- generator->send_target = EX_VAR(opline->result.var);
- ZVAL_NULL(generator->send_target);
- } else {
- generator->send_target = NULL;
+ destroy_op_array(new_op_array);
+ efree_size(new_op_array, sizeof(zend_op_array));
+ if (UNEXPECTED(EG(exception) != NULL)) {
+ zend_rethrow_exception(execute_data);
+ UNDEF_RESULT();
+ HANDLE_EXCEPTION();
+ }
+ } else if (RETURN_VALUE_USED(opline)) {
+ ZVAL_FALSE(EX_VAR(opline->result.var));
}
+ ZEND_VM_NEXT_OPCODE();
+}
- /* We increment to the next op, so we are at the correct position when the
- * generator is resumed. */
- ZEND_VM_INC_OPCODE();
+static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_EXIT_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+ USE_OPLINE
- /* The GOTO VM uses a local opline variable. We need to set the opline
- * variable in execute_data so we don't resume at an old position. */
SAVE_OPLINE();
+ if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
+ zend_free_op free_op1;
+ zval *ptr = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
- ZEND_VM_RETURN();
+ do {
+ if (Z_TYPE_P(ptr) == IS_LONG) {
+ EG(exit_status) = Z_LVAL_P(ptr);
+ } else {
+ if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(ptr)) {
+ ptr = Z_REFVAL_P(ptr);
+ if (Z_TYPE_P(ptr) == IS_LONG) {
+ EG(exit_status) = Z_LVAL_P(ptr);
+ break;
+ }
+ }
+ zend_print_zval(ptr, 0);
+ }
+ } while (0);
+ zval_ptr_dtor_nogc(free_op1);
+ }
+ zend_bailout();
+ ZEND_VM_NEXT_OPCODE(); /* Never reached */
}
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COALESCE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
zend_free_op free_op1;
{
USE_OPLINE
- zval *expr;
- zend_bool result;
+ zval *op1;
+
+ op1 = EX_VAR(opline->op1.var);
+ if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
+ ZVAL_LONG(EX_VAR(opline->result.var), ~Z_LVAL_P(op1));
+ ZEND_VM_NEXT_OPCODE();
+ }
SAVE_OPLINE();
- expr = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
+ bitwise_not_function(EX_VAR(opline->result.var),
+ _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC));
-try_instanceof:
- if (Z_TYPE_P(expr) == IS_OBJECT) {
- zend_class_entry *ce;
+ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
- if (IS_CONST == IS_CONST) {
- ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)));
- if (UNEXPECTED(ce == NULL)) {
- ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, ZEND_FETCH_CLASS_NO_AUTOLOAD);
- if (EXPECTED(ce)) {
- CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce);
- }
- }
- } else if (IS_CONST == IS_UNUSED) {
- ce = zend_fetch_class(NULL, opline->op2.num);
- if (UNEXPECTED(ce == NULL)) {
- ZEND_ASSERT(EG(exception));
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+ USE_OPLINE
+ zval *val;
- ZVAL_UNDEF(EX_VAR(opline->result.var));
- HANDLE_EXCEPTION();
- }
- } else {
- ce = Z_CE_P(EX_VAR(opline->op2.var));
+
+ val = EX_VAR(opline->op1.var);
+ if (Z_TYPE_INFO_P(val) == IS_TRUE) {
+ ZVAL_FALSE(EX_VAR(opline->result.var));
+ } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
++ /* The result and op1 can be the same cv zval */
++ const uint32_t orig_val_type = Z_TYPE_INFO_P(val);
+ ZVAL_TRUE(EX_VAR(opline->result.var));
- if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
++ if (IS_CV == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) {
+ SAVE_OPLINE();
+ GET_OP1_UNDEF_CV(val, BP_VAR_R);
+ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
- result = ce && instanceof_function(Z_OBJCE_P(expr), ce);
- } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) {
- expr = Z_REFVAL_P(expr);
- goto try_instanceof;
} else {
- if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) {
- GET_OP1_UNDEF_CV(expr, BP_VAR_R);
- }
- result = 0;
- }
+ SAVE_OPLINE();
+ ZVAL_BOOL(EX_VAR(opline->result.var), !i_zend_is_true(val));
- ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+ }
+ ZEND_VM_NEXT_OPCODE();
}
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
SAVE_OPLINE();
+ arg = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
+ param = ZEND_CALL_VAR(EX(call), opline->result.var);
- varname = _get_zval_ptr_cv_undef(opline->op1.var EXECUTE_DATA_CC);
-
- ZVAL_UNDEF(&tmp);
- if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
- if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
- varname = GET_OP1_UNDEF_CV(varname, BP_VAR_R);
- }
- ZVAL_STR(&tmp, zval_get_string(varname));
- varname = &tmp;
+ if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) {
+ zend_param_must_be_ref(EX(call)->func, opline->op2.num);
}
- if (IS_VAR == IS_CONST) {
- ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)));
- if (UNEXPECTED(ce == NULL)) {
- ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
- if (UNEXPECTED(ce == NULL)) {
- ZEND_ASSERT(EG(exception));
- if (IS_CV != IS_CONST && Z_TYPE(tmp) != IS_UNDEF) {
- zend_string_release(Z_STR(tmp));
- }
+ ZVAL_COPY(param, arg);
- HANDLE_EXCEPTION();
- }
- CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce);
- }
- } else if (IS_VAR == IS_UNUSED) {
- ce = zend_fetch_class(NULL, opline->op2.num);
- if (UNEXPECTED(ce == NULL)) {
- ZEND_ASSERT(EG(exception));
- if (IS_CV != IS_CONST && Z_TYPE(tmp) != IS_UNDEF) {
- zend_string_release(Z_STR(tmp));
- }
+ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
- HANDLE_EXCEPTION();
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+ USE_OPLINE
+ zval *val;
+
+
+ val = EX_VAR(opline->op1.var);
+ if (Z_TYPE_INFO_P(val) == IS_TRUE) {
+ ZVAL_TRUE(EX_VAR(opline->result.var));
+ } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
++ /* The result and op1 can be the same cv zval */
++ const uint32_t orig_val_type = Z_TYPE_INFO_P(val);
+ ZVAL_FALSE(EX_VAR(opline->result.var));
- if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
++ if (IS_CV == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) {
+ SAVE_OPLINE();
+ GET_OP1_UNDEF_CV(val, BP_VAR_R);
+ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
} else {
- ce = Z_CE_P(EX_VAR(opline->op2.var));
- }
- zend_std_unset_static_property(ce, Z_STR_P(varname));
+ SAVE_OPLINE();
+ ZVAL_BOOL(EX_VAR(opline->result.var), i_zend_is_true(val));
- if (IS_CV != IS_CONST && Z_TYPE(tmp) != IS_UNDEF) {
- zend_string_release(Z_STR(tmp));
+ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
-
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+ ZEND_VM_NEXT_OPCODE();
}
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
- zval *value;
- int result;
- zval tmp, *varname;
- zend_class_entry *ce;
+ zval *obj;
+ zend_class_entry *ce, *scope;
+ zend_function *clone;
+ zend_object_clone_obj_t clone_call;
SAVE_OPLINE();
- varname = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
- ZVAL_UNDEF(&tmp);
- if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
- ZVAL_STR(&tmp, zval_get_string(varname));
- varname = &tmp;
- }
-
- if (IS_VAR == IS_CONST) {
- if (IS_CV == IS_CONST && EXPECTED((ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)))) != NULL)) {
- value = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)) + sizeof(void*));
+ obj = EX_VAR(opline->op1.var);
- /* check if static properties were destoyed */
- if (UNEXPECTED(CE_STATIC_MEMBERS(ce) == NULL)) {
- value = NULL;
- }
+ if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) == IS_UNDEF)) {
+ ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+ }
- goto is_static_prop_return;
- } else if (UNEXPECTED((ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) == NULL)) {
- ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
- if (UNEXPECTED(ce == NULL)) {
- ZEND_ASSERT(EG(exception));
- ZVAL_UNDEF(EX_VAR(opline->result.var));
- HANDLE_EXCEPTION();
+ do {
+ if (IS_CV == IS_CONST ||
+ (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT))) {
+ if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) {
+ obj = Z_REFVAL_P(obj);
+ if (EXPECTED(Z_TYPE_P(obj) == IS_OBJECT)) {
+ break;
+ }
}
- CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce);
- }
- } else {
- if (IS_VAR == IS_UNUSED) {
- ce = zend_fetch_class(NULL, opline->op2.num);
- if (UNEXPECTED(ce == NULL)) {
- ZEND_ASSERT(EG(exception));
- if (IS_CV != IS_CONST && Z_TYPE(tmp) != IS_UNDEF) {
- zend_string_release(Z_STR(tmp));
+ ZVAL_UNDEF(EX_VAR(opline->result.var));
+ if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(obj) == IS_UNDEF)) {
+ GET_OP1_UNDEF_CV(obj, BP_VAR_R);
+ if (UNEXPECTED(EG(exception) != NULL)) {
+ HANDLE_EXCEPTION();
}
-
- ZVAL_UNDEF(EX_VAR(opline->result.var));
- HANDLE_EXCEPTION();
}
- } else {
- ce = Z_CE_P(EX_VAR(opline->op2.var));
- }
- if (IS_CV == IS_CONST &&
- EXPECTED(CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1))) == ce)) {
+ zend_throw_error(NULL, "__clone method called on non-object");
- value = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)) + sizeof(void*));
+ HANDLE_EXCEPTION();
+ }
+ } while (0);
- /* check if static properties were destoyed */
- if (UNEXPECTED(CE_STATIC_MEMBERS(ce) == NULL)) {
- value = NULL;
- }
+ ce = Z_OBJCE_P(obj);
+ clone = ce->clone;
+ clone_call = Z_OBJ_HT_P(obj)->clone_obj;
+ if (UNEXPECTED(clone_call == NULL)) {
+ zend_throw_error(NULL, "Trying to clone an uncloneable object of class %s", ZSTR_VAL(ce->name));
- goto is_static_prop_return;
- }
+ ZVAL_UNDEF(EX_VAR(opline->result.var));
+ HANDLE_EXCEPTION();
}
- value = zend_std_get_static_property(ce, Z_STR_P(varname), 1);
+ if (clone) {
+ if (clone->op_array.fn_flags & ZEND_ACC_PRIVATE) {
+ /* Ensure that if we're calling a private function, we're allowed to do so.
+ */
+ scope = EX(func)->op_array.scope;
+ if (!zend_check_private(clone, scope, clone->common.function_name)) {
+ zend_throw_error(NULL, "Call to private %s::__clone() from context '%s'", ZSTR_VAL(clone->common.scope->name), scope ? ZSTR_VAL(scope->name) : "");
- if (IS_CV == IS_CONST && value) {
- CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)), ce, value);
- }
+ ZVAL_UNDEF(EX_VAR(opline->result.var));
+ HANDLE_EXCEPTION();
+ }
+ } else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) {
+ /* Ensure that if we're calling a protected function, we're allowed to do so.
+ */
+ scope = EX(func)->op_array.scope;
+ if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), scope))) {
+ zend_throw_error(NULL, "Call to protected %s::__clone() from context '%s'", ZSTR_VAL(clone->common.scope->name), scope ? ZSTR_VAL(scope->name) : "");
- if (IS_CV != IS_CONST && Z_TYPE(tmp) != IS_UNDEF) {
- zend_string_release(Z_STR(tmp));
+ ZVAL_UNDEF(EX_VAR(opline->result.var));
+ HANDLE_EXCEPTION();
+ }
+ }
}
-is_static_prop_return:
- if (opline->extended_value & ZEND_ISSET) {
- result = value && Z_TYPE_P(value) > IS_NULL &&
- (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
- } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
- result = !value || !i_zend_is_true(value);
- }
+ ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(obj));
- ZEND_VM_SMART_BRANCH(result, 1);
- ZVAL_BOOL(EX_VAR(opline->result.var), result);
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
projects / php / commitdiff