Changed FETCH_CLASS instruction format (extended_value moved into op1)

diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index 226d44030069da77c2af19a44e600db8320a688c..fe2874e511cac6dd310000876fcf490545c84f24 100644 (file)
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -2501,7 +2501,7 @@ static zend_op *zend_compile_class_ref(znode *result, zend_ast *name_ast, int th
                fetch_type = zend_get_class_fetch_type(name);
 
                opline = zend_emit_op(result, ZEND_FETCH_CLASS, NULL, NULL);
-               opline->extended_value = fetch_type | (throw_exception ? ZEND_FETCH_CLASS_EXCEPTION : 0);
+               opline->op1.num = fetch_type | (throw_exception ? ZEND_FETCH_CLASS_EXCEPTION : 0);
 
                if (fetch_type == ZEND_FETCH_CLASS_DEFAULT) {
                        uint32_t type = name_ast->kind == ZEND_AST_ZVAL ? name_ast->attr : ZEND_NAME_FQ;
@@ -2515,7 +2515,7 @@ static zend_op *zend_compile_class_ref(znode *result, zend_ast *name_ast, int th
                zend_string_release(name);
        } else {
                opline = zend_emit_op(result, ZEND_FETCH_CLASS, NULL, &name_node);
-               opline->extended_value = ZEND_FETCH_CLASS_DEFAULT | (throw_exception ? ZEND_FETCH_CLASS_EXCEPTION : 0);
+               opline->op1.num = ZEND_FETCH_CLASS_DEFAULT | (throw_exception ? ZEND_FETCH_CLASS_EXCEPTION : 0);
        }
 
        return opline;
@@ -2553,7 +2553,7 @@ static void zend_compile_class_ref_ex(znode *result, zend_ast *name_ast, uint32_
                        zend_string_release(name);
                } else {
                        zend_op *opline = zend_emit_op(result, ZEND_FETCH_CLASS, NULL, &name_node);
-                       opline->extended_value = ZEND_FETCH_CLASS_DEFAULT | fetch_flags;
+                       opline->op1.num = ZEND_FETCH_CLASS_DEFAULT | fetch_flags;
                }
                return;
        }
@@ -7749,7 +7749,7 @@ void zend_compile_class_const(znode *result, zend_ast *ast) /* {{{ */
        if (zend_try_compile_const_expr_resolve_class_name(&result->u.constant, class_ast, const_ast, 0)) {
                if (Z_TYPE(result->u.constant) == IS_NULL) {
                        zend_op *opline = zend_emit_op_tmp(result, ZEND_FETCH_CLASS_NAME, NULL, NULL);
-                       opline->extended_value = zend_get_class_fetch_type(zend_ast_get_str(class_ast));
+                       opline->op1.num = zend_get_class_fetch_type(zend_ast_get_str(class_ast));
                } else {
                        result->op_type = IS_CONST;
                }
@@ -7807,14 +7807,14 @@ void zend_compile_resolve_class_name(znode *result, zend_ast *ast) /* {{{ */
                                ZVAL_STR_COPY(&result->u.constant, CG(active_class_entry)->name);
                        } else {
                                zend_op *opline = zend_emit_op_tmp(result, ZEND_FETCH_CLASS_NAME, NULL, NULL);
-                               opline->extended_value = fetch_type;
+                               opline->op1.num = fetch_type;
                        }
                        break;
                case ZEND_FETCH_CLASS_STATIC:
                case ZEND_FETCH_CLASS_PARENT:
                        {
                                zend_op *opline = zend_emit_op_tmp(result, ZEND_FETCH_CLASS_NAME, NULL, NULL);
-                               opline->extended_value = fetch_type;
+                               opline->op1.num = fetch_type;
                        }
                        break;
                case ZEND_FETCH_CLASS_DEFAULT:
@@ -7972,7 +7972,7 @@ void zend_compile_magic_const(znode *result, zend_ast *ast) /* {{{ */
                    (CG(active_class_entry)->ce_flags & ZEND_ACC_TRAIT) != 0);
 
        opline = zend_emit_op_tmp(result, ZEND_FETCH_CLASS_NAME, NULL, NULL);
-       opline->extended_value = ZEND_FETCH_CLASS_SELF;
+       opline->op1.num = ZEND_FETCH_CLASS_SELF;
 }
 /* }}} */
 

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index f74c622926c83ba38cd9876e3072ebbd922074cf..a093f5dcf49d5e4890ca7720fac9145844c96f90 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -2910,13 +2910,13 @@ ZEND_VM_HANDLER(56, ZEND_ROPE_END, TMP, CONST|TMPVAR|CV, NUM)
        ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HANDLER(109, ZEND_FETCH_CLASS, ANY, CONST|TMPVAR|UNUSED|CV, CLASS_FETCH)
