From 9176b013cc9179672a756b19c22b24c8710ac136 Mon Sep 17 00:00:00 2001 From: Michal Kral Date: Mon, 15 Jun 2026 21:29:29 +0200 Subject: [PATCH 01/14] chore: baseline debug build for typed-locals work From b7c3b1c28c361f786b94b7047173f5a3eb17f9f7 Mon Sep 17 00:00:00 2001 From: Michal Kral Date: Mon, 15 Jun 2026 21:33:47 +0200 Subject: [PATCH 02/14] feat(parser): typed local declaration grammar (bare-prefix, conflict-free under %expect 0) --- Zend/zend_language_parser.y | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/Zend/zend_language_parser.y b/Zend/zend_language_parser.y index b4dda00404ea..003aba76a292 100644 --- a/Zend/zend_language_parser.y +++ b/Zend/zend_language_parser.y @@ -278,6 +278,7 @@ static YYSIZE_T zend_yytnamerr(char*, const char*); %type lexical_var_list encaps_list %type array_pair non_empty_array_pair_list array_pair_list possible_array_pair %type isset_variable type return_type type_expr type_without_static +%type local_var_type typed_local_decl %type identifier type_expr_without_static union_type_without_static_element union_type_without_static intersection_type_without_static %type inline_function union_type_element union_type intersection_type %type attributed_statement attributed_top_statement attributed_class_statement attributed_parameter @@ -541,6 +542,7 @@ statement: | T_GOTO T_STRING ';' { $$ = zend_ast_create(ZEND_AST_GOTO, $2); } | T_STRING ':' { $$ = zend_ast_create(ZEND_AST_LABEL, $1); } | T_VOID_CAST expr ';' { $$ = zend_ast_create(ZEND_AST_CAST_VOID, $2); } + | typed_local_decl ';' { $$ = $1; } ; catch_list: @@ -875,6 +877,18 @@ type_without_static: | name { $$ = $1; } ; +local_var_type: + type_without_static { $$ = $1; } + | '?' type_without_static { $$ = $2; $$->attr |= ZEND_TYPE_NULLABLE; } +; + +typed_local_decl: + local_var_type T_VARIABLE '=' expr + { $$ = zend_ast_create(ZEND_AST_TYPED_VAR_DECL, $1, $2, $4); } + | local_var_type T_VARIABLE + { $$ = zend_ast_create(ZEND_AST_TYPED_VAR_DECL, $1, $2, NULL); } +; + union_type_without_static_element: type_without_static { $$ = $1; } | '(' intersection_type_without_static ')' { $$ = $2; } From 881ec6d9bedefc304db29d1d59b0c5f9a939ad6e Mon Sep 17 00:00:00 2001 From: Michal Kral Date: Mon, 15 Jun 2026 21:39:36 +0200 Subject: [PATCH 03/14] feat(engine): ZEND_AST_TYPED_VAR_DECL node + op_array->cv_types storage --- Zend/zend_ast.h | 1 + Zend/zend_compile.h | 1 + Zend/zend_opcode.c | 11 +++++++++++ 3 files changed, 13 insertions(+) diff --git a/Zend/zend_ast.h b/Zend/zend_ast.h index 24b77d7d3493..5d9e1fa4f74b 100644 --- a/Zend/zend_ast.h +++ b/Zend/zend_ast.h @@ -165,6 +165,7 @@ enum _zend_ast_kind { ZEND_AST_PROP_GROUP, ZEND_AST_CONST_ELEM, ZEND_AST_CLASS_CONST_GROUP, + ZEND_AST_TYPED_VAR_DECL, /* 4 child nodes */ ZEND_AST_FOR = 4 << ZEND_AST_NUM_CHILDREN_SHIFT, diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h index 2351882a560d..db851d0afe73 100644 --- a/Zend/zend_compile.h +++ b/Zend/zend_compile.h @@ -556,6 +556,7 @@ struct _zend_op_array { ZEND_MAP_PTR_DEF(HashTable *, static_variables_ptr); HashTable *static_variables; zend_string **vars; /* names of CV variables */ + zend_property_info **cv_types; /* parallel to vars[]; NULL entry = untyped CV; whole pointer NULL if no typed locals */ uint32_t *refcount; diff --git a/Zend/zend_opcode.c b/Zend/zend_opcode.c index 538eff3ea34d..21a6956edbe7 100644 --- a/Zend/zend_opcode.c +++ b/Zend/zend_opcode.c @@ -58,6 +58,7 @@ void init_op_array(zend_op_array *op_array, zend_function_type type, int initial op_array->last_var = 0; op_array->vars = NULL; + op_array->cv_types = NULL; op_array->T = 0; @@ -588,6 +589,16 @@ ZEND_API void destroy_op_array(zend_op_array *op_array) efree(op_array->vars); } + if (op_array->cv_types) { + for (i = 0; i < (uint32_t) op_array->last_var; i++) { + if (op_array->cv_types[i]) { + zend_type_release(op_array->cv_types[i]->type, /* persistent */ 0); + efree(op_array->cv_types[i]); + } + } + efree(op_array->cv_types); + } + /* ZEND_ACC_PTR_OPS and ZEND_ACC_OVERRIDE use the same value */ if ((op_array->fn_flags & ZEND_ACC_PTR_OPS) && !op_array->function_name) { zend_op *op = op_array->opcodes; From 8b90236748fe353e049dead7c691974ab14a95f4 Mon Sep 17 00:00:00 2001 From: Michal Kral Date: Mon, 15 Jun 2026 21:56:08 +0200 Subject: [PATCH 04/14] feat(engine): compile + enforce typed local variables on direct assignment Compile ZEND_AST_TYPED_VAR_DECL into a cv_types entry plus a new ZEND_ASSIGN_TYPED opcode that verifies/coerces the RHS against the declared scalar type using the same scalar path typed properties use, honoring strict/weak mode. The RHS is copied into a separated tmp before coercion so a CONST literal is never mutated in place. cv_types is kept parallel to vars[] as new CVs are interned, and its synthesized name is released on teardown. --- Zend/zend_compile.c | 79 ++++ Zend/zend_compile.h | 2 +- Zend/zend_execute.c | 42 ++ Zend/zend_opcode.c | 1 + Zend/zend_vm_def.h | 30 ++ Zend/zend_vm_execute.h | 734 +++++++++++++++++++++++++++---- Zend/zend_vm_handlers.h | 944 ++++++++++++++++++++-------------------- Zend/zend_vm_opcodes.c | 6 +- Zend/zend_vm_opcodes.h | 3 +- 9 files changed, 1277 insertions(+), 564 deletions(-) diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index 7e9f7ceac8db..aa0b80ae69b4 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -556,6 +556,16 @@ static uint32_t lookup_cv(zend_string *name) /* {{{ */{ } op_array->vars[i] = zend_string_copy(name); + + /* Keep cv_types[] parallel to vars[] when typed locals are in use. vars[] is + * grown in chunks (vars_size), but cv_types[] is sized to exactly last_var, so + * grow it by one for the CV just appended. Guarded so untyped functions, which + * never allocate cv_types, pay nothing. */ + if (op_array->cv_types) { + op_array->cv_types = erealloc(op_array->cv_types, sizeof(zend_property_info*) * op_array->last_var); + op_array->cv_types[op_array->last_var - 1] = NULL; + } + return EX_NUM_TO_VAR(i); } /* }}} */ @@ -11978,6 +11988,72 @@ void zend_compile_top_stmt(zend_ast *ast) /* {{{ */ } /* }}} */ +static void zend_compile_typed_var_decl(zend_ast *ast) /* {{{ */ +{ + zend_ast *type_ast = ast->child[0]; + zend_ast *var_ast = ast->child[1]; + zend_ast *init_ast = ast->child[2]; /* may be NULL */ + zend_op_array *op_array = CG(active_op_array); + + /* child[1] is the raw T_VARIABLE semantic value: a ZEND_AST_ZVAL node whose + * zval is the variable name (the leading '$' was stripped by the scanner). */ + zend_string *name = zend_ast_get_str(var_ast); + + /* lookup_cv() returns an EX_NUM_TO_VAR()-encoded operand, not a raw index, and + * it appends a new CV (growing last_var) only when the name is not yet interned. + * Capture last_var beforehand so we can tell whether this decl is the variable's + * first appearance. */ + uint32_t prev_last_var = op_array->last_var; + uint32_t var = lookup_cv(name); + uint32_t var_num = EX_VAR_TO_NUM(var); + + /* First-appearance rule: a typed decl must be the variable's first use, and it + * must not re-type an already-typed local (spec §6.3). */ + if (var_num < prev_last_var) { + if (op_array->cv_types && op_array->cv_types[var_num]) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare typed local variable $%s", ZSTR_VAL(name)); + } + zend_error_noreturn(E_COMPILE_ERROR, + "Cannot declare a type for $%s after it has already been used", ZSTR_VAL(name)); + } + + /* Resolve + restrict to scalars only (spec §6.4). */ + zend_type type = zend_compile_typename(type_ast); + uint32_t mask = ZEND_TYPE_PURE_MASK(type); + uint32_t base = mask & ~MAY_BE_NULL; + if (!(base == MAY_BE_STRING || base == MAY_BE_LONG || base == MAY_BE_DOUBLE || base == MAY_BE_BOOL)) { + zend_type_release(type, 0); + zend_error_noreturn(E_COMPILE_ERROR, + "Typed local variables support only scalar types (int, float, string, bool) in this version"); + } + + zend_property_info *info = emalloc(sizeof(zend_property_info)); + memset(info, 0, sizeof(*info)); + info->type = type; + info->name = zend_string_copy(name); /* owned; released in destroy_op_array */ + info->flags = ZEND_ACC_PUBLIC; + + if (!op_array->cv_types) { + op_array->cv_types = ecalloc(op_array->last_var, sizeof(zend_property_info*)); + } + op_array->cv_types[var_num] = info; + + if (init_ast) { + /* Emit ZEND_ASSIGN_TYPED with op1 = the CV target, op2 = the value. The CV + * operand is built exactly as zend_try_compile_cv() builds it for `$cv = expr`. */ + znode var_node, value_node; + + zend_compile_expr(&value_node, init_ast); + + var_node.op_type = IS_CV; + var_node.u.op.var = var; + + CG(zend_lineno) = zend_ast_get_lineno(var_ast); + zend_emit_op(NULL, ZEND_ASSIGN_TYPED, &var_node, &value_node); + } +} +/* }}} */ + static void zend_compile_stmt(zend_ast *ast) /* {{{ */ { if (!ast) { @@ -12092,6 +12168,9 @@ static void zend_compile_stmt(zend_ast *ast) /* {{{ */ case ZEND_AST_ASSIGN_REF: zend_compile_assign_ref(NULL, ast, BP_VAR_R); return; + case ZEND_AST_TYPED_VAR_DECL: + zend_compile_typed_var_decl(ast); + break; default: { znode result; diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h index db851d0afe73..6edf898ff4d3 100644 --- a/Zend/zend_compile.h +++ b/Zend/zend_compile.h @@ -556,7 +556,7 @@ struct _zend_op_array { ZEND_MAP_PTR_DEF(HashTable *, static_variables_ptr); HashTable *static_variables; zend_string **vars; /* names of CV variables */ - zend_property_info **cv_types; /* parallel to vars[]; NULL entry = untyped CV; whole pointer NULL if no typed locals */ + zend_property_info **cv_types; /* parallel to vars[]; NULL entry = untyped CV; whole pointer NULL if no typed locals */ /* TODO(opcache): persist cv_types — Plan 4 */ uint32_t *refcount; diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c index 1b28ce25fe37..92ef19669a8a 100644 --- a/Zend/zend_execute.c +++ b/Zend/zend_execute.c @@ -1098,6 +1098,48 @@ static zend_never_inline zval* zend_assign_to_typed_prop(const zend_property_inf return zend_assign_to_variable_ex(property_val, &tmp, IS_TMP_VAR, EX_USES_STRICT_TYPES(), garbage_ptr); } +static zend_never_inline ZEND_COLD void zend_typed_cv_type_error( + const zend_property_info *info, const zend_string *name, const zval *value) +{ + if (EG(exception)) { + return; + } + zend_string *type_str = zend_type_to_string(info->type); + zend_type_error("Cannot assign %s to local variable $%s of type %s", + zend_zval_value_name(value), ZSTR_VAL(name), ZSTR_VAL(type_str)); + zend_string_release(type_str); +} + +/* Verify + coerce a value against a typed local variable's declared (scalar-only) + * type and assign it. Modeled on zend_assign_to_typed_prop(): the value is copied + * into a separated tmp before coercion, so a CONST/read-only RHS literal is never + * mutated in place. Honors strict/weak mode via EX_USES_STRICT_TYPES(). On a type + * mismatch a TypeError is thrown and the variable is left unchanged. */ +static zend_never_inline zval* zend_assign_to_typed_cv( + const zend_property_info *info, const zend_string *name, + zval *variable_ptr, zval *value, zend_refcounted **garbage_ptr EXECUTE_DATA_DC) +{ + zval tmp; + bool strict = EX_USES_STRICT_TYPES(); + + ZVAL_DEREF(value); + ZVAL_COPY(&tmp, value); + + /* Fast path: exact type code already allowed (covers nullable + matching scalar). */ + if (!ZEND_TYPE_CONTAINS_CODE(info->type, Z_TYPE(tmp))) { + /* cv_types is restricted to scalar (int/float/string/bool, optionally nullable) + * at compile time, so the scalar coercion path is sufficient and never touches + * info->ce (which is NULL for synthesized local-variable infos). */ + if (UNEXPECTED(!zend_verify_scalar_type_hint(ZEND_TYPE_FULL_MASK(info->type), &tmp, strict, false))) { + zend_typed_cv_type_error(info, name, &tmp); + zval_ptr_dtor(&tmp); + return &EG(uninitialized_zval); + } + } + + return zend_assign_to_variable_ex(variable_ptr, &tmp, IS_TMP_VAR, strict, garbage_ptr); +} + static zend_always_inline bool zend_value_instanceof_static(const zval *zv) { if (Z_TYPE_P(zv) != IS_OBJECT) { return 0; diff --git a/Zend/zend_opcode.c b/Zend/zend_opcode.c index 21a6956edbe7..2751b071bb2c 100644 --- a/Zend/zend_opcode.c +++ b/Zend/zend_opcode.c @@ -592,6 +592,7 @@ ZEND_API void destroy_op_array(zend_op_array *op_array) if (op_array->cv_types) { for (i = 0; i < (uint32_t) op_array->last_var; i++) { if (op_array->cv_types[i]) { + zend_string_release(op_array->cv_types[i]->name); zend_type_release(op_array->cv_types[i]->type, /* persistent */ 0); efree(op_array->cv_types[i]); } diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 1de7a7cd4195..a2a22ee8daa7 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -2859,6 +2859,36 @@ ZEND_VM_HANDLER(22, ZEND_ASSIGN, VAR|CV, CONST|TMP|CV, SPEC(RETVAL)) ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +ZEND_VM_HANDLER(212, ZEND_ASSIGN_TYPED, CV, CONST|TMP|VAR|CV, SPEC(RETVAL)) +{ + USE_OPLINE + zval *value; + zval *variable_ptr; + const zend_property_info *info; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + value = GET_OP2_ZVAL_PTR(BP_VAR_R); + variable_ptr = EX_VAR(opline->op1.var); + info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + + /* zend_assign_to_typed_cv() copies the value into a separated tmp before any + * coercion, so a CONST literal RHS is never mutated in place. It consumes the + * tmp (IS_TMP_VAR) but NOT the source operand, so we free op2 ourselves below. */ + value = zend_assign_to_typed_cv(info, info->name, variable_ptr, value, &garbage EXECUTE_DATA_CC); + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + + FREE_OP2(); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + ZEND_VM_HANDLER(30, ZEND_ASSIGN_REF, VAR|CV, VAR|CV, SRC) { USE_OPLINE diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 5b52f1941845..da05ddb05d52 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -43542,6 +43542,66 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_SPEC_C ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_TYPED_SPEC_CV_CONST_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + zval *variable_ptr; + const zend_property_info *info; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + value = RT_CONSTANT(opline, opline->op2); + variable_ptr = EX_VAR(opline->op1.var); + info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + + /* zend_assign_to_typed_cv() copies the value into a separated tmp before any + * coercion, so a CONST literal RHS is never mutated in place. It consumes the + * tmp (IS_TMP_VAR) but NOT the source operand, so we free op2 ourselves below. */ + value = zend_assign_to_typed_cv(info, info->name, variable_ptr, value, &garbage EXECUTE_DATA_CC); + + if (UNEXPECTED(0)) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_TYPED_SPEC_CV_CONST_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + zval *variable_ptr; + const zend_property_info *info; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + value = RT_CONSTANT(opline, opline->op2); + variable_ptr = EX_VAR(opline->op1.var); + info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + + /* zend_assign_to_typed_cv() copies the value into a separated tmp before any + * coercion, so a CONST literal RHS is never mutated in place. It consumes the + * tmp (IS_TMP_VAR) but NOT the source operand, so we free op2 ourselves below. */ + value = zend_assign_to_typed_cv(info, info->name, variable_ptr, value, &garbage EXECUTE_DATA_CC); + + if (UNEXPECTED(1)) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -47359,6 +47419,66 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_SPEC_C ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_TYPED_SPEC_CV_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + zval *variable_ptr; + const zend_property_info *info; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + variable_ptr = EX_VAR(opline->op1.var); + info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + + /* zend_assign_to_typed_cv() copies the value into a separated tmp before any + * coercion, so a CONST literal RHS is never mutated in place. It consumes the + * tmp (IS_TMP_VAR) but NOT the source operand, so we free op2 ourselves below. */ + value = zend_assign_to_typed_cv(info, info->name, variable_ptr, value, &garbage EXECUTE_DATA_CC); + + if (UNEXPECTED(0)) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_TYPED_SPEC_CV_TMP_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + zval *variable_ptr; + const zend_property_info *info; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + variable_ptr = EX_VAR(opline->op1.var); + info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + + /* zend_assign_to_typed_cv() copies the value into a separated tmp before any + * coercion, so a CONST literal RHS is never mutated in place. It consumes the + * tmp (IS_TMP_VAR) but NOT the source operand, so we free op2 ourselves below. */ + value = zend_assign_to_typed_cv(info, info->name, variable_ptr, value, &garbage EXECUTE_DATA_CC); + + if (UNEXPECTED(1)) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMP_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -48287,6 +48407,66 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_YIELD_SPEC_CV ZEND_VM_RETURN(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_TYPED_SPEC_CV_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + zval *variable_ptr; + const zend_property_info *info; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + variable_ptr = EX_VAR(opline->op1.var); + info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + + /* zend_assign_to_typed_cv() copies the value into a separated tmp before any + * coercion, so a CONST literal RHS is never mutated in place. It consumes the + * tmp (IS_TMP_VAR) but NOT the source operand, so we free op2 ourselves below. */ + value = zend_assign_to_typed_cv(info, info->name, variable_ptr, value, &garbage EXECUTE_DATA_CC); + + if (UNEXPECTED(0)) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_TYPED_SPEC_CV_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + zval *variable_ptr; + const zend_property_info *info; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + variable_ptr = EX_VAR(opline->op1.var); + info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + + /* zend_assign_to_typed_cv() copies the value into a separated tmp before any + * coercion, so a CONST literal RHS is never mutated in place. It consumes the + * tmp (IS_TMP_VAR) but NOT the source operand, so we free op2 ourselves below. */ + value = zend_assign_to_typed_cv(info, info->name, variable_ptr, value, &garbage EXECUTE_DATA_CC); + + if (UNEXPECTED(1)) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -52481,6 +52661,66 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_SPEC_C ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_TYPED_SPEC_CV_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + zval *variable_ptr; + const zend_property_info *info; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); + variable_ptr = EX_VAR(opline->op1.var); + info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + + /* zend_assign_to_typed_cv() copies the value into a separated tmp before any + * coercion, so a CONST literal RHS is never mutated in place. It consumes the + * tmp (IS_TMP_VAR) but NOT the source operand, so we free op2 ourselves below. */ + value = zend_assign_to_typed_cv(info, info->name, variable_ptr, value, &garbage EXECUTE_DATA_CC); + + if (UNEXPECTED(0)) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_TYPED_SPEC_CV_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + zval *variable_ptr; + const zend_property_info *info; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); + variable_ptr = EX_VAR(opline->op1.var); + info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + + /* zend_assign_to_typed_cv() copies the value into a separated tmp before any + * coercion, so a CONST literal RHS is never mutated in place. It consumes the + * tmp (IS_TMP_VAR) but NOT the source operand, so we free op2 ourselves below. */ + value = zend_assign_to_typed_cv(info, info->name, variable_ptr, value, &garbage EXECUTE_DATA_CC); + + if (UNEXPECTED(1)) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -96014,6 +96254,66 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_SPEC_CV_CON ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_TYPED_SPEC_CV_CONST_RETVAL_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + zval *variable_ptr; + const zend_property_info *info; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + value = RT_CONSTANT(opline, opline->op2); + variable_ptr = EX_VAR(opline->op1.var); + info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + + /* zend_assign_to_typed_cv() copies the value into a separated tmp before any + * coercion, so a CONST literal RHS is never mutated in place. It consumes the + * tmp (IS_TMP_VAR) but NOT the source operand, so we free op2 ourselves below. */ + value = zend_assign_to_typed_cv(info, info->name, variable_ptr, value, &garbage EXECUTE_DATA_CC); + + if (UNEXPECTED(0)) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_TYPED_SPEC_CV_CONST_RETVAL_USED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + zval *variable_ptr; + const zend_property_info *info; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + value = RT_CONSTANT(opline, opline->op2); + variable_ptr = EX_VAR(opline->op1.var); + info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + + /* zend_assign_to_typed_cv() copies the value into a separated tmp before any + * coercion, so a CONST literal RHS is never mutated in place. It consumes the + * tmp (IS_TMP_VAR) but NOT the source operand, so we free op2 ourselves below. */ + value = zend_assign_to_typed_cv(info, info->name, variable_ptr, value, &garbage EXECUTE_DATA_CC); + + if (UNEXPECTED(1)) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -99831,6 +100131,66 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_SPEC_CV_TMP ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_TYPED_SPEC_CV_TMP_RETVAL_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + zval *variable_ptr; + const zend_property_info *info; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + variable_ptr = EX_VAR(opline->op1.var); + info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + + /* zend_assign_to_typed_cv() copies the value into a separated tmp before any + * coercion, so a CONST literal RHS is never mutated in place. It consumes the + * tmp (IS_TMP_VAR) but NOT the source operand, so we free op2 ourselves below. */ + value = zend_assign_to_typed_cv(info, info->name, variable_ptr, value, &garbage EXECUTE_DATA_CC); + + if (UNEXPECTED(0)) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_TYPED_SPEC_CV_TMP_RETVAL_USED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + zval *variable_ptr; + const zend_property_info *info; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + variable_ptr = EX_VAR(opline->op1.var); + info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + + /* zend_assign_to_typed_cv() copies the value into a separated tmp before any + * coercion, so a CONST literal RHS is never mutated in place. It consumes the + * tmp (IS_TMP_VAR) but NOT the source operand, so we free op2 ourselves below. */ + value = zend_assign_to_typed_cv(info, info->name, variable_ptr, value, &garbage EXECUTE_DATA_CC); + + if (UNEXPECTED(1)) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMP_OP_DATA_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -100759,6 +101119,66 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_YIELD_SPEC_CV_TMP_ ZEND_VM_RETURN(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_TYPED_SPEC_CV_VAR_RETVAL_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + zval *variable_ptr; + const zend_property_info *info; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + variable_ptr = EX_VAR(opline->op1.var); + info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + + /* zend_assign_to_typed_cv() copies the value into a separated tmp before any + * coercion, so a CONST literal RHS is never mutated in place. It consumes the + * tmp (IS_TMP_VAR) but NOT the source operand, so we free op2 ourselves below. */ + value = zend_assign_to_typed_cv(info, info->name, variable_ptr, value, &garbage EXECUTE_DATA_CC); + + if (UNEXPECTED(0)) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_TYPED_SPEC_CV_VAR_RETVAL_USED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + zval *variable_ptr; + const zend_property_info *info; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + variable_ptr = EX_VAR(opline->op1.var); + info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + + /* zend_assign_to_typed_cv() copies the value into a separated tmp before any + * coercion, so a CONST literal RHS is never mutated in place. It consumes the + * tmp (IS_TMP_VAR) but NOT the source operand, so we free op2 ourselves below. */ + value = zend_assign_to_typed_cv(info, info->name, variable_ptr, value, &garbage EXECUTE_DATA_CC); + + if (UNEXPECTED(1)) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_REF_SPEC_CV_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -104851,6 +105271,66 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_SPEC_CV_CV_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_TYPED_SPEC_CV_CV_RETVAL_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + zval *variable_ptr; + const zend_property_info *info; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); + variable_ptr = EX_VAR(opline->op1.var); + info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + + /* zend_assign_to_typed_cv() copies the value into a separated tmp before any + * coercion, so a CONST literal RHS is never mutated in place. It consumes the + * tmp (IS_TMP_VAR) but NOT the source operand, so we free op2 ourselves below. */ + value = zend_assign_to_typed_cv(info, info->name, variable_ptr, value, &garbage EXECUTE_DATA_CC); + + if (UNEXPECTED(0)) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_TYPED_SPEC_CV_CV_RETVAL_USED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + zval *variable_ptr; + const zend_property_info *info; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); + variable_ptr = EX_VAR(opline->op1.var); + info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + + /* zend_assign_to_typed_cv() copies the value into a separated tmp before any + * coercion, so a CONST literal RHS is never mutated in place. It consumes the + * tmp (IS_TMP_VAR) but NOT the source operand, so we free op2 ourselves below. */ + value = zend_assign_to_typed_cv(info, info->name, variable_ptr, value, &garbage EXECUTE_DATA_CC); + + if (UNEXPECTED(1)) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_REF_SPEC_CV_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -109243,6 +109723,16 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED_LABEL, (void*)&&ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST_LABEL, (void*)&&ZEND_TYPE_ASSERT_SPEC_CONST_LABEL, + (void*)&&ZEND_ASSIGN_TYPED_SPEC_CV_CONST_RETVAL_UNUSED_LABEL, + (void*)&&ZEND_ASSIGN_TYPED_SPEC_CV_CONST_RETVAL_USED_LABEL, + (void*)&&ZEND_ASSIGN_TYPED_SPEC_CV_TMP_RETVAL_UNUSED_LABEL, + (void*)&&ZEND_ASSIGN_TYPED_SPEC_CV_TMP_RETVAL_USED_LABEL, + (void*)&&ZEND_ASSIGN_TYPED_SPEC_CV_VAR_RETVAL_UNUSED_LABEL, + (void*)&&ZEND_ASSIGN_TYPED_SPEC_CV_VAR_RETVAL_USED_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_TYPED_SPEC_CV_CV_RETVAL_UNUSED_LABEL, + (void*)&&ZEND_ASSIGN_TYPED_SPEC_CV_CV_RETVAL_USED_LABEL, (void*)&&ZEND_INIT_FCALL_OFFSET_SPEC_CONST_LABEL, (void*)&&ZEND_RECV_NOTYPE_SPEC_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -114739,6 +115229,16 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED) HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_TYPED_SPEC_CV_CONST_RETVAL_UNUSED): + VM_TRACE(ZEND_ASSIGN_TYPED_SPEC_CV_CONST_RETVAL_UNUSED) + ZEND_ASSIGN_TYPED_SPEC_CV_CONST_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_TYPED_SPEC_CV_CONST_RETVAL_UNUSED) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_TYPED_SPEC_CV_CONST_RETVAL_USED): + VM_TRACE(ZEND_ASSIGN_TYPED_SPEC_CV_CONST_RETVAL_USED) + ZEND_ASSIGN_TYPED_SPEC_CV_CONST_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_TYPED_SPEC_CV_CONST_RETVAL_USED) + HYBRID_BREAK(); HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR): VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR) ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -115039,6 +115539,16 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED) HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_TYPED_SPEC_CV_TMP_RETVAL_UNUSED): + VM_TRACE(ZEND_ASSIGN_TYPED_SPEC_CV_TMP_RETVAL_UNUSED) + ZEND_ASSIGN_TYPED_SPEC_CV_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_TYPED_SPEC_CV_TMP_RETVAL_UNUSED) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_TYPED_SPEC_CV_TMP_RETVAL_USED): + VM_TRACE(ZEND_ASSIGN_TYPED_SPEC_CV_TMP_RETVAL_USED) + ZEND_ASSIGN_TYPED_SPEC_CV_TMP_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_TYPED_SPEC_CV_TMP_RETVAL_USED) + HYBRID_BREAK(); HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMP_OP_DATA_VAR): VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMP_OP_DATA_VAR) ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMP_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -115099,6 +115609,16 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_YIELD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_YIELD_SPEC_CV_TMP) HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_TYPED_SPEC_CV_VAR_RETVAL_UNUSED): + VM_TRACE(ZEND_ASSIGN_TYPED_SPEC_CV_VAR_RETVAL_UNUSED) + ZEND_ASSIGN_TYPED_SPEC_CV_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_TYPED_SPEC_CV_VAR_RETVAL_UNUSED) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_TYPED_SPEC_CV_VAR_RETVAL_USED): + VM_TRACE(ZEND_ASSIGN_TYPED_SPEC_CV_VAR_RETVAL_USED) + ZEND_ASSIGN_TYPED_SPEC_CV_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_TYPED_SPEC_CV_VAR_RETVAL_USED) + HYBRID_BREAK(); HYBRID_CASE(ZEND_ASSIGN_REF_SPEC_CV_VAR): VM_TRACE(ZEND_ASSIGN_REF_SPEC_CV_VAR) ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -115469,6 +115989,16 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED) HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_TYPED_SPEC_CV_CV_RETVAL_UNUSED): + VM_TRACE(ZEND_ASSIGN_TYPED_SPEC_CV_CV_RETVAL_UNUSED) + ZEND_ASSIGN_TYPED_SPEC_CV_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_TYPED_SPEC_CV_CV_RETVAL_UNUSED) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_TYPED_SPEC_CV_CV_RETVAL_USED): + VM_TRACE(ZEND_ASSIGN_TYPED_SPEC_CV_CV_RETVAL_USED) + ZEND_ASSIGN_TYPED_SPEC_CV_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_TYPED_SPEC_CV_CV_RETVAL_USED) + HYBRID_BREAK(); HYBRID_CASE(ZEND_ASSIGN_REF_SPEC_CV_CV): VM_TRACE(ZEND_ASSIGN_REF_SPEC_CV_CV) ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -118181,6 +118711,16 @@ void zend_vm_init(void) ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED_HANDLER, ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST_HANDLER, ZEND_TYPE_ASSERT_SPEC_CONST_HANDLER, + ZEND_ASSIGN_TYPED_SPEC_CV_CONST_RETVAL_UNUSED_HANDLER, + ZEND_ASSIGN_TYPED_SPEC_CV_CONST_RETVAL_USED_HANDLER, + ZEND_ASSIGN_TYPED_SPEC_CV_TMP_RETVAL_UNUSED_HANDLER, + ZEND_ASSIGN_TYPED_SPEC_CV_TMP_RETVAL_USED_HANDLER, + ZEND_ASSIGN_TYPED_SPEC_CV_VAR_RETVAL_UNUSED_HANDLER, + ZEND_ASSIGN_TYPED_SPEC_CV_VAR_RETVAL_USED_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_ASSIGN_TYPED_SPEC_CV_CV_RETVAL_UNUSED_HANDLER, + ZEND_ASSIGN_TYPED_SPEC_CV_CV_RETVAL_USED_HANDLER, ZEND_INIT_FCALL_OFFSET_SPEC_CONST_HANDLER, ZEND_RECV_NOTYPE_SPEC_HANDLER, ZEND_NULL_HANDLER, @@ -121659,6 +122199,16 @@ void zend_vm_init(void) ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED_TAILCALL_HANDLER, ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST_TAILCALL_HANDLER, ZEND_TYPE_ASSERT_SPEC_CONST_TAILCALL_HANDLER, + ZEND_ASSIGN_TYPED_SPEC_CV_CONST_RETVAL_UNUSED_TAILCALL_HANDLER, + ZEND_ASSIGN_TYPED_SPEC_CV_CONST_RETVAL_USED_TAILCALL_HANDLER, + ZEND_ASSIGN_TYPED_SPEC_CV_TMP_RETVAL_UNUSED_TAILCALL_HANDLER, + ZEND_ASSIGN_TYPED_SPEC_CV_TMP_RETVAL_USED_TAILCALL_HANDLER, + ZEND_ASSIGN_TYPED_SPEC_CV_VAR_RETVAL_UNUSED_TAILCALL_HANDLER, + ZEND_ASSIGN_TYPED_SPEC_CV_VAR_RETVAL_USED_TAILCALL_HANDLER, + ZEND_NULL_TAILCALL_HANDLER, + ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_TYPED_SPEC_CV_CV_RETVAL_UNUSED_TAILCALL_HANDLER, + ZEND_ASSIGN_TYPED_SPEC_CV_CV_RETVAL_USED_TAILCALL_HANDLER, ZEND_INIT_FCALL_OFFSET_SPEC_CONST_TAILCALL_HANDLER, ZEND_RECV_NOTYPE_SPEC_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -122627,7 +123177,7 @@ void zend_vm_init(void) 1255, 1256 | SPEC_RULE_OP1, 1261 | SPEC_RULE_OP1, - 3474, + 3484, 1266 | SPEC_RULE_OP1, 1271 | SPEC_RULE_OP1, 1276 | SPEC_RULE_OP2, @@ -122661,7 +123211,7 @@ void zend_vm_init(void) 1559 | SPEC_RULE_OP1 | SPEC_RULE_OP2, 1584 | SPEC_RULE_OP1, 1589, - 3474, + 3484, 1590 | SPEC_RULE_OP1, 1595 | SPEC_RULE_OP1 | SPEC_RULE_OP2, 1620 | SPEC_RULE_OP1 | SPEC_RULE_OP2, @@ -122794,50 +123344,50 @@ void zend_vm_init(void) 2556, 2557, 2558, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, + 2559 | SPEC_RULE_OP2 | SPEC_RULE_RETVAL, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, }; #if 0 #elif (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID) @@ -123030,7 +123580,7 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2567 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2577 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -123038,7 +123588,7 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2592 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2602 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -123046,7 +123596,7 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2617 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2627 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -123057,17 +123607,17 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2642 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2652 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } else if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2667 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2677 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2692 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2702 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_MUL: @@ -123078,17 +123628,17 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2717 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2727 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } else if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2742 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2752 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2767 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2777 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_IDENTICAL: @@ -123099,16 +123649,16 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2792 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2802 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2867 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2877 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op2_type == IS_CONST && (Z_TYPE_P(RT_CONSTANT(op, op->op2)) == IS_ARRAY && zend_hash_num_elements(Z_ARR_P(RT_CONSTANT(op, op->op2))) == 0)) { - spec = 3092 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3102 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF))) { - spec = 3098 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3108 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_IDENTICAL: @@ -123119,16 +123669,16 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2942 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2952 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3017 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3027 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op2_type == IS_CONST && (Z_TYPE_P(RT_CONSTANT(op, op->op2)) == IS_ARRAY && zend_hash_num_elements(Z_ARR_P(RT_CONSTANT(op, op->op2))) == 0)) { - spec = 3095 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3105 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF))) { - spec = 3103 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3113 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_EQUAL: @@ -123139,12 +123689,12 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2792 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2802 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2867 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2877 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_EQUAL: @@ -123155,12 +123705,12 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2942 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2952 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3017 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3027 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_SMALLER: @@ -123168,12 +123718,12 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3108 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3118 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3183 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3193 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_IS_SMALLER_OR_EQUAL: @@ -123181,79 +123731,79 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3258 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3268 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3333 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3343 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_QM_ASSIGN: if (op1_info == MAY_BE_LONG) { - spec = 3420 | SPEC_RULE_OP1; + spec = 3430 | SPEC_RULE_OP1; } else if (op1_info == MAY_BE_DOUBLE) { - spec = 3425 | SPEC_RULE_OP1; + spec = 3435 | SPEC_RULE_OP1; } else if ((op->op1_type == IS_CONST) ? !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1)) : (!(op1_info & ((MAY_BE_ANY|MAY_BE_UNDEF)-(MAY_BE_NULL|MAY_BE_FALSE|MAY_BE_TRUE|MAY_BE_LONG|MAY_BE_DOUBLE))))) { - spec = 3430 | SPEC_RULE_OP1; + spec = 3440 | SPEC_RULE_OP1; } break; case ZEND_PRE_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3408 | SPEC_RULE_RETVAL; + spec = 3418 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3410 | SPEC_RULE_RETVAL; + spec = 3420 | SPEC_RULE_RETVAL; } break; case ZEND_PRE_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3412 | SPEC_RULE_RETVAL; + spec = 3422 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3414 | SPEC_RULE_RETVAL; + spec = 3424 | SPEC_RULE_RETVAL; } break; case ZEND_POST_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3416; + spec = 3426; } else if (op1_info == MAY_BE_LONG) { - spec = 3417; + spec = 3427; } break; case ZEND_POST_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3418; + spec = 3428; } else if (op1_info == MAY_BE_LONG) { - spec = 3419; + spec = 3429; } break; case ZEND_JMP: if (OP_JMP_ADDR(op, op->op1) > op) { - spec = 2566; + spec = 2576; } break; case ZEND_INIT_FCALL: if (Z_EXTRA_P(RT_CONSTANT(op, op->op2)) != 0) { - spec = 2559; + spec = 2569; } break; case ZEND_RECV: if (op->op2.num == MAY_BE_ANY) { - spec = 2560; + spec = 2570; } break; case ZEND_SEND_VAL: if (op->op1_type == IS_CONST && op->op2_type == IS_UNUSED && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3470; + spec = 3480; } break; case ZEND_SEND_VAR_EX: if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3465 | SPEC_RULE_OP1; + spec = 3475 | SPEC_RULE_OP1; } break; case ZEND_FE_FETCH_R: if (op->op2_type == IS_CV && (op1_info & (MAY_BE_ANY|MAY_BE_REF)) == MAY_BE_ARRAY) { - spec = 3472 | SPEC_RULE_RETVAL; + spec = 3482 | SPEC_RULE_RETVAL; } break; case ZEND_FETCH_DIM_R: @@ -123261,22 +123811,22 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3435 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 3445 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_SEND_VAL_EX: if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3471; + spec = 3481; } break; case ZEND_SEND_VAR: if (op->op2_type == IS_UNUSED && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3460 | SPEC_RULE_OP1; + spec = 3470 | SPEC_RULE_OP1; } break; case ZEND_COUNT: if ((op1_info & (MAY_BE_ANY|MAY_BE_UNDEF|MAY_BE_REF)) == MAY_BE_ARRAY) { - spec = 2561 | SPEC_RULE_OP1; + spec = 2571 | SPEC_RULE_OP1; } break; case ZEND_BW_OR: diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h index 6f1595195450..bf2fda8784f2 100644 --- a/Zend/zend_vm_handlers.h +++ b/Zend/zend_vm_handlers.h @@ -1087,507 +1087,515 @@ _(2556, ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED) \ _(2557, ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST) \ _(2558, ZEND_TYPE_ASSERT_SPEC_CONST) \ - _(2559, ZEND_INIT_FCALL_OFFSET_SPEC_CONST) \ - _(2560, ZEND_RECV_NOTYPE_SPEC) \ - _(2562, ZEND_COUNT_ARRAY_SPEC_TMP_UNUSED) \ - _(2565, ZEND_COUNT_ARRAY_SPEC_CV_UNUSED) \ - _(2566, ZEND_JMP_FORWARD_SPEC) \ - _(2572, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2573, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2574, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2576, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2577, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2578, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2579, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2581, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2559, ZEND_ASSIGN_TYPED_SPEC_CV_CONST_RETVAL_UNUSED) \ + _(2560, ZEND_ASSIGN_TYPED_SPEC_CV_CONST_RETVAL_USED) \ + _(2561, ZEND_ASSIGN_TYPED_SPEC_CV_TMP_RETVAL_UNUSED) \ + _(2562, ZEND_ASSIGN_TYPED_SPEC_CV_TMP_RETVAL_USED) \ + _(2563, ZEND_ASSIGN_TYPED_SPEC_CV_VAR_RETVAL_UNUSED) \ + _(2564, ZEND_ASSIGN_TYPED_SPEC_CV_VAR_RETVAL_USED) \ + _(2567, ZEND_ASSIGN_TYPED_SPEC_CV_CV_RETVAL_UNUSED) \ + _(2568, ZEND_ASSIGN_TYPED_SPEC_CV_CV_RETVAL_USED) \ + _(2569, ZEND_INIT_FCALL_OFFSET_SPEC_CONST) \ + _(2570, ZEND_RECV_NOTYPE_SPEC) \ + _(2572, ZEND_COUNT_ARRAY_SPEC_TMP_UNUSED) \ + _(2575, ZEND_COUNT_ARRAY_SPEC_CV_UNUSED) \ + _(2576, ZEND_JMP_FORWARD_SPEC) \ + _(2582, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2583, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2584, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2586, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2587, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2588, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2589, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2591, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2597, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2598, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2599, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2601, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2602, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2603, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2604, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2606, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2597, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2598, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2599, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2601, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2607, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2608, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2609, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2611, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2612, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ _(2613, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2614, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2616, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2622, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2623, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2624, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2626, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2627, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2628, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2629, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2631, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2622, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2623, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2624, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2626, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2632, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2633, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2634, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2636, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2637, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2638, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2639, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2641, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2643, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2644, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2646, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2647, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2648, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2649, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2651, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2652, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2653, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2654, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2656, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2647, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2648, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2649, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2651, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2653, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2654, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2656, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2657, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2658, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2659, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2661, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2662, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2663, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2664, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2666, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2668, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2669, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2671, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2672, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2673, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2674, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2676, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2677, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2678, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2679, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2681, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2672, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2673, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2674, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2676, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2678, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2679, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2681, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2682, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2683, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2684, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2686, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2687, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ _(2688, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2689, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2691, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2693, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2694, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2696, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2697, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2698, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2699, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2701, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2702, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2703, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2704, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2706, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2697, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2698, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2699, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2701, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2703, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2704, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2706, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2707, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2708, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2709, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2711, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2712, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2713, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2714, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2716, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2722, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2723, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2724, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2726, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2727, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2728, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2729, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2731, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2722, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2723, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2724, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2726, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2732, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2733, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2734, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2736, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2737, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2738, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2739, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2741, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2747, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2748, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2749, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2751, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2752, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2753, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2754, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2756, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2747, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2748, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2749, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2751, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2757, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2758, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2759, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2761, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2762, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ _(2763, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2764, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2766, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2772, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2773, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2774, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2776, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2777, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2778, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2779, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2781, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2772, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2773, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2774, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2776, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2782, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2783, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2784, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2786, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2787, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2788, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2789, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2791, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2807, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2808, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2809, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2810, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2811, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2812, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2813, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2814, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2815, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2819, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2820, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2821, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2822, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2823, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2824, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2825, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2826, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2827, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2828, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2829, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2830, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2834, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2835, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2836, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2852, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2853, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2854, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2855, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2856, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2857, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2858, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2859, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2860, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2864, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2865, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2866, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2882, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2883, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2884, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2885, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2886, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2887, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2888, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2889, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2890, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2894, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2895, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2896, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2897, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2898, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2899, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2900, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2901, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2902, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2903, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2904, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2905, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2909, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2910, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2911, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2927, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2928, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2929, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2930, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2931, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2932, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2933, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2934, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2935, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2939, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2940, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2941, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2957, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2958, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2959, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2960, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2961, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2962, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2963, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2964, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2965, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2969, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2970, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2971, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2972, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2973, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2974, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2975, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2976, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2977, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2978, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2979, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2980, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2984, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2985, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2986, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3002, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3003, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3004, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3005, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3006, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3007, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3008, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3009, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3010, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3014, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3015, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3016, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3032, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3033, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3034, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3035, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3036, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3037, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3038, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3039, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3040, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3044, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3045, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3046, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3047, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3048, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3049, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3050, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3051, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3052, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3053, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3054, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3055, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3059, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3060, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3061, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3077, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3078, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3079, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3080, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3081, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3082, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3083, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3084, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3085, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3089, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3090, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3091, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3092, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST) \ - _(3093, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3094, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3095, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST) \ - _(3096, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3097, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3098, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(3102, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(3103, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(3107, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(3111, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3112, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3113, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3114, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3115, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3116, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3120, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3121, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3122, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3123, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3124, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3125, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3126, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3127, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3128, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3129, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3130, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3131, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3135, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3136, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3137, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3138, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3139, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3140, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3141, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3142, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3143, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3144, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3145, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3146, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3150, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3151, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3152, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3168, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3169, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3170, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3171, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3172, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3173, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3174, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3175, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3176, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3180, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3181, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3182, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3186, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3187, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3188, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3189, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3190, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3191, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3195, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3196, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3197, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3198, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3199, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3200, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3201, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3202, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3203, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3204, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3205, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3206, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3210, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3211, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3212, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3213, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3214, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3215, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3216, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3217, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3218, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3219, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3220, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3221, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3225, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3226, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3227, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3243, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3244, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3245, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3246, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3247, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3248, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3249, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3250, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3251, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3255, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3256, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3257, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3261, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3262, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3263, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3264, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3265, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3266, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3270, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3271, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3272, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3273, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3274, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3275, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3276, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3277, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3278, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3279, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3280, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3281, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3285, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3286, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3287, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3288, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3289, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3290, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3291, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3292, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3293, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3294, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3295, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3296, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3300, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3301, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3302, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3318, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3319, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3320, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3321, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3322, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3323, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3324, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3325, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3326, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3330, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3331, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3332, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3336, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3337, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3338, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3339, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3340, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3341, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3345, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3346, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3347, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3348, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3349, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3350, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3351, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3352, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3353, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3354, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3355, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3356, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3360, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3361, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3362, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3363, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3364, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3365, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3366, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3367, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3368, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3369, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3370, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3371, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3375, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3376, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3377, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3393, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3394, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3395, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3396, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3397, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3398, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3399, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3400, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3401, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3405, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3406, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3407, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3408, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3409, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3410, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3411, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ - _(3412, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3413, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3414, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3415, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ - _(3416, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3417, ZEND_POST_INC_LONG_SPEC_CV) \ - _(3418, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3419, ZEND_POST_DEC_LONG_SPEC_CV) \ - _(3420, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ - _(3421, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3422, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3424, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3425, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ - _(3426, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3427, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3429, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3430, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ - _(3431, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3432, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3434, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3436, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3437, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3439, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3440, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(3441, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3442, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3444, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3445, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(3446, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3447, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3449, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3455, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ - _(3456, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3457, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3459, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3462, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ - _(3464, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ - _(3467, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ - _(3469, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ - _(3470, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ - _(3471, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ - _(3472, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ - _(3473, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ - _(3473+1, ZEND_NULL) + _(2797, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2798, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2799, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2801, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2817, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2818, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2819, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2820, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2821, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2822, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2823, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2824, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2825, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2829, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2830, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2831, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2832, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2833, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2834, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2835, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2836, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2837, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2838, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2839, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2840, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2844, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2845, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2846, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2862, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2863, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2864, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2865, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2866, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2867, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2868, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2869, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2870, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2874, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2875, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2876, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2892, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2893, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2894, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2895, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2896, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2897, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2898, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2899, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2900, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2904, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2905, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2906, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2907, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2908, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2909, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2910, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2911, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2912, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2913, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2914, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2915, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2919, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2920, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2921, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2937, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2938, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2939, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2940, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2941, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2942, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2943, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2944, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2945, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2949, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2950, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2951, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2967, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2968, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2969, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2970, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2971, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2972, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2973, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2974, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2975, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2979, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2980, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2981, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2982, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2983, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2984, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2985, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2986, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2987, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2988, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2989, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2990, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2994, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2995, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2996, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3012, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3013, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3014, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3015, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3016, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3017, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3018, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3019, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3020, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3024, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3025, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3026, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3042, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3043, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3044, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3045, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3046, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3047, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3048, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3049, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3050, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3054, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3055, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3056, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3057, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3058, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3059, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3060, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3061, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3062, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3063, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3064, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3065, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3069, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3070, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3071, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3087, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3088, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3089, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3090, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3091, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3092, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3093, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3094, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3095, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3099, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3100, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3101, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3102, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST) \ + _(3103, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3104, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3105, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST) \ + _(3106, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3107, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3108, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3112, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3113, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3117, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3121, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3122, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3123, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3124, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3125, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3126, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3130, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3131, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3132, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3133, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3134, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3135, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3136, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3137, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3138, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3139, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3140, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3141, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3145, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3146, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3147, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3148, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3149, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3150, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3151, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3152, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3153, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3154, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3155, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3156, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3160, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3161, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3162, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3178, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3179, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3180, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3181, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3182, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3183, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3184, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3185, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3186, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3190, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3191, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3192, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3196, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3197, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3198, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3199, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3200, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3201, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3205, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3206, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3207, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3208, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3209, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3210, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3211, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3212, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3213, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3214, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3215, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3216, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3220, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3221, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3222, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3223, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3224, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3225, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3226, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3227, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3228, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3229, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3230, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3231, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3235, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3236, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3237, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3253, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3254, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3255, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3256, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3257, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3258, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3259, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3260, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3261, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3265, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3266, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3267, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3271, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3272, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3273, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3274, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3275, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3276, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3280, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3281, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3282, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3283, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3284, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3285, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3286, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3287, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3288, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3289, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3290, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3291, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3295, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3296, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3297, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3298, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3299, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3300, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3301, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3302, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3303, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3304, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3305, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3306, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3310, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3311, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3312, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3328, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3329, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3330, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3331, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3332, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3333, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3334, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3335, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3336, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3340, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3341, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3342, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3346, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3347, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3348, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3349, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3350, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3351, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3355, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3356, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3357, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3358, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3359, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3360, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3361, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3362, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3363, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3364, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3365, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3366, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3370, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3371, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3372, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3373, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3374, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3375, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3376, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3377, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3378, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3379, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3380, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3381, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3385, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3386, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3387, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3403, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3404, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3405, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3406, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3407, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3408, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3409, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3410, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3411, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3415, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3416, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3417, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3418, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3419, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3420, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3421, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ + _(3422, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3423, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3424, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3425, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ + _(3426, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3427, ZEND_POST_INC_LONG_SPEC_CV) \ + _(3428, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3429, ZEND_POST_DEC_LONG_SPEC_CV) \ + _(3430, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ + _(3431, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3432, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3434, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3435, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ + _(3436, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3437, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3439, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3440, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ + _(3441, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3442, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3444, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3446, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3447, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3449, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3450, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3451, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3452, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3454, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3455, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3456, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3457, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3459, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3465, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ + _(3466, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3467, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3469, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3472, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ + _(3474, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ + _(3477, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ + _(3479, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ + _(3480, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ + _(3481, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ + _(3482, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ + _(3483, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ + _(3483+1, ZEND_NULL) diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c index 0ece3e6f0c66..43076acb33a1 100644 --- a/Zend/zend_vm_opcodes.c +++ b/Zend/zend_vm_opcodes.c @@ -21,7 +21,7 @@ #include #include -static const char *zend_vm_opcodes_names[212] = { +static const char *zend_vm_opcodes_names[213] = { "ZEND_NOP", "ZEND_ADD", "ZEND_SUB", @@ -234,9 +234,10 @@ static const char *zend_vm_opcodes_names[212] = { "ZEND_INIT_PARENT_PROPERTY_HOOK_CALL", "ZEND_DECLARE_ATTRIBUTED_CONST", "ZEND_TYPE_ASSERT", + "ZEND_ASSIGN_TYPED", }; -static uint32_t zend_vm_opcodes_flags[212] = { +static uint32_t zend_vm_opcodes_flags[213] = { 0x00000000, 0x00000b0b, 0x00000b0b, @@ -449,6 +450,7 @@ static uint32_t zend_vm_opcodes_flags[212] = { 0x01001103, 0x00000303, 0x01000003, + 0x00000301, }; ZEND_API const char* ZEND_FASTCALL zend_get_opcode_name(uint8_t opcode) { diff --git a/Zend/zend_vm_opcodes.h b/Zend/zend_vm_opcodes.h index 92b46e6628f3..7765ab5a5054 100644 --- a/Zend/zend_vm_opcodes.h +++ b/Zend/zend_vm_opcodes.h @@ -331,7 +331,8 @@ END_EXTERN_C() #define ZEND_INIT_PARENT_PROPERTY_HOOK_CALL 209 #define ZEND_DECLARE_ATTRIBUTED_CONST 210 #define ZEND_TYPE_ASSERT 211 +#define ZEND_ASSIGN_TYPED 212 -#define ZEND_VM_LAST_OPCODE 211 +#define ZEND_VM_LAST_OPCODE 212 #endif From 13fc79901f0338e9a09b13aca1f3f7ff1f625b3c Mon Sep 17 00:00:00 2001 From: Michal Kral Date: Mon, 15 Jun 2026 22:30:30 +0200 Subject: [PATCH 05/14] fix(compile): enforce typed locals on reassignment; reject auto-globals/$this/$GLOBALS FIX A: zend_compile_assign() now emits ZEND_ASSIGN_TYPED (instead of plain ZEND_ASSIGN) for a simple CV target that has a non-NULL cv_types[] entry, so the declared type is enforced on every (re)assignment, not just the initializer. Operand setup mirrors the initializer path in zend_compile_typed_var_decl(); the CV index is computed via EX_VAR_TO_NUM(var_node.u.op.var), matching the VM handler. Because cv_types[] persists, this also covers `int $x; $x = ...;` and post-unset reassignment. Only the simple-CV-target case changes; dim/prop/list/dynamic targets are untouched (a non-CV var_node falls through to ZEND_ASSIGN unchanged). FIX B (finding I1): zend_compile_typed_var_decl() now rejects auto-globals, $this and $GLOBALS with E_COMPILE_ERROR, mirroring how the canonical CV path (zend_try_compile_cv) handles these special names. The variable name is now interned via zval_make_interned_string() so vars[] stays consistent with the canonical path and opcache's interned-string accounting. --- Zend/zend_compile.c | 36 ++++++++++++++++++++++++++++++++++-- 1 file changed, 34 insertions(+), 2 deletions(-) diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index aa0b80ae69b4..c93ea5652dd6 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -3530,6 +3530,20 @@ static void zend_compile_assign(znode *result, zend_ast *ast, bool stmt, uint32_ zend_compile_expr(&expr_node, expr_ast); zend_delayed_compile_end(offset); CG(zend_lineno) = zend_ast_get_lineno(var_ast); + /* If the target is a typed local CV, enforce the declared type on every + * (re)assignment by emitting ZEND_ASSIGN_TYPED instead of plain ZEND_ASSIGN. + * The operand setup mirrors the initializer path in + * zend_compile_typed_var_decl(); cv_types[] persists across unset()/reuse, + * so this also covers `int $x; $x = ...;` and post-unset reassignment. + * Only simple CV targets are affected; dynamic/auto-global $$vars compile to + * a non-CV var_node and fall through to plain ZEND_ASSIGN unchanged. */ + if (var_node.op_type == IS_CV && CG(active_op_array)->cv_types) { + uint32_t cv_index = EX_VAR_TO_NUM(var_node.u.op.var); + if (CG(active_op_array)->cv_types[cv_index]) { + zend_emit_op_tmp(result, ZEND_ASSIGN_TYPED, &var_node, &expr_node); + return; + } + } zend_emit_op_tmp(result, ZEND_ASSIGN, &var_node, &expr_node); return; case ZEND_AST_STATIC_PROP: @@ -11996,8 +12010,26 @@ static void zend_compile_typed_var_decl(zend_ast *ast) /* {{{ */ zend_op_array *op_array = CG(active_op_array); /* child[1] is the raw T_VARIABLE semantic value: a ZEND_AST_ZVAL node whose - * zval is the variable name (the leading '$' was stripped by the scanner). */ - zend_string *name = zend_ast_get_str(var_ast); + * zval is the variable name (the leading '$' was stripped by the scanner). The + * grammar (typed_local_decl) always produces an IS_STRING zval here. Intern it the + * same way zend_try_compile_cv() does so the string stored in vars[] matches the + * canonical CV path (and opcache's interned-string accounting). zval_make_interned_string() + * replaces the zval in place; the AST keeps ownership, so we hold only a borrowed ref. */ + zval *name_zv = zend_ast_get_zval(var_ast); + ZEND_ASSERT(Z_TYPE_P(name_zv) == IS_STRING); + zend_string *name = zval_make_interned_string(name_zv); + + /* Special variables cannot be given a type. The canonical CV path + * (zend_try_compile_cv) silently routes auto-globals / $this / $GLOBALS away from + * the CV slot; for a typed declaration that would mean the type is silently + * dropped (or, worse, a superglobal gets shadowed), so reject them outright + * (finding I1). Mirrors is_this_fetch()/is_globals_fetch() name handling. */ + if (zend_is_auto_global(name) + || zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)) + || zend_string_equals_literal(name, "GLOBALS")) { + zend_error_noreturn(E_COMPILE_ERROR, + "Cannot declare a type for the special variable $%s", ZSTR_VAL(name)); + } /* lookup_cv() returns an EX_NUM_TO_VAR()-encoded operand, not a raw index, and * it appends a new CV (growing last_var) only when the name is not yet interned. From e072f6903924d346842bcb58aea91e36fddda2ff Mon Sep 17 00:00:00 2001 From: Michal Kral Date: Mon, 15 Jun 2026 22:40:47 +0200 Subject: [PATCH 06/14] fix(opcache): persist op_array->cv_types (SHM + file cache) cv_types[] (the parallel array of zend_property_info* describing typed local variables) was request-memory only and had no opcache handling: with opcache enabled it leaked on compile, and a file-cached op_array reloaded in another process carried a dangling cv_types pointer, causing a SIGSEGV when a typed local was assigned (finding C1). Mirror the existing op_array->vars handling in all three persistence layers: - zend_persist_calc.c: account for the pointer array plus, per typed slot, the zend_property_info struct and its interned name. - zend_persist.c: zend_shared_memdup the array and each zend_property_info into SHM and intern each name. Types are pure scalar masks, so zend_persist_type() is a no-op (no class/list pointers to relocate). - zend_file_cache.c: SERIALIZE_PTR/UNSERIALIZE_PTR the array and each entry, plus SERIALIZE_STR/UNSERIALIZE_STR each name, in both the full walk and the shared- method (refcount) fast paths. serialize/unserialize_type are no-ops for masks. destroy_op_array() needs no change: persisted op_arrays have refcount==NULL and return early before the vars[]/cv_types[] efree, so the existing guard that protects vars[] already protects cv_types[]. Verified: SHM run with report_memleaks shows no leak; file-cache write+reload (including overwriting the source with garbage under validate_timestamps=0 to force a pure cache load) prints correctly and does not segfault, for both plain functions and class methods. --- ext/opcache/zend_file_cache.c | 50 +++++++++++++++++++++++++++++++++ ext/opcache/zend_persist.c | 17 +++++++++++ ext/opcache/zend_persist_calc.c | 17 +++++++++++ 3 files changed, 84 insertions(+) diff --git a/ext/opcache/zend_file_cache.c b/ext/opcache/zend_file_cache.c index af59b9b2c34a..e21413e81463 100644 --- a/ext/opcache/zend_file_cache.c +++ b/ext/opcache/zend_file_cache.c @@ -512,6 +512,7 @@ static void zend_file_cache_serialize_op_array(zend_op_array *op_arra SERIALIZE_PTR(op_array->opcodes); SERIALIZE_PTR(op_array->arg_info); SERIALIZE_PTR(op_array->vars); + SERIALIZE_PTR(op_array->cv_types); SERIALIZE_STR(op_array->function_name); SERIALIZE_STR(op_array->filename); SERIALIZE_PTR(op_array->live_range); @@ -677,6 +678,31 @@ static void zend_file_cache_serialize_op_array(zend_op_array *op_arra } } + /* Typed local variables: parallel to vars[]. Serialize the pointer array and, + * for each non-NULL slot, the zend_property_info pointer, its name and its type + * (a pure scalar mask, so serialize_type is a no-op). Mirrors the vars[] block. */ + if (op_array->cv_types) { + zend_property_info **p, **end; + + SERIALIZE_PTR(op_array->cv_types); + p = op_array->cv_types; + UNSERIALIZE_PTR(p); + end = p + op_array->last_var; + while (p < end) { + if (*p) { + zend_property_info *prop_info; + SERIALIZE_PTR(*p); + prop_info = *p; + UNSERIALIZE_PTR(prop_info); + if (!IS_SERIALIZED(prop_info->name)) { + SERIALIZE_STR(prop_info->name); + } + zend_file_cache_serialize_type(&prop_info->type, script, info, buf); + } + p++; + } + } + if (op_array->num_dynamic_func_defs) { zend_op_array **defs; SERIALIZE_PTR(op_array->dynamic_func_defs); @@ -1444,6 +1470,7 @@ static void zend_file_cache_unserialize_op_array(zend_op_array *op_arr UNSERIALIZE_PTR(op_array->opcodes); UNSERIALIZE_PTR(op_array->arg_info); UNSERIALIZE_PTR(op_array->vars); + UNSERIALIZE_PTR(op_array->cv_types); UNSERIALIZE_STR(op_array->function_name); UNSERIALIZE_STR(op_array->filename); UNSERIALIZE_PTR(op_array->live_range); @@ -1580,6 +1607,29 @@ static void zend_file_cache_unserialize_op_array(zend_op_array *op_arr } } + /* Typed local variables: parallel to vars[]. Fix up the pointer array, then for + * each non-NULL slot the zend_property_info pointer, its name and its type + * (a pure scalar mask, so unserialize_type is a no-op). Mirrors the vars[] block. */ + if (op_array->cv_types) { + zend_property_info **p, **end; + + UNSERIALIZE_PTR(op_array->cv_types); + p = op_array->cv_types; + end = p + op_array->last_var; + while (p < end) { + if (*p) { + zend_property_info *prop_info; + UNSERIALIZE_PTR(*p); + prop_info = *p; + if (!IS_UNSERIALIZED(prop_info->name)) { + UNSERIALIZE_STR(prop_info->name); + } + zend_file_cache_unserialize_type(&prop_info->type, (op_array->fn_flags & ZEND_ACC_CLOSURE) ? NULL : op_array->scope, script, buf); + } + p++; + } + } + if (op_array->num_dynamic_func_defs) { UNSERIALIZE_PTR(op_array->dynamic_func_defs); for (uint32_t i = 0; i < op_array->num_dynamic_func_defs; i++) { diff --git a/ext/opcache/zend_persist.c b/ext/opcache/zend_persist.c index c06452e6acf2..2aa0e6768b6c 100644 --- a/ext/opcache/zend_persist.c +++ b/ext/opcache/zend_persist.c @@ -688,6 +688,23 @@ static void zend_persist_op_array_ex(zend_op_array *op_array, zend_persistent_sc } } + /* Typed local variables: parallel to vars[]. Copy the pointer array into SHM, then + * deep-copy each non-NULL zend_property_info and intern its name. The type is a pure + * scalar mask, so zend_persist_type() copies it in place (no pointers). Mirrors the + * vars[] block above; matching cleanup is guarded in destroy_op_array() by the + * refcount==NULL early-return that already protects vars[] on persisted op_arrays. */ + if (op_array->cv_types) { + int i; + op_array->cv_types = zend_shared_memdup_put_free(op_array->cv_types, sizeof(zend_property_info*) * op_array->last_var); + for (i = 0; i < op_array->last_var; i++) { + if (op_array->cv_types[i]) { + op_array->cv_types[i] = zend_shared_memdup_put_free(op_array->cv_types[i], sizeof(zend_property_info)); + zend_accel_store_interned_string(op_array->cv_types[i]->name); + zend_persist_type(&op_array->cv_types[i]->type); + } + } + } + if (op_array->num_dynamic_func_defs) { op_array->dynamic_func_defs = zend_shared_memdup_put_free( op_array->dynamic_func_defs, sizeof(zend_function *) * op_array->num_dynamic_func_defs); diff --git a/ext/opcache/zend_persist_calc.c b/ext/opcache/zend_persist_calc.c index 9ff37079193b..d1a1cdc70cbf 100644 --- a/ext/opcache/zend_persist_calc.c +++ b/ext/opcache/zend_persist_calc.c @@ -335,6 +335,23 @@ static void zend_persist_op_array_calc_ex(zend_op_array *op_array) } } + /* Typed local variables: parallel to vars[]. Account for the pointer array plus, + * for each typed slot, the zend_property_info struct and its interned name. The + * type is a pure scalar mask (no class/list pointers), so zend_persist_type_calc() + * adds nothing. Mirrors the vars[] accounting above. */ + if (op_array->cv_types) { + int i; + + ADD_SIZE(sizeof(zend_property_info*) * op_array->last_var); + for (i = 0; i < op_array->last_var; i++) { + if (op_array->cv_types[i]) { + ADD_SIZE(sizeof(zend_property_info)); + ADD_INTERNED_STRING(op_array->cv_types[i]->name); + zend_persist_type_calc(&op_array->cv_types[i]->type); + } + } + } + if (op_array->num_dynamic_func_defs) { ADD_SIZE(sizeof(void *) * op_array->num_dynamic_func_defs); for (uint32_t i = 0; i < op_array->num_dynamic_func_defs; i++) { From 53364bc0e710f18f9586a3400cd2e094090b1e45 Mon Sep 17 00:00:00 2001 From: Michal Kral Date: Mon, 15 Jun 2026 22:56:04 +0200 Subject: [PATCH 07/14] chore: drop completed opcache TODO marker on cv_types --- Zend/zend_compile.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h index 6edf898ff4d3..db851d0afe73 100644 --- a/Zend/zend_compile.h +++ b/Zend/zend_compile.h @@ -556,7 +556,7 @@ struct _zend_op_array { ZEND_MAP_PTR_DEF(HashTable *, static_variables_ptr); HashTable *static_variables; zend_string **vars; /* names of CV variables */ - zend_property_info **cv_types; /* parallel to vars[]; NULL entry = untyped CV; whole pointer NULL if no typed locals */ /* TODO(opcache): persist cv_types — Plan 4 */ + zend_property_info **cv_types; /* parallel to vars[]; NULL entry = untyped CV; whole pointer NULL if no typed locals */ uint32_t *refcount; From 052029f6391752d0ee52b9cbaf92337690992a7a Mon Sep 17 00:00:00 2001 From: Michal Kral Date: Mon, 15 Jun 2026 23:02:13 +0200 Subject: [PATCH 08/14] test: typed local variables (.phpt suite) Add 13 .phpt tests covering the typed-locals feature: basic scalars, weak-mode coercion on init and reassign, strict-mode TypeErrors, uninitialized-then-assign, nullable types, non-numeric weak TypeError, and compile errors for non-scalar type / redeclaration / $this / superglobals. Includes an opcache_persist test guarding cv_types SHM/file-cache continuity. --- tests/lang/typed_locals/basic.phpt | 15 +++++++++++ tests/lang/typed_locals/nullable.phpt | 13 +++++++++ tests/lang/typed_locals/opcache_persist.phpt | 27 +++++++++++++++++++ .../lang/typed_locals/reassign_enforced.phpt | 17 ++++++++++++ tests/lang/typed_locals/redeclare_error.phpt | 9 +++++++ .../lang/typed_locals/scalar_only_error.phpt | 8 ++++++ .../special_var_superglobal_error.phpt | 8 ++++++ .../typed_locals/special_var_this_error.phpt | 12 +++++++++ .../lang/typed_locals/strict_init_error.phpt | 13 +++++++++ .../typed_locals/strict_reassign_error.phpt | 14 ++++++++++ .../uninitialized_then_assign.phpt | 10 +++++++ tests/lang/typed_locals/weak_coerce_init.phpt | 13 +++++++++ .../typed_locals/weak_nonnumeric_error.phpt | 13 +++++++++ 13 files changed, 172 insertions(+) create mode 100644 tests/lang/typed_locals/basic.phpt create mode 100644 tests/lang/typed_locals/nullable.phpt create mode 100644 tests/lang/typed_locals/opcache_persist.phpt create mode 100644 tests/lang/typed_locals/reassign_enforced.phpt create mode 100644 tests/lang/typed_locals/redeclare_error.phpt create mode 100644 tests/lang/typed_locals/scalar_only_error.phpt create mode 100644 tests/lang/typed_locals/special_var_superglobal_error.phpt create mode 100644 tests/lang/typed_locals/special_var_this_error.phpt create mode 100644 tests/lang/typed_locals/strict_init_error.phpt create mode 100644 tests/lang/typed_locals/strict_reassign_error.phpt create mode 100644 tests/lang/typed_locals/uninitialized_then_assign.phpt create mode 100644 tests/lang/typed_locals/weak_coerce_init.phpt create mode 100644 tests/lang/typed_locals/weak_nonnumeric_error.phpt diff --git a/tests/lang/typed_locals/basic.phpt b/tests/lang/typed_locals/basic.phpt new file mode 100644 index 000000000000..c94d5af7c1e6 --- /dev/null +++ b/tests/lang/typed_locals/basic.phpt @@ -0,0 +1,15 @@ +--TEST-- +Typed local variables: basic declaration and var_dump of all four scalar types +--FILE-- + +--EXPECT-- +string(2) "hi" +int(3) +float(1.5) +bool(true) diff --git a/tests/lang/typed_locals/nullable.phpt b/tests/lang/typed_locals/nullable.phpt new file mode 100644 index 000000000000..f281cab3bf04 --- /dev/null +++ b/tests/lang/typed_locals/nullable.phpt @@ -0,0 +1,13 @@ +--TEST-- +Typed local variables: nullable scalar types (?int, ?string) +--FILE-- + +--EXPECT-- +NULL +int(5) +NULL diff --git a/tests/lang/typed_locals/opcache_persist.phpt b/tests/lang/typed_locals/opcache_persist.phpt new file mode 100644 index 000000000000..b6428dd38e30 --- /dev/null +++ b/tests/lang/typed_locals/opcache_persist.phpt @@ -0,0 +1,27 @@ +--TEST-- +Typed local variables: cv_types are preserved through opcache (SHM/file-cache persistence) +--EXTENSIONS-- +opcache +--INI-- +opcache.enable=1 +opcache.enable_cli=1 +opcache.file_cache_only=0 +--FILE-- + +--EXPECT-- +int(5) +string(5) "hello" +float(3.14) diff --git a/tests/lang/typed_locals/reassign_enforced.phpt b/tests/lang/typed_locals/reassign_enforced.phpt new file mode 100644 index 000000000000..4209e2d63a0a --- /dev/null +++ b/tests/lang/typed_locals/reassign_enforced.phpt @@ -0,0 +1,17 @@ +--TEST-- +Typed local variables: type enforcement (with coercion) on reassignment +--FILE-- + +--EXPECT-- +int(7) +string(1) "5" diff --git a/tests/lang/typed_locals/redeclare_error.phpt b/tests/lang/typed_locals/redeclare_error.phpt new file mode 100644 index 000000000000..53788dc4d07e --- /dev/null +++ b/tests/lang/typed_locals/redeclare_error.phpt @@ -0,0 +1,9 @@ +--TEST-- +Typed local variables: redeclaring a typed local is a compile error +--FILE-- + +--EXPECTF-- +Fatal error: Cannot redeclare typed local variable $x in %s on line %d diff --git a/tests/lang/typed_locals/scalar_only_error.phpt b/tests/lang/typed_locals/scalar_only_error.phpt new file mode 100644 index 000000000000..59108f572ec3 --- /dev/null +++ b/tests/lang/typed_locals/scalar_only_error.phpt @@ -0,0 +1,8 @@ +--TEST-- +Typed local variables: non-scalar type triggers compile error +--FILE-- + +--EXPECTF-- +Fatal error: Typed local variables support only scalar types (int, float, string, bool) in this version in %s on line %d diff --git a/tests/lang/typed_locals/special_var_superglobal_error.phpt b/tests/lang/typed_locals/special_var_superglobal_error.phpt new file mode 100644 index 000000000000..8615b643e785 --- /dev/null +++ b/tests/lang/typed_locals/special_var_superglobal_error.phpt @@ -0,0 +1,8 @@ +--TEST-- +Typed local variables: typing a superglobal is a compile error +--FILE-- + +--EXPECTF-- +Fatal error: Cannot declare a type for the special variable $_GET in %s on line %d diff --git a/tests/lang/typed_locals/special_var_this_error.phpt b/tests/lang/typed_locals/special_var_this_error.phpt new file mode 100644 index 000000000000..fe11f3cf8758 --- /dev/null +++ b/tests/lang/typed_locals/special_var_this_error.phpt @@ -0,0 +1,12 @@ +--TEST-- +Typed local variables: typing $this is a compile error +--FILE-- + +--EXPECTF-- +Fatal error: Cannot declare a type for the special variable $this in %s on line %d diff --git a/tests/lang/typed_locals/strict_init_error.phpt b/tests/lang/typed_locals/strict_init_error.phpt new file mode 100644 index 000000000000..f42e16a4b30b --- /dev/null +++ b/tests/lang/typed_locals/strict_init_error.phpt @@ -0,0 +1,13 @@ +--TEST-- +Typed local variables: strict_types=1 throws TypeError on non-coercible init +--FILE-- +getMessage(), "\n"; +} +?> +--EXPECTF-- +Cannot assign string to local variable $n of type int diff --git a/tests/lang/typed_locals/strict_reassign_error.phpt b/tests/lang/typed_locals/strict_reassign_error.phpt new file mode 100644 index 000000000000..3720431bf824 --- /dev/null +++ b/tests/lang/typed_locals/strict_reassign_error.phpt @@ -0,0 +1,14 @@ +--TEST-- +Typed local variables: strict_types=1 throws TypeError on non-coercible reassignment +--FILE-- +getMessage(), "\n"; +} +?> +--EXPECTF-- +Cannot assign string to local variable $x of type int diff --git a/tests/lang/typed_locals/uninitialized_then_assign.phpt b/tests/lang/typed_locals/uninitialized_then_assign.phpt new file mode 100644 index 000000000000..92fdc9d08853 --- /dev/null +++ b/tests/lang/typed_locals/uninitialized_then_assign.phpt @@ -0,0 +1,10 @@ +--TEST-- +Typed local variables: declaration without initializer, then assignment +--FILE-- + +--EXPECT-- +int(9) diff --git a/tests/lang/typed_locals/weak_coerce_init.phpt b/tests/lang/typed_locals/weak_coerce_init.phpt new file mode 100644 index 000000000000..fe7b36f101da --- /dev/null +++ b/tests/lang/typed_locals/weak_coerce_init.phpt @@ -0,0 +1,13 @@ +--TEST-- +Typed local variables: weak-mode coercion on initialization +--FILE-- + +--EXPECT-- +string(1) "5" +int(42) +float(3) diff --git a/tests/lang/typed_locals/weak_nonnumeric_error.phpt b/tests/lang/typed_locals/weak_nonnumeric_error.phpt new file mode 100644 index 000000000000..f3a267e052f3 --- /dev/null +++ b/tests/lang/typed_locals/weak_nonnumeric_error.phpt @@ -0,0 +1,13 @@ +--TEST-- +Typed local variables: weak mode, non-numeric string to int throws TypeError +--FILE-- + +--EXPECT-- +caught From aa77d20190a1aef53583384700750ad582612f8c Mon Sep 17 00:00:00 2001 From: Michal Kral Date: Mon, 15 Jun 2026 23:43:39 +0200 Subject: [PATCH 09/14] feat(engine): enforce typed locals through references (lazy typed-reference) Close gap #2: references could bypass a typed local's declared type (`int $x=1; $y=&$x; $y="s";` and `function m(&$r){$r="s";} m($x);`). Reuse the typed-property reference machinery: when a typed CV is aliased by a reference, attach its op_array-owned synthesized zend_property_info as a type source on the resulting zend_reference, so writes through the reference are checked by zend_verify_ref_assignable_zval(). The CV stays a plain value until referenced (no read overhead). ENFORCED reference-creation paths (source attached at ref creation): - ZEND_ASSIGN_REF (`$y = &$x`): new helper zend_assign_to_typed_cv_reference() mirrors zend_assign_to_typed_property_reference() and handles either/both operands typed, the re-binding DEL-before-ADD, and the `$x = &$x` self-alias. - by-ref argument passing (ZEND_SEND_REF, ZEND_SEND_VAR_EX) and ZEND_MAKE_REF: attach when a typed CV is freshly wrapped into a reference. FORBIDDEN at compile time (E_COMPILE_ERROR; these ref paths are not enforced, so they must not silently bypass the type): - `global $x`, `static $x`, `foreach (... as &$x)` on a typed local. Lifecycle: the source list stores only the pointer and never frees the property_info; ZEND_REF_DEL_TYPE_SOURCE frees only the list allocation. The synthesized info is owned by the op_array (freed in destroy_op_array), so the matching DEL is performed when the CV slot is torn down or moved out of the frame -- in i_free_compiled_variables() and zend_detach_symbol_table() (the top-level/symbol-table path) -- before the CV drops its refcount. A frame uses exactly one of those teardown paths, so ADD/DEL stay balanced one-per-CV-slot and the reference can never outlive the op_array with a dangling source. Reference type-error messages (zend_throw_ref_type_error_zval/_type, zend_throw_conflicting_coercion_error, zend_verify_property_type_error) now branch on prop->ce: synthesized local infos have ce == NULL, so they print "local variable $x" instead of dereferencing ce->name (which would segfault). Tests: 7 new .phpt under tests/lang/typed_locals (alias enforce/coerce, by-ref param weak+strict, target-typed alias, and the three compile-error forbids). --- Zend/zend_compile.c | 54 +++- Zend/zend_execute.c | 162 ++++++++-- Zend/zend_execute_API.c | 16 + Zend/zend_vm_def.h | 41 ++- Zend/zend_vm_execute.h | 296 +++++++++++++++++- .../lang/typed_locals/ref_alias_enforced.phpt | 32 ++ tests/lang/typed_locals/ref_byref_param.phpt | 25 ++ .../typed_locals/ref_byref_param_strict.phpt | 19 ++ .../lang/typed_locals/ref_forbid_foreach.phpt | 10 + .../lang/typed_locals/ref_forbid_global.phpt | 9 + .../lang/typed_locals/ref_forbid_static.phpt | 12 + tests/lang/typed_locals/ref_target_typed.phpt | 34 ++ 12 files changed, 670 insertions(+), 40 deletions(-) create mode 100644 tests/lang/typed_locals/ref_alias_enforced.phpt create mode 100644 tests/lang/typed_locals/ref_byref_param.phpt create mode 100644 tests/lang/typed_locals/ref_byref_param_strict.phpt create mode 100644 tests/lang/typed_locals/ref_forbid_foreach.phpt create mode 100644 tests/lang/typed_locals/ref_forbid_global.phpt create mode 100644 tests/lang/typed_locals/ref_forbid_static.phpt create mode 100644 tests/lang/typed_locals/ref_target_typed.phpt diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index c93ea5652dd6..d9defadb68e5 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -570,6 +570,26 @@ static uint32_t lookup_cv(zend_string *name) /* {{{ */{ } /* }}} */ +/* Returns the synthesized type info of an already-declared typed local with this name, + * or NULL if no such CV exists or it is untyped. Does NOT create a CV (unlike lookup_cv), + * so it is safe to probe from compile paths that must reject typed locals. */ +static zend_property_info *zend_find_typed_local(zend_string *name) /* {{{ */ +{ + zend_op_array *op_array = CG(active_op_array); + if (!op_array->cv_types) { + return NULL; + } + zend_ulong hash_value = zend_string_hash_val(name); + for (int i = 0; i < op_array->last_var; i++) { + if (ZSTR_H(op_array->vars[i]) == hash_value + && zend_string_equals(op_array->vars[i], name)) { + return op_array->cv_types[i]; + } + } + return NULL; +} +/* }}} */ + zend_string *zval_make_interned_string(zval *zv) { ZEND_ASSERT(Z_TYPE_P(zv) == IS_STRING); @@ -5755,7 +5775,18 @@ static void zend_compile_global_var(zend_ast *ast) /* {{{ */ // TODO(GLOBALS) Forbid "global $GLOBALS"? if (is_this_fetch(var_ast)) { zend_error_noreturn(E_COMPILE_ERROR, "Cannot use $this as global variable"); - } else if (zend_try_compile_cv(&result, var_ast, BP_VAR_R) == SUCCESS) { + } + /* A `global $x` binding turns $x into a reference to the global, bypassing the + * declared scalar type. This reference path is not enforced, so forbid it. */ + if (name_ast->kind == ZEND_AST_ZVAL && Z_TYPE_P(zend_ast_get_zval(name_ast)) == IS_STRING) { + zend_property_info *info = zend_find_typed_local(Z_STR_P(zend_ast_get_zval(name_ast))); + if (info) { + zend_error_noreturn(E_COMPILE_ERROR, + "Cannot use typed local variable $%s as global variable", + ZSTR_VAL(info->name)); + } + } + if (zend_try_compile_cv(&result, var_ast, BP_VAR_R) == SUCCESS) { zend_op *opline = zend_emit_op(NULL, ZEND_BIND_GLOBAL, &result, &name_node); opline->extended_value = zend_alloc_cache_slot(); } else { @@ -5809,6 +5840,13 @@ static void zend_compile_static_var(zend_ast *ast) /* {{{ */ zend_error_noreturn(E_COMPILE_ERROR, "Cannot use $this as static variable"); } + /* A `static $x` binding turns $x into a reference to the static slot, bypassing the + * declared scalar type. This reference path is not enforced, so forbid it. */ + if (zend_find_typed_local(var_name)) { + zend_error_noreturn(E_COMPILE_ERROR, + "Cannot use typed local variable $%s as static variable", ZSTR_VAL(var_name)); + } + if (!CG(active_op_array)->static_variables) { if (CG(active_op_array)->scope) { CG(active_op_array)->scope->ce_flags |= ZEND_HAS_STATIC_IN_METHODS; @@ -6424,6 +6462,20 @@ static void zend_compile_foreach(zend_ast *ast) /* {{{ */ by_ref = true; } + /* `foreach ($arr as &$x)` makes the typed local $x a reference into the array + * element, bypassing its declared scalar type. This reference path is not + * enforced, so forbid it. */ + if (by_ref && value_ast->kind == ZEND_AST_VAR + && value_ast->child[0]->kind == ZEND_AST_ZVAL + && Z_TYPE_P(zend_ast_get_zval(value_ast->child[0])) == IS_STRING) { + zend_property_info *info = zend_find_typed_local(Z_STR_P(zend_ast_get_zval(value_ast->child[0]))); + if (info) { + zend_error_noreturn(E_COMPILE_ERROR, + "Cannot use typed local variable $%s as foreach by-reference value", + ZSTR_VAL(info->name)); + } + } + if (by_ref && is_variable) { zend_compile_var(&expr_node, expr_ast, BP_VAR_W, true); } else { diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c index 92ef19669a8a..6d8402de6301 100644 --- a/Zend/zend_execute.c +++ b/Zend/zend_execute.c @@ -592,6 +592,61 @@ static zend_never_inline zval* zend_assign_to_typed_property_reference(zend_prop return prop; } +/* Reference binding `$target = &$source` (ZEND_ASSIGN_REF) where the target and/or the + * source is a typed local variable. Mirrors zend_assign_to_typed_property_reference(): + * the resulting (shared) zend_reference gets each involved typed local's synthesized + * type added as a source, so any later write through the reference is type-checked by + * zend_verify_ref_assignable_zval(). The matching removal happens at frame teardown in + * i_free_compiled_variables(). target_info/source_info are NULL for untyped operands. + * Source-add bookkeeping is kept balanced at one-per-typed-CV-slot. */ +static zend_never_inline zval* zend_assign_to_typed_cv_reference( + zend_property_info *target_info, zend_property_info *source_info, + zval *variable_ptr, zval *value_ptr, zend_refcounted **garbage_ptr EXECUTE_DATA_DC) +{ + bool same_slot = (variable_ptr == value_ptr); + bool source_was_ref = Z_ISREF_P(value_ptr); + + /* If the target is typed, the value it is about to alias must satisfy the target's + * declared type up front (e.g. `int $x; $x = &$strvar;` is rejected). */ + if (target_info + && !zend_verify_prop_assignable_by_ref(target_info, value_ptr, EX_USES_STRICT_TYPES())) { + return &EG(uninitialized_zval); + } + + /* The target is being re-pointed: drop its old source (if it was a typed ref) so the + * count stays balanced when the old reference is released below. */ + if (target_info && Z_ISREF_P(variable_ptr)) { + ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(variable_ptr), target_info); + } + + zend_assign_to_variable_reference(variable_ptr, value_ptr, garbage_ptr); + + /* Attach the source operand's type, but only if its slot newly began holding this + * reference (otherwise its source is already present from a prior binding). When the + * target and source are the same CV slot the target-add below already covers it. */ + if (source_info && !source_was_ref && !same_slot) { + ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(value_ptr), source_info); + } + /* Attach the target's type to the now-shared reference. */ + if (target_info) { + ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(variable_ptr), target_info); + } + return variable_ptr; +} + +/* Attach a typed local's synthesized type as a source on a reference that a typed CV + * has just been wrapped into (by-ref argument passing, ZEND_MAKE_REF). Called only when + * the CV slot transitioned from a plain value to a freshly created reference, so exactly + * one source is added per CV slot; the balancing removal is in i_free_compiled_variables(). */ +static zend_always_inline void zend_attach_cv_type_source_ex( + const zend_op_array *op_array, uint32_t var, zend_reference *ref) +{ + zend_property_info *info = op_array->cv_types[EX_VAR_TO_NUM(var)]; + if (UNEXPECTED(info != NULL)) { + ZEND_REF_ADD_TYPE_SOURCE(ref, info); + } +} + static zend_never_inline ZEND_COLD zval *zend_wrong_assign_to_variable_reference(zval *variable_ptr, zval *value_ptr, zend_refcounted **garbage_ptr OPLINE_DC EXECUTE_DATA_DC) { zend_error(E_NOTICE, "Only variables should be assigned by reference"); @@ -858,11 +913,19 @@ static zend_never_inline ZEND_COLD void zend_verify_property_type_error(const ze } type_str = zend_type_to_string(info->type); - zend_type_error("Cannot assign %s to property %s::$%s of type %s", - zend_zval_value_name(property), - ZSTR_VAL(info->ce->name), - zend_get_unmangled_property_name(info->name), - ZSTR_VAL(type_str)); + if (info->ce) { + zend_type_error("Cannot assign %s to property %s::$%s of type %s", + zend_zval_value_name(property), + ZSTR_VAL(info->ce->name), + zend_get_unmangled_property_name(info->name), + ZSTR_VAL(type_str)); + } else { + /* Synthesized info for a typed local variable (ce == NULL). */ + zend_type_error("Cannot assign %s to local variable $%s of type %s", + zend_zval_value_name(property), + ZSTR_VAL(info->name), + ZSTR_VAL(type_str)); + } zend_string_release(type_str); } @@ -3939,45 +4002,59 @@ ZEND_API zval* ZEND_FASTCALL zend_fetch_static_property(zend_execute_data *ex, i return result; } +/* A typed local variable is modeled by a synthesized zend_property_info whose ce is + * NULL (it does not belong to a class). Reference type-error messages must therefore + * branch on ce: "property C::$x" for real properties, "local variable $x" otherwise. + * info->name holds the plain (unmangled) variable/property name in the local case. */ +static zend_always_inline const char *zend_ref_source_name(const zend_property_info *info) { + return info->ce ? zend_get_unmangled_property_name(info->name) : ZSTR_VAL(info->name); +} + ZEND_API zend_never_inline ZEND_COLD void zend_throw_ref_type_error_type(const zend_property_info *prop1, const zend_property_info *prop2, const zval *zv) { zend_string *type1_str = zend_type_to_string(prop1->type); zend_string *type2_str = zend_type_to_string(prop2->type); - zend_type_error("Reference with value of type %s held by property %s::$%s of type %s is not compatible with property %s::$%s of type %s", - zend_zval_type_name(zv), - ZSTR_VAL(prop1->ce->name), - zend_get_unmangled_property_name(prop1->name), - ZSTR_VAL(type1_str), - ZSTR_VAL(prop2->ce->name), - zend_get_unmangled_property_name(prop2->name), - ZSTR_VAL(type2_str) - ); + if (prop1->ce && prop2->ce) { + zend_type_error("Reference with value of type %s held by property %s::$%s of type %s is not compatible with property %s::$%s of type %s", + zend_zval_type_name(zv), + ZSTR_VAL(prop1->ce->name), zend_get_unmangled_property_name(prop1->name), ZSTR_VAL(type1_str), + ZSTR_VAL(prop2->ce->name), zend_get_unmangled_property_name(prop2->name), ZSTR_VAL(type2_str)); + } else { + zend_type_error("Reference with value of type %s held by %s%s of type %s is not compatible with %s%s of type %s", + zend_zval_type_name(zv), + prop1->ce ? "property " : "local variable $", zend_ref_source_name(prop1), ZSTR_VAL(type1_str), + prop2->ce ? "property " : "local variable $", zend_ref_source_name(prop2), ZSTR_VAL(type2_str)); + } zend_string_release(type1_str); zend_string_release(type2_str); } ZEND_API zend_never_inline ZEND_COLD void zend_throw_ref_type_error_zval(const zend_property_info *prop, const zval *zv) { zend_string *type_str = zend_type_to_string(prop->type); - zend_type_error("Cannot assign %s to reference held by property %s::$%s of type %s", - zend_zval_value_name(zv), - ZSTR_VAL(prop->ce->name), - zend_get_unmangled_property_name(prop->name), - ZSTR_VAL(type_str) - ); + if (prop->ce) { + zend_type_error("Cannot assign %s to reference held by property %s::$%s of type %s", + zend_zval_value_name(zv), + ZSTR_VAL(prop->ce->name), zend_get_unmangled_property_name(prop->name), ZSTR_VAL(type_str)); + } else { + zend_type_error("Cannot assign %s to reference held by local variable $%s of type %s", + zend_zval_value_name(zv), ZSTR_VAL(prop->name), ZSTR_VAL(type_str)); + } zend_string_release(type_str); } static zend_never_inline ZEND_COLD void zend_throw_conflicting_coercion_error(const zend_property_info *prop1, const zend_property_info *prop2, const zval *zv) { zend_string *type1_str = zend_type_to_string(prop1->type); zend_string *type2_str = zend_type_to_string(prop2->type); - zend_type_error("Cannot assign %s to reference held by property %s::$%s of type %s and property %s::$%s of type %s, as this would result in an inconsistent type conversion", - zend_zval_value_name(zv), - ZSTR_VAL(prop1->ce->name), - zend_get_unmangled_property_name(prop1->name), - ZSTR_VAL(type1_str), - ZSTR_VAL(prop2->ce->name), - zend_get_unmangled_property_name(prop2->name), - ZSTR_VAL(type2_str) - ); + if (prop1->ce && prop2->ce) { + zend_type_error("Cannot assign %s to reference held by property %s::$%s of type %s and property %s::$%s of type %s, as this would result in an inconsistent type conversion", + zend_zval_value_name(zv), + ZSTR_VAL(prop1->ce->name), zend_get_unmangled_property_name(prop1->name), ZSTR_VAL(type1_str), + ZSTR_VAL(prop2->ce->name), zend_get_unmangled_property_name(prop2->name), ZSTR_VAL(type2_str)); + } else { + zend_type_error("Cannot assign %s to reference held by %s%s of type %s and %s%s of type %s, as this would result in an inconsistent type conversion", + zend_zval_value_name(zv), + prop1->ce ? "property " : "local variable $", zend_ref_source_name(prop1), ZSTR_VAL(type1_str), + prop2->ce ? "property " : "local variable $", zend_ref_source_name(prop2), ZSTR_VAL(type2_str)); + } zend_string_release(type1_str); zend_string_release(type2_str); } @@ -4337,8 +4414,33 @@ ZEND_API void zend_clean_and_cache_symbol_table(zend_array *symbol_table) /* {{{ static zend_always_inline void i_free_compiled_variables(zend_execute_data *execute_data) /* {{{ */ { + const zend_op_array *op_array = &EX(func)->op_array; zval *cv = EX_VAR_NUM(0); - int count = EX(func)->op_array.last_var; + int count = op_array->last_var; + + if (UNEXPECTED(op_array->cv_types != NULL)) { + /* A typed local that was aliased by a reference (e.g. `$y = &$x` or a by-ref + * argument) attached its synthesized type as a source on that reference. The + * source is owned by this op_array and must be removed from the reference + * before the CV slot drops its refcount, so the reference never outlives the + * op_array carrying a dangling type-source pointer. This mirrors how a typed + * object property removes its source in zend_object_dtor_property(). The + * ADD (at ref-creation time) and this DEL are balanced one-per-CV-slot. */ + zend_property_info **cv_types = op_array->cv_types; + int i = 0; + while (EXPECTED(i != count)) { + if (UNEXPECTED(cv_types[i] != NULL) + && UNEXPECTED(Z_ISREF_P(cv)) + && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(cv))) { + ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(cv), cv_types[i]); + } + i_zval_ptr_dtor(cv); + cv++; + i++; + } + return; + } + while (EXPECTED(count != 0)) { i_zval_ptr_dtor(cv); cv++; diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c index 71e0c56a51c8..05578489435f 100644 --- a/Zend/zend_execute_API.c +++ b/Zend/zend_execute_API.c @@ -1899,8 +1899,23 @@ ZEND_API void zend_detach_symbol_table(zend_execute_data *execute_data) /* {{{ * zend_string **str = op_array->vars; zend_string **end = str + op_array->last_var; zval *var = EX_VAR_NUM(0); + zend_property_info **cv_types = op_array->cv_types; + uint32_t i = 0; do { + /* A typed local that was aliased by a reference attached its op_array-owned + * type as a source on that reference (see zend_assign_to_typed_cv_reference). + * The CV is about to be moved out of the op_array's frame into the symbol + * table; remove the source first so the reference never carries a dangling + * type-source pointer once the op_array (and its cv_types) is gone. Frame + * teardown either calls i_free_compiled_variables() OR this function, never + * both, so the ADD/DEL bookkeeping stays balanced one-per-CV-slot. */ + if (UNEXPECTED(cv_types != NULL) + && UNEXPECTED(cv_types[i] != NULL) + && Z_ISREF_P(var) + && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(var))) { + ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(var), cv_types[i]); + } if (Z_TYPE_P(var) == IS_UNDEF) { zend_hash_del(ht, *str); } else { @@ -1909,6 +1924,7 @@ ZEND_API void zend_detach_symbol_table(zend_execute_data *execute_data) /* {{{ * } str++; var++; + i++; } while (str != end); } } diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index a2a22ee8daa7..e4ce2c2f0d6b 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -2912,7 +2912,25 @@ ZEND_VM_HANDLER(30, ZEND_ASSIGN_REF, VAR|CV, VAR|CV, SRC) variable_ptr = zend_wrong_assign_to_variable_reference( variable_ptr, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC); } else { - zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage); + /* Typed local variables: if either side of `$target = &$source` is a typed + * CV, route through a helper that enforces the type and attaches it as a + * source on the resulting (shared) reference. Only IS_CV operands can be + * typed locals. */ + zend_property_info *target_info = NULL, *source_info = NULL; + if (UNEXPECTED(EX(func)->op_array.cv_types != NULL)) { + if (OP1_TYPE == IS_CV) { + target_info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + } + if (OP2_TYPE == IS_CV) { + source_info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op2.var)]; + } + } + if (UNEXPECTED(target_info || source_info)) { + variable_ptr = zend_assign_to_typed_cv_reference( + target_info, source_info, variable_ptr, value_ptr, &garbage EXECUTE_DATA_CC); + } else { + zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage); + } } if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -5171,6 +5189,11 @@ ZEND_VM_HANDLER(67, ZEND_SEND_REF, VAR|CV, CONST|UNUSED|NUM) Z_ADDREF_P(varptr); } else { ZVAL_MAKE_REF_EX(varptr, 2); + /* Typed local passed by reference: attach its type to the new reference so + * the callee cannot write through it in a type-violating way. */ + if (OP1_TYPE == IS_CV && UNEXPECTED(EX(func)->op_array.cv_types != NULL)) { + zend_attach_cv_type_source_ex(&EX(func)->op_array, opline->op1.var, Z_REF_P(varptr)); + } } ZVAL_REF(arg, Z_REF_P(varptr)); @@ -5208,6 +5231,10 @@ ZEND_VM_C_LABEL(send_var_by_ref): Z_ADDREF_P(varptr); } else { ZVAL_MAKE_REF_EX(varptr, 2); + /* Typed local passed by reference: enforce the type on the new reference. */ + if (OP1_TYPE == IS_CV && UNEXPECTED(EX(func)->op_array.cv_types != NULL)) { + zend_attach_cv_type_source_ex(&EX(func)->op_array, opline->op1.var, Z_REF_P(varptr)); + } } ZVAL_REF(arg, Z_REF_P(varptr)); @@ -9373,16 +9400,28 @@ ZEND_VM_HANDLER(140, ZEND_MAKE_REF, VAR|CV, UNUSED) zval *op1 = EX_VAR(opline->op1.var); if (OP1_TYPE == IS_CV) { + zend_property_info *cv_info = NULL; + if (UNEXPECTED(EX(func)->op_array.cv_types != NULL)) { + cv_info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + } if (UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { ZVAL_NEW_EMPTY_REF(op1); Z_SET_REFCOUNT_P(op1, 2); ZVAL_NULL(Z_REFVAL_P(op1)); + /* Newly created reference for a typed local: attach its type. */ + if (UNEXPECTED(cv_info != NULL)) { + ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(op1), cv_info); + } ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1)); } else { if (Z_ISREF_P(op1)) { Z_ADDREF_P(op1); } else { ZVAL_MAKE_REF_EX(op1, 2); + /* Newly created reference for a typed local: attach its type. */ + if (UNEXPECTED(cv_info != NULL)) { + ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(op1), cv_info); + } } ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1)); } diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index da05ddb05d52..66985d028633 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -25816,6 +25816,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_REF_SPEC Z_ADDREF_P(varptr); } else { ZVAL_MAKE_REF_EX(varptr, 2); + /* Typed local passed by reference: attach its type to the new reference so + * the callee cannot write through it in a type-violating way. */ + if (IS_VAR == IS_CV && UNEXPECTED(EX(func)->op_array.cv_types != NULL)) { + zend_attach_cv_type_source_ex(&EX(func)->op_array, opline->op1.var, Z_REF_P(varptr)); + } } ZVAL_REF(arg, Z_REF_P(varptr)); @@ -25853,6 +25858,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_VAR_EX_S Z_ADDREF_P(varptr); } else { ZVAL_MAKE_REF_EX(varptr, 2); + /* Typed local passed by reference: enforce the type on the new reference. */ + if (IS_VAR == IS_CV && UNEXPECTED(EX(func)->op_array.cv_types != NULL)) { + zend_attach_cv_type_source_ex(&EX(func)->op_array, opline->op1.var, Z_REF_P(varptr)); + } } ZVAL_REF(arg, Z_REF_P(varptr)); @@ -28765,7 +28774,25 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_REF_SP variable_ptr = zend_wrong_assign_to_variable_reference( variable_ptr, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC); } else { - zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage); + /* Typed local variables: if either side of `$target = &$source` is a typed + * CV, route through a helper that enforces the type and attaches it as a + * source on the resulting (shared) reference. Only IS_CV operands can be + * typed locals. */ + zend_property_info *target_info = NULL, *source_info = NULL; + if (UNEXPECTED(EX(func)->op_array.cv_types != NULL)) { + if (IS_VAR == IS_CV) { + target_info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + } + if (IS_VAR == IS_CV) { + source_info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op2.var)]; + } + } + if (UNEXPECTED(target_info || source_info)) { + variable_ptr = zend_assign_to_typed_cv_reference( + target_info, source_info, variable_ptr, value_ptr, &garbage EXECUTE_DATA_CC); + } else { + zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage); + } } if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -29851,6 +29878,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_REF_SPEC Z_ADDREF_P(varptr); } else { ZVAL_MAKE_REF_EX(varptr, 2); + /* Typed local passed by reference: attach its type to the new reference so + * the callee cannot write through it in a type-violating way. */ + if (IS_VAR == IS_CV && UNEXPECTED(EX(func)->op_array.cv_types != NULL)) { + zend_attach_cv_type_source_ex(&EX(func)->op_array, opline->op1.var, Z_REF_P(varptr)); + } } ZVAL_REF(arg, Z_REF_P(varptr)); @@ -29888,6 +29920,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_VAR_EX_S Z_ADDREF_P(varptr); } else { ZVAL_MAKE_REF_EX(varptr, 2); + /* Typed local passed by reference: enforce the type on the new reference. */ + if (IS_VAR == IS_CV && UNEXPECTED(EX(func)->op_array.cv_types != NULL)) { + zend_attach_cv_type_source_ex(&EX(func)->op_array, opline->op1.var, Z_REF_P(varptr)); + } } ZVAL_REF(arg, Z_REF_P(varptr)); @@ -29954,6 +29990,10 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_S Z_ADDREF_P(varptr); } else { ZVAL_MAKE_REF_EX(varptr, 2); + /* Typed local passed by reference: enforce the type on the new reference. */ + if (IS_VAR == IS_CV && UNEXPECTED(EX(func)->op_array.cv_types != NULL)) { + zend_attach_cv_type_source_ex(&EX(func)->op_array, opline->op1.var, Z_REF_P(varptr)); + } } ZVAL_REF(arg, Z_REF_P(varptr)); @@ -30385,16 +30425,28 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_MAKE_REF_SPEC zval *op1 = EX_VAR(opline->op1.var); if (IS_VAR == IS_CV) { + zend_property_info *cv_info = NULL; + if (UNEXPECTED(EX(func)->op_array.cv_types != NULL)) { + cv_info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + } if (UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { ZVAL_NEW_EMPTY_REF(op1); Z_SET_REFCOUNT_P(op1, 2); ZVAL_NULL(Z_REFVAL_P(op1)); + /* Newly created reference for a typed local: attach its type. */ + if (UNEXPECTED(cv_info != NULL)) { + ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(op1), cv_info); + } ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1)); } else { if (Z_ISREF_P(op1)) { Z_ADDREF_P(op1); } else { ZVAL_MAKE_REF_EX(op1, 2); + /* Newly created reference for a typed local: attach its type. */ + if (UNEXPECTED(cv_info != NULL)) { + ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(op1), cv_info); + } } ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1)); } @@ -31987,7 +32039,25 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_REF_SP variable_ptr = zend_wrong_assign_to_variable_reference( variable_ptr, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC); } else { - zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage); + /* Typed local variables: if either side of `$target = &$source` is a typed + * CV, route through a helper that enforces the type and attaches it as a + * source on the resulting (shared) reference. Only IS_CV operands can be + * typed locals. */ + zend_property_info *target_info = NULL, *source_info = NULL; + if (UNEXPECTED(EX(func)->op_array.cv_types != NULL)) { + if (IS_VAR == IS_CV) { + target_info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + } + if (IS_CV == IS_CV) { + source_info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op2.var)]; + } + } + if (UNEXPECTED(target_info || source_info)) { + variable_ptr = zend_assign_to_typed_cv_reference( + target_info, source_info, variable_ptr, value_ptr, &garbage EXECUTE_DATA_CC); + } else { + zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage); + } } if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -44041,6 +44111,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_REF_SPEC Z_ADDREF_P(varptr); } else { ZVAL_MAKE_REF_EX(varptr, 2); + /* Typed local passed by reference: attach its type to the new reference so + * the callee cannot write through it in a type-violating way. */ + if (IS_CV == IS_CV && UNEXPECTED(EX(func)->op_array.cv_types != NULL)) { + zend_attach_cv_type_source_ex(&EX(func)->op_array, opline->op1.var, Z_REF_P(varptr)); + } } ZVAL_REF(arg, Z_REF_P(varptr)); @@ -44079,6 +44154,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_VAR_EX_S Z_ADDREF_P(varptr); } else { ZVAL_MAKE_REF_EX(varptr, 2); + /* Typed local passed by reference: enforce the type on the new reference. */ + if (IS_CV == IS_CV && UNEXPECTED(EX(func)->op_array.cv_types != NULL)) { + zend_attach_cv_type_source_ex(&EX(func)->op_array, opline->op1.var, Z_REF_P(varptr)); + } } ZVAL_REF(arg, Z_REF_P(varptr)); @@ -48490,7 +48569,25 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_REF_SP variable_ptr = zend_wrong_assign_to_variable_reference( variable_ptr, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC); } else { - zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage); + /* Typed local variables: if either side of `$target = &$source` is a typed + * CV, route through a helper that enforces the type and attaches it as a + * source on the resulting (shared) reference. Only IS_CV operands can be + * typed locals. */ + zend_property_info *target_info = NULL, *source_info = NULL; + if (UNEXPECTED(EX(func)->op_array.cv_types != NULL)) { + if (IS_CV == IS_CV) { + target_info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + } + if (IS_VAR == IS_CV) { + source_info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op2.var)]; + } + } + if (UNEXPECTED(target_info || source_info)) { + variable_ptr = zend_assign_to_typed_cv_reference( + target_info, source_info, variable_ptr, value_ptr, &garbage EXECUTE_DATA_CC); + } else { + zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage); + } } if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -49462,6 +49559,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_REF_SPEC Z_ADDREF_P(varptr); } else { ZVAL_MAKE_REF_EX(varptr, 2); + /* Typed local passed by reference: attach its type to the new reference so + * the callee cannot write through it in a type-violating way. */ + if (IS_CV == IS_CV && UNEXPECTED(EX(func)->op_array.cv_types != NULL)) { + zend_attach_cv_type_source_ex(&EX(func)->op_array, opline->op1.var, Z_REF_P(varptr)); + } } ZVAL_REF(arg, Z_REF_P(varptr)); @@ -49500,6 +49602,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_VAR_EX_S Z_ADDREF_P(varptr); } else { ZVAL_MAKE_REF_EX(varptr, 2); + /* Typed local passed by reference: enforce the type on the new reference. */ + if (IS_CV == IS_CV && UNEXPECTED(EX(func)->op_array.cv_types != NULL)) { + zend_attach_cv_type_source_ex(&EX(func)->op_array, opline->op1.var, Z_REF_P(varptr)); + } } ZVAL_REF(arg, Z_REF_P(varptr)); @@ -49567,6 +49673,10 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_S Z_ADDREF_P(varptr); } else { ZVAL_MAKE_REF_EX(varptr, 2); + /* Typed local passed by reference: enforce the type on the new reference. */ + if (IS_CV == IS_CV && UNEXPECTED(EX(func)->op_array.cv_types != NULL)) { + zend_attach_cv_type_source_ex(&EX(func)->op_array, opline->op1.var, Z_REF_P(varptr)); + } } ZVAL_REF(arg, Z_REF_P(varptr)); @@ -50072,16 +50182,28 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_MAKE_REF_SPEC zval *op1 = EX_VAR(opline->op1.var); if (IS_CV == IS_CV) { + zend_property_info *cv_info = NULL; + if (UNEXPECTED(EX(func)->op_array.cv_types != NULL)) { + cv_info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + } if (UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { ZVAL_NEW_EMPTY_REF(op1); Z_SET_REFCOUNT_P(op1, 2); ZVAL_NULL(Z_REFVAL_P(op1)); + /* Newly created reference for a typed local: attach its type. */ + if (UNEXPECTED(cv_info != NULL)) { + ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(op1), cv_info); + } ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1)); } else { if (Z_ISREF_P(op1)) { Z_ADDREF_P(op1); } else { ZVAL_MAKE_REF_EX(op1, 2); + /* Newly created reference for a typed local: attach its type. */ + if (UNEXPECTED(cv_info != NULL)) { + ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(op1), cv_info); + } } ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1)); } @@ -52744,7 +52866,25 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_REF_SP variable_ptr = zend_wrong_assign_to_variable_reference( variable_ptr, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC); } else { - zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage); + /* Typed local variables: if either side of `$target = &$source` is a typed + * CV, route through a helper that enforces the type and attaches it as a + * source on the resulting (shared) reference. Only IS_CV operands can be + * typed locals. */ + zend_property_info *target_info = NULL, *source_info = NULL; + if (UNEXPECTED(EX(func)->op_array.cv_types != NULL)) { + if (IS_CV == IS_CV) { + target_info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + } + if (IS_CV == IS_CV) { + source_info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op2.var)]; + } + } + if (UNEXPECTED(target_info || source_info)) { + variable_ptr = zend_assign_to_typed_cv_reference( + target_info, source_info, variable_ptr, value_ptr, &garbage EXECUTE_DATA_CC); + } else { + zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage); + } } if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -78528,6 +78668,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_REF_SPEC_VAR_ Z_ADDREF_P(varptr); } else { ZVAL_MAKE_REF_EX(varptr, 2); + /* Typed local passed by reference: attach its type to the new reference so + * the callee cannot write through it in a type-violating way. */ + if (IS_VAR == IS_CV && UNEXPECTED(EX(func)->op_array.cv_types != NULL)) { + zend_attach_cv_type_source_ex(&EX(func)->op_array, opline->op1.var, Z_REF_P(varptr)); + } } ZVAL_REF(arg, Z_REF_P(varptr)); @@ -78565,6 +78710,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_VAR_EX_SPEC_V Z_ADDREF_P(varptr); } else { ZVAL_MAKE_REF_EX(varptr, 2); + /* Typed local passed by reference: enforce the type on the new reference. */ + if (IS_VAR == IS_CV && UNEXPECTED(EX(func)->op_array.cv_types != NULL)) { + zend_attach_cv_type_source_ex(&EX(func)->op_array, opline->op1.var, Z_REF_P(varptr)); + } } ZVAL_REF(arg, Z_REF_P(varptr)); @@ -81477,7 +81626,25 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_REF_SPEC_VA variable_ptr = zend_wrong_assign_to_variable_reference( variable_ptr, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC); } else { - zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage); + /* Typed local variables: if either side of `$target = &$source` is a typed + * CV, route through a helper that enforces the type and attaches it as a + * source on the resulting (shared) reference. Only IS_CV operands can be + * typed locals. */ + zend_property_info *target_info = NULL, *source_info = NULL; + if (UNEXPECTED(EX(func)->op_array.cv_types != NULL)) { + if (IS_VAR == IS_CV) { + target_info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + } + if (IS_VAR == IS_CV) { + source_info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op2.var)]; + } + } + if (UNEXPECTED(target_info || source_info)) { + variable_ptr = zend_assign_to_typed_cv_reference( + target_info, source_info, variable_ptr, value_ptr, &garbage EXECUTE_DATA_CC); + } else { + zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage); + } } if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -82563,6 +82730,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_REF_SPEC_VAR_ Z_ADDREF_P(varptr); } else { ZVAL_MAKE_REF_EX(varptr, 2); + /* Typed local passed by reference: attach its type to the new reference so + * the callee cannot write through it in a type-violating way. */ + if (IS_VAR == IS_CV && UNEXPECTED(EX(func)->op_array.cv_types != NULL)) { + zend_attach_cv_type_source_ex(&EX(func)->op_array, opline->op1.var, Z_REF_P(varptr)); + } } ZVAL_REF(arg, Z_REF_P(varptr)); @@ -82600,6 +82772,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_VAR_EX_SPEC_V Z_ADDREF_P(varptr); } else { ZVAL_MAKE_REF_EX(varptr, 2); + /* Typed local passed by reference: enforce the type on the new reference. */ + if (IS_VAR == IS_CV && UNEXPECTED(EX(func)->op_array.cv_types != NULL)) { + zend_attach_cv_type_source_ex(&EX(func)->op_array, opline->op1.var, Z_REF_P(varptr)); + } } ZVAL_REF(arg, Z_REF_P(varptr)); @@ -82666,6 +82842,10 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_V Z_ADDREF_P(varptr); } else { ZVAL_MAKE_REF_EX(varptr, 2); + /* Typed local passed by reference: enforce the type on the new reference. */ + if (IS_VAR == IS_CV && UNEXPECTED(EX(func)->op_array.cv_types != NULL)) { + zend_attach_cv_type_source_ex(&EX(func)->op_array, opline->op1.var, Z_REF_P(varptr)); + } } ZVAL_REF(arg, Z_REF_P(varptr)); @@ -83097,16 +83277,28 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_MAKE_REF_SPEC_VAR_ zval *op1 = EX_VAR(opline->op1.var); if (IS_VAR == IS_CV) { + zend_property_info *cv_info = NULL; + if (UNEXPECTED(EX(func)->op_array.cv_types != NULL)) { + cv_info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + } if (UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { ZVAL_NEW_EMPTY_REF(op1); Z_SET_REFCOUNT_P(op1, 2); ZVAL_NULL(Z_REFVAL_P(op1)); + /* Newly created reference for a typed local: attach its type. */ + if (UNEXPECTED(cv_info != NULL)) { + ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(op1), cv_info); + } ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1)); } else { if (Z_ISREF_P(op1)) { Z_ADDREF_P(op1); } else { ZVAL_MAKE_REF_EX(op1, 2); + /* Newly created reference for a typed local: attach its type. */ + if (UNEXPECTED(cv_info != NULL)) { + ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(op1), cv_info); + } } ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1)); } @@ -84699,7 +84891,25 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_REF_SPEC_VA variable_ptr = zend_wrong_assign_to_variable_reference( variable_ptr, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC); } else { - zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage); + /* Typed local variables: if either side of `$target = &$source` is a typed + * CV, route through a helper that enforces the type and attaches it as a + * source on the resulting (shared) reference. Only IS_CV operands can be + * typed locals. */ + zend_property_info *target_info = NULL, *source_info = NULL; + if (UNEXPECTED(EX(func)->op_array.cv_types != NULL)) { + if (IS_VAR == IS_CV) { + target_info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + } + if (IS_CV == IS_CV) { + source_info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op2.var)]; + } + } + if (UNEXPECTED(target_info || source_info)) { + variable_ptr = zend_assign_to_typed_cv_reference( + target_info, source_info, variable_ptr, value_ptr, &garbage EXECUTE_DATA_CC); + } else { + zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage); + } } if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -96753,6 +96963,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_REF_SPEC_CV_C Z_ADDREF_P(varptr); } else { ZVAL_MAKE_REF_EX(varptr, 2); + /* Typed local passed by reference: attach its type to the new reference so + * the callee cannot write through it in a type-violating way. */ + if (IS_CV == IS_CV && UNEXPECTED(EX(func)->op_array.cv_types != NULL)) { + zend_attach_cv_type_source_ex(&EX(func)->op_array, opline->op1.var, Z_REF_P(varptr)); + } } ZVAL_REF(arg, Z_REF_P(varptr)); @@ -96791,6 +97006,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_VAR_EX_SPEC_C Z_ADDREF_P(varptr); } else { ZVAL_MAKE_REF_EX(varptr, 2); + /* Typed local passed by reference: enforce the type on the new reference. */ + if (IS_CV == IS_CV && UNEXPECTED(EX(func)->op_array.cv_types != NULL)) { + zend_attach_cv_type_source_ex(&EX(func)->op_array, opline->op1.var, Z_REF_P(varptr)); + } } ZVAL_REF(arg, Z_REF_P(varptr)); @@ -101202,7 +101421,25 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_REF_SPEC_CV variable_ptr = zend_wrong_assign_to_variable_reference( variable_ptr, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC); } else { - zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage); + /* Typed local variables: if either side of `$target = &$source` is a typed + * CV, route through a helper that enforces the type and attaches it as a + * source on the resulting (shared) reference. Only IS_CV operands can be + * typed locals. */ + zend_property_info *target_info = NULL, *source_info = NULL; + if (UNEXPECTED(EX(func)->op_array.cv_types != NULL)) { + if (IS_CV == IS_CV) { + target_info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + } + if (IS_VAR == IS_CV) { + source_info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op2.var)]; + } + } + if (UNEXPECTED(target_info || source_info)) { + variable_ptr = zend_assign_to_typed_cv_reference( + target_info, source_info, variable_ptr, value_ptr, &garbage EXECUTE_DATA_CC); + } else { + zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage); + } } if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -102072,6 +102309,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_REF_SPEC_CV_U Z_ADDREF_P(varptr); } else { ZVAL_MAKE_REF_EX(varptr, 2); + /* Typed local passed by reference: attach its type to the new reference so + * the callee cannot write through it in a type-violating way. */ + if (IS_CV == IS_CV && UNEXPECTED(EX(func)->op_array.cv_types != NULL)) { + zend_attach_cv_type_source_ex(&EX(func)->op_array, opline->op1.var, Z_REF_P(varptr)); + } } ZVAL_REF(arg, Z_REF_P(varptr)); @@ -102110,6 +102352,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_VAR_EX_SPEC_C Z_ADDREF_P(varptr); } else { ZVAL_MAKE_REF_EX(varptr, 2); + /* Typed local passed by reference: enforce the type on the new reference. */ + if (IS_CV == IS_CV && UNEXPECTED(EX(func)->op_array.cv_types != NULL)) { + zend_attach_cv_type_source_ex(&EX(func)->op_array, opline->op1.var, Z_REF_P(varptr)); + } } ZVAL_REF(arg, Z_REF_P(varptr)); @@ -102177,6 +102423,10 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_V Z_ADDREF_P(varptr); } else { ZVAL_MAKE_REF_EX(varptr, 2); + /* Typed local passed by reference: enforce the type on the new reference. */ + if (IS_CV == IS_CV && UNEXPECTED(EX(func)->op_array.cv_types != NULL)) { + zend_attach_cv_type_source_ex(&EX(func)->op_array, opline->op1.var, Z_REF_P(varptr)); + } } ZVAL_REF(arg, Z_REF_P(varptr)); @@ -102682,16 +102932,28 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_MAKE_REF_SPEC_CV_U zval *op1 = EX_VAR(opline->op1.var); if (IS_CV == IS_CV) { + zend_property_info *cv_info = NULL; + if (UNEXPECTED(EX(func)->op_array.cv_types != NULL)) { + cv_info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + } if (UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { ZVAL_NEW_EMPTY_REF(op1); Z_SET_REFCOUNT_P(op1, 2); ZVAL_NULL(Z_REFVAL_P(op1)); + /* Newly created reference for a typed local: attach its type. */ + if (UNEXPECTED(cv_info != NULL)) { + ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(op1), cv_info); + } ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1)); } else { if (Z_ISREF_P(op1)) { Z_ADDREF_P(op1); } else { ZVAL_MAKE_REF_EX(op1, 2); + /* Newly created reference for a typed local: attach its type. */ + if (UNEXPECTED(cv_info != NULL)) { + ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(op1), cv_info); + } } ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1)); } @@ -105354,7 +105616,25 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_REF_SPEC_CV variable_ptr = zend_wrong_assign_to_variable_reference( variable_ptr, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC); } else { - zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage); + /* Typed local variables: if either side of `$target = &$source` is a typed + * CV, route through a helper that enforces the type and attaches it as a + * source on the resulting (shared) reference. Only IS_CV operands can be + * typed locals. */ + zend_property_info *target_info = NULL, *source_info = NULL; + if (UNEXPECTED(EX(func)->op_array.cv_types != NULL)) { + if (IS_CV == IS_CV) { + target_info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + } + if (IS_CV == IS_CV) { + source_info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op2.var)]; + } + } + if (UNEXPECTED(target_info || source_info)) { + variable_ptr = zend_assign_to_typed_cv_reference( + target_info, source_info, variable_ptr, value_ptr, &garbage EXECUTE_DATA_CC); + } else { + zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage); + } } if (UNEXPECTED(RETURN_VALUE_USED(opline))) { diff --git a/tests/lang/typed_locals/ref_alias_enforced.phpt b/tests/lang/typed_locals/ref_alias_enforced.phpt new file mode 100644 index 000000000000..7c805a765f20 --- /dev/null +++ b/tests/lang/typed_locals/ref_alias_enforced.phpt @@ -0,0 +1,32 @@ +--TEST-- +Typed local variables: writes through an alias reference ($y = &$x) are type-checked +--FILE-- +getMessage(), "\n"; +} +var_dump($x); + +// A coercible write through the alias succeeds and is coerced. +$y = "5"; +var_dump($x); + +// Writing through the original variable is enforced too (shared reference). +try { + $x = []; +} catch (\TypeError $e) { + echo $e->getMessage(), "\n"; +} +var_dump($x); +?> +--EXPECT-- +Cannot assign string to reference held by local variable $x of type int +int(1) +int(5) +Cannot assign array to local variable $x of type int +int(5) diff --git a/tests/lang/typed_locals/ref_byref_param.phpt b/tests/lang/typed_locals/ref_byref_param.phpt new file mode 100644 index 000000000000..8be486d94df7 --- /dev/null +++ b/tests/lang/typed_locals/ref_byref_param.phpt @@ -0,0 +1,25 @@ +--TEST-- +Typed local variables: passing one by reference enforces its type on writes by the callee +--FILE-- + coerced. +int $a = 1; +coerce($a); +var_dump($a); + +// Weak mode: callee writes a non-coercible value -> TypeError, value unchanged. +int $b = 2; +try { + bad($b); +} catch (\TypeError $e) { + echo $e->getMessage(), "\n"; +} +var_dump($b); +?> +--EXPECT-- +int(5) +Cannot assign string to reference held by local variable $b of type int +int(2) diff --git a/tests/lang/typed_locals/ref_byref_param_strict.phpt b/tests/lang/typed_locals/ref_byref_param_strict.phpt new file mode 100644 index 000000000000..2cf136d4c788 --- /dev/null +++ b/tests/lang/typed_locals/ref_byref_param_strict.phpt @@ -0,0 +1,19 @@ +--TEST-- +Typed local variables: by-reference parameter is enforced under strict_types +--FILE-- + +--EXPECT-- +TypeError +int(1) diff --git a/tests/lang/typed_locals/ref_forbid_foreach.phpt b/tests/lang/typed_locals/ref_forbid_foreach.phpt new file mode 100644 index 000000000000..4183a6e35742 --- /dev/null +++ b/tests/lang/typed_locals/ref_forbid_foreach.phpt @@ -0,0 +1,10 @@ +--TEST-- +Typed local variables: using a typed local as a foreach by-reference value is a compile error +--FILE-- + +--EXPECTF-- +Fatal error: Cannot use typed local variable $x as foreach by-reference value in %s on line %d diff --git a/tests/lang/typed_locals/ref_forbid_global.phpt b/tests/lang/typed_locals/ref_forbid_global.phpt new file mode 100644 index 000000000000..87abae55a639 --- /dev/null +++ b/tests/lang/typed_locals/ref_forbid_global.phpt @@ -0,0 +1,9 @@ +--TEST-- +Typed local variables: using a typed local as a global is a compile error +--FILE-- + +--EXPECTF-- +Fatal error: Cannot use typed local variable $x as global variable in %s on line %d diff --git a/tests/lang/typed_locals/ref_forbid_static.phpt b/tests/lang/typed_locals/ref_forbid_static.phpt new file mode 100644 index 000000000000..c98b41cc8baa --- /dev/null +++ b/tests/lang/typed_locals/ref_forbid_static.phpt @@ -0,0 +1,12 @@ +--TEST-- +Typed local variables: using a typed local as a static variable is a compile error +--FILE-- + +--EXPECTF-- +Fatal error: Cannot use typed local variable $x as static variable in %s on line %d diff --git a/tests/lang/typed_locals/ref_target_typed.phpt b/tests/lang/typed_locals/ref_target_typed.phpt new file mode 100644 index 000000000000..55e445080da4 --- /dev/null +++ b/tests/lang/typed_locals/ref_target_typed.phpt @@ -0,0 +1,34 @@ +--TEST-- +Typed local variables: aliasing a typed local to a source ($typed = &$src) checks the source value +--FILE-- +getMessage(), "\n"; +} +var_dump($y, $s); + +// A compatible source aliases fine, and the type is then enforced on the shared reference. +$n = 7; +int $z = 0; +$z = &$n; +$n = 9; +var_dump($z); +try { + $n = "nope"; +} catch (\TypeError $e) { + echo "TypeError\n"; +} +var_dump($z); +?> +--EXPECT-- +Cannot assign string to local variable $y of type int +int(0) +string(3) "abc" +int(9) +TypeError +int(9) From 9f40730de1488ed8025367fa6fc65fe578c6c190 Mon Sep 17 00:00:00 2001 From: Michal Kral Date: Tue, 16 Jun 2026 00:15:27 +0200 Subject: [PATCH 10/14] feat(engine): enforce typed locals on compound assignment and inc/dec --- Zend/zend_compile.c | 42 +- Zend/zend_execute.c | 66 +- Zend/zend_vm_def.h | 183 ++++ Zend/zend_vm_execute.h | 900 ++++++++++++++++-- Zend/zend_vm_handlers.h | 781 +++++++-------- Zend/zend_vm_opcodes.c | 14 +- Zend/zend_vm_opcodes.h | 7 +- .../compound_assign_enforced.phpt | 42 + .../compound_assign_strict_error.phpt | 16 + .../compound_incdec_via_ref_enforced.phpt | 34 + tests/lang/typed_locals/incdec_enforced.phpt | 32 + .../typed_locals/incdec_overflow_error.phpt | 27 + 12 files changed, 1639 insertions(+), 505 deletions(-) create mode 100644 tests/lang/typed_locals/compound_assign_enforced.phpt create mode 100644 tests/lang/typed_locals/compound_assign_strict_error.phpt create mode 100644 tests/lang/typed_locals/compound_incdec_via_ref_enforced.phpt create mode 100644 tests/lang/typed_locals/incdec_enforced.phpt create mode 100644 tests/lang/typed_locals/incdec_overflow_error.phpt diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index d9defadb68e5..785838debeb7 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -790,6 +790,7 @@ bool zend_op_may_elide_result(uint8_t opcode) case ZEND_ASSIGN_OBJ: case ZEND_ASSIGN_STATIC_PROP: case ZEND_ASSIGN_OP: + case ZEND_ASSIGN_OP_TYPED: case ZEND_ASSIGN_DIM_OP: case ZEND_ASSIGN_OBJ_OP: case ZEND_ASSIGN_STATIC_PROP_OP: @@ -799,6 +800,8 @@ bool zend_op_may_elide_result(uint8_t opcode) case ZEND_PRE_DEC_OBJ: case ZEND_PRE_INC: case ZEND_PRE_DEC: + case ZEND_PRE_INC_TYPED: + case ZEND_PRE_DEC_TYPED: case ZEND_DO_FCALL: case ZEND_DO_ICALL: case ZEND_DO_UCALL: @@ -834,7 +837,9 @@ static void zend_do_free(znode *op1) /* {{{ */ case ZEND_POST_DEC_OBJ: case ZEND_POST_INC: case ZEND_POST_DEC: - /* convert $i++ to ++$i */ + case ZEND_POST_INC_TYPED: + case ZEND_POST_DEC_TYPED: + /* convert $i++ to ++$i (POST_*_TYPED = PRE_*_TYPED + 2) */ opline->opcode -= 2; SET_UNUSED(opline->result); return; @@ -3745,7 +3750,18 @@ static void zend_compile_compound_assign(znode *result, zend_ast *ast) /* {{{ */ zend_delayed_compile_var(&var_node, var_ast, BP_VAR_RW, false); zend_compile_expr(&expr_node, expr_ast); zend_delayed_compile_end(offset); - opline = zend_emit_op_tmp(result, ZEND_ASSIGN_OP, &var_node, &expr_node); + /* If the target is a typed local CV, enforce the declared type on the + * result of the compound operation by emitting ZEND_ASSIGN_OP_TYPED + * instead of plain ZEND_ASSIGN_OP, mirroring the ZEND_ASSIGN_TYPED + * choice in zend_compile_assign(). Only simple CV targets are typed; + * dynamic/auto-global $$vars compile to a non-CV var_node and fall + * through to plain ZEND_ASSIGN_OP unchanged. */ + if (var_node.op_type == IS_CV && CG(active_op_array)->cv_types + && CG(active_op_array)->cv_types[EX_VAR_TO_NUM(var_node.u.op.var)]) { + opline = zend_emit_op_tmp(result, ZEND_ASSIGN_OP_TYPED, &var_node, &expr_node); + } else { + opline = zend_emit_op_tmp(result, ZEND_ASSIGN_OP, &var_node, &expr_node); + } opline->extended_value = opcode; return; case ZEND_AST_STATIC_PROP: @@ -10795,8 +10811,15 @@ static void zend_compile_post_incdec(znode *result, const zend_ast *ast) /* {{{ if (opline && opline->opcode == ZEND_FETCH_DIM_RW) { opline->extended_value = ZEND_FETCH_DIM_INCDEC; } - zend_emit_op_tmp(result, ast->kind == ZEND_AST_POST_INC ? ZEND_POST_INC : ZEND_POST_DEC, - &var_node, NULL); + /* Typed local CV: emit the type-enforcing variant (see ZEND_PRE_INC_TYPED). */ + uint8_t opcode; + if (var_node.op_type == IS_CV && CG(active_op_array)->cv_types + && CG(active_op_array)->cv_types[EX_VAR_TO_NUM(var_node.u.op.var)]) { + opcode = ast->kind == ZEND_AST_POST_INC ? ZEND_POST_INC_TYPED : ZEND_POST_DEC_TYPED; + } else { + opcode = ast->kind == ZEND_AST_POST_INC ? ZEND_POST_INC : ZEND_POST_DEC; + } + zend_emit_op_tmp(result, opcode, &var_node, NULL); } } /* }}} */ @@ -10824,8 +10847,15 @@ static void zend_compile_pre_incdec(znode *result, const zend_ast *ast) /* {{{ * if (opline && opline->opcode == ZEND_FETCH_DIM_RW) { opline->extended_value = ZEND_FETCH_DIM_INCDEC; } - zend_emit_op_tmp(result, ast->kind == ZEND_AST_PRE_INC ? ZEND_PRE_INC : ZEND_PRE_DEC, - &var_node, NULL); + /* Typed local CV: emit the type-enforcing variant (see ZEND_PRE_INC_TYPED). */ + uint8_t opcode; + if (var_node.op_type == IS_CV && CG(active_op_array)->cv_types + && CG(active_op_array)->cv_types[EX_VAR_TO_NUM(var_node.u.op.var)]) { + opcode = ast->kind == ZEND_AST_PRE_INC ? ZEND_PRE_INC_TYPED : ZEND_PRE_DEC_TYPED; + } else { + opcode = ast->kind == ZEND_AST_PRE_INC ? ZEND_PRE_INC : ZEND_PRE_DEC; + } + zend_emit_op_tmp(result, opcode, &var_node, NULL); } } /* }}} */ diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c index 6d8402de6301..2cb4e34f3dd1 100644 --- a/Zend/zend_execute.c +++ b/Zend/zend_execute.c @@ -2296,19 +2296,35 @@ static zend_never_inline ZEND_COLD zend_long zend_throw_incdec_ref_error(const z { zend_string *type_str = zend_type_to_string(error_prop->type); if (ZEND_IS_INCREMENT(opline->opcode)) { - zend_type_error( - "Cannot increment a reference held by property %s::$%s of type %s past its maximal value", - ZSTR_VAL(error_prop->ce->name), - zend_get_unmangled_property_name(error_prop->name), - ZSTR_VAL(type_str)); + if (error_prop->ce) { + zend_type_error( + "Cannot increment a reference held by property %s::$%s of type %s past its maximal value", + ZSTR_VAL(error_prop->ce->name), + zend_get_unmangled_property_name(error_prop->name), + ZSTR_VAL(type_str)); + } else { + /* Synthesized info for a typed local variable (ce == NULL). */ + zend_type_error( + "Cannot increment a reference held by local variable $%s of type %s past its maximal value", + ZSTR_VAL(error_prop->name), + ZSTR_VAL(type_str)); + } zend_string_release(type_str); return ZEND_LONG_MAX; } else { - zend_type_error( - "Cannot decrement a reference held by property %s::$%s of type %s past its minimal value", - ZSTR_VAL(error_prop->ce->name), - zend_get_unmangled_property_name(error_prop->name), - ZSTR_VAL(type_str)); + if (error_prop->ce) { + zend_type_error( + "Cannot decrement a reference held by property %s::$%s of type %s past its minimal value", + ZSTR_VAL(error_prop->ce->name), + zend_get_unmangled_property_name(error_prop->name), + ZSTR_VAL(type_str)); + } else { + /* Synthesized info for a typed local variable (ce == NULL). */ + zend_type_error( + "Cannot decrement a reference held by local variable $%s of type %s past its minimal value", + ZSTR_VAL(error_prop->name), + ZSTR_VAL(type_str)); + } zend_string_release(type_str); return ZEND_LONG_MIN; } @@ -2317,17 +2333,31 @@ static zend_never_inline ZEND_COLD zend_long zend_throw_incdec_ref_error(const z static zend_never_inline ZEND_COLD zend_long zend_throw_incdec_prop_error(const zend_property_info *prop OPLINE_DC) { zend_string *type_str = zend_type_to_string(prop->type); if (ZEND_IS_INCREMENT(opline->opcode)) { - zend_type_error("Cannot increment property %s::$%s of type %s past its maximal value", - ZSTR_VAL(prop->ce->name), - zend_get_unmangled_property_name(prop->name), - ZSTR_VAL(type_str)); + if (prop->ce) { + zend_type_error("Cannot increment property %s::$%s of type %s past its maximal value", + ZSTR_VAL(prop->ce->name), + zend_get_unmangled_property_name(prop->name), + ZSTR_VAL(type_str)); + } else { + /* Synthesized info for a typed local variable (ce == NULL). */ + zend_type_error("Cannot increment local variable $%s of type %s past its maximal value", + ZSTR_VAL(prop->name), + ZSTR_VAL(type_str)); + } zend_string_release(type_str); return ZEND_LONG_MAX; } else { - zend_type_error("Cannot decrement property %s::$%s of type %s past its minimal value", - ZSTR_VAL(prop->ce->name), - zend_get_unmangled_property_name(prop->name), - ZSTR_VAL(type_str)); + if (prop->ce) { + zend_type_error("Cannot decrement property %s::$%s of type %s past its minimal value", + ZSTR_VAL(prop->ce->name), + zend_get_unmangled_property_name(prop->name), + ZSTR_VAL(type_str)); + } else { + /* Synthesized info for a typed local variable (ce == NULL). */ + zend_type_error("Cannot decrement local variable $%s of type %s past its minimal value", + ZSTR_VAL(prop->name), + ZSTR_VAL(type_str)); + } zend_string_release(type_str); return ZEND_LONG_MIN; } diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index e4ce2c2f0d6b..7f9c3cad11a3 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -2889,6 +2889,189 @@ ZEND_VM_HANDLER(212, ZEND_ASSIGN_TYPED, CV, CONST|TMP|VAR|CV, SPEC(RETVAL)) ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +/* Compound assignment (`+= -= .= ...`) to a typed local CV. Emitted by the + * compiler in place of ZEND_ASSIGN_OP when op1 is a typed local (cv_types[idx] + * is set), mirroring the ZEND_ASSIGN_TYPED choice. Behaves exactly like the + * typed-property case in ZEND_ASSIGN_OBJ_OP: a typed reference enforces the + * type through its sources, and a plain typed-CV value is routed through + * zend_binary_assign_op_typed_prop (compute via zend_binary_op, then verify / + * coerce against the declared scalar type honoring strict/weak mode). The + * untyped ASSIGN_OP hot path is left untouched. */ +ZEND_VM_HANDLER(213, ZEND_ASSIGN_OP_TYPED, CV, CONST|TMP|CV, OP) +{ + USE_OPLINE + zval *var_ptr; + zval *value; + const zend_property_info *info; + + SAVE_OPLINE(); + value = GET_OP2_ZVAL_PTR(BP_VAR_R); + var_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW); + info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + + do { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) { + zend_reference *ref = Z_REF_P(var_ptr); + var_ptr = Z_REFVAL_P(var_ptr); + if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { + zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC); + break; + } + } + zend_binary_assign_op_typed_prop(info, var_ptr, value OPLINE_CC EXECUTE_DATA_CC); + } while (0); + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + } + + FREE_OP2(); + FREE_OP1(); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +/* ++/-- on a typed local CV. Emitted by the compiler in place of the plain + * ZEND_PRE_INC / ZEND_PRE_DEC / ZEND_POST_INC / ZEND_POST_DEC when op1 is a + * typed local. The increment/decrement is computed first (so int overflow can + * be detected) and then verified against the declared type exactly as for a + * typed property (zend_incdec_typed_prop): an int that overflows to float is + * rejected with a TypeError unless the type admits float, otherwise the value + * is coerced/verified honoring strict/weak mode. A typed reference is handled + * through its sources, matching the untyped helpers. The opcode numbers keep + * the increment/decrement parity required by ZEND_IS_INCREMENT() and the + * POST = PRE + 2 relationship used by zend_do_free()'s $i++ -> ++$i rewrite. */ +ZEND_VM_HANDLER(214, ZEND_PRE_INC_TYPED, CV, ANY) +{ + USE_OPLINE + zval *var_ptr; + const zend_property_info *info; + + SAVE_OPLINE(); + var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW); + info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + + if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); + ZVAL_NULL(var_ptr); + } + + do { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) { + zend_reference *ref = Z_REF_P(var_ptr); + var_ptr = Z_REFVAL_P(var_ptr); + if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { + zend_incdec_typed_ref(ref, NULL OPLINE_CC EXECUTE_DATA_CC); + break; + } + } + zend_incdec_typed_prop(info, var_ptr, NULL OPLINE_CC EXECUTE_DATA_CC); + } while (0); + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + } + + FREE_OP1(); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +ZEND_VM_HANDLER(215, ZEND_PRE_DEC_TYPED, CV, ANY) +{ + USE_OPLINE + zval *var_ptr; + const zend_property_info *info; + + SAVE_OPLINE(); + var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW); + info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + + if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); + ZVAL_NULL(var_ptr); + } + + do { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) { + zend_reference *ref = Z_REF_P(var_ptr); + var_ptr = Z_REFVAL_P(var_ptr); + if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { + zend_incdec_typed_ref(ref, NULL OPLINE_CC EXECUTE_DATA_CC); + break; + } + } + zend_incdec_typed_prop(info, var_ptr, NULL OPLINE_CC EXECUTE_DATA_CC); + } while (0); + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + } + + FREE_OP1(); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +ZEND_VM_HANDLER(216, ZEND_POST_INC_TYPED, CV, ANY) +{ + USE_OPLINE + zval *var_ptr; + const zend_property_info *info; + + SAVE_OPLINE(); + var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW); + info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + + if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); + ZVAL_NULL(var_ptr); + } + + do { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) { + zend_reference *ref = Z_REF_P(var_ptr); + var_ptr = Z_REFVAL_P(var_ptr); + if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { + zend_incdec_typed_ref(ref, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC); + break; + } + } + zend_incdec_typed_prop(info, var_ptr, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC); + } while (0); + + FREE_OP1(); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +ZEND_VM_HANDLER(217, ZEND_POST_DEC_TYPED, CV, ANY) +{ + USE_OPLINE + zval *var_ptr; + const zend_property_info *info; + + SAVE_OPLINE(); + var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW); + info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + + if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); + ZVAL_NULL(var_ptr); + } + + do { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) { + zend_reference *ref = Z_REF_P(var_ptr); + var_ptr = Z_REFVAL_P(var_ptr); + if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { + zend_incdec_typed_ref(ref, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC); + break; + } + } + zend_incdec_typed_prop(info, var_ptr, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC); + } while (0); + + FREE_OP1(); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + ZEND_VM_HANDLER(30, ZEND_ASSIGN_REF, VAR|CV, VAR|CV, SRC) { USE_OPLINE diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 66985d028633..65ceb48525f6 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -39700,6 +39700,138 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ECHO_SPEC_CV_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_PRE_INC_TYPED_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *var_ptr; + const zend_property_info *info; + + SAVE_OPLINE(); + var_ptr = EX_VAR(opline->op1.var); + info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + + if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); + ZVAL_NULL(var_ptr); + } + + do { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) { + zend_reference *ref = Z_REF_P(var_ptr); + var_ptr = Z_REFVAL_P(var_ptr); + if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { + zend_incdec_typed_ref(ref, NULL OPLINE_CC EXECUTE_DATA_CC); + break; + } + } + zend_incdec_typed_prop(info, var_ptr, NULL OPLINE_CC EXECUTE_DATA_CC); + } while (0); + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + } + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_PRE_DEC_TYPED_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *var_ptr; + const zend_property_info *info; + + SAVE_OPLINE(); + var_ptr = EX_VAR(opline->op1.var); + info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + + if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); + ZVAL_NULL(var_ptr); + } + + do { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) { + zend_reference *ref = Z_REF_P(var_ptr); + var_ptr = Z_REFVAL_P(var_ptr); + if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { + zend_incdec_typed_ref(ref, NULL OPLINE_CC EXECUTE_DATA_CC); + break; + } + } + zend_incdec_typed_prop(info, var_ptr, NULL OPLINE_CC EXECUTE_DATA_CC); + } while (0); + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + } + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_POST_INC_TYPED_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *var_ptr; + const zend_property_info *info; + + SAVE_OPLINE(); + var_ptr = EX_VAR(opline->op1.var); + info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + + if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); + ZVAL_NULL(var_ptr); + } + + do { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) { + zend_reference *ref = Z_REF_P(var_ptr); + var_ptr = Z_REFVAL_P(var_ptr); + if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { + zend_incdec_typed_ref(ref, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC); + break; + } + } + zend_incdec_typed_prop(info, var_ptr, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC); + } while (0); + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_POST_DEC_TYPED_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *var_ptr; + const zend_property_info *info; + + SAVE_OPLINE(); + var_ptr = EX_VAR(opline->op1.var); + info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + + if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); + ZVAL_NULL(var_ptr); + } + + do { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) { + zend_reference *ref = Z_REF_P(var_ptr); + var_ptr = Z_REFVAL_P(var_ptr); + if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { + zend_incdec_typed_ref(ref, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC); + break; + } + } + zend_incdec_typed_prop(info, var_ptr, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC); + } while (0); + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_JMPZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -43642,6 +43774,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_TYPED_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +/* Compound assignment (`+= -= .= ...`) to a typed local CV. Emitted by the + * compiler in place of ZEND_ASSIGN_OP when op1 is a typed local (cv_types[idx] + * is set), mirroring the ZEND_ASSIGN_TYPED choice. Behaves exactly like the + * typed-property case in ZEND_ASSIGN_OBJ_OP: a typed reference enforces the + * type through its sources, and a plain typed-CV value is routed through + * zend_binary_assign_op_typed_prop (compute via zend_binary_op, then verify / + * coerce against the declared scalar type honoring strict/weak mode). The + * untyped ASSIGN_OP hot path is left untouched. */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_TYPED_SPEC_CV_CONST_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -43672,6 +43812,58 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_TYPED_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +/* Compound assignment (`+= -= .= ...`) to a typed local CV. Emitted by the + * compiler in place of ZEND_ASSIGN_OP when op1 is a typed local (cv_types[idx] + * is set), mirroring the ZEND_ASSIGN_TYPED choice. Behaves exactly like the + * typed-property case in ZEND_ASSIGN_OBJ_OP: a typed reference enforces the + * type through its sources, and a plain typed-CV value is routed through + * zend_binary_assign_op_typed_prop (compute via zend_binary_op, then verify / + * coerce against the declared scalar type honoring strict/weak mode). The + * untyped ASSIGN_OP hot path is left untouched. */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OP_TYPED_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *var_ptr; + zval *value; + const zend_property_info *info; + + SAVE_OPLINE(); + value = RT_CONSTANT(opline, opline->op2); + var_ptr = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC); + info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + + do { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) { + zend_reference *ref = Z_REF_P(var_ptr); + var_ptr = Z_REFVAL_P(var_ptr); + if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { + zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC); + break; + } + } + zend_binary_assign_op_typed_prop(info, var_ptr, value OPLINE_CC EXECUTE_DATA_CC); + } while (0); + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + } + + + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +/* ++/-- on a typed local CV. Emitted by the compiler in place of the plain + * ZEND_PRE_INC / ZEND_PRE_DEC / ZEND_POST_INC / ZEND_POST_DEC when op1 is a + * typed local. The increment/decrement is computed first (so int overflow can + * be detected) and then verified against the declared type exactly as for a + * typed property (zend_incdec_typed_prop): an int that overflows to float is + * rejected with a TypeError unless the type admits float, otherwise the value + * is coerced/verified honoring strict/weak mode. A typed reference is handled + * through its sources, matching the untyped helpers. The opcode numbers keep + * the increment/decrement parity required by ZEND_IS_INCREMENT() and the + * POST = PRE + 2 relationship used by zend_do_free()'s $i++ -> ++$i rewrite. */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -47528,6 +47720,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_TYPED_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +/* Compound assignment (`+= -= .= ...`) to a typed local CV. Emitted by the + * compiler in place of ZEND_ASSIGN_OP when op1 is a typed local (cv_types[idx] + * is set), mirroring the ZEND_ASSIGN_TYPED choice. Behaves exactly like the + * typed-property case in ZEND_ASSIGN_OBJ_OP: a typed reference enforces the + * type through its sources, and a plain typed-CV value is routed through + * zend_binary_assign_op_typed_prop (compute via zend_binary_op, then verify / + * coerce against the declared scalar type honoring strict/weak mode). The + * untyped ASSIGN_OP hot path is left untouched. */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_TYPED_SPEC_CV_TMP_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -47558,6 +47758,58 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_TYPED_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +/* Compound assignment (`+= -= .= ...`) to a typed local CV. Emitted by the + * compiler in place of ZEND_ASSIGN_OP when op1 is a typed local (cv_types[idx] + * is set), mirroring the ZEND_ASSIGN_TYPED choice. Behaves exactly like the + * typed-property case in ZEND_ASSIGN_OBJ_OP: a typed reference enforces the + * type through its sources, and a plain typed-CV value is routed through + * zend_binary_assign_op_typed_prop (compute via zend_binary_op, then verify / + * coerce against the declared scalar type honoring strict/weak mode). The + * untyped ASSIGN_OP hot path is left untouched. */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OP_TYPED_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *var_ptr; + zval *value; + const zend_property_info *info; + + SAVE_OPLINE(); + value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + var_ptr = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC); + info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + + do { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) { + zend_reference *ref = Z_REF_P(var_ptr); + var_ptr = Z_REFVAL_P(var_ptr); + if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { + zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC); + break; + } + } + zend_binary_assign_op_typed_prop(info, var_ptr, value OPLINE_CC EXECUTE_DATA_CC); + } while (0); + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +/* ++/-- on a typed local CV. Emitted by the compiler in place of the plain + * ZEND_PRE_INC / ZEND_PRE_DEC / ZEND_POST_INC / ZEND_POST_DEC when op1 is a + * typed local. The increment/decrement is computed first (so int overflow can + * be detected) and then verified against the declared type exactly as for a + * typed property (zend_incdec_typed_prop): an int that overflows to float is + * rejected with a TypeError unless the type admits float, otherwise the value + * is coerced/verified honoring strict/weak mode. A typed reference is handled + * through its sources, matching the untyped helpers. The opcode numbers keep + * the increment/decrement parity required by ZEND_IS_INCREMENT() and the + * POST = PRE + 2 relationship used by zend_do_free()'s $i++ -> ++$i rewrite. */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMP_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -48516,6 +48768,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_TYPED_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +/* Compound assignment (`+= -= .= ...`) to a typed local CV. Emitted by the + * compiler in place of ZEND_ASSIGN_OP when op1 is a typed local (cv_types[idx] + * is set), mirroring the ZEND_ASSIGN_TYPED choice. Behaves exactly like the + * typed-property case in ZEND_ASSIGN_OBJ_OP: a typed reference enforces the + * type through its sources, and a plain typed-CV value is routed through + * zend_binary_assign_op_typed_prop (compute via zend_binary_op, then verify / + * coerce against the declared scalar type honoring strict/weak mode). The + * untyped ASSIGN_OP hot path is left untouched. */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_TYPED_SPEC_CV_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -48546,6 +48806,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_TYPED_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +/* Compound assignment (`+= -= .= ...`) to a typed local CV. Emitted by the + * compiler in place of ZEND_ASSIGN_OP when op1 is a typed local (cv_types[idx] + * is set), mirroring the ZEND_ASSIGN_TYPED choice. Behaves exactly like the + * typed-property case in ZEND_ASSIGN_OBJ_OP: a typed reference enforces the + * type through its sources, and a plain typed-CV value is routed through + * zend_binary_assign_op_typed_prop (compute via zend_binary_op, then verify / + * coerce against the declared scalar type honoring strict/weak mode). The + * untyped ASSIGN_OP hot path is left untouched. */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -52813,6 +53081,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_TYPED_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +/* Compound assignment (`+= -= .= ...`) to a typed local CV. Emitted by the + * compiler in place of ZEND_ASSIGN_OP when op1 is a typed local (cv_types[idx] + * is set), mirroring the ZEND_ASSIGN_TYPED choice. Behaves exactly like the + * typed-property case in ZEND_ASSIGN_OBJ_OP: a typed reference enforces the + * type through its sources, and a plain typed-CV value is routed through + * zend_binary_assign_op_typed_prop (compute via zend_binary_op, then verify / + * coerce against the declared scalar type honoring strict/weak mode). The + * untyped ASSIGN_OP hot path is left untouched. */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_TYPED_SPEC_CV_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -52843,6 +53119,58 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_TYPED_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +/* Compound assignment (`+= -= .= ...`) to a typed local CV. Emitted by the + * compiler in place of ZEND_ASSIGN_OP when op1 is a typed local (cv_types[idx] + * is set), mirroring the ZEND_ASSIGN_TYPED choice. Behaves exactly like the + * typed-property case in ZEND_ASSIGN_OBJ_OP: a typed reference enforces the + * type through its sources, and a plain typed-CV value is routed through + * zend_binary_assign_op_typed_prop (compute via zend_binary_op, then verify / + * coerce against the declared scalar type honoring strict/weak mode). The + * untyped ASSIGN_OP hot path is left untouched. */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OP_TYPED_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *var_ptr; + zval *value; + const zend_property_info *info; + + SAVE_OPLINE(); + value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); + var_ptr = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC); + info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + + do { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) { + zend_reference *ref = Z_REF_P(var_ptr); + var_ptr = Z_REFVAL_P(var_ptr); + if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { + zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC); + break; + } + } + zend_binary_assign_op_typed_prop(info, var_ptr, value OPLINE_CC EXECUTE_DATA_CC); + } while (0); + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + } + + + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +/* ++/-- on a typed local CV. Emitted by the compiler in place of the plain + * ZEND_PRE_INC / ZEND_PRE_DEC / ZEND_POST_INC / ZEND_POST_DEC when op1 is a + * typed local. The increment/decrement is computed first (so int overflow can + * be detected) and then verified against the declared type exactly as for a + * typed property (zend_incdec_typed_prop): an int that overflows to float is + * rejected with a TypeError unless the type admits float, otherwise the value + * is coerced/verified honoring strict/weak mode. A typed reference is handled + * through its sources, matching the untyped helpers. The opcode numbers keep + * the increment/decrement parity required by ZEND_IS_INCREMENT() and the + * POST = PRE + 2 relationship used by zend_do_free()'s $i++ -> ++$i rewrite. */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -92552,6 +92880,138 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ECHO_SPEC_CV_TAILC ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_PRE_INC_TYPED_SPEC_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *var_ptr; + const zend_property_info *info; + + SAVE_OPLINE(); + var_ptr = EX_VAR(opline->op1.var); + info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + + if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); + ZVAL_NULL(var_ptr); + } + + do { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) { + zend_reference *ref = Z_REF_P(var_ptr); + var_ptr = Z_REFVAL_P(var_ptr); + if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { + zend_incdec_typed_ref(ref, NULL OPLINE_CC EXECUTE_DATA_CC); + break; + } + } + zend_incdec_typed_prop(info, var_ptr, NULL OPLINE_CC EXECUTE_DATA_CC); + } while (0); + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + } + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_PRE_DEC_TYPED_SPEC_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *var_ptr; + const zend_property_info *info; + + SAVE_OPLINE(); + var_ptr = EX_VAR(opline->op1.var); + info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + + if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); + ZVAL_NULL(var_ptr); + } + + do { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) { + zend_reference *ref = Z_REF_P(var_ptr); + var_ptr = Z_REFVAL_P(var_ptr); + if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { + zend_incdec_typed_ref(ref, NULL OPLINE_CC EXECUTE_DATA_CC); + break; + } + } + zend_incdec_typed_prop(info, var_ptr, NULL OPLINE_CC EXECUTE_DATA_CC); + } while (0); + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + } + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_POST_INC_TYPED_SPEC_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *var_ptr; + const zend_property_info *info; + + SAVE_OPLINE(); + var_ptr = EX_VAR(opline->op1.var); + info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + + if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); + ZVAL_NULL(var_ptr); + } + + do { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) { + zend_reference *ref = Z_REF_P(var_ptr); + var_ptr = Z_REFVAL_P(var_ptr); + if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { + zend_incdec_typed_ref(ref, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC); + break; + } + } + zend_incdec_typed_prop(info, var_ptr, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC); + } while (0); + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_POST_DEC_TYPED_SPEC_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *var_ptr; + const zend_property_info *info; + + SAVE_OPLINE(); + var_ptr = EX_VAR(opline->op1.var); + info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + + if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); + ZVAL_NULL(var_ptr); + } + + do { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) { + zend_reference *ref = Z_REF_P(var_ptr); + var_ptr = Z_REFVAL_P(var_ptr); + if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { + zend_incdec_typed_ref(ref, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC); + break; + } + } + zend_incdec_typed_prop(info, var_ptr, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC); + } while (0); + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_JMPZ_SPEC_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -96494,6 +96954,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_TYPED_SPEC_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +/* Compound assignment (`+= -= .= ...`) to a typed local CV. Emitted by the + * compiler in place of ZEND_ASSIGN_OP when op1 is a typed local (cv_types[idx] + * is set), mirroring the ZEND_ASSIGN_TYPED choice. Behaves exactly like the + * typed-property case in ZEND_ASSIGN_OBJ_OP: a typed reference enforces the + * type through its sources, and a plain typed-CV value is routed through + * zend_binary_assign_op_typed_prop (compute via zend_binary_op, then verify / + * coerce against the declared scalar type honoring strict/weak mode). The + * untyped ASSIGN_OP hot path is left untouched. */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_TYPED_SPEC_CV_CONST_RETVAL_USED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -96524,6 +96992,58 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_TYPED_SPEC_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +/* Compound assignment (`+= -= .= ...`) to a typed local CV. Emitted by the + * compiler in place of ZEND_ASSIGN_OP when op1 is a typed local (cv_types[idx] + * is set), mirroring the ZEND_ASSIGN_TYPED choice. Behaves exactly like the + * typed-property case in ZEND_ASSIGN_OBJ_OP: a typed reference enforces the + * type through its sources, and a plain typed-CV value is routed through + * zend_binary_assign_op_typed_prop (compute via zend_binary_op, then verify / + * coerce against the declared scalar type honoring strict/weak mode). The + * untyped ASSIGN_OP hot path is left untouched. */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OP_TYPED_SPEC_CV_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *var_ptr; + zval *value; + const zend_property_info *info; + + SAVE_OPLINE(); + value = RT_CONSTANT(opline, opline->op2); + var_ptr = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC); + info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + + do { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) { + zend_reference *ref = Z_REF_P(var_ptr); + var_ptr = Z_REFVAL_P(var_ptr); + if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { + zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC); + break; + } + } + zend_binary_assign_op_typed_prop(info, var_ptr, value OPLINE_CC EXECUTE_DATA_CC); + } while (0); + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + } + + + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +/* ++/-- on a typed local CV. Emitted by the compiler in place of the plain + * ZEND_PRE_INC / ZEND_PRE_DEC / ZEND_POST_INC / ZEND_POST_DEC when op1 is a + * typed local. The increment/decrement is computed first (so int overflow can + * be detected) and then verified against the declared type exactly as for a + * typed property (zend_incdec_typed_prop): an int that overflows to float is + * rejected with a TypeError unless the type admits float, otherwise the value + * is coerced/verified honoring strict/weak mode. A typed reference is handled + * through its sources, matching the untyped helpers. The opcode numbers keep + * the increment/decrement parity required by ZEND_IS_INCREMENT() and the + * POST = PRE + 2 relationship used by zend_do_free()'s $i++ -> ++$i rewrite. */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -100380,6 +100900,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_TYPED_SPEC_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +/* Compound assignment (`+= -= .= ...`) to a typed local CV. Emitted by the + * compiler in place of ZEND_ASSIGN_OP when op1 is a typed local (cv_types[idx] + * is set), mirroring the ZEND_ASSIGN_TYPED choice. Behaves exactly like the + * typed-property case in ZEND_ASSIGN_OBJ_OP: a typed reference enforces the + * type through its sources, and a plain typed-CV value is routed through + * zend_binary_assign_op_typed_prop (compute via zend_binary_op, then verify / + * coerce against the declared scalar type honoring strict/weak mode). The + * untyped ASSIGN_OP hot path is left untouched. */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_TYPED_SPEC_CV_TMP_RETVAL_USED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -100410,6 +100938,58 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_TYPED_SPEC_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +/* Compound assignment (`+= -= .= ...`) to a typed local CV. Emitted by the + * compiler in place of ZEND_ASSIGN_OP when op1 is a typed local (cv_types[idx] + * is set), mirroring the ZEND_ASSIGN_TYPED choice. Behaves exactly like the + * typed-property case in ZEND_ASSIGN_OBJ_OP: a typed reference enforces the + * type through its sources, and a plain typed-CV value is routed through + * zend_binary_assign_op_typed_prop (compute via zend_binary_op, then verify / + * coerce against the declared scalar type honoring strict/weak mode). The + * untyped ASSIGN_OP hot path is left untouched. */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OP_TYPED_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *var_ptr; + zval *value; + const zend_property_info *info; + + SAVE_OPLINE(); + value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + var_ptr = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC); + info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + + do { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) { + zend_reference *ref = Z_REF_P(var_ptr); + var_ptr = Z_REFVAL_P(var_ptr); + if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { + zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC); + break; + } + } + zend_binary_assign_op_typed_prop(info, var_ptr, value OPLINE_CC EXECUTE_DATA_CC); + } while (0); + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +/* ++/-- on a typed local CV. Emitted by the compiler in place of the plain + * ZEND_PRE_INC / ZEND_PRE_DEC / ZEND_POST_INC / ZEND_POST_DEC when op1 is a + * typed local. The increment/decrement is computed first (so int overflow can + * be detected) and then verified against the declared type exactly as for a + * typed property (zend_incdec_typed_prop): an int that overflows to float is + * rejected with a TypeError unless the type admits float, otherwise the value + * is coerced/verified honoring strict/weak mode. A typed reference is handled + * through its sources, matching the untyped helpers. The opcode numbers keep + * the increment/decrement parity required by ZEND_IS_INCREMENT() and the + * POST = PRE + 2 relationship used by zend_do_free()'s $i++ -> ++$i rewrite. */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMP_OP_DATA_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -101368,6 +101948,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_TYPED_SPEC_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +/* Compound assignment (`+= -= .= ...`) to a typed local CV. Emitted by the + * compiler in place of ZEND_ASSIGN_OP when op1 is a typed local (cv_types[idx] + * is set), mirroring the ZEND_ASSIGN_TYPED choice. Behaves exactly like the + * typed-property case in ZEND_ASSIGN_OBJ_OP: a typed reference enforces the + * type through its sources, and a plain typed-CV value is routed through + * zend_binary_assign_op_typed_prop (compute via zend_binary_op, then verify / + * coerce against the declared scalar type honoring strict/weak mode). The + * untyped ASSIGN_OP hot path is left untouched. */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_TYPED_SPEC_CV_VAR_RETVAL_USED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -101398,6 +101986,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_TYPED_SPEC_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +/* Compound assignment (`+= -= .= ...`) to a typed local CV. Emitted by the + * compiler in place of ZEND_ASSIGN_OP when op1 is a typed local (cv_types[idx] + * is set), mirroring the ZEND_ASSIGN_TYPED choice. Behaves exactly like the + * typed-property case in ZEND_ASSIGN_OBJ_OP: a typed reference enforces the + * type through its sources, and a plain typed-CV value is routed through + * zend_binary_assign_op_typed_prop (compute via zend_binary_op, then verify / + * coerce against the declared scalar type honoring strict/weak mode). The + * untyped ASSIGN_OP hot path is left untouched. */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_REF_SPEC_CV_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -105563,6 +106159,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_TYPED_SPEC_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +/* Compound assignment (`+= -= .= ...`) to a typed local CV. Emitted by the + * compiler in place of ZEND_ASSIGN_OP when op1 is a typed local (cv_types[idx] + * is set), mirroring the ZEND_ASSIGN_TYPED choice. Behaves exactly like the + * typed-property case in ZEND_ASSIGN_OBJ_OP: a typed reference enforces the + * type through its sources, and a plain typed-CV value is routed through + * zend_binary_assign_op_typed_prop (compute via zend_binary_op, then verify / + * coerce against the declared scalar type honoring strict/weak mode). The + * untyped ASSIGN_OP hot path is left untouched. */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_TYPED_SPEC_CV_CV_RETVAL_USED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -105593,6 +106197,58 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_TYPED_SPEC_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +/* Compound assignment (`+= -= .= ...`) to a typed local CV. Emitted by the + * compiler in place of ZEND_ASSIGN_OP when op1 is a typed local (cv_types[idx] + * is set), mirroring the ZEND_ASSIGN_TYPED choice. Behaves exactly like the + * typed-property case in ZEND_ASSIGN_OBJ_OP: a typed reference enforces the + * type through its sources, and a plain typed-CV value is routed through + * zend_binary_assign_op_typed_prop (compute via zend_binary_op, then verify / + * coerce against the declared scalar type honoring strict/weak mode). The + * untyped ASSIGN_OP hot path is left untouched. */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OP_TYPED_SPEC_CV_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *var_ptr; + zval *value; + const zend_property_info *info; + + SAVE_OPLINE(); + value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); + var_ptr = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC); + info = EX(func)->op_array.cv_types[EX_VAR_TO_NUM(opline->op1.var)]; + + do { + if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) { + zend_reference *ref = Z_REF_P(var_ptr); + var_ptr = Z_REFVAL_P(var_ptr); + if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { + zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC); + break; + } + } + zend_binary_assign_op_typed_prop(info, var_ptr, value OPLINE_CC EXECUTE_DATA_CC); + } while (0); + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); + } + + + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +/* ++/-- on a typed local CV. Emitted by the compiler in place of the plain + * ZEND_PRE_INC / ZEND_PRE_DEC / ZEND_POST_INC / ZEND_POST_DEC when op1 is a + * typed local. The increment/decrement is computed first (so int overflow can + * be detected) and then verified against the declared type exactly as for a + * typed property (zend_incdec_typed_prop): an int that overflows to float is + * rejected with a TypeError unless the type admits float, otherwise the value + * is coerced/verified honoring strict/weak mode. A typed reference is handled + * through its sources, matching the untyped helpers. The opcode numbers keep + * the increment/decrement parity required by ZEND_IS_INCREMENT() and the + * POST = PRE + 2 relationship used by zend_do_free()'s $i++ -> ++$i rewrite. */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_REF_SPEC_CV_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -110013,6 +110669,15 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ASSIGN_TYPED_SPEC_CV_CV_RETVAL_UNUSED_LABEL, (void*)&&ZEND_ASSIGN_TYPED_SPEC_CV_CV_RETVAL_USED_LABEL, + (void*)&&ZEND_ASSIGN_OP_TYPED_SPEC_CV_CONST_LABEL, + (void*)&&ZEND_ASSIGN_OP_TYPED_SPEC_CV_TMP_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_OP_TYPED_SPEC_CV_CV_LABEL, + (void*)&&ZEND_PRE_INC_TYPED_SPEC_CV_LABEL, + (void*)&&ZEND_PRE_DEC_TYPED_SPEC_CV_LABEL, + (void*)&&ZEND_POST_INC_TYPED_SPEC_CV_LABEL, + (void*)&&ZEND_POST_DEC_TYPED_SPEC_CV_LABEL, (void*)&&ZEND_INIT_FCALL_OFFSET_SPEC_CONST_LABEL, (void*)&&ZEND_RECV_NOTYPE_SPEC_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -115050,6 +115715,26 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_ECHO_SPEC_CV) HYBRID_BREAK(); + HYBRID_CASE(ZEND_PRE_INC_TYPED_SPEC_CV): + VM_TRACE(ZEND_PRE_INC_TYPED_SPEC_CV) + ZEND_PRE_INC_TYPED_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_PRE_INC_TYPED_SPEC_CV) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_PRE_DEC_TYPED_SPEC_CV): + VM_TRACE(ZEND_PRE_DEC_TYPED_SPEC_CV) + ZEND_PRE_DEC_TYPED_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_PRE_DEC_TYPED_SPEC_CV) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_POST_INC_TYPED_SPEC_CV): + VM_TRACE(ZEND_POST_INC_TYPED_SPEC_CV) + ZEND_POST_INC_TYPED_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_POST_INC_TYPED_SPEC_CV) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_POST_DEC_TYPED_SPEC_CV): + VM_TRACE(ZEND_POST_DEC_TYPED_SPEC_CV) + ZEND_POST_DEC_TYPED_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_POST_DEC_TYPED_SPEC_CV) + HYBRID_BREAK(); HYBRID_CASE(ZEND_JMPZ_SPEC_CV): VM_TRACE(ZEND_JMPZ_SPEC_CV) ZEND_JMPZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -115519,6 +116204,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_ASSIGN_TYPED_SPEC_CV_CONST_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_ASSIGN_TYPED_SPEC_CV_CONST_RETVAL_USED) HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_OP_TYPED_SPEC_CV_CONST): + VM_TRACE(ZEND_ASSIGN_OP_TYPED_SPEC_CV_CONST) + ZEND_ASSIGN_OP_TYPED_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_OP_TYPED_SPEC_CV_CONST) + HYBRID_BREAK(); HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR): VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR) ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -115829,6 +116519,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_ASSIGN_TYPED_SPEC_CV_TMP_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_ASSIGN_TYPED_SPEC_CV_TMP_RETVAL_USED) HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_OP_TYPED_SPEC_CV_TMP): + VM_TRACE(ZEND_ASSIGN_OP_TYPED_SPEC_CV_TMP) + ZEND_ASSIGN_OP_TYPED_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_OP_TYPED_SPEC_CV_TMP) + HYBRID_BREAK(); HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMP_OP_DATA_VAR): VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMP_OP_DATA_VAR) ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMP_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -116279,6 +116974,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_ASSIGN_TYPED_SPEC_CV_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_ASSIGN_TYPED_SPEC_CV_CV_RETVAL_USED) HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_OP_TYPED_SPEC_CV_CV): + VM_TRACE(ZEND_ASSIGN_OP_TYPED_SPEC_CV_CV) + ZEND_ASSIGN_OP_TYPED_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_OP_TYPED_SPEC_CV_CV) + HYBRID_BREAK(); HYBRID_CASE(ZEND_ASSIGN_REF_SPEC_CV_CV): VM_TRACE(ZEND_ASSIGN_REF_SPEC_CV_CV) ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -119001,6 +119701,15 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_ASSIGN_TYPED_SPEC_CV_CV_RETVAL_UNUSED_HANDLER, ZEND_ASSIGN_TYPED_SPEC_CV_CV_RETVAL_USED_HANDLER, + ZEND_ASSIGN_OP_TYPED_SPEC_CV_CONST_HANDLER, + ZEND_ASSIGN_OP_TYPED_SPEC_CV_TMP_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_ASSIGN_OP_TYPED_SPEC_CV_CV_HANDLER, + ZEND_PRE_INC_TYPED_SPEC_CV_HANDLER, + ZEND_PRE_DEC_TYPED_SPEC_CV_HANDLER, + ZEND_POST_INC_TYPED_SPEC_CV_HANDLER, + ZEND_POST_DEC_TYPED_SPEC_CV_HANDLER, ZEND_INIT_FCALL_OFFSET_SPEC_CONST_HANDLER, ZEND_RECV_NOTYPE_SPEC_HANDLER, ZEND_NULL_HANDLER, @@ -122489,6 +123198,15 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_ASSIGN_TYPED_SPEC_CV_CV_RETVAL_UNUSED_TAILCALL_HANDLER, ZEND_ASSIGN_TYPED_SPEC_CV_CV_RETVAL_USED_TAILCALL_HANDLER, + ZEND_ASSIGN_OP_TYPED_SPEC_CV_CONST_TAILCALL_HANDLER, + ZEND_ASSIGN_OP_TYPED_SPEC_CV_TMP_TAILCALL_HANDLER, + ZEND_NULL_TAILCALL_HANDLER, + ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_OP_TYPED_SPEC_CV_CV_TAILCALL_HANDLER, + ZEND_PRE_INC_TYPED_SPEC_CV_TAILCALL_HANDLER, + ZEND_PRE_DEC_TYPED_SPEC_CV_TAILCALL_HANDLER, + ZEND_POST_INC_TYPED_SPEC_CV_TAILCALL_HANDLER, + ZEND_POST_DEC_TYPED_SPEC_CV_TAILCALL_HANDLER, ZEND_INIT_FCALL_OFFSET_SPEC_CONST_TAILCALL_HANDLER, ZEND_RECV_NOTYPE_SPEC_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -123457,7 +124175,7 @@ void zend_vm_init(void) 1255, 1256 | SPEC_RULE_OP1, 1261 | SPEC_RULE_OP1, - 3484, + 3493, 1266 | SPEC_RULE_OP1, 1271 | SPEC_RULE_OP1, 1276 | SPEC_RULE_OP2, @@ -123491,7 +124209,7 @@ void zend_vm_init(void) 1559 | SPEC_RULE_OP1 | SPEC_RULE_OP2, 1584 | SPEC_RULE_OP1, 1589, - 3484, + 3493, 1590 | SPEC_RULE_OP1, 1595 | SPEC_RULE_OP1 | SPEC_RULE_OP2, 1620 | SPEC_RULE_OP1 | SPEC_RULE_OP2, @@ -123625,49 +124343,49 @@ void zend_vm_init(void) 2557, 2558, 2559 | SPEC_RULE_OP2 | SPEC_RULE_RETVAL, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, + 2569 | SPEC_RULE_OP2, + 2574, + 2575, + 2576, + 2577, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, }; #if 0 #elif (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID) @@ -123860,7 +124578,7 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2577 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2586 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -123868,7 +124586,7 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2602 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2611 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -123876,7 +124594,7 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2627 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2636 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -123887,17 +124605,17 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2652 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2661 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } else if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2677 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2686 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2702 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2711 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_MUL: @@ -123908,17 +124626,17 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2727 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2736 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } else if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2752 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2761 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2777 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2786 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_IDENTICAL: @@ -123929,16 +124647,16 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2802 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2811 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2877 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2886 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op2_type == IS_CONST && (Z_TYPE_P(RT_CONSTANT(op, op->op2)) == IS_ARRAY && zend_hash_num_elements(Z_ARR_P(RT_CONSTANT(op, op->op2))) == 0)) { - spec = 3102 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3111 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF))) { - spec = 3108 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3117 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_IDENTICAL: @@ -123949,16 +124667,16 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2952 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2961 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3027 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3036 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op2_type == IS_CONST && (Z_TYPE_P(RT_CONSTANT(op, op->op2)) == IS_ARRAY && zend_hash_num_elements(Z_ARR_P(RT_CONSTANT(op, op->op2))) == 0)) { - spec = 3105 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3114 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF))) { - spec = 3113 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3122 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_EQUAL: @@ -123969,12 +124687,12 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2802 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2811 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2877 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2886 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_EQUAL: @@ -123985,12 +124703,12 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2952 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2961 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3027 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3036 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_SMALLER: @@ -123998,12 +124716,12 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3118 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3127 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3193 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3202 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_IS_SMALLER_OR_EQUAL: @@ -124011,79 +124729,79 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3268 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3277 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3343 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3352 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_QM_ASSIGN: if (op1_info == MAY_BE_LONG) { - spec = 3430 | SPEC_RULE_OP1; + spec = 3439 | SPEC_RULE_OP1; } else if (op1_info == MAY_BE_DOUBLE) { - spec = 3435 | SPEC_RULE_OP1; + spec = 3444 | SPEC_RULE_OP1; } else if ((op->op1_type == IS_CONST) ? !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1)) : (!(op1_info & ((MAY_BE_ANY|MAY_BE_UNDEF)-(MAY_BE_NULL|MAY_BE_FALSE|MAY_BE_TRUE|MAY_BE_LONG|MAY_BE_DOUBLE))))) { - spec = 3440 | SPEC_RULE_OP1; + spec = 3449 | SPEC_RULE_OP1; } break; case ZEND_PRE_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3418 | SPEC_RULE_RETVAL; + spec = 3427 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3420 | SPEC_RULE_RETVAL; + spec = 3429 | SPEC_RULE_RETVAL; } break; case ZEND_PRE_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3422 | SPEC_RULE_RETVAL; + spec = 3431 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3424 | SPEC_RULE_RETVAL; + spec = 3433 | SPEC_RULE_RETVAL; } break; case ZEND_POST_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3426; + spec = 3435; } else if (op1_info == MAY_BE_LONG) { - spec = 3427; + spec = 3436; } break; case ZEND_POST_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3428; + spec = 3437; } else if (op1_info == MAY_BE_LONG) { - spec = 3429; + spec = 3438; } break; case ZEND_JMP: if (OP_JMP_ADDR(op, op->op1) > op) { - spec = 2576; + spec = 2585; } break; case ZEND_INIT_FCALL: if (Z_EXTRA_P(RT_CONSTANT(op, op->op2)) != 0) { - spec = 2569; + spec = 2578; } break; case ZEND_RECV: if (op->op2.num == MAY_BE_ANY) { - spec = 2570; + spec = 2579; } break; case ZEND_SEND_VAL: if (op->op1_type == IS_CONST && op->op2_type == IS_UNUSED && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3480; + spec = 3489; } break; case ZEND_SEND_VAR_EX: if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3475 | SPEC_RULE_OP1; + spec = 3484 | SPEC_RULE_OP1; } break; case ZEND_FE_FETCH_R: if (op->op2_type == IS_CV && (op1_info & (MAY_BE_ANY|MAY_BE_REF)) == MAY_BE_ARRAY) { - spec = 3482 | SPEC_RULE_RETVAL; + spec = 3491 | SPEC_RULE_RETVAL; } break; case ZEND_FETCH_DIM_R: @@ -124091,22 +124809,22 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3445 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 3454 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_SEND_VAL_EX: if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3481; + spec = 3490; } break; case ZEND_SEND_VAR: if (op->op2_type == IS_UNUSED && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3470 | SPEC_RULE_OP1; + spec = 3479 | SPEC_RULE_OP1; } break; case ZEND_COUNT: if ((op1_info & (MAY_BE_ANY|MAY_BE_UNDEF|MAY_BE_REF)) == MAY_BE_ARRAY) { - spec = 2571 | SPEC_RULE_OP1; + spec = 2580 | SPEC_RULE_OP1; } break; case ZEND_BW_OR: diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h index bf2fda8784f2..07b586e9fc72 100644 --- a/Zend/zend_vm_handlers.h +++ b/Zend/zend_vm_handlers.h @@ -1095,507 +1095,514 @@ _(2564, ZEND_ASSIGN_TYPED_SPEC_CV_VAR_RETVAL_USED) \ _(2567, ZEND_ASSIGN_TYPED_SPEC_CV_CV_RETVAL_UNUSED) \ _(2568, ZEND_ASSIGN_TYPED_SPEC_CV_CV_RETVAL_USED) \ - _(2569, ZEND_INIT_FCALL_OFFSET_SPEC_CONST) \ - _(2570, ZEND_RECV_NOTYPE_SPEC) \ - _(2572, ZEND_COUNT_ARRAY_SPEC_TMP_UNUSED) \ - _(2575, ZEND_COUNT_ARRAY_SPEC_CV_UNUSED) \ - _(2576, ZEND_JMP_FORWARD_SPEC) \ - _(2582, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2583, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2584, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2586, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2587, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2588, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2589, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2591, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2597, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2569, ZEND_ASSIGN_OP_TYPED_SPEC_CV_CONST) \ + _(2570, ZEND_ASSIGN_OP_TYPED_SPEC_CV_TMP) \ + _(2573, ZEND_ASSIGN_OP_TYPED_SPEC_CV_CV) \ + _(2574, ZEND_PRE_INC_TYPED_SPEC_CV) \ + _(2575, ZEND_PRE_DEC_TYPED_SPEC_CV) \ + _(2576, ZEND_POST_INC_TYPED_SPEC_CV) \ + _(2577, ZEND_POST_DEC_TYPED_SPEC_CV) \ + _(2578, ZEND_INIT_FCALL_OFFSET_SPEC_CONST) \ + _(2579, ZEND_RECV_NOTYPE_SPEC) \ + _(2581, ZEND_COUNT_ARRAY_SPEC_TMP_UNUSED) \ + _(2584, ZEND_COUNT_ARRAY_SPEC_CV_UNUSED) \ + _(2585, ZEND_JMP_FORWARD_SPEC) \ + _(2591, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2592, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2593, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2595, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2596, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2597, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2598, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2599, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2601, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2607, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2608, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2609, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2611, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2612, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2613, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2614, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2616, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2622, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2600, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2606, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2607, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2608, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2610, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2616, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2617, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2618, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2620, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2621, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2622, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2623, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2624, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2626, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2632, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2633, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2634, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2636, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2637, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2638, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2639, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2641, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2647, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2625, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2631, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2632, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2633, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2635, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2641, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2642, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2643, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2645, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2646, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2647, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2648, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2649, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2651, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2653, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2654, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2656, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2657, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2658, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2659, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2661, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2662, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2663, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2664, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2666, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2672, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2650, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2656, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2657, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2658, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2660, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2662, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2663, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2665, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2666, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2667, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2668, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2670, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2671, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2672, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2673, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2674, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2676, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2678, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2679, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2681, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2682, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2683, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2684, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2686, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2687, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2688, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2689, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2691, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2697, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2675, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2681, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2682, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2683, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2685, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2687, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2688, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2690, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2691, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2692, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2693, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2695, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2696, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2697, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2698, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2699, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2701, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2703, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2704, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2706, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2707, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2708, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2709, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2711, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2712, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2713, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2714, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2716, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2722, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2700, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2706, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2707, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2708, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2710, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2712, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2713, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2715, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2716, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2717, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2718, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2720, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2721, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2722, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2723, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2724, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2726, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2732, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2733, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2734, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2736, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2737, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2738, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2739, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2741, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2747, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2725, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2731, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2732, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2733, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2735, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2741, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2742, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2743, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2745, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2746, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2747, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2748, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2749, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2751, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2757, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2758, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2759, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2761, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2762, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2763, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2764, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2766, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2772, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2750, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2756, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2757, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2758, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2760, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2766, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2767, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2768, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2770, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2771, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2772, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2773, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2774, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2776, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2782, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2783, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2784, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2786, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2787, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2788, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2789, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2791, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2797, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2775, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2781, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2782, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2783, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2785, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2791, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2792, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2793, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2795, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2796, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2797, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2798, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2799, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2801, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2817, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2818, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2819, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2820, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2821, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2822, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2823, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2824, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2825, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2800, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2806, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2807, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2808, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2810, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2826, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2827, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2828, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ _(2829, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2830, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(2831, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2832, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2833, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2834, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2835, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2836, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2837, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2832, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2833, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2834, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ _(2838, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2839, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(2840, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2841, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2842, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2843, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ _(2844, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2845, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(2846, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2862, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2863, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2864, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2865, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2866, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2867, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2868, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2869, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2870, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2847, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2848, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2849, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2853, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2854, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2855, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2871, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2872, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2873, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ _(2874, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2875, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(2876, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2892, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2893, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2894, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2895, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2896, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2897, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2898, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2899, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2900, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2877, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2878, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2879, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2883, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2884, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2885, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2901, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2902, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2903, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ _(2904, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2905, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(2906, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2907, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2908, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2909, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2910, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2911, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2912, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2907, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2908, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2909, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ _(2913, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2914, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(2915, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2916, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2917, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2918, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ _(2919, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2920, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(2921, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2937, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2938, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2939, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2940, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2941, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2942, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2943, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2944, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2945, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2922, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2923, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2924, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2928, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2929, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2930, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2946, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2947, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2948, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ _(2949, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2950, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(2951, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2967, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2968, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2969, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2970, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2971, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2972, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2973, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2974, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2975, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2952, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2953, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2954, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2958, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2959, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2960, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2976, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2977, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2978, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ _(2979, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2980, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(2981, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2982, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2983, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2984, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2985, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2986, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2987, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2982, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2983, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2984, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ _(2988, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2989, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(2990, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2991, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2992, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2993, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ _(2994, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2995, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(2996, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3012, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3013, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3014, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3015, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3016, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3017, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3018, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3019, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3020, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2997, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2998, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2999, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3003, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3004, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3005, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3021, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3022, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3023, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ _(3024, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(3025, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(3026, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3042, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3043, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3044, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3045, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3046, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3047, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3048, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3049, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3050, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3027, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3028, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3029, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3033, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3034, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3035, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3051, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3052, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3053, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ _(3054, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(3055, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(3056, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3057, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3058, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3059, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3060, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3061, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3062, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3057, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3058, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3059, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ _(3063, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(3064, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(3065, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3066, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3067, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3068, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ _(3069, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(3070, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(3071, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3087, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3088, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3089, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3090, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3091, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3092, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3093, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3094, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3095, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3072, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3073, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3074, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3078, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3079, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3080, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3096, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3097, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3098, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ _(3099, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(3100, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(3101, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3102, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST) \ - _(3103, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3104, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3105, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST) \ - _(3106, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3107, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3108, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(3112, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(3113, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(3117, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(3121, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3122, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3123, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3124, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3125, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3126, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3102, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3103, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3104, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3108, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3109, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3110, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3111, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST) \ + _(3112, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3113, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3114, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST) \ + _(3115, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3116, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3117, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3121, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3122, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3126, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ _(3130, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ _(3131, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ _(3132, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3133, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3134, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3135, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3136, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3137, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3138, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3139, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3140, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3141, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3133, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3134, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3135, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3139, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3140, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3141, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3142, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3143, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3144, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ _(3145, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(3146, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(3147, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3148, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3149, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3150, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3151, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3152, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3153, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3148, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3149, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3150, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ _(3154, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(3155, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(3156, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3157, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3158, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3159, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ _(3160, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(3161, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(3162, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3178, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3179, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3180, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3181, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3182, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3183, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3184, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3185, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3186, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3163, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3164, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3165, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3169, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3170, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3171, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3187, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3188, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3189, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ _(3190, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(3191, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(3192, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3196, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3197, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3198, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3199, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3200, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3201, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3193, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3194, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3195, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3199, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3200, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3201, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ _(3205, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ _(3206, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ _(3207, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3208, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3209, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3210, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3211, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3212, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3213, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3214, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3215, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3216, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3208, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3209, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3210, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3214, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3215, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3216, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3217, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3218, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3219, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ _(3220, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(3221, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(3222, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3223, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3224, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3225, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3226, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3227, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3228, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3223, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3224, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3225, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ _(3229, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(3230, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(3231, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3232, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3233, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3234, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ _(3235, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(3236, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(3237, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3253, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3254, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3255, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3256, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3257, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3258, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3259, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3260, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3261, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3238, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3239, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3240, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3244, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3245, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3246, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3262, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3263, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3264, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ _(3265, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(3266, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(3267, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3271, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3272, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3273, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3274, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3275, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3276, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3268, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3269, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3270, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3274, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3275, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3276, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ _(3280, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ _(3281, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ _(3282, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3283, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3284, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3285, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3286, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3287, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3288, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3289, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3290, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3291, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3283, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3284, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3285, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3289, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3290, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3291, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3292, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3293, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3294, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ _(3295, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(3296, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(3297, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3298, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3299, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3300, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3301, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3302, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3303, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3298, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3299, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3300, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ _(3304, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(3305, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(3306, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3307, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3308, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3309, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ _(3310, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(3311, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(3312, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3328, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3329, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3330, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3331, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3332, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3333, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3334, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3335, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3336, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3313, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3314, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3315, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3319, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3320, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3321, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3337, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3338, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3339, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ _(3340, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(3341, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(3342, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3346, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3347, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3348, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3349, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3350, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3351, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3343, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3344, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3345, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3349, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3350, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3351, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ _(3355, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ _(3356, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ _(3357, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3358, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3359, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3360, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3361, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3362, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3363, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3364, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3365, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3366, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3358, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3359, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3360, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3364, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3365, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3366, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3367, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3368, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3369, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ _(3370, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(3371, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(3372, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3373, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3374, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3375, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3376, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3377, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3378, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3373, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3374, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3375, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ _(3379, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(3380, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(3381, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3382, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3383, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3384, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ _(3385, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(3386, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(3387, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3403, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3404, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3405, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3406, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3407, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3408, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3409, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3410, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3411, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3388, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3389, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3390, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3394, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3395, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3396, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3412, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3413, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3414, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ _(3415, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(3416, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(3417, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3418, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3419, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3420, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3421, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ - _(3422, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3423, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3424, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3425, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ - _(3426, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3427, ZEND_POST_INC_LONG_SPEC_CV) \ - _(3428, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3429, ZEND_POST_DEC_LONG_SPEC_CV) \ - _(3430, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ - _(3431, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3432, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3434, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3435, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ - _(3436, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3437, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3439, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3440, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ - _(3441, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3442, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3444, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3446, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3447, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3449, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3450, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(3451, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3452, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3454, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3455, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(3456, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3457, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3459, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3465, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ - _(3466, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3467, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3469, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3472, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ - _(3474, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ - _(3477, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ - _(3479, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ - _(3480, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ - _(3481, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ - _(3482, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ - _(3483, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ - _(3483+1, ZEND_NULL) + _(3418, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3419, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3420, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3424, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3425, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3426, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3427, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3428, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3429, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3430, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ + _(3431, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3432, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3433, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3434, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ + _(3435, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3436, ZEND_POST_INC_LONG_SPEC_CV) \ + _(3437, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3438, ZEND_POST_DEC_LONG_SPEC_CV) \ + _(3439, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ + _(3440, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3441, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3443, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3444, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ + _(3445, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3446, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3448, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3449, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ + _(3450, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3451, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3453, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3455, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3456, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3458, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3459, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3460, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3461, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3463, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3464, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3465, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3466, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3468, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3474, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ + _(3475, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3476, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3478, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3481, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ + _(3483, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ + _(3486, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ + _(3488, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ + _(3489, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ + _(3490, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ + _(3491, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ + _(3492, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ + _(3492+1, ZEND_NULL) diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c index 43076acb33a1..92f49afba7bf 100644 --- a/Zend/zend_vm_opcodes.c +++ b/Zend/zend_vm_opcodes.c @@ -21,7 +21,7 @@ #include #include -static const char *zend_vm_opcodes_names[213] = { +static const char *zend_vm_opcodes_names[218] = { "ZEND_NOP", "ZEND_ADD", "ZEND_SUB", @@ -235,9 +235,14 @@ static const char *zend_vm_opcodes_names[213] = { "ZEND_DECLARE_ATTRIBUTED_CONST", "ZEND_TYPE_ASSERT", "ZEND_ASSIGN_TYPED", + "ZEND_ASSIGN_OP_TYPED", + "ZEND_PRE_INC_TYPED", + "ZEND_PRE_DEC_TYPED", + "ZEND_POST_INC_TYPED", + "ZEND_POST_DEC_TYPED", }; -static uint32_t zend_vm_opcodes_flags[213] = { +static uint32_t zend_vm_opcodes_flags[218] = { 0x00000000, 0x00000b0b, 0x00000b0b, @@ -451,6 +456,11 @@ static uint32_t zend_vm_opcodes_flags[213] = { 0x00000303, 0x01000003, 0x00000301, + 0x04000301, + 0x00000001, + 0x00000001, + 0x00000001, + 0x00000001, }; ZEND_API const char* ZEND_FASTCALL zend_get_opcode_name(uint8_t opcode) { diff --git a/Zend/zend_vm_opcodes.h b/Zend/zend_vm_opcodes.h index 7765ab5a5054..ebecf765a776 100644 --- a/Zend/zend_vm_opcodes.h +++ b/Zend/zend_vm_opcodes.h @@ -332,7 +332,12 @@ END_EXTERN_C() #define ZEND_DECLARE_ATTRIBUTED_CONST 210 #define ZEND_TYPE_ASSERT 211 #define ZEND_ASSIGN_TYPED 212 +#define ZEND_ASSIGN_OP_TYPED 213 +#define ZEND_PRE_INC_TYPED 214 +#define ZEND_PRE_DEC_TYPED 215 +#define ZEND_POST_INC_TYPED 216 +#define ZEND_POST_DEC_TYPED 217 -#define ZEND_VM_LAST_OPCODE 212 +#define ZEND_VM_LAST_OPCODE 217 #endif diff --git a/tests/lang/typed_locals/compound_assign_enforced.phpt b/tests/lang/typed_locals/compound_assign_enforced.phpt new file mode 100644 index 000000000000..65dba1275a71 --- /dev/null +++ b/tests/lang/typed_locals/compound_assign_enforced.phpt @@ -0,0 +1,42 @@ +--TEST-- +Typed local variables: compound assignment (+= .= etc.) enforces the declared type +--FILE-- +>= 1; +$b %= 7; +$b **= 2; +var_dump($b); +?> +--EXPECTF-- +Deprecated: Implicit conversion from float 1.5 to int loses precision in %s on line %d +int(1) +string(2) "ab" +float(3) +int(105) +int(0) diff --git a/tests/lang/typed_locals/compound_assign_strict_error.phpt b/tests/lang/typed_locals/compound_assign_strict_error.phpt new file mode 100644 index 000000000000..599c37fab546 --- /dev/null +++ b/tests/lang/typed_locals/compound_assign_strict_error.phpt @@ -0,0 +1,16 @@ +--TEST-- +Typed local variables: strict_types=1 throws TypeError on lossy compound assignment +--FILE-- +getMessage(), "\n"; +} +var_dump($x); +?> +--EXPECTF-- +Cannot assign float to local variable $x of type int +int(1) diff --git a/tests/lang/typed_locals/compound_incdec_via_ref_enforced.phpt b/tests/lang/typed_locals/compound_incdec_via_ref_enforced.phpt new file mode 100644 index 000000000000..51836f0e6955 --- /dev/null +++ b/tests/lang/typed_locals/compound_incdec_via_ref_enforced.phpt @@ -0,0 +1,34 @@ +--TEST-- +Typed local variables: compound assignment and ++/-- through an alias reference stay enforced +--FILE-- +getMessage(), "\n"; +} +var_dump($z === PHP_INT_MAX); +?> +--EXPECTF-- +Deprecated: Implicit conversion from float 1.5 to int loses precision in %s on line %d +int(1) + +Deprecated: Implicit conversion from float 1.5 to int loses precision in %s on line %d +int(1) +Cannot increment a reference held by local variable $z of type int past its maximal value +bool(true) diff --git a/tests/lang/typed_locals/incdec_enforced.phpt b/tests/lang/typed_locals/incdec_enforced.phpt new file mode 100644 index 000000000000..65514f4ea7b4 --- /dev/null +++ b/tests/lang/typed_locals/incdec_enforced.phpt @@ -0,0 +1,32 @@ +--TEST-- +Typed local variables: ++ and -- enforce the declared type (pre/post) +--FILE-- + +--EXPECT-- +int(2) +int(2) +int(3) +int(2) +int(2) +int(1) +float(2.5) +float(3) diff --git a/tests/lang/typed_locals/incdec_overflow_error.phpt b/tests/lang/typed_locals/incdec_overflow_error.phpt new file mode 100644 index 000000000000..445f4eedf558 --- /dev/null +++ b/tests/lang/typed_locals/incdec_overflow_error.phpt @@ -0,0 +1,27 @@ +--TEST-- +Typed local variables: int overflow on ++/-- throws TypeError and clamps (matches typed property) +--FILE-- +getMessage(), "\n"; +} +var_dump($x === PHP_INT_MAX); + +// Decrementing an int local past PHP_INT_MIN throws and clamps to PHP_INT_MIN. +int $y = PHP_INT_MIN; +try { + --$y; +} catch (\TypeError $e) { + echo $e->getMessage(), "\n"; +} +var_dump($y === PHP_INT_MIN); +?> +--EXPECT-- +Cannot increment local variable $x of type int past its maximal value +bool(true) +Cannot decrement local variable $y of type int past its minimal value +bool(true) From 60f57dddfdefd4bfe4fc4d0131c60d353e608762 Mon Sep 17 00:00:00 2001 From: Michal Kral Date: Tue, 16 Jun 2026 01:21:43 +0200 Subject: [PATCH 11/14] feat(scalar-methods): add Str backing class (trim/upper/lower/length) --- ext/standard/basic_functions.c | 2 + ext/standard/config.m4 | 1 + ext/standard/str.c | 89 ++++++++++++++++++++++++++++++++++ ext/standard/str.stub.php | 15 ++++++ ext/standard/str_arginfo.h | 42 ++++++++++++++++ 5 files changed, 149 insertions(+) create mode 100644 ext/standard/str.c create mode 100644 ext/standard/str.stub.php create mode 100644 ext/standard/str_arginfo.h diff --git a/ext/standard/basic_functions.c b/ext/standard/basic_functions.c index f8b1cb5c4fdb..fc458cb94844 100644 --- a/ext/standard/basic_functions.c +++ b/ext/standard/basic_functions.c @@ -113,6 +113,7 @@ PHPAPI php_basic_globals basic_globals; #include "streamsfuncs.h" #include "zend_frameless_function.h" #include "basic_functions_arginfo.h" +#include "str_arginfo.h" #if __has_feature(memory_sanitizer) # include @@ -297,6 +298,7 @@ PHP_MINIT_FUNCTION(basic) /* {{{ */ rounding_mode_ce = register_class_RoundingMode(); sort_direction_ce = register_class_SortDirection(); + BASIC_MINIT_SUBMODULE(str) BASIC_MINIT_SUBMODULE(var) BASIC_MINIT_SUBMODULE(file) BASIC_MINIT_SUBMODULE(browscap) diff --git a/ext/standard/config.m4 b/ext/standard/config.m4 index 67c36b93ba34..06e518c60ccc 100644 --- a/ext/standard/config.m4 +++ b/ext/standard/config.m4 @@ -439,6 +439,7 @@ PHP_NEW_EXTENSION([standard], m4_normalize([ sha1.c soundex.c streamsfuncs.c + str.c string.c strnatcmp.c syslog.c diff --git a/ext/standard/str.c b/ext/standard/str.c new file mode 100644 index 000000000000..bfa4476df4c9 --- /dev/null +++ b/ext/standard/str.c @@ -0,0 +1,89 @@ +/* + +----------------------------------------------------------------------+ + | Copyright © The PHP Group and Contributors. | + +----------------------------------------------------------------------+ + | This source file is subject to the Modified BSD License that is | + | bundled with this package in the file LICENSE, and is available | + | through the World Wide Web at . | + | | + | SPDX-License-Identifier: BSD-3-Clause | + +----------------------------------------------------------------------+ +*/ + +/* Str — internal backing class for scalar string methods. + * + * Each method is static and takes the subject string as its first argument, + * returning a new value (immutable). This class is the dispatch target for + * the scalar-objects compiler feature; userland should not instantiate it. + */ + +#include "php.h" +#include "php_string.h" +#include "str_arginfo.h" + +zend_class_entry *str_ce; + +/* {{{ Str::trim(string $string, string $characters = " \n\r\t\v\0"): string */ +PHP_METHOD(Str, trim) +{ + zend_string *str; + zend_string *what = NULL; + + ZEND_PARSE_PARAMETERS_START(1, 2) + Z_PARAM_STR(str) + Z_PARAM_OPTIONAL + Z_PARAM_STR(what) + ZEND_PARSE_PARAMETERS_END(); + + RETURN_STR(php_trim(str, + what ? ZSTR_VAL(what) : NULL, + what ? ZSTR_LEN(what) : 0, + 3 /* both ends */)); +} +/* }}} */ + +/* {{{ Str::upper(string $string): string */ +PHP_METHOD(Str, upper) +{ + zend_string *str; + + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(str) + ZEND_PARSE_PARAMETERS_END(); + + RETURN_STR(zend_string_toupper(str)); +} +/* }}} */ + +/* {{{ Str::lower(string $string): string */ +PHP_METHOD(Str, lower) +{ + zend_string *str; + + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(str) + ZEND_PARSE_PARAMETERS_END(); + + RETURN_STR(zend_string_tolower(str)); +} +/* }}} */ + +/* {{{ Str::length(string $string): int */ +PHP_METHOD(Str, length) +{ + zend_string *str; + + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STR(str) + ZEND_PARSE_PARAMETERS_END(); + + RETURN_LONG((zend_long) ZSTR_LEN(str)); +} +/* }}} */ + +PHP_MINIT_FUNCTION(str) /* {{{ */ +{ + str_ce = register_class_Str(); + return SUCCESS; +} +/* }}} */ diff --git a/ext/standard/str.stub.php b/ext/standard/str.stub.php new file mode 100644 index 000000000000..6be7ebd776bd --- /dev/null +++ b/ext/standard/str.stub.php @@ -0,0 +1,15 @@ + Date: Tue, 16 Jun 2026 01:36:17 +0200 Subject: [PATCH 12/14] feat(scalar-methods): desugar method calls on static-string receivers to Str:: --- Zend/zend_compile.c | 60 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 60 insertions(+) diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index 785838debeb7..f23975942415 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -101,6 +101,7 @@ static zend_op *zend_delayed_compile_var(znode *result, zend_ast *ast, uint32_t static void zend_compile_expr(znode *result, zend_ast *ast); static void zend_compile_stmt(zend_ast *ast); static void zend_compile_assign(znode *result, zend_ast *ast, bool stmt, uint32_t type); +static void zend_compile_static_call(znode *result, zend_ast *ast, uint32_t type); #ifdef ZEND_CHECK_STACK_LIMIT zend_never_inline static void zend_stack_limit_error(void) @@ -5541,12 +5542,71 @@ static void zend_compile_call(znode *result, const zend_ast *ast, uint32_t type) } /* }}} */ +/* True if the expression is a compile-time-known string for the purpose of + * dispatching scalar methods to the Str backing class. For now this is limited + * to string literals and explicit (string) casts. */ +static bool zend_is_static_string_ast(zend_ast *ast) /* {{{ */ +{ + if (ast->kind == ZEND_AST_ZVAL) { + return Z_TYPE_P(zend_ast_get_zval(ast)) == IS_STRING; + } + if (ast->kind == ZEND_AST_CAST) { + return ast->attr == IS_STRING; + } + return false; +} +/* }}} */ + +/* Rewrite `->()` into `Str::(, )` + * and compile it as a static call. Returns true if the rewrite applied. */ +static bool zend_try_compile_scalar_string_method_call(znode *result, zend_ast *ast, uint32_t type) /* {{{ */ +{ + zend_ast *obj_ast = ast->child[0]; + zend_ast *method_ast = ast->child[1]; + zend_ast *args_ast = ast->child[2]; + + /* Only plain `->` calls with a literal method name on a static-string receiver. */ + if (ast->kind != ZEND_AST_METHOD_CALL + || !zend_is_static_string_ast(obj_ast) + || method_ast->kind != ZEND_AST_ZVAL + || Z_TYPE_P(zend_ast_get_zval(method_ast)) != IS_STRING) { + return false; + } + + /* Build the class-name node for `Str`. ZEND_NAME_FQ makes it resolve as the + * global `\Str` regardless of the current namespace. The name is interned so + * that the orphan AST zval node carries no refcounted string to leak. */ + zval class_zv; + ZVAL_STRINGL(&class_zv, "Str", sizeof("Str") - 1); + zval_make_interned_string(&class_zv); + zend_ast *class_ast = zend_ast_create_zval_ex(&class_zv, ZEND_NAME_FQ); + + /* Build a new argument list with the receiver prepended before the original args. */ + zend_ast_list *orig_args = zend_ast_get_list(args_ast); + zend_ast *new_args = zend_ast_create_arg_list(1, ZEND_AST_ARG_LIST, obj_ast); + for (uint32_t i = 0; i < orig_args->children; i++) { + new_args = zend_ast_arg_list_add(new_args, orig_args->child[i]); + } + + zend_ast *static_call_ast = zend_ast_create( + ZEND_AST_STATIC_CALL, class_ast, method_ast, new_args); + static_call_ast->lineno = ast->lineno; + + zend_compile_static_call(result, static_call_ast, type); + return true; +} +/* }}} */ + static void zend_compile_method_call(znode *result, zend_ast *ast, uint32_t type) /* {{{ */ { zend_ast *obj_ast = ast->child[0]; zend_ast *method_ast = ast->child[1]; zend_ast *args_ast = ast->child[2]; + if (zend_try_compile_scalar_string_method_call(result, ast, type)) { + return; + } + znode obj_node, method_node; zend_op *opline; const zend_function *fbc = NULL; From a90d229fc492a450200c78c7215310aa565ac946 Mon Sep 17 00:00:00 2001 From: Michal Kral Date: Tue, 16 Jun 2026 01:39:53 +0200 Subject: [PATCH 13/14] test: update string-literal method-call test for scalar-method dispatch --- .../varSyntax/method_call_on_string_literal.phpt | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/Zend/tests/varSyntax/method_call_on_string_literal.phpt b/Zend/tests/varSyntax/method_call_on_string_literal.phpt index 40f48d197373..50185794dbff 100644 --- a/Zend/tests/varSyntax/method_call_on_string_literal.phpt +++ b/Zend/tests/varSyntax/method_call_on_string_literal.phpt @@ -1,11 +1,19 @@ --TEST-- -Method call on string literal +Method call on string literal dispatches to the Str backing class (scalar methods) --FILE-- length(); +var_dump(" string "->trim()); +var_dump("string"->length()); +var_dump("ABC"->lower()); +// An unknown method errors as an undefined method on Str, not "member function on string". +"string"->noSuchMethod(); ?> --EXPECTF-- -Fatal error: Uncaught Error: Call to a member function length() on string in %s:%d +string(6) "string" +int(6) +string(3) "abc" + +Fatal error: Uncaught Error: Call to undefined method Str::noSuchMethod() in %s:%d Stack trace: #0 {main} thrown in %s on line %d From 1f4fbe1a11ca714f61bb54c43e2ab88a4f640156 Mon Sep 17 00:00:00 2001 From: Michal Kral Date: Tue, 16 Jun 2026 01:53:16 +0200 Subject: [PATCH 14/14] feat(scalar-methods): chained dispatch on string-returning Str methods + tests --- Zend/tests/scalar_methods/args.phpt | 12 ++++ Zend/tests/scalar_methods/cast_receiver.phpt | 13 ++++ Zend/tests/scalar_methods/chain.phpt | 12 ++++ Zend/tests/scalar_methods/direct_call.phpt | 14 ++++ .../tests/scalar_methods/length_no_chain.phpt | 20 ++++++ Zend/tests/scalar_methods/not_desugared.phpt | 32 +++++++++ Zend/tests/scalar_methods/single.phpt | 12 ++++ .../scalar_methods/undefined_method.phpt | 11 +++ Zend/zend_compile.c | 70 +++++++++++++++++-- 9 files changed, 189 insertions(+), 7 deletions(-) create mode 100644 Zend/tests/scalar_methods/args.phpt create mode 100644 Zend/tests/scalar_methods/cast_receiver.phpt create mode 100644 Zend/tests/scalar_methods/chain.phpt create mode 100644 Zend/tests/scalar_methods/direct_call.phpt create mode 100644 Zend/tests/scalar_methods/length_no_chain.phpt create mode 100644 Zend/tests/scalar_methods/not_desugared.phpt create mode 100644 Zend/tests/scalar_methods/single.phpt create mode 100644 Zend/tests/scalar_methods/undefined_method.phpt diff --git a/Zend/tests/scalar_methods/args.phpt b/Zend/tests/scalar_methods/args.phpt new file mode 100644 index 000000000000..b331bd0704cc --- /dev/null +++ b/Zend/tests/scalar_methods/args.phpt @@ -0,0 +1,12 @@ +--TEST-- +Scalar methods: extra arguments are forwarded after the receiver +--FILE-- +trim("x") desugars to Str::trim("xxhixx", "x"). +var_dump("xxhixx"->trim("x")); +// Argument plus chaining. +var_dump("--Hi--"->trim("-")->upper()); +?> +--EXPECT-- +string(2) "hi" +string(2) "HI" diff --git a/Zend/tests/scalar_methods/cast_receiver.phpt b/Zend/tests/scalar_methods/cast_receiver.phpt new file mode 100644 index 000000000000..98bc26ab7279 --- /dev/null +++ b/Zend/tests/scalar_methods/cast_receiver.phpt @@ -0,0 +1,13 @@ +--TEST-- +Scalar methods: a (string) cast is a valid scalar-method receiver +--FILE-- +upper()); +// Chaining also works off a (string) cast receiver. +$s = " Mixed "; +var_dump(((string)$s)->trim()->lower()); +?> +--EXPECT-- +string(2) "42" +string(5) "mixed" diff --git a/Zend/tests/scalar_methods/chain.phpt b/Zend/tests/scalar_methods/chain.phpt new file mode 100644 index 000000000000..bd5772d775b6 --- /dev/null +++ b/Zend/tests/scalar_methods/chain.phpt @@ -0,0 +1,12 @@ +--TEST-- +Scalar methods: chained dispatch on string-returning Str methods +--FILE-- +(...). +var_dump(" Hello World "->trim()->upper()); +// Triple chain: trim -> upper -> lower. +var_dump(" abc "->trim()->upper()->lower()); +?> +--EXPECT-- +string(11) "HELLO WORLD" +string(3) "abc" diff --git a/Zend/tests/scalar_methods/direct_call.phpt b/Zend/tests/scalar_methods/direct_call.phpt new file mode 100644 index 000000000000..7bba1cc0b00a --- /dev/null +++ b/Zend/tests/scalar_methods/direct_call.phpt @@ -0,0 +1,14 @@ +--TEST-- +Scalar methods: the Str backing class can still be called directly +--FILE-- + +--EXPECT-- +string(1) "x" +string(3) "ABC" +string(3) "abc" +int(5) diff --git a/Zend/tests/scalar_methods/length_no_chain.phpt b/Zend/tests/scalar_methods/length_no_chain.phpt new file mode 100644 index 000000000000..1f25d8951252 --- /dev/null +++ b/Zend/tests/scalar_methods/length_no_chain.phpt @@ -0,0 +1,20 @@ +--TEST-- +Scalar methods: length() returns int and is not treated as a chainable string +--FILE-- +length()); + +// Because length() returns int (not string), it is NOT a chainable string +// receiver: the OUTER call is left as a normal method call on an int, which +// fails at runtime with "member function on int" -- proving the outer call was +// not desugared to a Str:: dispatch. +"hi"->length()->upper(); +?> +--EXPECTF-- +int(5) + +Fatal error: Uncaught Error: Call to a member function upper() on int in %s:%d +Stack trace: +#0 {main} + thrown in %s on line %d diff --git a/Zend/tests/scalar_methods/not_desugared.phpt b/Zend/tests/scalar_methods/not_desugared.phpt new file mode 100644 index 000000000000..f2b71870c925 --- /dev/null +++ b/Zend/tests/scalar_methods/not_desugared.phpt @@ -0,0 +1,32 @@ +--TEST-- +Scalar methods: only static-string receivers desugar; vars/objects/nullsafe unaffected +--FILE-- +trim(); +} catch (\Error $e) { + echo $e->getMessage(), "\n"; +} + +// A genuine object's method call works normally. +class C { + public function trim() { return "object-trim"; } +} +$o = new C(); +var_dump($o->trim()); + +// Nullsafe on a string literal is deliberately excluded from desugaring and +// behaves exactly as before. +try { + var_dump("x"?->trim()); +} catch (\Error $e) { + echo $e->getMessage(), "\n"; +} +?> +--EXPECT-- +Call to a member function trim() on string +string(11) "object-trim" +Call to a member function trim() on string diff --git a/Zend/tests/scalar_methods/single.phpt b/Zend/tests/scalar_methods/single.phpt new file mode 100644 index 000000000000..15a1ef4b9754 --- /dev/null +++ b/Zend/tests/scalar_methods/single.phpt @@ -0,0 +1,12 @@ +--TEST-- +Scalar methods: single method calls on a string-literal receiver +--FILE-- +trim()); +var_dump("AB"->lower()); +var_dump("hello"->length()); +?> +--EXPECT-- +string(2) "hi" +string(2) "ab" +int(5) diff --git a/Zend/tests/scalar_methods/undefined_method.phpt b/Zend/tests/scalar_methods/undefined_method.phpt new file mode 100644 index 000000000000..44b7562d7985 --- /dev/null +++ b/Zend/tests/scalar_methods/undefined_method.phpt @@ -0,0 +1,11 @@ +--TEST-- +Scalar methods: unknown method on a string literal errors as undefined Str method +--FILE-- +nope(); +?> +--EXPECTF-- +Fatal error: Uncaught Error: Call to undefined method Str::nope() in %s:%d +Stack trace: +#0 {main} + thrown in %s on line %d diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index f23975942415..f1f87143e607 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -5542,9 +5542,51 @@ static void zend_compile_call(znode *result, const zend_ast *ast, uint32_t type) } /* }}} */ +static bool zend_is_static_string_ast(zend_ast *ast); + +/* True if `Str::` exists and is declared to return `string`. Used to + * decide whether a `->()` call may itself act as a static + * string receiver for chaining (e.g. `"..."->trim()->upper()`). This is real + * return-type introspection: the Str class is an internal class registered at + * MINIT, so it is always present in the class table during compilation, and + * zend_lookup_class() does not autoload while compiling (it returns NULL instead). + * Methods such as length() that return int are intentionally rejected, so the int + * result is not treated as a chainable string receiver. */ +static bool zend_str_method_returns_string(zval *method_name) /* {{{ */ +{ + if (Z_TYPE_P(method_name) != IS_STRING) { + return false; + } + + zend_string *class_name = ZSTR_INIT_LITERAL("Str", 0); + zend_class_entry *ce = zend_lookup_class(class_name); + zend_string_release(class_name); + if (!ce) { + return false; + } + + zend_string *lcname = zend_string_tolower(Z_STR_P(method_name)); + const zend_function *fbc = zend_hash_find_ptr(&ce->function_table, lcname); + zend_string_release(lcname); + if (!fbc) { + return false; + } + + if (!(fbc->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE)) { + return false; + } + + /* arg_info[-1] is the return type slot when a return type is declared. */ + const zend_arg_info *return_info = fbc->common.arg_info - 1; + return ZEND_TYPE_CONTAINS_CODE(return_info->type, IS_STRING); +} +/* }}} */ + /* True if the expression is a compile-time-known string for the purpose of - * dispatching scalar methods to the Str backing class. For now this is limited - * to string literals and explicit (string) casts. */ + * dispatching scalar methods to the Str backing class. This covers string + * literals, explicit (string) casts, and — to support method chaining — a + * `->()` call whose Str method is declared to return + * `string` (so the call's result is itself a static-string receiver). */ static bool zend_is_static_string_ast(zend_ast *ast) /* {{{ */ { if (ast->kind == ZEND_AST_ZVAL) { @@ -5553,6 +5595,16 @@ static bool zend_is_static_string_ast(zend_ast *ast) /* {{{ */ if (ast->kind == ZEND_AST_CAST) { return ast->attr == IS_STRING; } + /* Chaining: a method call on a static-string receiver with a literal method + * name that resolves to a string-returning Str method is itself a static + * string. nullsafe (`?->`) is deliberately excluded. */ + if (ast->kind == ZEND_AST_METHOD_CALL) { + zend_ast *recv_ast = ast->child[0]; + zend_ast *method_ast = ast->child[1]; + return zend_is_static_string_ast(recv_ast) + && method_ast->kind == ZEND_AST_ZVAL + && zend_str_method_returns_string(zend_ast_get_zval(method_ast)); + } return false; } /* }}} */ @@ -5573,12 +5625,16 @@ static bool zend_try_compile_scalar_string_method_call(znode *result, zend_ast * return false; } - /* Build the class-name node for `Str`. ZEND_NAME_FQ makes it resolve as the - * global `\Str` regardless of the current namespace. The name is interned so - * that the orphan AST zval node carries no refcounted string to leak. */ + /* Build the class-name node for `Str`. ZEND_NAME_FQ resolves it as the global + * `\Str` regardless of namespace. This transient AST is arena-allocated and + * bulk-freed WITHOUT running zval dtors, so the name must be non-refcounted or + * it leaks. Request-time interning is unreliable here (under opcache, interning + * during arbitrary compilation may hand back a refcounted string), so we use a + * PERMANENT interned string (persistent=1): never refcounted, never per-request + * freed — leak-safe in every config including opcache. Repeated calls dedup to + * the same permanent entry. */ zval class_zv; - ZVAL_STRINGL(&class_zv, "Str", sizeof("Str") - 1); - zval_make_interned_string(&class_zv); + ZVAL_STR(&class_zv, zend_string_init_interned("Str", sizeof("Str") - 1, 1)); zend_ast *class_ast = zend_ast_create_zval_ex(&class_zv, ZEND_NAME_FQ); /* Build a new argument list with the receiver prepended before the original args. */