Remove uses of VARs in extended_value

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.

diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index 13e222836aa5b67a69f093e88d093d93c78b566c..acf312cfa624502cc8262bf4d65a277aae7a7fa5 100644 (file)
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -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);
        }

diff --git a/Zend/zend_opcode.c b/Zend/zend_opcode.c
index 0ce6b8593873489509575ad7298c9e3710e09871..a6dc49c10b14daf62f9768247aa3f0f385cd0572 100644 (file)
--- a/Zend/zend_opcode.c
+++ b/Zend/zend_opcode.c
@@ -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:

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index 75c1a021d2c4fa4d531ca837d51334b7a11627da..85c9c626053f54070daa067c715e8a01d912b795 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -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();
 }

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index d9b9e615d44185bbe0b19e300be45c40a055c883..4e7e20ebcc36fc304c3c49f234bb15a07e6a7f11 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -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,

diff --git a/Zend/zend_vm_gen.php b/Zend/zend_vm_gen.php
index c82d59f2f94956b4f877fe5b6ad3282b2b2d5278..aeea969389969e37053c545168ba91d8ccbda8d8 100644 (file)
--- a/Zend/zend_vm_gen.php
+++ b/Zend/zend_vm_gen.php
@@ -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,

diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c
index d8952ecc4c6b22ba057e3ce6d955a3bf61392468..2776a80e6ff2acf74e47895fb29545a87330d397 100644 (file)
--- a/Zend/zend_vm_opcodes.c
+++ b/Zend/zend_vm_opcodes.c
@@ -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,

diff --git a/Zend/zend_vm_opcodes.h b/Zend/zend_vm_opcodes.h
index 760b18c31c999caddd4fd11e56528fa357ec2930..21f48cdb2b1cd965a26b9153070fccbf66fe2073 100644 (file)
--- a/Zend/zend_vm_opcodes.h
+++ b/Zend/zend_vm_opcodes.h
@@ -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

diff --git a/ext/opcache/Optimizer/block_pass.c b/ext/opcache/Optimizer/block_pass.c
index dc49ef216d301b59f5eab2876068c6a9ae87403f..4b6ef50d86864bfa01cc9fdde8083c1864b24366 100644 (file)
--- a/ext/opcache/Optimizer/block_pass.c
+++ b/ext/opcache/Optimizer/block_pass.c
@@ -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);

diff --git a/ext/opcache/Optimizer/compact_literals.c b/ext/opcache/Optimizer/compact_literals.c
index 518708b6252d1bcec6760525f8eefb9a195bb416..2a4beb0833421d0d98f126c0e2395fd689df2430 100644 (file)
--- a/ext/opcache/Optimizer/compact_literals.c
+++ b/ext/opcache/Optimizer/compact_literals.c
@@ -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:

diff --git a/ext/opcache/Optimizer/nop_removal.c b/ext/opcache/Optimizer/nop_removal.c
index 4f6983c79511277dfa8224393dd7f895d73f0317..899839feb7f0d8252cba51fe10697767641239f4 100644 (file)
--- a/ext/opcache/Optimizer/nop_removal.c
+++ b/ext/opcache/Optimizer/nop_removal.c
@@ -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:

diff --git a/ext/opcache/Optimizer/optimize_temp_vars_5.c b/ext/opcache/Optimizer/optimize_temp_vars_5.c
index 586471017c5e8e20ce49b98f1f63e4c087468a42..26cd135376da7cb690a13427c59108502bd336db 100644 (file)
--- a/ext/opcache/Optimizer/optimize_temp_vars_5.c
+++ b/ext/opcache/Optimizer/optimize_temp_vars_5.c
@@ -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 &&

diff --git a/ext/opcache/Optimizer/zend_cfg.c b/ext/opcache/Optimizer/zend_cfg.c
index c7399316842e6f4ed398c68fcbb05026524440ae..9446954e518e5b71c87e76672670ffb2609f2cab 100644 (file)
--- a/ext/opcache/Optimizer/zend_cfg.c
+++ b/ext/opcache/Optimizer/zend_cfg.c
@@ -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)]);

diff --git a/ext/opcache/Optimizer/zend_dump.c b/ext/opcache/Optimizer/zend_dump.c
index 5e7f64859fe8511f7abddeeb17e572f3310fe589..1046044f1c0d4b545533a5e53a90a91ed6c104ee 100644 (file)
--- a/ext/opcache/Optimizer/zend_dump.c
+++ b/ext/opcache/Optimizer/zend_dump.c
@@ -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)));

diff --git a/ext/opcache/Optimizer/zend_optimizer.c b/ext/opcache/Optimizer/zend_optimizer.c
index aeb2c42542f5450521a3984b38691a09a8eadac0..443410108192c3d4672bfbeb3157e570514398d9 100644 (file)
--- a/ext/opcache/Optimizer/zend_optimizer.c
+++ b/ext/opcache/Optimizer/zend_optimizer.c
@@ -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++;
                }
        }

diff --git a/ext/opcache/zend_file_cache.c b/ext/opcache/zend_file_cache.c
index ee8c6bad88649453278a2b3636ffa48d21c62773..f63a23f6a603c83ae6bf0f371159daca6df7c65c 100644 (file)
--- a/ext/opcache/zend_file_cache.c
+++ b/ext/opcache/zend_file_cache.c
@@ -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 */

diff --git a/ext/opcache/zend_persist.c b/ext/opcache/zend_persist.c
index d7c56cdfe433bb534b55a478a84dd38bf81ec18d..f74de00f33bfb2410068db86e7a8e3b3732d3182 100644 (file)
--- a/ext/opcache/zend_persist.c
+++ b/ext/opcache/zend_persist.c
@@ -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 */