+ZEND_VM_HANDLER(109, ZEND_FETCH_CLASS, UNUSED|CLASS_FETCH, CONST|TMPVAR|UNUSED|CV)
 {
        USE_OPLINE
 
        SAVE_OPLINE();
        if (OP2_TYPE == IS_UNUSED) {
-               Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->extended_value);
+               Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->op1.num);
                ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
        } else {
                zend_free_op free_op2;
@@ -2927,14 +2927,14 @@ ZEND_VM_C_LABEL(try_class_name):
                        zend_class_entry *ce = CACHED_PTR(Z_CACHE_SLOT_P(class_name));
 
                        if (UNEXPECTED(ce == NULL)) {
-                               ce = zend_fetch_class_by_name(Z_STR_P(class_name), RT_CONSTANT(opline, opline->op2) + 1, opline->extended_value);
+                               ce = zend_fetch_class_by_name(Z_STR_P(class_name), RT_CONSTANT(opline, opline->op2) + 1, opline->op1.num);
                                CACHE_PTR(Z_CACHE_SLOT_P(class_name), ce);
                        }
                        Z_CE_P(EX_VAR(opline->result.var)) = ce;
                } else if (Z_TYPE_P(class_name) == IS_OBJECT) {
                        Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
                } else if (Z_TYPE_P(class_name) == IS_STRING) {
-                       Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->extended_value);
+                       Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->op1.num);
                } else if ((OP2_TYPE & (IS_VAR|IS_CV)) && Z_TYPE_P(class_name) == IS_REFERENCE) {
                        class_name = Z_REFVAL_P(class_name);
                        ZEND_VM_C_GOTO(try_class_name);
@@ -7726,13 +7726,13 @@ ZEND_VM_HANDLER(151, ZEND_ASSERT_CHECK, ANY, JMP_ADDR)
        }
 }
 
-ZEND_VM_HANDLER(157, ZEND_FETCH_CLASS_NAME, ANY, ANY, CLASS_FETCH)
+ZEND_VM_HANDLER(157, ZEND_FETCH_CLASS_NAME, UNUSED|CLASS_FETCH, ANY)
 {
        uint32_t fetch_type;
        zend_class_entry *called_scope, *scope;
        USE_OPLINE
 
-       fetch_type = opline->extended_value;
+       fetch_type = opline->op1.num;
 
        scope = EX(func)->op_array.scope;
        if (UNEXPECTED(scope == NULL)) {

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index 404bb6b4105d4065c22995b4c12f32b2acf72ede..5c694e4feaacf2fc753f7d324808acf561d2d49d 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -1932,51 +1932,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSERT_CHECK_SPEC_HANDLER(ZEND
        }
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_NAME_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       uint32_t fetch_type;
-       zend_class_entry *called_scope, *scope;
-       USE_OPLINE
-
-       fetch_type = opline->extended_value;
-
-       scope = EX(func)->op_array.scope;
-       if (UNEXPECTED(scope == NULL)) {
-               SAVE_OPLINE();
-               zend_throw_error(NULL, "Cannot use \"%s\" when no class scope is active",
-                       fetch_type == ZEND_FETCH_CLASS_SELF ? "self" :
-                       fetch_type == ZEND_FETCH_CLASS_PARENT ? "parent" : "static");
-               ZVAL_UNDEF(EX_VAR(opline->result.var));
-               HANDLE_EXCEPTION();
-       }
-
-       switch (fetch_type) {
-               case ZEND_FETCH_CLASS_SELF:
-                       ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->name);
-                       break;
-               case ZEND_FETCH_CLASS_PARENT:
-                       if (UNEXPECTED(scope->parent == NULL)) {
-                               SAVE_OPLINE();
-                               zend_throw_error(NULL,
-                                       "Cannot use \"parent\" when current class scope has no parent");
-                               ZVAL_UNDEF(EX_VAR(opline->result.var));
-                               HANDLE_EXCEPTION();
-                       }
-                       ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->parent->name);
-                       break;
-               case ZEND_FETCH_CLASS_STATIC:
-                       if (Z_TYPE(EX(This)) == IS_OBJECT) {
-                               called_scope = Z_OBJCE(EX(This));
-                       } else {
-                               called_scope = Z_CE(EX(This));
-                       }
-                       ZVAL_STR_COPY(EX_VAR(opline->result.var), called_scope->name);
-                       break;
-               EMPTY_SWITCH_DEFAULT_CASE()
-       }
-       ZEND_VM_NEXT_OPCODE();
-}
-
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CALL_TRAMPOLINE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_array *args;
@@ -2125,48 +2080,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_interrupt_helper_SPEC(ZEND_OPC
        }
        ZEND_VM_CONTINUE();
 }
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-
-       SAVE_OPLINE();
-       if (IS_CONST == IS_UNUSED) {
-               Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->extended_value);
-               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
-       } else {
-
-               zval *class_name = RT_CONSTANT(opline, opline->op2);
-
-try_class_name:
-               if (IS_CONST == IS_CONST) {
-                       zend_class_entry *ce = CACHED_PTR(Z_CACHE_SLOT_P(class_name));
-
-                       if (UNEXPECTED(ce == NULL)) {
-                               ce = zend_fetch_class_by_name(Z_STR_P(class_name), RT_CONSTANT(opline, opline->op2) + 1, opline->extended_value);
-                               CACHE_PTR(Z_CACHE_SLOT_P(class_name), ce);
-                       }
-                       Z_CE_P(EX_VAR(opline->result.var)) = ce;
-               } else if (Z_TYPE_P(class_name) == IS_OBJECT) {
-                       Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
-               } else if (Z_TYPE_P(class_name) == IS_STRING) {
-                       Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->extended_value);
-               } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_TYPE_P(class_name) == IS_REFERENCE) {
-                       class_name = Z_REFVAL_P(class_name);
-                       goto try_class_name;
-               } else {
-                       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(class_name) == IS_UNDEF)) {
-                               GET_OP2_UNDEF_CV(class_name, BP_VAR_R);
-                               if (UNEXPECTED(EG(exception) != NULL)) {
-                                       HANDLE_EXCEPTION();
-                               }
-                       }
-                       zend_throw_error(NULL, "Class name must be a valid object or a string");
-               }
-
-               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
-       }
-}
-
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -2381,49 +2294,6 @@ 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_FETCH_CLASS_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-
-       SAVE_OPLINE();
-       if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
-               Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->extended_value);
-               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
-       } else {
-               zend_free_op free_op2;
-               zval *class_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
-
-try_class_name:
-               if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
-                       zend_class_entry *ce = CACHED_PTR(Z_CACHE_SLOT_P(class_name));
-
-                       if (UNEXPECTED(ce == NULL)) {
-                               ce = zend_fetch_class_by_name(Z_STR_P(class_name), RT_CONSTANT(opline, opline->op2) + 1, opline->extended_value);
-                               CACHE_PTR(Z_CACHE_SLOT_P(class_name), ce);
-                       }
-                       Z_CE_P(EX_VAR(opline->result.var)) = ce;
-               } else if (Z_TYPE_P(class_name) == IS_OBJECT) {
-                       Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
-               } else if (Z_TYPE_P(class_name) == IS_STRING) {
-                       Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->extended_value);
-               } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(class_name) == IS_REFERENCE) {
-                       class_name = Z_REFVAL_P(class_name);
-                       goto try_class_name;
-               } else {
-                       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(class_name) == IS_UNDEF)) {
-                               GET_OP2_UNDEF_CV(class_name, BP_VAR_R);
-                               if (UNEXPECTED(EG(exception) != NULL)) {
-                                       HANDLE_EXCEPTION();
-                               }
-                       }
-                       zend_throw_error(NULL, "Class name must be a valid object or a string");
-               }
-
-               zval_ptr_dtor_nogc(free_op2);
-               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
-       }
-}
-
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -2526,90 +2396,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_ANON_INHERITED_CLASS_S
        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
