From: Nikita Popov <nikita.ppv@gmail.com>
Date: Sun, 25 Jun 2017 13:31:06 +0000 (+0200)
Subject: Merge branch 'PHP-7.1'
X-Git-Tag: php-7.2.0alpha3~34^2~20
X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=191f154d40f63e79e3588070269e75697801e755;p=php

Merge branch 'PHP-7.1'
---

191f154d40f63e79e3588070269e75697801e755
diff --cc Zend/zend_vm_def.h
index 591387f939,9a633780b1..5d4a916971
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@@ -7964,294 -8210,7 +7964,298 @@@ ZEND_VM_HANDLER(51, ZEND_MAKE_REF, VAR|
  	ZEND_VM_NEXT_OPCODE();
  }
  
 -ZEND_VM_TYPE_SPEC_HANDLER(ZEND_ADD, (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG), ZEND_ADD_LONG_NO_OVERFLOW, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(NO_CONST_CONST,COMMUTATIVE))
 +ZEND_VM_HANDLER(187, ZEND_SWITCH_LONG, CONST|TMPVAR|CV, CONST, JMP_ADDR)
 +{
 +	USE_OPLINE
 +	zend_free_op free_op1, free_op2;
 +	zval *op, *jump_zv;
 +	HashTable *jumptable;
 +
 +	op = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
 +	jumptable = Z_ARRVAL_P(GET_OP2_ZVAL_PTR(BP_VAR_R));
 +
 +	if (Z_TYPE_P(op) != IS_LONG) {
 +		ZVAL_DEREF(op);
 +		if (Z_TYPE_P(op) != IS_LONG) {
 +			/* Wrong type, fall back to ZEND_CASE chain */
 +			ZEND_VM_NEXT_OPCODE();
 +		}
 +	}
 +
 +	jump_zv = zend_hash_index_find(jumptable, Z_LVAL_P(op));
 +	if (jump_zv != NULL) {
 +		ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
 +		ZEND_VM_CONTINUE();
 +	} else {
 +		/* default */
 +		ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
 +		ZEND_VM_CONTINUE();
 +	}
 +}
 +
 +ZEND_VM_HANDLER(188, ZEND_SWITCH_STRING, CONST|TMPVAR|CV, CONST, JMP_ADDR)
 +{
 +	USE_OPLINE
 +	zend_free_op free_op1, free_op2;
 +	zval *op, *jump_zv;
 +	HashTable *jumptable;
 +
 +	op = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
 +	jumptable = Z_ARRVAL_P(GET_OP2_ZVAL_PTR(BP_VAR_R));
 +
 +	if (Z_TYPE_P(op) != IS_STRING) {
 +		ZVAL_DEREF(op);
 +		if (Z_TYPE_P(op) != IS_STRING) {
 +			/* Wrong type, fall back to ZEND_CASE chain */
 +			ZEND_VM_NEXT_OPCODE();
 +		}
 +	}
 +
 +	jump_zv = zend_hash_find(jumptable, Z_STR_P(op));
 +	if (jump_zv != NULL) {
 +		ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
 +		ZEND_VM_CONTINUE();
 +	} else {
 +		/* default */
 +		ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
 +		ZEND_VM_CONTINUE();
 +	}
 +}
 +
 +ZEND_VM_HANDLER(189, ZEND_IN_ARRAY, CONST|TMP|VAR|CV, CONST, NUM)
 +{
 +	USE_OPLINE
 +	zend_free_op free_op1;
 +	zval *op1;
 +	HashTable *ht = Z_ARRVAL_P(EX_CONSTANT(opline->op2));
 +	int result;
 +
 +	SAVE_OPLINE();
 +	op1 = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
 +	if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
 +		result = zend_hash_exists(ht, Z_STR_P(op1));
 +	} else if (opline->extended_value) {
 +		if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
 +			result = zend_hash_index_exists(ht, Z_LVAL_P(op1));
 +		} else {
 +			result = 0;
 +		}
 +	} else if (Z_TYPE_P(op1) <= IS_FALSE) {
 +		result = zend_hash_exists(ht, ZSTR_EMPTY_ALLOC());
 +	} else {
 +		zend_string *key;
 +		zval tmp;
 +
 +		result = 0;
 +		ZEND_HASH_FOREACH_STR_KEY(ht, key) {
 +			ZVAL_STR(&tmp, key);
 +			compare_function(&tmp, op1, &tmp);
 +			if (Z_LVAL(tmp) == 0) {
 +				result = 1;
 +				break;
 +			}
 +		} ZEND_HASH_FOREACH_END();
 +	}
 +	FREE_OP1();
 +	ZEND_VM_SMART_BRANCH(result, 1);
 +	ZVAL_BOOL(EX_VAR(opline->result.var), result);
 +	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 +}
 +
 +ZEND_VM_HANDLER(190, ZEND_COUNT, CONST|TMP|VAR|CV, UNUSED)
 +{
 +	USE_OPLINE
 +	zend_free_op free_op1;
 +	zval *op1;
 +	zend_long count;
 +
 +	SAVE_OPLINE();
 +	op1 = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
 +	do {
 +		if (Z_TYPE_P(op1) == IS_ARRAY) {
 +			count = zend_array_count(Z_ARRVAL_P(op1));
 +			break;
 +		} else if (Z_TYPE_P(op1) == IS_OBJECT) {
 +			/* first, we check if the handler is defined */
 +			if (Z_OBJ_HT_P(op1)->count_elements) {
 +				if (SUCCESS == Z_OBJ_HT_P(op1)->count_elements(op1, &count)) {
 +					break;
 +				}
 +			}
 +
 +			/* if not and the object implements Countable we call its count() method */
 +			if (instanceof_function(Z_OBJCE_P(op1), zend_ce_countable)) {
 +				zval retval;
 +
 +				zend_call_method_with_0_params(op1, NULL, NULL, "count", &retval);
 +				count = zval_get_long(&retval);
 +				zval_ptr_dtor(&retval);
 +				break;
 +			}
 +
 +			/* If There's no handler and it doesn't implement Countable then add a warning */
 +			count = 1;
 +		} else if (Z_TYPE_P(op1) == IS_NULL) {
 +			count = 0;
 +		} else {
 +			count = 1;
 +		}
 +		zend_error(E_WARNING, "count(): Parameter must be an array or an object that implements Countable");
 +	} while (0);
 +
 +	ZVAL_LONG(EX_VAR(opline->result.var), count);
 +	FREE_OP1();
 +	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 +}
 +
 +ZEND_VM_HANDLER(191, ZEND_GET_CLASS, UNUSED|CONST|TMP|VAR|CV, UNUSED)
 +{
 +	USE_OPLINE
 +
 +	if (OP1_TYPE == IS_UNUSED) {
 +		if (UNEXPECTED(!EX(func)->common.scope)) {
 +			SAVE_OPLINE();
 +			zend_error(E_WARNING, "get_class() called without object from outside a class");
 +			ZVAL_FALSE(EX_VAR(opline->result.var));
 +			ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 +		} else {
 +			ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->name);
 +			ZEND_VM_NEXT_OPCODE();
 +		}
 +	} else {
 +		zend_free_op free_op1;
 +		zval *op1;
 +
 +		SAVE_OPLINE();
 +		op1 = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
 +		if (Z_TYPE_P(op1) == IS_OBJECT) {
 +			ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name);
 +		} else {
 +			zend_error(E_WARNING, "get_class() expects parameter 1 to be object, %s given", zend_get_type_by_const(Z_TYPE_P(op1)));
 +			ZVAL_FALSE(EX_VAR(opline->result.var));
 +		}
 +		FREE_OP1();
 +		ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 +	}
 +}
 +
 +ZEND_VM_HANDLER(192, ZEND_GET_CALLED_CLASS, UNUSED, UNUSED)
 +{
 +	USE_OPLINE
 +
 +	if (Z_TYPE(EX(This)) == IS_OBJECT) {
 +		ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE(EX(This))->name);
 +	} else if (Z_CE(EX(This))) {
 +		ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_CE(EX(This))->name);
 +	} else {
 +		ZVAL_FALSE(EX_VAR(opline->result.var));
 +		if (UNEXPECTED(!EX(func)->common.scope)) {
 +			SAVE_OPLINE();
 +			zend_error(E_WARNING, "get_called_class() called from outside a class");
 +			ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 +		}
 +	}
 +	ZEND_VM_NEXT_OPCODE();
 +}
 +
 +ZEND_VM_HANDLER(193, ZEND_GET_TYPE, CONST|TMP|VAR|CV, UNUSED)
 +{
 +	USE_OPLINE
 +	zend_free_op free_op1;
 +	zval *op1;
 +	zend_string *type;
 +
 +	SAVE_OPLINE();
 +	op1 = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
 +	type = zend_zval_get_type(op1);
 +	if (EXPECTED(type)) {
 +		ZVAL_INTERNED_STR(EX_VAR(opline->result.var), type);
 +	} else {
 +		ZVAL_STRING(EX_VAR(opline->result.var), "unknown type");
 +	}
 +	FREE_OP1();
 +	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 +}
 +
 +ZEND_VM_HANDLER(194, ZEND_FUNC_NUM_ARGS, UNUSED, UNUSED)
 +{
 +	USE_OPLINE
 +
 +	ZVAL_LONG(EX_VAR(opline->result.var), EX_NUM_ARGS());
 +	ZEND_VM_NEXT_OPCODE();
 +}
 +
 +ZEND_VM_HANDLER(195, ZEND_FUNC_GET_ARGS, UNUSED|CONST, UNUSED)
 +{
 +	USE_OPLINE
 +	zend_array *ht;
 +	uint32_t arg_count, first_extra_arg, i, n;
 +	zval *p, *q;
 +
 +	arg_count = EX_NUM_ARGS();
 +	ht = (zend_array *) emalloc(sizeof(zend_array));
 +	if (OP1_TYPE == IS_CONST) {
 +		i = Z_LVAL_P(EX_CONSTANT(opline->op1));
 +		if (arg_count < i) {
 +			i = 0;
 +		} else {
 +			i = arg_count - i;
 +		}
 +		zend_hash_init(ht, i, NULL, ZVAL_PTR_DTOR, 0);
 +	} else {
 +		zend_hash_init(ht, arg_count, NULL, ZVAL_PTR_DTOR, 0);
 +	}
 +	ZVAL_ARR(EX_VAR(opline->result.var), ht);
 +	if (arg_count) {
 +		first_extra_arg = EX(func)->op_array.num_args;
 +		zend_hash_real_init(ht, 1);
 +		ZEND_HASH_FILL_PACKED(ht) {
 +			i = 0;
 +			n = 0;
 +			if (OP1_TYPE == IS_CONST) {
 +				i = Z_LVAL_P(EX_CONSTANT(opline->op1));
 +			}
 +			p = EX_VAR_NUM(i);
 +			if (arg_count > first_extra_arg) {
 +				while (i < first_extra_arg) {
 +					q = p;
 +					if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) {
 +						ZVAL_DEREF(q);
 +						if (Z_OPT_REFCOUNTED_P(q)) {
 +							Z_ADDREF_P(q);
 +						}
- 						n++;
++					} else {
++						q = &EG(uninitialized_zval);
 +					}
 +					ZEND_HASH_FILL_ADD(q);
++					n++;
 +					p++;
 +					i++;
 +				}
 +				p = EX_VAR_NUM(EX(func)->op_array.last_var + EX(func)->op_array.T);
 +			}
 +			while (i < arg_count) {
 +				q = p;
 +				if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) {
 +					ZVAL_DEREF(q);
 +					if (Z_OPT_REFCOUNTED_P(q)) {
 +						Z_ADDREF_P(q);
 +					}
- 					n++;
++				} else {
++					q = &EG(uninitialized_zval);
 +				}
 +				ZEND_HASH_FILL_ADD(q);
++				n++;
 +				p++;
 +				i++;
 +			}
 +		} ZEND_HASH_FILL_END();
 +		ht->nNumOfElements = n;
 +	}
 +	ZEND_VM_NEXT_OPCODE();
 +}
 +
 +ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_ADD, (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG), ZEND_ADD_LONG_NO_OVERFLOW, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(NO_CONST_CONST,COMMUTATIVE))
  {
  	USE_OPLINE
  	zval *op1, *op2, *result;
diff --cc Zend/zend_vm_execute.h
index e87f5c7251,bb4f50a431..01b036bed6
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@@ -8051,168 -8225,6 +8051,172 @@@ static ZEND_OPCODE_HANDLER_RET ZEND_FAS
  	ZEND_VM_RETURN();
  }
  
 +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COUNT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 +{
 +	USE_OPLINE
 +
 +	zval *op1;
 +	zend_long count;
 +
 +	SAVE_OPLINE();
 +	op1 = EX_CONSTANT(opline->op1);
 +	do {
 +		if (Z_TYPE_P(op1) == IS_ARRAY) {
 +			count = zend_array_count(Z_ARRVAL_P(op1));
 +			break;
 +		} else if (Z_TYPE_P(op1) == IS_OBJECT) {
 +			/* first, we check if the handler is defined */
 +			if (Z_OBJ_HT_P(op1)->count_elements) {
 +				if (SUCCESS == Z_OBJ_HT_P(op1)->count_elements(op1, &count)) {
 +					break;
 +				}
 +			}
 +
 +			/* if not and the object implements Countable we call its count() method */
 +			if (instanceof_function(Z_OBJCE_P(op1), zend_ce_countable)) {
 +				zval retval;
 +
 +				zend_call_method_with_0_params(op1, NULL, NULL, "count", &retval);
 +				count = zval_get_long(&retval);
 +				zval_ptr_dtor(&retval);
 +				break;
 +			}
 +
 +			/* If There's no handler and it doesn't implement Countable then add a warning */
 +			count = 1;
 +		} else if (Z_TYPE_P(op1) == IS_NULL) {
 +			count = 0;
 +		} else {
 +			count = 1;
 +		}
 +		zend_error(E_WARNING, "count(): Parameter must be an array or an object that implements Countable");
 +	} while (0);
 +
 +	ZVAL_LONG(EX_VAR(opline->result.var), count);
 +
 +	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 +}
 +
 +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 +{
 +	USE_OPLINE
 +
 +	if (IS_CONST == IS_UNUSED) {
 +		if (UNEXPECTED(!EX(func)->common.scope)) {
 +			SAVE_OPLINE();
 +			zend_error(E_WARNING, "get_class() called without object from outside a class");
 +			ZVAL_FALSE(EX_VAR(opline->result.var));
 +			ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 +		} else {
 +			ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->name);
 +			ZEND_VM_NEXT_OPCODE();
 +		}
 +	} else {
 +
 +		zval *op1;
 +
 +		SAVE_OPLINE();
 +		op1 = EX_CONSTANT(opline->op1);
 +		if (Z_TYPE_P(op1) == IS_OBJECT) {
 +			ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name);
 +		} else {
 +			zend_error(E_WARNING, "get_class() expects parameter 1 to be object, %s given", zend_get_type_by_const(Z_TYPE_P(op1)));
 +			ZVAL_FALSE(EX_VAR(opline->result.var));
 +		}
 +
 +		ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 +	}
 +}
 +
 +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_TYPE_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 +{
 +	USE_OPLINE
 +
 +	zval *op1;
 +	zend_string *type;
 +
 +	SAVE_OPLINE();
 +	op1 = EX_CONSTANT(opline->op1);
 +	type = zend_zval_get_type(op1);
 +	if (EXPECTED(type)) {
 +		ZVAL_INTERNED_STR(EX_VAR(opline->result.var), type);
 +	} else {
 +		ZVAL_STRING(EX_VAR(opline->result.var), "unknown type");
 +	}
 +
 +	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 +}
 +
 +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 +{
 +	USE_OPLINE
 +	zend_array *ht;
 +	uint32_t arg_count, first_extra_arg, i, n;
 +	zval *p, *q;
 +
 +	arg_count = EX_NUM_ARGS();
 +	ht = (zend_array *) emalloc(sizeof(zend_array));
 +	if (IS_CONST == IS_CONST) {
 +		i = Z_LVAL_P(EX_CONSTANT(opline->op1));
 +		if (arg_count < i) {
 +			i = 0;
 +		} else {
 +			i = arg_count - i;
 +		}
 +		zend_hash_init(ht, i, NULL, ZVAL_PTR_DTOR, 0);
 +	} else {
 +		zend_hash_init(ht, arg_count, NULL, ZVAL_PTR_DTOR, 0);
 +	}
 +	ZVAL_ARR(EX_VAR(opline->result.var), ht);
 +	if (arg_count) {
 +		first_extra_arg = EX(func)->op_array.num_args;
 +		zend_hash_real_init(ht, 1);
 +		ZEND_HASH_FILL_PACKED(ht) {
 +			i = 0;
 +			n = 0;
 +			if (IS_CONST == IS_CONST) {
 +				i = Z_LVAL_P(EX_CONSTANT(opline->op1));
 +			}
 +			p = EX_VAR_NUM(i);
 +			if (arg_count > first_extra_arg) {
 +				while (i < first_extra_arg) {
 +					q = p;
 +					if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) {
 +						ZVAL_DEREF(q);
 +						if (Z_OPT_REFCOUNTED_P(q)) {
 +							Z_ADDREF_P(q);
 +						}
- 						n++;
++					} else {
++						q = &EG(uninitialized_zval);
 +					}
 +					ZEND_HASH_FILL_ADD(q);
++					n++;
 +					p++;
 +					i++;
 +				}
 +				p = EX_VAR_NUM(EX(func)->op_array.last_var + EX(func)->op_array.T);
 +			}
 +			while (i < arg_count) {
 +				q = p;
 +				if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) {
 +					ZVAL_DEREF(q);
 +					if (Z_OPT_REFCOUNTED_P(q)) {
 +						Z_ADDREF_P(q);
 +					}
- 					n++;
++				} else {
++					q = &EG(uninitialized_zval);
 +				}
 +				ZEND_HASH_FILL_ADD(q);
++				n++;
 +				p++;
 +				i++;
 +			}
 +		} ZEND_HASH_FILL_END();
 +		ht->nNumOfElements = n;
 +	}
 +	ZEND_VM_NEXT_OPCODE();
 +}
 +
  static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
  {
  	USE_OPLINE
@@@ -29171,130 -30777,6 +29175,134 @@@ static ZEND_OPCODE_HANDLER_RET ZEND_FAS
  	ZEND_VM_NEXT_OPCODE();
  }
  
 +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 +{
 +	USE_OPLINE
 +
 +	if (IS_UNUSED == IS_UNUSED) {
 +		if (UNEXPECTED(!EX(func)->common.scope)) {
 +			SAVE_OPLINE();
 +			zend_error(E_WARNING, "get_class() called without object from outside a class");
 +			ZVAL_FALSE(EX_VAR(opline->result.var));
 +			ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 +		} else {
 +			ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->name);
 +			ZEND_VM_NEXT_OPCODE();
 +		}
 +	} else {
 +
 +		zval *op1;
 +
 +		SAVE_OPLINE();
 +		op1 = NULL;
 +		if (Z_TYPE_P(op1) == IS_OBJECT) {
 +			ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name);
 +		} else {
 +			zend_error(E_WARNING, "get_class() expects parameter 1 to be object, %s given", zend_get_type_by_const(Z_TYPE_P(op1)));
 +			ZVAL_FALSE(EX_VAR(opline->result.var));
 +		}
 +
 +		ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 +	}
 +}
 +
 +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 +{
 +	USE_OPLINE
 +
 +	if (Z_TYPE(EX(This)) == IS_OBJECT) {
 +		ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE(EX(This))->name);
 +	} else if (Z_CE(EX(This))) {
 +		ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_CE(EX(This))->name);
 +	} else {
 +		ZVAL_FALSE(EX_VAR(opline->result.var));
 +		if (UNEXPECTED(!EX(func)->common.scope)) {
 +			SAVE_OPLINE();
 +			zend_error(E_WARNING, "get_called_class() called from outside a class");
 +			ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 +		}
 +	}
 +	ZEND_VM_NEXT_OPCODE();
 +}
 +
 +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 +{
 +	USE_OPLINE
 +
 +	ZVAL_LONG(EX_VAR(opline->result.var), EX_NUM_ARGS());
 +	ZEND_VM_NEXT_OPCODE();
 +}
 +
 +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 +{
 +	USE_OPLINE
 +	zend_array *ht;
 +	uint32_t arg_count, first_extra_arg, i, n;
 +	zval *p, *q;
 +
 +	arg_count = EX_NUM_ARGS();
 +	ht = (zend_array *) emalloc(sizeof(zend_array));
 +	if (IS_UNUSED == IS_CONST) {
 +		i = Z_LVAL_P(EX_CONSTANT(opline->op1));
 +		if (arg_count < i) {
 +			i = 0;
 +		} else {
 +			i = arg_count - i;
 +		}
 +		zend_hash_init(ht, i, NULL, ZVAL_PTR_DTOR, 0);
 +	} else {
 +		zend_hash_init(ht, arg_count, NULL, ZVAL_PTR_DTOR, 0);
 +	}
 +	ZVAL_ARR(EX_VAR(opline->result.var), ht);
 +	if (arg_count) {
 +		first_extra_arg = EX(func)->op_array.num_args;
 +		zend_hash_real_init(ht, 1);
 +		ZEND_HASH_FILL_PACKED(ht) {
 +			i = 0;
 +			n = 0;
 +			if (IS_UNUSED == IS_CONST) {
 +				i = Z_LVAL_P(EX_CONSTANT(opline->op1));
 +			}
 +			p = EX_VAR_NUM(i);
 +			if (arg_count > first_extra_arg) {
 +				while (i < first_extra_arg) {
 +					q = p;
 +					if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) {
 +						ZVAL_DEREF(q);
 +						if (Z_OPT_REFCOUNTED_P(q)) {
 +							Z_ADDREF_P(q);
 +						}
- 						n++;
++					} else {
++						q = &EG(uninitialized_zval);
 +					}
 +					ZEND_HASH_FILL_ADD(q);
++					n++;
 +					p++;
 +					i++;
 +				}
 +				p = EX_VAR_NUM(EX(func)->op_array.last_var + EX(func)->op_array.T);
 +			}
 +			while (i < arg_count) {
 +				q = p;
 +				if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) {
 +					ZVAL_DEREF(q);
 +					if (Z_OPT_REFCOUNTED_P(q)) {
 +						Z_ADDREF_P(q);
 +					}
- 					n++;
++				} else {
++					q = &EG(uninitialized_zval);
 +				}
 +				ZEND_HASH_FILL_ADD(q);
++				n++;
 +				p++;
 +				i++;
 +			}
 +		} ZEND_HASH_FILL_END();
 +		ht->nNumOfElements = n;
 +	}
 +	ZEND_VM_NEXT_OPCODE();
 +}
 +
  static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
  {
  	USE_OPLINE