clones/php-src
1
0
Fork 0
mirror of https://github.com/php/php-src.git synced 2024-09-22 18:37:25 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove uses of VARs in extended_value

Browse Source 
The DECLARE_(ANON_)INHERITED_CLASS(_DELAYED) opcodes were
referencing the parent ce VAR through extended_value. This is
hacky and we can't track the def-use chain in SSA.

To avoid this, the layout of declaration opcodes is changed
as follows: op1 points to the lcname and rtd_key literals, in
that order. (For anon/lambda declarations only one of lcname or
rtd_key is present.) This frees up op2, which is now used to
reference the parent ce VAR in inheriting declarations. The
jmp offset for anon class declarations is moved frop op2 to
extended_value.

The changes were applied both to class and function declarations
to keep everything symmetric.
This commit is contained in:
Nikita Popov 2015-12-20 13:42:26 +01:00
parent 1fe8a1dec9
commit 88eae43ff9
16 changed files with 210 additions and 252 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

91
Zend/zend_compile.c
View File

@ -979,24 +979,24 @@ ZEND_API void function_add_ref(zend_function *function) /* {{{ */
ZEND_API int do_bind_function(const zend_op_array *op_array, const zend_op *opline, HashTable *function_table, zend_bool compile_time) /* {{{ */
{
zend_function *function, *new_function;
zval *op1, *op2;
zval *lcname, *rtd_key;
if (compile_time) {
op1 = CT_CONSTANT_EX(op_array, opline->op1.constant);
op2 = CT_CONSTANT_EX(op_array, opline->op2.constant);
lcname = CT_CONSTANT_EX(op_array, opline->op1.constant);
rtd_key = lcname + 1;
} else {
op1 = RT_CONSTANT(op_array, opline->op1);
op2 = RT_CONSTANT(op_array, opline->op2);
lcname = RT_CONSTANT(op_array, opline->op1);
rtd_key = lcname + 1;
}
function = zend_hash_find_ptr(function_table, Z_STR_P(op1));
function = zend_hash_find_ptr(function_table, Z_STR_P(rtd_key));
new_function = zend_arena_alloc(&CG(arena), sizeof(zend_op_array));
memcpy(new_function, function, sizeof(zend_op_array));
if (zend_hash_add_ptr(function_table, Z_STR_P(op2), new_function) == NULL) {
if (zend_hash_add_ptr(function_table, Z_STR_P(lcname), new_function) == NULL) {
int error_level = compile_time ? E_COMPILE_ERROR : E_ERROR;
zend_function *old_function;
if ((old_function = zend_hash_find_ptr(function_table, Z_STR_P(op2))) != NULL
if ((old_function = zend_hash_find_ptr(function_table, Z_STR_P(lcname))) != NULL
&& old_function->type == ZEND_USER_FUNCTION
&& old_function->op_array.last > 0) {
zend_error_noreturn(error_level, "Cannot redeclare %s() (previously declared in %s:%d)",
@ -1020,21 +1020,21 @@ ZEND_API int do_bind_function(const zend_op_array *op_array, const zend_op *opli
ZEND_API zend_class_entry *do_bind_class(const zend_op_array* op_array, const zend_op *opline, HashTable *class_table, zend_bool compile_time) /* {{{ */
{
zend_class_entry *ce;
zval *op1, *op2;
zval *lcname, *rtd_key;
if (compile_time) {
op1 = CT_CONSTANT_EX(op_array, opline->op1.constant);
op2 = CT_CONSTANT_EX(op_array, opline->op2.constant);
lcname = CT_CONSTANT_EX(op_array, opline->op1.constant);
rtd_key = lcname + 1;
} else {
op1 = RT_CONSTANT(op_array, opline->op1);
op2 = RT_CONSTANT(op_array, opline->op2);
lcname = RT_CONSTANT(op_array, opline->op1);
rtd_key = lcname + 1;
}
if ((ce = zend_hash_find_ptr(class_table, Z_STR_P(op1))) == NULL) {
zend_error_noreturn(E_COMPILE_ERROR, "Internal Zend error - Missing class information for %s", Z_STRVAL_P(op1));
if ((ce = zend_hash_find_ptr(class_table, Z_STR_P(rtd_key))) == NULL) {
zend_error_noreturn(E_COMPILE_ERROR, "Internal Zend error - Missing class information for %s", Z_STRVAL_P(rtd_key));
return NULL;
}
ce->refcount++;
if (zend_hash_add_ptr(class_table, Z_STR_P(op2), ce) == NULL) {
if (zend_hash_add_ptr(class_table, Z_STR_P(lcname), ce) == NULL) {
ce->refcount--;
if (!compile_time) {
/* If we're in compile time, in practice, it's quite possible
@ -1057,17 +1057,17 @@ ZEND_API zend_class_entry *do_bind_class(const zend_op_array* op_array, const ze
ZEND_API zend_class_entry *do_bind_inherited_class(const zend_op_array *op_array, const zend_op *opline, HashTable *class_table, zend_class_entry *parent_ce, zend_bool compile_time) /* {{{ */
{
zend_class_entry *ce;
zval *op1, *op2;
zval *lcname, *rtd_key;
if (compile_time) {
op1 = CT_CONSTANT_EX(op_array, opline->op1.constant);
op2 = CT_CONSTANT_EX(op_array, opline->op2.constant);
lcname = CT_CONSTANT_EX(op_array, opline->op1.constant);
rtd_key = lcname + 1;
} else {
op1 = RT_CONSTANT(op_array, opline->op1);
op2 = RT_CONSTANT(op_array, opline->op2);
lcname = RT_CONSTANT(op_array, opline->op1);
rtd_key = lcname + 1;
}
ce = zend_hash_find_ptr(class_table, Z_STR_P(op1));
ce = zend_hash_find_ptr(class_table, Z_STR_P(rtd_key));
if (!ce) {
if (!compile_time) {
@ -1076,12 +1076,12 @@ ZEND_API zend_class_entry *do_bind_inherited_class(const zend_op_array *op_array
* so we shut up about it. This allows the if (!defined('FOO')) { return; }
* approach to work.
*/
zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare %s %s, because the name is already in use", zend_get_object_type(Z_OBJCE_P(op2)), Z_STRVAL_P(op2));
zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare %s, because the name is already in use", zend_get_object_type(Z_OBJCE_P(lcname)), Z_STRVAL_P(lcname));
}
return NULL;
}
if (zend_hash_exists(class_table, Z_STR_P(op2))) {
if (zend_hash_exists(class_table, Z_STR_P(lcname))) {
zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare %s %s, because the name is already in use", zend_get_object_type(ce), ZSTR_VAL(ce->name));
}
@ -1090,7 +1090,7 @@ ZEND_API zend_class_entry *do_bind_inherited_class(const zend_op_array *op_array
ce->refcount++;
/* Register the derived class */
if (zend_hash_add_ptr(class_table, Z_STR_P(op2), ce) == NULL) {
if (zend_hash_add_ptr(class_table, Z_STR_P(lcname), ce) == NULL) {
zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare %s %s, because the name is already in use", zend_get_object_type(ce), ZSTR_VAL(ce->name));
}
return ce;
@ -1164,9 +1164,9 @@ void zend_do_early_binding(void) /* {{{ */
return;
}
zend_hash_del(table, Z_STR_P(CT_CONSTANT(opline->op1)));
zend_hash_del(table, Z_STR_P(CT_CONSTANT(opline->op1)+1));
zend_del_literal(CG(active_op_array), opline->op1.constant+1);
zend_del_literal(CG(active_op_array), opline->op1.constant);
zend_del_literal(CG(active_op_array), opline->op2.constant);
MAKE_NOP(opline);
}
/* }}} */
@ -3590,7 +3590,7 @@ void zend_compile_new(znode *result, zend_ast *ast) /* {{{ */
}
class_node.op_type = opline->result_type;
class_node.u.op.var = opline->result.var;
opline->op1.opline_num = get_next_op_number(CG(active_op_array));
opline->extended_value = get_next_op_number(CG(active_op_array));
} else {
zend_compile_class_ref_ex(&class_node, class_ast, ZEND_FETCH_CLASS_EXCEPTION);
}
@ -5027,7 +5027,7 @@ void zend_begin_method_decl(zend_op_array *op_array, zend_string *name, zend_boo
static void zend_begin_func_decl(znode *result, zend_op_array *op_array, zend_ast_decl *decl) /* {{{ */
{
zend_ast *params_ast = decl->child[0];
zend_string *name = decl->name, *lcname;
zend_string *name = decl->name, *lcname, *key;
zend_op *opline;
op_array->function_name = name = zend_prefix_with_ns(name);
@ -5049,22 +5049,20 @@ static void zend_begin_func_decl(znode *result, zend_op_array *op_array, zend_as
ZEND_AUTOLOAD_FUNC_NAME);
}
key = zend_build_runtime_definition_key(lcname, decl->lex_pos);
zend_hash_update_ptr(CG(function_table), key, op_array);
if (op_array->fn_flags & ZEND_ACC_CLOSURE) {
opline = zend_emit_op_tmp(result, ZEND_DECLARE_LAMBDA_FUNCTION, NULL, NULL);
opline->op1_type = IS_CONST;
LITERAL_STR(opline->op1, key);
} else {
opline = get_next_op(CG(active_op_array));
opline->opcode = ZEND_DECLARE_FUNCTION;
opline->op2_type = IS_CONST;
LITERAL_STR(opline->op2, zend_string_copy(lcname));
}
{
zend_string *key = zend_build_runtime_definition_key(lcname, decl->lex_pos);
opline->op1_type = IS_CONST;
LITERAL_STR(opline->op1, key);
zend_hash_update_ptr(CG(function_table), key, op_array);
LITERAL_STR(opline->op1, zend_string_copy(lcname));
/* RTD key is placed after lcname literal in op1 */
zend_add_literal_string(CG(active_op_array), &key);
}
zend_string_release(lcname);
@ -5492,34 +5490,31 @@ void zend_compile_class_decl(zend_ast *ast) /* {{{ */
GET_NODE(&FC(implementing_class), opline->result);
opline->op2_type = IS_CONST;
LITERAL_STR(opline->op2, lcname);
opline->op1_type = IS_CONST;
LITERAL_STR(opline->op1, lcname);
if (decl->flags & ZEND_ACC_ANON_CLASS) {
if (extends_ast) {
opline->opcode = ZEND_DECLARE_ANON_INHERITED_CLASS;
opline->extended_value = extends_node.u.op.var;
SET_NODE(opline->op2, &extends_node);
} else {
opline->opcode = ZEND_DECLARE_ANON_CLASS;
}
opline->op1_type = IS_UNUSED;
zend_hash_update_ptr(CG(class_table), lcname, ce);
} else {
zend_string *key;
if (extends_ast) {
opline->opcode = ZEND_DECLARE_INHERITED_CLASS;
opline->extended_value = extends_node.u.op.var;
SET_NODE(opline->op2, &extends_node);
} else {
opline->opcode = ZEND_DECLARE_CLASS;
}
key = zend_build_runtime_definition_key(lcname, decl->lex_pos);
opline->op1_type = IS_CONST;
LITERAL_STR(opline->op1, key);
/* RTD key is placed after lcname literal in op1 */
zend_add_literal_string(CG(active_op_array), &key);
zend_hash_update_ptr(CG(class_table), key, ce);
}

16
Zend/zend_opcode.c
View File

@ -639,13 +639,6 @@ ZEND_API int pass_two(zend_op_array *op_array)
case ZEND_FAST_RET:
zend_resolve_finally_ret(op_array, opline - op_array->opcodes);
break;
case ZEND_DECLARE_ANON_INHERITED_CLASS:
ZEND_PASS_TWO_UPDATE_JMP_TARGET(op_array, opline, opline->op1);
/* break omitted intentionally */
case ZEND_DECLARE_INHERITED_CLASS:
case ZEND_DECLARE_INHERITED_CLASS_DELAYED:
opline->extended_value = (uint32_t)(zend_intptr_t)ZEND_CALL_VAR_NUM(NULL, op_array->last_var + opline->extended_value);
break;
case ZEND_BRK:
case ZEND_CONT:
{
@ -667,13 +660,8 @@ ZEND_API int pass_two(zend_op_array *op_array)
}
/* break omitted intentionally */
case ZEND_JMP:
case ZEND_DECLARE_ANON_CLASS:
ZEND_PASS_TWO_UPDATE_JMP_TARGET(op_array, opline, opline->op1);
break;
case ZEND_CATCH:
/* absolute index to relative offset */
opline->extended_value = ZEND_OPLINE_NUM_TO_OFFSET(op_array, opline, opline->extended_value);
break;
case ZEND_JMPZNZ:
/* absolute index to relative offset */
opline->extended_value = ZEND_OPLINE_NUM_TO_OFFSET(op_array, opline, opline->extended_value);
@ -696,8 +684,12 @@ ZEND_API int pass_two(zend_op_array *op_array)
}
ZEND_PASS_TWO_UPDATE_JMP_TARGET(op_array, opline, opline->op2);
break;
case ZEND_DECLARE_ANON_CLASS:
case ZEND_DECLARE_ANON_INHERITED_CLASS:
case ZEND_CATCH:
case ZEND_FE_FETCH_R:
case ZEND_FE_FETCH_RW:
/* absolute index to relative offset */
opline->extended_value = ZEND_OPLINE_NUM_TO_OFFSET(op_array, opline, opline->extended_value);
break;
case ZEND_VERIFY_RETURN_TYPE:

28
Zend/zend_vm_def.h
View File

@ -7058,41 +7058,42 @@ ZEND_VM_HANDLER(139, ZEND_DECLARE_CLASS, ANY, ANY)
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
ZEND_VM_HANDLER(140, ZEND_DECLARE_INHERITED_CLASS, ANY, ANY, VAR)
ZEND_VM_HANDLER(140, ZEND_DECLARE_INHERITED_CLASS, ANY, VAR)
{
USE_OPLINE
SAVE_OPLINE();
Z_CE_P(EX_VAR(opline->result.var)) = do_bind_inherited_class(&EX(func)->op_array, opline, EG(class_table), Z_CE_P(EX_VAR(opline->extended_value)), 0);
Z_CE_P(EX_VAR(opline->result.var)) = do_bind_inherited_class(&EX(func)->op_array, opline, EG(class_table), Z_CE_P(EX_VAR(opline->op2.var)), 0);
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
ZEND_VM_HANDLER(145, ZEND_DECLARE_INHERITED_CLASS_DELAYED, ANY, ANY, VAR)
ZEND_VM_HANDLER(145, ZEND_DECLARE_INHERITED_CLASS_DELAYED, ANY, VAR)
{
USE_OPLINE
zval *zce, *orig_zce;
SAVE_OPLINE();
if ((zce = zend_hash_find(EG(class_table), Z_STR_P(EX_CONSTANT(opline->op2)))) == NULL ||
((orig_zce = zend_hash_find(EG(class_table), Z_STR_P(EX_CONSTANT(opline->op1)))) != NULL &&
if ((zce = zend_hash_find(EG(class_table), Z_STR_P(EX_CONSTANT(opline->op1)))) == NULL ||
((orig_zce = zend_hash_find(EG(class_table), Z_STR_P(EX_CONSTANT(opline->op1)+1))) != NULL &&
Z_CE_P(zce) != Z_CE_P(orig_zce))) {
do_bind_inherited_class(&EX(func)->op_array, opline, EG(class_table), Z_CE_P(EX_VAR(opline->extended_value)), 0);
do_bind_inherited_class(&EX(func)->op_array, opline, EG(class_table), Z_CE_P(EX_VAR(opline->op2.var)), 0);
}
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
ZEND_VM_HANDLER(171, ZEND_DECLARE_ANON_CLASS, JMP_ADDR, ANY)
ZEND_VM_HANDLER(171, ZEND_DECLARE_ANON_CLASS, ANY, ANY, JMP_ADDR)
{
zend_class_entry *ce;
USE_OPLINE
SAVE_OPLINE();
ce = zend_hash_find_ptr(EG(class_table), Z_STR_P(EX_CONSTANT(opline->op2)));
ce = zend_hash_find_ptr(EG(class_table), Z_STR_P(EX_CONSTANT(opline->op1)));
Z_CE_P(EX_VAR(opline->result.var)) = ce;
ZEND_ASSERT(ce != NULL);
if (ce->ce_flags & ZEND_ACC_ANON_BOUND) {
ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op1));
ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
ZEND_VM_CONTINUE();
}
if (!(ce->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_IMPLEMENT_INTERFACES|ZEND_ACC_IMPLEMENT_TRAITS))) {
@ -7102,21 +7103,22 @@ ZEND_VM_HANDLER(171, ZEND_DECLARE_ANON_CLASS, JMP_ADDR, ANY)
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
ZEND_VM_HANDLER(172, ZEND_DECLARE_ANON_INHERITED_CLASS, JMP_ADDR, ANY, VAR)
ZEND_VM_HANDLER(172, ZEND_DECLARE_ANON_INHERITED_CLASS, ANY, VAR, JMP_ADDR)
{
zend_class_entry *ce;
USE_OPLINE
SAVE_OPLINE();
ce = zend_hash_find_ptr(EG(class_table), Z_STR_P(EX_CONSTANT(opline->op2)));
ce = zend_hash_find_ptr(EG(class_table), Z_STR_P(EX_CONSTANT(opline->op1)));
Z_CE_P(EX_VAR(opline->result.var)) = ce;
ZEND_ASSERT(ce != NULL);
if (ce->ce_flags & ZEND_ACC_ANON_BOUND) {
ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op1));
ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
ZEND_VM_CONTINUE();
}
zend_do_inheritance(ce, Z_CE_P(EX_VAR(opline->extended_value)));
zend_do_inheritance(ce, Z_CE_P(EX_VAR(opline->op2.var)));
ce->ce_flags |= ZEND_ACC_ANON_BOUND;
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}

240
Zend/zend_vm_execute.h
View File

@ -1336,41 +1336,19 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_CLASS_SPEC_HANDLER(ZEN
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
SAVE_OPLINE();
Z_CE_P(EX_VAR(opline->result.var)) = do_bind_inherited_class(&EX(func)->op_array, opline, EG(class_table), Z_CE_P(EX_VAR(opline->extended_value)), 0);
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
zval *zce, *orig_zce;
SAVE_OPLINE();
if ((zce = zend_hash_find(EG(class_table), Z_STR_P(EX_CONSTANT(opline->op2)))) == NULL ||
((orig_zce = zend_hash_find(EG(class_table), Z_STR_P(EX_CONSTANT(opline->op1)))) != NULL &&
Z_CE_P(zce) != Z_CE_P(orig_zce))) {
do_bind_inherited_class(&EX(func)->op_array, opline, EG(class_table), Z_CE_P(EX_VAR(opline->extended_value)), 0);
}
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_ANON_CLASS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
zend_class_entry *ce;
USE_OPLINE
SAVE_OPLINE();
ce = zend_hash_find_ptr(EG(class_table), Z_STR_P(EX_CONSTANT(opline->op2)));
ce = zend_hash_find_ptr(EG(class_table), Z_STR_P(EX_CONSTANT(opline->op1)));
Z_CE_P(EX_VAR(opline->result.var)) = ce;
ZEND_ASSERT(ce != NULL);
if (ce->ce_flags & ZEND_ACC_ANON_BOUND) {
ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op1));
ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
ZEND_VM_CONTINUE();
}
if (!(ce->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_IMPLEMENT_INTERFACES|ZEND_ACC_IMPLEMENT_TRAITS))) {
@ -1380,25 +1358,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_ANON_CLASS_SPEC_HANDLE
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
zend_class_entry *ce;
USE_OPLINE
SAVE_OPLINE();
ce = zend_hash_find_ptr(EG(class_table), Z_STR_P(EX_CONSTANT(opline->op2)));
Z_CE_P(EX_VAR(opline->result.var)) = ce;
ZEND_ASSERT(ce != NULL);
if (ce->ce_flags & ZEND_ACC_ANON_BOUND) {
ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op1));
}
zend_do_inheritance(ce, Z_CE_P(EX_VAR(opline->extended_value)));
ce->ce_flags |= ZEND_ACC_ANON_BOUND;
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_FUNCTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
@ -2265,6 +2224,49 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_INTERFACE_SPEC_CONST_HANDL
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_INHERITED_CLASS_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
SAVE_OPLINE();
Z_CE_P(EX_VAR(opline->result.var)) = do_bind_inherited_class(&EX(func)->op_array, opline, EG(class_table), Z_CE_P(EX_VAR(opline->op2.var)), 0);
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
zval *zce, *orig_zce;
SAVE_OPLINE();
if ((zce = zend_hash_find(EG(class_table), Z_STR_P(EX_CONSTANT(opline->op1)))) == NULL ||
((orig_zce = zend_hash_find(EG(class_table), Z_STR_P(EX_CONSTANT(opline->op1)+1))) != NULL &&
Z_CE_P(zce) != Z_CE_P(orig_zce))) {
do_bind_inherited_class(&EX(func)->op_array, opline, EG(class_table), Z_CE_P(EX_VAR(opline->op2.var)), 0);
}
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
zend_class_entry *ce;
USE_OPLINE
SAVE_OPLINE();
ce = zend_hash_find_ptr(EG(class_table), Z_STR_P(EX_CONSTANT(opline->op1)));
Z_CE_P(EX_VAR(opline->result.var)) = ce;
ZEND_ASSERT(ce != NULL);
if (ce->ce_flags & ZEND_ACC_ANON_BOUND) {
ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
ZEND_VM_CONTINUE();
}
zend_do_inheritance(ce, Z_CE_P(EX_VAR(opline->op2.var)));
ce->ce_flags |= ZEND_ACC_ANON_BOUND;
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
@ -49584,31 +49586,31 @@ void zend_init_opcodes_handlers(void)
ZEND_DECLARE_CLASS_SPEC_HANDLER,
ZEND_DECLARE_CLASS_SPEC_HANDLER,
ZEND_DECLARE_CLASS_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_SPEC_VAR_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_SPEC_VAR_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_SPEC_VAR_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_SPEC_VAR_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_SPEC_VAR_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
@ -49709,31 +49711,31 @@ void zend_init_opcodes_handlers(void)
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_VAR_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_VAR_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_VAR_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_VAR_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_VAR_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER,
@ -50384,31 +50386,31 @@ void zend_init_opcodes_handlers(void)
ZEND_DECLARE_ANON_CLASS_SPEC_HANDLER,
ZEND_DECLARE_ANON_CLASS_SPEC_HANDLER,
ZEND_DECLARE_ANON_CLASS_SPEC_HANDLER,
ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_HANDLER,
ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_VAR_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_VAR_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_VAR_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_VAR_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_VAR_HANDLER,
ZEND_NULL_HANDLER,
ZEND_NULL_HANDLER,
ZEND_FETCH_STATIC_PROP_R_SPEC_CONST_CONST_HANDLER,
ZEND_NULL_HANDLER,
ZEND_FETCH_STATIC_PROP_R_SPEC_CONST_VAR_HANDLER,

3
Zend/zend_vm_gen.php
View File

@ -88,7 +88,7 @@ $vm_op_flags = array(
"ZEND_VM_EXT_REF" => 1<<20,
"ZEND_VM_EXT_MASK" => 0xff000000,
"ZEND_VM_EXT_NUM" => 0x01000000,
"ZEND_VM_EXT_VAR" => 0x02000000,
// unused 0x2000000
"ZEND_VM_EXT_JMP_ADDR" => 0x03000000,
"ZEND_VM_EXT_DIM_OBJ" => 0x04000000,
"ZEND_VM_EXT_CLASS_FETCH" => 0x05000000,
@ -125,7 +125,6 @@ $vm_op_decode = array(
$vm_ext_decode = array(
"NUM" => ZEND_VM_EXT_NUM,
"VAR" => ZEND_VM_EXT_VAR,
"JMP_ADDR" => ZEND_VM_EXT_JMP_ADDR,
"DIM_OBJ" => ZEND_VM_EXT_DIM_OBJ,
"CLASS_FETCH" => ZEND_VM_EXT_CLASS_FETCH,

8
Zend/zend_vm_opcodes.c
View File

@ -347,12 +347,12 @@ static uint32_t zend_vm_opcodes_flags[182] = {
0x00000000,
0x00007305,
0x00000000,
0x02000000,
0x00000100,
0x00000000,
0x00000003,
0x00000303,
0x00000300,
0x02000000,
0x00000100,
0x00000000,
0x00006701,
0x00020757,
@ -378,8 +378,8 @@ static uint32_t zend_vm_opcodes_flags[182] = {
0x00000301,
0x00002003,
0x00000707,
0x00000020,
0x02000020,
0x03000000,
0x03000100,
0x00007307,
0x00007307,
0x00007307,

1
Zend/zend_vm_opcodes.h
View File

@ -59,7 +59,6 @@
#define ZEND_VM_EXT_REF 0x00100000
#define ZEND_VM_EXT_MASK 0xff000000
#define ZEND_VM_EXT_NUM 0x01000000
#define ZEND_VM_EXT_VAR 0x02000000
#define ZEND_VM_EXT_JMP_ADDR 0x03000000
#define ZEND_VM_EXT_DIM_OBJ 0x04000000
#define ZEND_VM_EXT_CLASS_FETCH 0x05000000

4
ext/opcache/Optimizer/block_pass.c
View File

@ -836,8 +836,6 @@ static void assemble_code_blocks(zend_cfg *cfg, zend_op_array *op_array)
switch (opline->opcode) {
case ZEND_FAST_CALL:
case ZEND_JMP:
case ZEND_DECLARE_ANON_CLASS:
case ZEND_DECLARE_ANON_INHERITED_CLASS:
ZEND_SET_OP_JMP_ADDR(opline, opline->op1, new_opcodes + blocks[b->successors[0]].start);
break;
case ZEND_JMPZNZ:
@ -860,6 +858,8 @@ static void assemble_code_blocks(zend_cfg *cfg, zend_op_array *op_array)
opline->extended_value = ZEND_OPLINE_TO_OFFSET(opline, new_opcodes + blocks[b->successors[0]].start);
}
break;
case ZEND_DECLARE_ANON_CLASS:
case ZEND_DECLARE_ANON_INHERITED_CLASS:
case ZEND_FE_FETCH_R:
case ZEND_FE_FETCH_RW:
opline->extended_value = ZEND_OPLINE_TO_OFFSET(opline, new_opcodes + blocks[b->successors[0]].start);

18
ext/opcache/Optimizer/compact_literals.c
View File

@ -195,18 +195,6 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx
LITERAL_CLASS_CONST, (ZEND_OP1_TYPE(opline) == IS_CONST) ? 1 : 2, 1,
op_array);
break;
case ZEND_FETCH_R:
case ZEND_FETCH_W:
case ZEND_FETCH_RW:
case ZEND_FETCH_IS:
case ZEND_FETCH_UNSET:
case ZEND_FETCH_FUNC_ARG:
case ZEND_UNSET_VAR:
case ZEND_ISSET_ISEMPTY_VAR:
if (ZEND_OP1_TYPE(opline) == IS_CONST) {
LITERAL_INFO(opline->op1.constant, LITERAL_VALUE, 1, 0, 1);
}
break;
case ZEND_FETCH_STATIC_PROP_R:
case ZEND_FETCH_STATIC_PROP_W:
case ZEND_FETCH_STATIC_PROP_RW:
@ -300,6 +288,12 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx
cache_size += sizeof(void *);
}
break;
case ZEND_DECLARE_FUNCTION:
case ZEND_DECLARE_CLASS:
case ZEND_DECLARE_INHERITED_CLASS:
case ZEND_DECLARE_INHERITED_CLASS_DELAYED:
LITERAL_INFO(opline->op1.constant, LITERAL_VALUE, 1, 0, 2);
break;
case ZEND_RECV:
case ZEND_RECV_VARIADIC:
case ZEND_VERIFY_RETURN_TYPE:

8
ext/opcache/Optimizer/nop_removal.c
View File

@ -69,8 +69,6 @@ void zend_optimizer_nop_removal(zend_op_array *op_array)
switch (new_opline->opcode) {
case ZEND_JMP:
case ZEND_FAST_CALL:
case ZEND_DECLARE_ANON_CLASS:
case ZEND_DECLARE_ANON_INHERITED_CLASS:
ZEND_SET_OP_JMP_ADDR(new_opline, new_opline->op1, ZEND_OP1_JMP_ADDR(opline));
break;
case ZEND_JMPZNZ:
@ -93,6 +91,8 @@ void zend_optimizer_nop_removal(zend_op_array *op_array)
new_opline->extended_value = ZEND_OPLINE_NUM_TO_OFFSET(op_array, new_opline, ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, opline->extended_value));
}
break;
case ZEND_DECLARE_ANON_CLASS:
case ZEND_DECLARE_ANON_INHERITED_CLASS:
case ZEND_FE_FETCH_R:
case ZEND_FE_FETCH_RW:
new_opline->extended_value = ZEND_OPLINE_NUM_TO_OFFSET(op_array, new_opline, ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, opline->extended_value));
@ -112,8 +112,6 @@ void zend_optimizer_nop_removal(zend_op_array *op_array)
switch (opline->opcode) {
case ZEND_JMP:
case ZEND_FAST_CALL:
case ZEND_DECLARE_ANON_CLASS:
case ZEND_DECLARE_ANON_INHERITED_CLASS:
ZEND_SET_OP_JMP_ADDR(opline, opline->op1, ZEND_OP1_JMP_ADDR(opline) - shiftlist[ZEND_OP1_JMP_ADDR(opline) - op_array->opcodes]);
break;
case ZEND_JMPZNZ:
@ -131,6 +129,8 @@ void zend_optimizer_nop_removal(zend_op_array *op_array)
case ZEND_ASSERT_CHECK:
ZEND_SET_OP_JMP_ADDR(opline, opline->op2, ZEND_OP2_JMP_ADDR(opline) - shiftlist[ZEND_OP2_JMP_ADDR(opline) - op_array->opcodes]);
break;
case ZEND_DECLARE_ANON_CLASS:
case ZEND_DECLARE_ANON_INHERITED_CLASS:
case ZEND_FE_FETCH_R:
case ZEND_FE_FETCH_RW:
case ZEND_CATCH:

12
ext/opcache/Optimizer/optimize_temp_vars_5.c
View File

@ -156,18 +156,6 @@ void optimize_temporary_variables(zend_op_array *op_array, zend_optimizer_ctx *c
ZEND_OP2(opline).var = NUM_VAR(map_T[currT] + offset);
}
if (opline->opcode == ZEND_DECLARE_INHERITED_CLASS ||
opline->opcode == ZEND_DECLARE_ANON_INHERITED_CLASS ||
opline->opcode == ZEND_DECLARE_INHERITED_CLASS_DELAYED) {
currT = VAR_NUM(opline->extended_value) - offset;
if (!zend_bitset_in(valid_T, currT)) {
GET_AVAILABLE_T();
map_T[currT] = i;
zend_bitset_incl(valid_T, currT);
}
opline->extended_value = NUM_VAR(map_T[currT] + offset);
}
/* Allocate OP_DATA->op2 after "operands", but before "result" */
if (opline->opcode == ZEND_ASSIGN_DIM &&
(opline + 1)->opcode == ZEND_OP_DATA &&

14
ext/opcache/Optimizer/zend_cfg.c
View File

@ -329,11 +329,6 @@ int zend_build_cfg(zend_arena **arena, const zend_op_array *op_array, uint32_t b
BB_START(i + 1);
}
break;
case ZEND_DECLARE_ANON_CLASS:
case ZEND_DECLARE_ANON_INHERITED_CLASS:
BB_START(OP_JMP_ADDR(opline, opline->op1) - op_array->opcodes);
BB_START(i + 1);
break;
case ZEND_JMP:
BB_START(OP_JMP_ADDR(opline, opline->op1) - op_array->opcodes);
if (i + 1 < op_array->last) {
@ -364,6 +359,8 @@ int zend_build_cfg(zend_arena **arena, const zend_op_array *op_array, uint32_t b
}
BB_START(i + 1);
break;
case ZEND_DECLARE_ANON_CLASS:
case ZEND_DECLARE_ANON_INHERITED_CLASS:
case ZEND_FE_FETCH_R:
case ZEND_FE_FETCH_RW:
BB_START(ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, opline->extended_value));
@ -478,11 +475,6 @@ int zend_build_cfg(zend_arena **arena, const zend_op_array *op_array, uint32_t b
case ZEND_EXIT:
case ZEND_THROW:
break;
case ZEND_DECLARE_ANON_CLASS:
case ZEND_DECLARE_ANON_INHERITED_CLASS:
record_successor(blocks, j, 0, block_map[OP_JMP_ADDR(opline, opline->op1) - op_array->opcodes]);
record_successor(blocks, j, 1, j + 1);
break;
case ZEND_JMP:
record_successor(blocks, j, 0, block_map[OP_JMP_ADDR(opline, opline->op1) - op_array->opcodes]);
break;
@ -508,6 +500,8 @@ int zend_build_cfg(zend_arena **arena, const zend_op_array *op_array, uint32_t b
record_successor(blocks, j, 0, j + 1);
}
break;
case ZEND_DECLARE_ANON_CLASS:
case ZEND_DECLARE_ANON_INHERITED_CLASS:
case ZEND_FE_FETCH_R:
case ZEND_FE_FETCH_RW:
record_successor(blocks, j, 0, block_map[ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, opline->extended_value)]);

2
ext/opcache/Optimizer/zend_dump.c
View File

@ -648,8 +648,6 @@ static void zend_dump_op(const zend_op_array *op_array, const zend_basic_block *
fprintf(stderr, " L%u", (uint32_t)ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, opline->extended_value));
}
}
} else if (ZEND_VM_EXT_VAR == (flags & ZEND_VM_EXT_MASK)) {
fprintf(stderr, " V%u", EX_VAR_TO_NUM(opline->extended_value));
}
if (opline->result_type == IS_CONST) {
zend_dump_const(CRT_CONSTANT_EX(op_array, opline->result, (dump_flags & ZEND_DUMP_RT_CONSTANTS)));

5
ext/opcache/Optimizer/zend_optimizer.c
View File

@ -91,11 +91,6 @@ int zend_optimizer_lookup_cv(zend_op_array *op_array, zend_string* name)
if (opline->result_type & (IS_TMP_VAR|IS_VAR)) {
opline->result.var += sizeof(zval);
}
if (opline->opcode == ZEND_DECLARE_INHERITED_CLASS ||
opline->opcode == ZEND_DECLARE_ANON_INHERITED_CLASS ||
opline->opcode == ZEND_DECLARE_INHERITED_CLASS_DELAYED) {
opline->extended_value += sizeof(zval);
}
opline++;
}
}

8
ext/opcache/zend_file_cache.c
View File

@ -392,8 +392,6 @@ static void zend_file_cache_serialize_op_array(zend_op_array *op_arra
switch (opline->opcode) {
case ZEND_JMP:
case ZEND_FAST_CALL:
case ZEND_DECLARE_ANON_CLASS:
case ZEND_DECLARE_ANON_INHERITED_CLASS:
SERIALIZE_PTR(opline->op1.jmp_addr);
break;
case ZEND_JMPZNZ:
@ -411,6 +409,8 @@ static void zend_file_cache_serialize_op_array(zend_op_array *op_arra
case ZEND_ASSERT_CHECK:
SERIALIZE_PTR(opline->op2.jmp_addr);
break;
case ZEND_DECLARE_ANON_CLASS:
case ZEND_DECLARE_ANON_INHERITED_CLASS:
case ZEND_FE_FETCH_R:
case ZEND_FE_FETCH_RW:
/* relative extended_value don't have to be changed */
@ -969,8 +969,6 @@ static void zend_file_cache_unserialize_op_array(zend_op_array *op_arr
switch (opline->opcode) {
case ZEND_JMP:
case ZEND_FAST_CALL:
case ZEND_DECLARE_ANON_CLASS:
case ZEND_DECLARE_ANON_INHERITED_CLASS:
UNSERIALIZE_PTR(opline->op1.jmp_addr);
break;
case ZEND_JMPZNZ:
@ -988,6 +986,8 @@ static void zend_file_cache_unserialize_op_array(zend_op_array *op_arr
case ZEND_ASSERT_CHECK:
UNSERIALIZE_PTR(opline->op2.jmp_addr);
break;
case ZEND_DECLARE_ANON_CLASS:
case ZEND_DECLARE_ANON_INHERITED_CLASS:
case ZEND_FE_FETCH_R:
case ZEND_FE_FETCH_RW:
/* relative extended_value don't have to be changed */

4
ext/opcache/zend_persist.c
View File

@ -530,8 +530,6 @@ static void zend_persist_op_array_ex(zend_op_array *op_array, zend_persistent_sc
switch (opline->opcode) {
case ZEND_JMP:
case ZEND_FAST_CALL:
case ZEND_DECLARE_ANON_CLASS:
case ZEND_DECLARE_ANON_INHERITED_CLASS:
opline->op1.jmp_addr = &new_opcodes[opline->op1.jmp_addr - op_array->opcodes];
break;
case ZEND_JMPZNZ:
@ -549,6 +547,8 @@ static void zend_persist_op_array_ex(zend_op_array *op_array, zend_persistent_sc
case ZEND_ASSERT_CHECK:
opline->op2.jmp_addr = &new_opcodes[opline->op2.jmp_addr - op_array->opcodes];
break;
case ZEND_DECLARE_ANON_CLASS:
case ZEND_DECLARE_ANON_INHERITED_CLASS:
case ZEND_FE_FETCH_R:
case ZEND_FE_FETCH_RW:
/* relative extended_value don't have to be changed */