-
-       SAVE_OPLINE();
-       if (IS_UNUSED == IS_UNUSED) {
-               Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->extended_value);
-               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
-       } else {
-
-               zval *class_name = NULL;
-
-try_class_name:
-               if (IS_UNUSED == IS_CONST) {
-                       zend_class_entry *ce = CACHED_PTR(Z_CACHE_SLOT_P(class_name));
-
-                       if (UNEXPECTED(ce == NULL)) {
-                               ce = zend_fetch_class_by_name(Z_STR_P(class_name), RT_CONSTANT(opline, opline->op2) + 1, opline->extended_value);
-                               CACHE_PTR(Z_CACHE_SLOT_P(class_name), ce);
-                       }
-                       Z_CE_P(EX_VAR(opline->result.var)) = ce;
-               } else if (Z_TYPE_P(class_name) == IS_OBJECT) {
-                       Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
-               } else if (Z_TYPE_P(class_name) == IS_STRING) {
-                       Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->extended_value);
-               } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_TYPE_P(class_name) == IS_REFERENCE) {
-                       class_name = Z_REFVAL_P(class_name);
-                       goto try_class_name;
-               } else {
-                       if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(class_name) == IS_UNDEF)) {
-                               GET_OP2_UNDEF_CV(class_name, BP_VAR_R);
-                               if (UNEXPECTED(EG(exception) != NULL)) {
-                                       HANDLE_EXCEPTION();
-                               }
-                       }
-                       zend_throw_error(NULL, "Class name must be a valid object or a string");
-               }
-
-               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
-       }
-}
-
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-
-       SAVE_OPLINE();
-       if (IS_CV == IS_UNUSED) {
-               Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->extended_value);
-               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
-       } else {
-
-               zval *class_name = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
-
-try_class_name:
-               if (IS_CV == IS_CONST) {
-                       zend_class_entry *ce = CACHED_PTR(Z_CACHE_SLOT_P(class_name));
-
-                       if (UNEXPECTED(ce == NULL)) {
-                               ce = zend_fetch_class_by_name(Z_STR_P(class_name), RT_CONSTANT(opline, opline->op2) + 1, opline->extended_value);
-                               CACHE_PTR(Z_CACHE_SLOT_P(class_name), ce);
-                       }
-                       Z_CE_P(EX_VAR(opline->result.var)) = ce;
-               } else if (Z_TYPE_P(class_name) == IS_OBJECT) {
-                       Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
-               } else if (Z_TYPE_P(class_name) == IS_STRING) {
-                       Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->extended_value);
-               } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(class_name) == IS_REFERENCE) {
-                       class_name = Z_REFVAL_P(class_name);
-                       goto try_class_name;
-               } else {
-                       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(class_name) == IS_UNDEF)) {
-                               GET_OP2_UNDEF_CV(class_name, BP_VAR_R);
-                               if (UNEXPECTED(EG(exception) != NULL)) {
-                                       HANDLE_EXCEPTION();
-                               }
-                       }
-                       zend_throw_error(NULL, "Class name must be a valid object or a string");
-               }
-
-               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
-       }
-}
-
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_DYNAMIC_CALL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -31904,6 +31690,51 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_EXIT_SPEC_UNUSED_HANDLER(ZEND_
        ZEND_VM_NEXT_OPCODE(); /* Never reached */
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       uint32_t fetch_type;
+       zend_class_entry *called_scope, *scope;
+       USE_OPLINE
+
+       fetch_type = opline->op1.num;
+
+       scope = EX(func)->op_array.scope;
+       if (UNEXPECTED(scope == NULL)) {
+               SAVE_OPLINE();
+               zend_throw_error(NULL, "Cannot use \"%s\" when no class scope is active",
+                       fetch_type == ZEND_FETCH_CLASS_SELF ? "self" :
+                       fetch_type == ZEND_FETCH_CLASS_PARENT ? "parent" : "static");
+               ZVAL_UNDEF(EX_VAR(opline->result.var));
+               HANDLE_EXCEPTION();
+       }
+
+       switch (fetch_type) {
+               case ZEND_FETCH_CLASS_SELF:
+                       ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->name);
+                       break;
+               case ZEND_FETCH_CLASS_PARENT:
+                       if (UNEXPECTED(scope->parent == NULL)) {
+                               SAVE_OPLINE();
+                               zend_throw_error(NULL,
+                                       "Cannot use \"parent\" when current class scope has no parent");
+                               ZVAL_UNDEF(EX_VAR(opline->result.var));
+                               HANDLE_EXCEPTION();
+                       }
+                       ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->parent->name);
+                       break;
+               case ZEND_FETCH_CLASS_STATIC:
+                       if (Z_TYPE(EX(This)) == IS_OBJECT) {
+                               called_scope = Z_OBJCE(EX(This));
+                       } else {
+                               called_scope = Z_CE(EX(This));
+                       }
+                       ZVAL_STR_COPY(EX_VAR(opline->result.var), called_scope->name);
+                       break;
+               EMPTY_SWITCH_DEFAULT_CASE()
+       }
+       ZEND_VM_NEXT_OPCODE();
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
@@ -33109,6 +32940,48 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_INIT_SPEC_UNUSED_CONST_HA
        ZEND_VM_NEXT_OPCODE();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       SAVE_OPLINE();
