From: Dmitry Stogov Date: Wed, 31 Jan 2018 15:14:43 +0000 (+0300) Subject: Changed FETCH_CLASS instruction format (extended_value moved into op1) X-Git-Tag: php-7.3.0alpha1~515 X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=f67f455ef70c2cffcf8c14c0172ba57126221eff;p=php Changed FETCH_CLASS instruction format (extended_value moved into op1) --- diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index 226d440300..fe2874e511 100644 --- 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 f74c622926..a093f5dcf4 100644 --- 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 404bb6b410..5c694e4fea 100644 --- 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 858b8cfdf3..33e6318041 100644 --- 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 2464cc4eb8..e0ddd8ab7c 100644 --- 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 f9603dfcb7..05de3a4a9e 100644 --- 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 72e926bf6c..7eb80317e2 100644 --- 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 0e84c1a337..bf6d57f030 100644 --- 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 1d757aeb9d..07e5dfe9f7 100644 --- 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 65c5c694db..fef99bc053 100644 --- 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);