From: Dmitry Stogov <dmitry@zend.com>
Date: Mon, 18 Nov 2019 08:26:30 +0000 (+0300)
Subject: Merge branch 'PHP-7.2' into PHP-7.3
X-Git-Tag: php-7.3.13RC1~17
X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=e72e3370c64cdb5094fa881fb513e2b6300796b1;p=php

Merge branch 'PHP-7.2' into PHP-7.3

* PHP-7.2:
  Fix $x = (bool)$x; for undefined with opcache
---

e72e3370c64cdb5094fa881fb513e2b6300796b1
diff --cc Zend/zend_vm_execute.h
index f935b6c9f5,3f975dec0b..11bc82c1c4
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@@ -12091,32 -13485,49 +12095,34 @@@ static ZEND_OPCODE_HANDLER_RET ZEND_FAS
  	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;
@@@ -12336,223 -13818,168 +12342,225 @@@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_
  	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;
@@@ -36386,47 -38532,52 +36394,49 @@@ static ZEND_OPCODE_HANDLER_RET ZEND_FAS
  {
  	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
  
@@@ -37212,117 -39450,139 +37222,119 @@@ static ZEND_OPCODE_HANDLER_RET ZEND_FAS
  
  
  	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();
  }