+       if (IS_CONST == IS_UNUSED) {
+               Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->op1.num);
+               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+       } else {
+
+               zval *class_name = RT_CONSTANT(opline, opline->op2);
+
+try_class_name:
+               if (IS_CONST == IS_CONST) {
+                       zend_class_entry *ce = CACHED_PTR(Z_CACHE_SLOT_P(class_name));
+
+                       if (UNEXPECTED(ce == NULL)) {
+                               ce = zend_fetch_class_by_name(Z_STR_P(class_name), RT_CONSTANT(opline, opline->op2) + 1, opline->op1.num);
+                               CACHE_PTR(Z_CACHE_SLOT_P(class_name), ce);
+                       }
+                       Z_CE_P(EX_VAR(opline->result.var)) = ce;
+               } else if (Z_TYPE_P(class_name) == IS_OBJECT) {
+                       Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
+               } else if (Z_TYPE_P(class_name) == IS_STRING) {
+                       Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->op1.num);
+               } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_TYPE_P(class_name) == IS_REFERENCE) {
+                       class_name = Z_REFVAL_P(class_name);
+                       goto try_class_name;
+               } else {
+                       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(class_name) == IS_UNDEF)) {
+                               GET_OP2_UNDEF_CV(class_name, BP_VAR_R);
+                               if (UNEXPECTED(EG(exception) != NULL)) {
+                                       HANDLE_EXCEPTION();
+                               }
+                       }
+                       zend_throw_error(NULL, "Class name must be a valid object or a string");
+               }
+
+               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+       }
+}
+
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -34934,6 +34807,49 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_H
        ZEND_VM_NEXT_OPCODE();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       SAVE_OPLINE();
+       if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
+               Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->op1.num);
+               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+       } else {
+               zend_free_op free_op2;
+               zval *class_name = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+
+try_class_name:
+               if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+                       zend_class_entry *ce = CACHED_PTR(Z_CACHE_SLOT_P(class_name));
+
+                       if (UNEXPECTED(ce == NULL)) {
+                               ce = zend_fetch_class_by_name(Z_STR_P(class_name), RT_CONSTANT(opline, opline->op2) + 1, opline->op1.num);
+                               CACHE_PTR(Z_CACHE_SLOT_P(class_name), ce);
+                       }
+                       Z_CE_P(EX_VAR(opline->result.var)) = ce;
+               } else if (Z_TYPE_P(class_name) == IS_OBJECT) {
+                       Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
+               } else if (Z_TYPE_P(class_name) == IS_STRING) {
+                       Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->op1.num);
+               } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(class_name) == IS_REFERENCE) {
+                       class_name = Z_REFVAL_P(class_name);
+                       goto try_class_name;
+               } else {
+                       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(class_name) == IS_UNDEF)) {
+                               GET_OP2_UNDEF_CV(class_name, BP_VAR_R);
+                               if (UNEXPECTED(EG(exception) != NULL)) {
+                                       HANDLE_EXCEPTION();
+                               }
+                       }
+                       zend_throw_error(NULL, "Class name must be a valid object or a string");
+               }
+
+               zval_ptr_dtor_nogc(free_op2);
+               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+       }
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -35581,6 +35497,48 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_VAR_HANDLER(
        ZEND_VM_RETURN();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       SAVE_OPLINE();
+       if (IS_UNUSED == IS_UNUSED) {
+               Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->op1.num);
+               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+       } else {
+
+               zval *class_name = NULL;
+
+try_class_name:
+               if (IS_UNUSED == IS_CONST) {
+                       zend_class_entry *ce = CACHED_PTR(Z_CACHE_SLOT_P(class_name));
+
+                       if (UNEXPECTED(ce == NULL)) {
+                               ce = zend_fetch_class_by_name(Z_STR_P(class_name), RT_CONSTANT(opline, opline->op2) + 1, opline->op1.num);
+                               CACHE_PTR(Z_CACHE_SLOT_P(class_name), ce);
+                       }
+                       Z_CE_P(EX_VAR(opline->result.var)) = ce;
+               } else if (Z_TYPE_P(class_name) == IS_OBJECT) {
+                       Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
+               } else if (Z_TYPE_P(class_name) == IS_STRING) {
+                       Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->op1.num);
+               } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_TYPE_P(class_name) == IS_REFERENCE) {
+                       class_name = Z_REFVAL_P(class_name);
+                       goto try_class_name;
+               } else {
+                       if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(class_name) == IS_UNDEF)) {
+                               GET_OP2_UNDEF_CV(class_name, BP_VAR_R);
+                               if (UNEXPECTED(EG(exception) != NULL)) {
+                                       HANDLE_EXCEPTION();
+                               }
+                       }
+                       zend_throw_error(NULL, "Class name must be a valid object or a string");
+               }
+
+               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+       }
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -37289,6 +37247,48 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_INIT_SPEC_UNUSED_CV_HANDL
        ZEND_VM_NEXT_OPCODE();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       SAVE_OPLINE();
+       if (IS_CV == IS_UNUSED) {
+               Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->op1.num);
+               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+       } else {
+
+               zval *class_name = _get_zval_ptr_cv_undef(opline->op2.var EXECUTE_DATA_CC);
+
+try_class_name:
+               if (IS_CV == IS_CONST) {
+                       zend_class_entry *ce = CACHED_PTR(Z_CACHE_SLOT_P(class_name));
+
+                       if (UNEXPECTED(ce == NULL)) {
+                               ce = zend_fetch_class_by_name(Z_STR_P(class_name), RT_CONSTANT(opline, opline->op2) + 1, opline->op1.num);
+                               CACHE_PTR(Z_CACHE_SLOT_P(class_name), ce);
+                       }
+                       Z_CE_P(EX_VAR(opline->result.var)) = ce;
+               } else if (Z_TYPE_P(class_name) == IS_OBJECT) {
+                       Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
+               } else if (Z_TYPE_P(class_name) == IS_STRING) {
+                       Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->op1.num);
+               } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(class_name) == IS_REFERENCE) {
+                       class_name = Z_REFVAL_P(class_name);
+                       goto try_class_name;
+               } else {
+                       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(class_name) == IS_UNDEF)) {
+                               GET_OP2_UNDEF_CV(class_name, BP_VAR_R);
+                               if (UNEXPECTED(EG(exception) != NULL)) {
+                                       HANDLE_EXCEPTION();
+                               }
+                       }
+                       zend_throw_error(NULL, "Class name must be a valid object or a string");
+               }
+
+               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+       }
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -54891,11 +54891,11 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        (void*)&&ZEND_THROW_SPEC_VAR_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_THROW_SPEC_CV_LABEL,
-                       (void*)&&ZEND_FETCH_CLASS_SPEC_CONST_LABEL,
-                       (void*)&&ZEND_FETCH_CLASS_SPEC_TMPVAR_LABEL,
-                       (void*)&&ZEND_FETCH_CLASS_SPEC_TMPVAR_LABEL,
-                       (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_LABEL,
-                       (void*)&&ZEND_FETCH_CLASS_SPEC_CV_LABEL,
+                       (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_CONST_LABEL,
+                       (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_LABEL,
+                       (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_LABEL,
+                       (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED_LABEL,
+                       (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_CV_LABEL,
                        (void*)&&ZEND_CLONE_SPEC_CONST_LABEL,
                        (void*)&&ZEND_CLONE_SPEC_TMPVAR_LABEL,
                        (void*)&&ZEND_CLONE_SPEC_TMPVAR_LABEL,
@@ -55471,7 +55471,7 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        (void*)&&ZEND_ADD_TRAIT_SPEC_LABEL,
                        (void*)&&ZEND_BIND_TRAITS_SPEC_LABEL,
                        (void*)&&ZEND_SEPARATE_SPEC_VAR_UNUSED_LABEL,
-                       (void*)&&ZEND_FETCH_CLASS_NAME_SPEC_LABEL,
+                       (void*)&&ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_LABEL,
                        (void*)&&ZEND_CALL_TRAMPOLINE_SPEC_LABEL,
                        (void*)&&ZEND_DISCARD_EXCEPTION_SPEC_LABEL,
                        (void*)&&ZEND_YIELD_SPEC_CONST_CONST_LABEL,
@@ -56937,18 +56937,12 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        HYBRID_CASE(ZEND_ASSERT_CHECK_SPEC):
                                ZEND_ASSERT_CHECK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
-                       HYBRID_CASE(ZEND_FETCH_CLASS_NAME_SPEC):
-                               ZEND_FETCH_CLASS_NAME_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_CALL_TRAMPOLINE_SPEC):
                                ZEND_CALL_TRAMPOLINE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
                        HYBRID_CASE(ZEND_JMP_FORWARD_SPEC):
                                ZEND_JMP_FORWARD_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
-                       HYBRID_CASE(ZEND_FETCH_CLASS_SPEC_CONST):
-                               ZEND_FETCH_CLASS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_INIT_FCALL_BY_NAME_SPEC_CONST):
                                ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
@@ -56967,9 +56961,6 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        HYBRID_CASE(ZEND_ADD_INTERFACE_SPEC_CONST):
                                ZEND_ADD_INTERFACE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
-                       HYBRID_CASE(ZEND_FETCH_CLASS_SPEC_TMPVAR):
-                               ZEND_FETCH_CLASS_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR):
                                ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
@@ -56982,12 +56973,6 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        HYBRID_CASE(ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_VAR):
                                ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
-                       HYBRID_CASE(ZEND_FETCH_CLASS_SPEC_UNUSED):
-                               ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-                               HYBRID_BREAK();
-                       HYBRID_CASE(ZEND_FETCH_CLASS_SPEC_CV):
-                               ZEND_FETCH_CLASS_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_INIT_DYNAMIC_CALL_SPEC_CV):
                                ZEND_INIT_DYNAMIC_CALL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
@@ -59196,6 +59181,9 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        HYBRID_CASE(ZEND_EXIT_SPEC_UNUSED):
                                ZEND_EXIT_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_FETCH_CLASS_NAME_SPEC_UNUSED):
+                               ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_ADD_SPEC_UNUSED_CONST_OBJ):
                                ZEND_ASSIGN_ADD_SPEC_UNUSED_CONST_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
@@ -59277,6 +59265,9 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        HYBRID_CASE(ZEND_ROPE_INIT_SPEC_UNUSED_CONST):
                                ZEND_ROPE_INIT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_FETCH_CLASS_SPEC_UNUSED_CONST):
+                               ZEND_FETCH_CLASS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST):
                                ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
@@ -59379,6 +59370,9 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        HYBRID_CASE(ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR):
                                ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR):
+                               ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR):
                                ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
@@ -59397,6 +59391,9 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        HYBRID_CASE(ZEND_YIELD_SPEC_UNUSED_VAR):
                                ZEND_YIELD_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED):
+                               ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED):
                                ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
@@ -59505,6 +59502,9 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        HYBRID_CASE(ZEND_ROPE_INIT_SPEC_UNUSED_CV):
                                ZEND_ROPE_INIT_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_FETCH_CLASS_SPEC_UNUSED_CV):
+                               ZEND_FETCH_CLASS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV):
                                ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
@@ -62776,11 +62776,11 @@ void zend_init_opcodes_handlers(void)
                ZEND_THROW_SPEC_VAR_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_THROW_SPEC_CV_HANDLER,
-               ZEND_FETCH_CLASS_SPEC_CONST_HANDLER,
-               ZEND_FETCH_CLASS_SPEC_TMPVAR_HANDLER,
-               ZEND_FETCH_CLASS_SPEC_TMPVAR_HANDLER,
-               ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER,
-               ZEND_FETCH_CLASS_SPEC_CV_HANDLER,
+               ZEND_FETCH_CLASS_SPEC_UNUSED_CONST_HANDLER,
+               ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_HANDLER,
+               ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_HANDLER,
+               ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED_HANDLER,
+               ZEND_FETCH_CLASS_SPEC_UNUSED_CV_HANDLER,
                ZEND_CLONE_SPEC_CONST_HANDLER,
                ZEND_CLONE_SPEC_TMPVAR_HANDLER,
                ZEND_CLONE_SPEC_TMPVAR_HANDLER,
@@ -63356,7 +63356,7 @@ void zend_init_opcodes_handlers(void)
                ZEND_ADD_TRAIT_SPEC_HANDLER,
                ZEND_BIND_TRAITS_SPEC_HANDLER,
                ZEND_SEPARATE_SPEC_VAR_UNUSED_HANDLER,
-               ZEND_FETCH_CLASS_NAME_SPEC_HANDLER,
+               ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_HANDLER,
                ZEND_CALL_TRAMPOLINE_SPEC_HANDLER,
                ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
                ZEND_YIELD_SPEC_CONST_CONST_HANDLER,

diff --git a/Zend/zend_vm_gen.php b/Zend/zend_vm_gen.php
index 858b8cfdf39dfe4e19e2cc3aa191d3771602214f..33e63180417437d2eb04740a11e5415fe106f077 100644 (file)
--- a/Zend/zend_vm_gen.php
+++ b/Zend/zend_vm_gen.php
@@ -80,7 +80,7 @@ $vm_op_flags = array(
     // unused 0x2000000
        "ZEND_VM_EXT_JMP_ADDR"    => 0x03000000,
        "ZEND_VM_EXT_DIM_OBJ"     => 0x04000000,
-       "ZEND_VM_EXT_CLASS_FETCH" => 0x05000000,
+    // unused 0x5000000
        "ZEND_VM_EXT_CONST_FETCH" => 0x06000000,
        "ZEND_VM_EXT_TYPE"        => 0x07000000,
        "ZEND_VM_EXT_EVAL"        => 0x08000000,
@@ -119,7 +119,6 @@ $vm_ext_decode = array(
        "NUM"                  => ZEND_VM_EXT_NUM,
        "JMP_ADDR"             => ZEND_VM_EXT_JMP_ADDR,
        "DIM_OBJ"              => ZEND_VM_EXT_DIM_OBJ,
-       "CLASS_FETCH"          => ZEND_VM_EXT_CLASS_FETCH,
        "CONST_FETCH"          => ZEND_VM_EXT_CONST_FETCH,
        "VAR_FETCH"            => ZEND_VM_EXT_VAR_FETCH,
        "ARRAY_INIT"           => ZEND_VM_EXT_ARRAY_INIT,

diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c
index 2464cc4eb8baf810ef27dea5be9455950770ad8e..e0ddd8ab7cb409d9cadd18f78f5dbb72ddfe5733 100644 (file)
--- a/Zend/zend_vm_opcodes.c
+++ b/Zend/zend_vm_opcodes.c
@@ -333,7 +333,7 @@ static uint32_t zend_vm_opcodes_flags[199] = {
        0x00001001,
        0x03000103,
        0x00000003,
-       0x05000700,
+       0x00000771,
        0x00000057,
        0x0b000003,
        0x01000757,
@@ -381,7 +381,7 @@ static uint32_t zend_vm_opcodes_flags[199] = {
        0x00000000,
        0x00000000,
        0x00000101,
-       0x05000000,
+       0x00000071,
        0x00000000,
        0x00000000,
        0x0b000303,

diff --git a/Zend/zend_vm_opcodes.h b/Zend/zend_vm_opcodes.h
index f9603dfcb7a1dfe929dd382813134d19359ddd0a..05de3a4a9e59b4e068049b26b4483cfafa6326a9 100644 (file)
--- a/Zend/zend_vm_opcodes.h
+++ b/Zend/zend_vm_opcodes.h
@@ -56,7 +56,6 @@
 #define ZEND_VM_EXT_NUM          0x01000000
 #define ZEND_VM_EXT_JMP_ADDR     0x03000000
 #define ZEND_VM_EXT_DIM_OBJ      0x04000000
-#define ZEND_VM_EXT_CLASS_FETCH  0x05000000
 #define ZEND_VM_EXT_CONST_FETCH  0x06000000
 #define ZEND_VM_EXT_TYPE         0x07000000
 #define ZEND_VM_EXT_EVAL         0x08000000

diff --git a/ext/opcache/Optimizer/pass1_5.c b/ext/opcache/Optimizer/pass1_5.c
index 72e926bf6c783c2385f02c785300a60c89f9d977..7eb80317e2e10f3705d76ded9e9c2cf901699de5 100644 (file)
--- a/ext/opcache/Optimizer/pass1_5.c
+++ b/ext/opcache/Optimizer/pass1_5.c
@@ -287,8 +287,8 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx)
                                } else if (op_array->scope &&
                                        opline->op1_type == IS_VAR &&
                                        (opline - 1)->opcode == ZEND_FETCH_CLASS &&
-                                       ((opline - 1)->op1_type == IS_UNUSED &&
-                                       ((opline - 1)->extended_value & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF) &&
+                                       ((opline - 1)->op2_type == IS_UNUSED &&
+                                       ((opline - 1)->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF) &&
                                        (opline - 1)->result.var == opline->op1.var) {
                                        /* for self::B */
                                        ce = op_array->scope;

diff --git a/ext/opcache/Optimizer/sccp.c b/ext/opcache/Optimizer/sccp.c
index 0e84c1a337a3939a3942255d414ad337f6366414..bf6d57f03081edcbf3bd630c8ed2d1a19102c493 100644 (file)
--- a/ext/opcache/Optimizer/sccp.c
+++ b/ext/opcache/Optimizer/sccp.c
@@ -1622,6 +1622,7 @@ static void sccp_visit_instr(scdf_ctx *scdf, zend_op *opline, zend_ssa_op *ssa_o
                case ZEND_COALESCE:
                        SET_RESULT(result, op1);
                        break;
+#if 0
                case ZEND_FETCH_CLASS:
                        if (!op1) {
                                SET_RESULT_BOT(result);
@@ -1629,6 +1630,7 @@ static void sccp_visit_instr(scdf_ctx *scdf, zend_op *opline, zend_ssa_op *ssa_o
                        }
                        SET_RESULT(result, op1);
                        break;
+#endif
                case ZEND_ISSET_ISEMPTY_CV:
                        SKIP_IF_TOP(op1);
                        if (ct_eval_isset_isempty(&zv, opline->extended_value, op1) == SUCCESS) {

diff --git a/ext/opcache/Optimizer/zend_dump.c b/ext/opcache/Optimizer/zend_dump.c
index 1d757aeb9df2a43d07467b1accddc139c7c704bf..07e5dfe9f759b54a7928eafe8e64995518bbc3a9 100644 (file)
--- a/ext/opcache/Optimizer/zend_dump.c
+++ b/ext/opcache/Optimizer/zend_dump.c
@@ -449,8 +449,6 @@ static void zend_dump_op(const zend_op_array *op_array, const zend_basic_block *
                } else if (opline->extended_value == ZEND_ASSIGN_OBJ) {
                        fprintf(stderr, " (obj)");
                }
-       } else if (ZEND_VM_EXT_CLASS_FETCH == (flags & ZEND_VM_EXT_MASK)) {
-               zend_dump_class_fetch_type(opline->extended_value);
        } else if (ZEND_VM_EXT_CONST_FETCH == (flags & ZEND_VM_EXT_MASK)) {
                if (opline->extended_value & IS_CONSTANT_UNQUALIFIED) {
                                fprintf(stderr, " (unqualified)");

diff --git a/ext/opcache/Optimizer/zend_inference.c b/ext/opcache/Optimizer/zend_inference.c
index 65c5c694dbe87195d90663a08a3297d3b334f4b5..fef99bc0538d555462c3a2ac4eabd1c517928d00 100644 (file)
--- a/ext/opcache/Optimizer/zend_inference.c
+++ b/ext/opcache/Optimizer/zend_inference.c
@@ -2821,7 +2821,7 @@ static int zend_update_type_info(const zend_op_array *op_array,
                case ZEND_FETCH_CLASS:
                        UPDATE_SSA_TYPE(MAY_BE_CLASS, ssa_ops[i].result_def);
                        if (opline->op2_type == IS_UNUSED) {
-                               switch (opline->extended_value & ZEND_FETCH_CLASS_MASK) {
+                               switch (opline->op1.num & ZEND_FETCH_CLASS_MASK) {
                                        case ZEND_FETCH_CLASS_SELF:
                                                if (op_array->scope) {
                                                        UPDATE_SSA_OBJ_TYPE(op_array->scope, 0, ssa_ops[i].result_def);