diff --git a/Zend/tests/cast_operators_chaining.phpt b/Zend/tests/cast_operators_chaining.phpt new file mode 100644 index 0000000000000..6e346404effce --- /dev/null +++ b/Zend/tests/cast_operators_chaining.phpt @@ -0,0 +1,22 @@ +--TEST-- +Cast operators chaining and precedence +--FILE-- + +--EXPECT-- +string(3) "123" +float(456) +int(100) +int(100) +int(15) +int(40) diff --git a/Zend/tests/cast_operators_expressions.phpt b/Zend/tests/cast_operators_expressions.phpt new file mode 100644 index 0000000000000..b6917f173eab0 --- /dev/null +++ b/Zend/tests/cast_operators_expressions.phpt @@ -0,0 +1,41 @@ +--TEST-- +Cast operators with complex expressions +--FILE-- + +--EXPECT-- +int(3) +int(12) +int(123) +int(123) +int(10) +array(3) { + [0]=> + NULL + [1]=> + int(789) + [2]=> + string(3) "123" +} diff --git a/Zend/tests/cast_operators_numeric_strings.phpt b/Zend/tests/cast_operators_numeric_strings.phpt new file mode 100644 index 0000000000000..987da7a0bdd39 --- /dev/null +++ b/Zend/tests/cast_operators_numeric_strings.phpt @@ -0,0 +1,43 @@ +--TEST-- +Cast operators with numeric strings +--FILE-- +getMessage() . "\n"; +} + +try { + var_dump((!float) "12.5xyz"); +} catch (TypeError $e) { + echo "Caught: " . $e->getMessage() . "\n"; +} + +// Completely non-numeric - should fail +try { + var_dump((?int) "hello"); +} catch (TypeError $e) { + echo "Caught: " . $e->getMessage() . "\n"; +} + +?> +--EXPECT-- +int(123) +int(123) +float(45.67) +float(45.67) +int(89) +int(89) +Caught: Cannot cast string to int +Caught: Cannot cast string to float +Caught: Cannot cast string to int diff --git a/Zend/tests/cast_operators_strict_types.phpt b/Zend/tests/cast_operators_strict_types.phpt new file mode 100644 index 0000000000000..7e9bf11ae3a5e --- /dev/null +++ b/Zend/tests/cast_operators_strict_types.phpt @@ -0,0 +1,37 @@ +--TEST-- +Nullable and non-null casts ignore strict_types declaration +--FILE-- +getMessage() . "\n"; +} + +try { + var_dump((!int) "abc"); +} catch (TypeError $e) { + echo "Caught: " . $e->getMessage() . "\n"; +} + +// Null handling +var_dump((?int) null); +try { + var_dump((!int) null); +} catch (TypeError $e) { + echo "Caught: " . $e->getMessage() . "\n"; +} + +?> +--EXPECT-- +int(123) +int(456) +Caught: Cannot cast string to int +Caught: Cannot cast string to int +NULL +Caught: Cannot cast null to int diff --git a/Zend/tests/cast_operators_variables.phpt b/Zend/tests/cast_operators_variables.phpt new file mode 100644 index 0000000000000..9150df9ccfeb5 --- /dev/null +++ b/Zend/tests/cast_operators_variables.phpt @@ -0,0 +1,38 @@ +--TEST-- +Cast operators with variables +--FILE-- + +--EXPECT-- +NULL +int(42) +int(123) +Caught TypeError for null +int(42) +int(123) +Caught TypeError for invalid string diff --git a/Zend/tests/nonnull_array_cast_basic.phpt b/Zend/tests/nonnull_array_cast_basic.phpt new file mode 100644 index 0000000000000..ff354b6d4cc69 --- /dev/null +++ b/Zend/tests/nonnull_array_cast_basic.phpt @@ -0,0 +1,26 @@ +--TEST-- +Non-null array cast: basic functionality +--FILE-- + +--EXPECT-- +array(3) { + [0]=> + int(1) + [1]=> + int(2) + [2]=> + int(3) +} +array(1) { + ["bar"]=> + string(3) "baz" +} diff --git a/Zend/tests/nonnull_array_cast_null.phpt b/Zend/tests/nonnull_array_cast_null.phpt new file mode 100644 index 0000000000000..2c92f168590fe --- /dev/null +++ b/Zend/tests/nonnull_array_cast_null.phpt @@ -0,0 +1,15 @@ +--TEST-- +Non-null array cast: null throws TypeError +--FILE-- +getMessage() . "\n"; +} + +?> +--EXPECT-- +TypeError: Cannot cast null to array diff --git a/Zend/tests/nonnull_bool_cast_basic.phpt b/Zend/tests/nonnull_bool_cast_basic.phpt new file mode 100644 index 0000000000000..335c0b4a7cbc2 --- /dev/null +++ b/Zend/tests/nonnull_bool_cast_basic.phpt @@ -0,0 +1,26 @@ +--TEST-- +Non-null bool cast: basic functionality +--FILE-- + +--EXPECT-- +bool(true) +bool(false) +bool(false) +bool(true) +bool(true) +bool(false) +bool(false) +bool(true) diff --git a/Zend/tests/nonnull_bool_cast_null.phpt b/Zend/tests/nonnull_bool_cast_null.phpt new file mode 100644 index 0000000000000..3be42b57302da --- /dev/null +++ b/Zend/tests/nonnull_bool_cast_null.phpt @@ -0,0 +1,15 @@ +--TEST-- +Non-null bool cast: null throws TypeError +--FILE-- +getMessage() . "\n"; +} + +?> +--EXPECT-- +TypeError: Cannot cast null to bool diff --git a/Zend/tests/nonnull_float_cast_basic.phpt b/Zend/tests/nonnull_float_cast_basic.phpt new file mode 100644 index 0000000000000..9272358fa22f7 --- /dev/null +++ b/Zend/tests/nonnull_float_cast_basic.phpt @@ -0,0 +1,21 @@ +--TEST-- +Non-null float cast: basic functionality +--FILE-- + +--EXPECT-- +float(12.34) +float(56) +float(78.9) +float(1) +float(0) diff --git a/Zend/tests/nonnull_float_cast_null.phpt b/Zend/tests/nonnull_float_cast_null.phpt new file mode 100644 index 0000000000000..8d3b965b0ceb3 --- /dev/null +++ b/Zend/tests/nonnull_float_cast_null.phpt @@ -0,0 +1,15 @@ +--TEST-- +Non-null float cast: null throws TypeError +--FILE-- +getMessage() . "\n"; +} + +?> +--EXPECT-- +TypeError: Cannot cast null to float diff --git a/Zend/tests/nonnull_int_cast_basic.phpt b/Zend/tests/nonnull_int_cast_basic.phpt new file mode 100644 index 0000000000000..2077587a07d99 --- /dev/null +++ b/Zend/tests/nonnull_int_cast_basic.phpt @@ -0,0 +1,23 @@ +--TEST-- +Non-null int cast: basic functionality +--FILE-- + +--EXPECTF-- +int(123) +int(456) + +Deprecated: Implicit conversion from float 78.9 to int loses precision in %s on line %d +int(78) +int(1) +int(0) diff --git a/Zend/tests/nonnull_int_cast_invalid.phpt b/Zend/tests/nonnull_int_cast_invalid.phpt new file mode 100644 index 0000000000000..d9c3d9f21066f --- /dev/null +++ b/Zend/tests/nonnull_int_cast_invalid.phpt @@ -0,0 +1,21 @@ +--TEST-- +Non-null int cast: invalid string throws TypeError +--FILE-- +getMessage() . "\n"; +} + +try { + var_dump((!int) "abc"); +} catch (TypeError $e) { + echo "TypeError: " . $e->getMessage() . "\n"; +} + +?> +--EXPECTF-- +TypeError: Cannot cast string to int +TypeError: Cannot cast string to int diff --git a/Zend/tests/nonnull_int_cast_null.phpt b/Zend/tests/nonnull_int_cast_null.phpt new file mode 100644 index 0000000000000..49f26b57f75e5 --- /dev/null +++ b/Zend/tests/nonnull_int_cast_null.phpt @@ -0,0 +1,14 @@ +--TEST-- +Non-null int cast: null throws TypeError +--FILE-- +getMessage() . "\n"; +} + +?> +--EXPECT-- +TypeError: Cannot cast null to int diff --git a/Zend/tests/nonnull_object_cast_basic.phpt b/Zend/tests/nonnull_object_cast_basic.phpt new file mode 100644 index 0000000000000..80dd4313bed50 --- /dev/null +++ b/Zend/tests/nonnull_object_cast_basic.phpt @@ -0,0 +1,22 @@ +--TEST-- +Non-null object cast: basic functionality +--FILE-- + "value"]); + +?> +--EXPECTF-- +object(Foo)#%d (1) { + ["bar"]=> + string(3) "baz" +} +object(stdClass)#%d (1) { + ["key"]=> + string(5) "value" +} diff --git a/Zend/tests/nonnull_object_cast_null.phpt b/Zend/tests/nonnull_object_cast_null.phpt new file mode 100644 index 0000000000000..509b585fd3b63 --- /dev/null +++ b/Zend/tests/nonnull_object_cast_null.phpt @@ -0,0 +1,14 @@ +--TEST-- +Non-null object cast: null throws TypeError +--FILE-- +getMessage() . "\n"; +} + +?> +--EXPECT-- +TypeError: Cannot cast null to object diff --git a/Zend/tests/nonnull_string_cast_basic.phpt b/Zend/tests/nonnull_string_cast_basic.phpt new file mode 100644 index 0000000000000..0ad1500b72292 --- /dev/null +++ b/Zend/tests/nonnull_string_cast_basic.phpt @@ -0,0 +1,18 @@ +--TEST-- +Non-null string cast: basic functionality +--FILE-- + +--EXPECT-- +string(5) "hello" +string(3) "123" +string(5) "45.67" +string(1) "1" +string(0) "" diff --git a/Zend/tests/nonnull_string_cast_null.phpt b/Zend/tests/nonnull_string_cast_null.phpt new file mode 100644 index 0000000000000..9e436037b0d47 --- /dev/null +++ b/Zend/tests/nonnull_string_cast_null.phpt @@ -0,0 +1,14 @@ +--TEST-- +Non-null string cast: null throws TypeError +--FILE-- +getMessage() . "\n"; +} + +?> +--EXPECT-- +TypeError: Cannot cast null to string diff --git a/Zend/tests/nullable_array_cast_basic.phpt b/Zend/tests/nullable_array_cast_basic.phpt new file mode 100644 index 0000000000000..9812fdfa8a7b3 --- /dev/null +++ b/Zend/tests/nullable_array_cast_basic.phpt @@ -0,0 +1,28 @@ +--TEST-- +Nullable array cast: basic functionality +--FILE-- + +--EXPECT-- +NULL +array(3) { + [0]=> + int(1) + [1]=> + int(2) + [2]=> + int(3) +} +array(1) { + ["bar"]=> + string(3) "baz" +} diff --git a/Zend/tests/nullable_array_cast_invalid.phpt b/Zend/tests/nullable_array_cast_invalid.phpt new file mode 100644 index 0000000000000..c63f464d983c5 --- /dev/null +++ b/Zend/tests/nullable_array_cast_invalid.phpt @@ -0,0 +1,21 @@ +--TEST-- +Nullable array cast: invalid types throw TypeError +--FILE-- +getMessage() . "\n"; +} + +try { + var_dump((?array) "hello"); +} catch (TypeError $e) { + echo "TypeError: " . $e->getMessage() . "\n"; +} + +?> +--EXPECTF-- +TypeError: Cannot cast int to array +TypeError: Cannot cast string to array diff --git a/Zend/tests/nullable_bool_cast_basic.phpt b/Zend/tests/nullable_bool_cast_basic.phpt new file mode 100644 index 0000000000000..7841188000f47 --- /dev/null +++ b/Zend/tests/nullable_bool_cast_basic.phpt @@ -0,0 +1,29 @@ +--TEST-- +Nullable bool cast: basic functionality +--FILE-- + +--EXPECT-- +NULL +bool(true) +bool(false) +bool(false) +bool(true) +bool(true) +bool(false) +bool(false) +bool(true) diff --git a/Zend/tests/nullable_float_cast_basic.phpt b/Zend/tests/nullable_float_cast_basic.phpt new file mode 100644 index 0000000000000..76a702bebde02 --- /dev/null +++ b/Zend/tests/nullable_float_cast_basic.phpt @@ -0,0 +1,20 @@ +--TEST-- +Nullable float cast: basic functionality +--FILE-- + +--EXPECT-- +NULL +float(12.34) +float(56) +float(78.9) +float(1) +float(0) diff --git a/Zend/tests/nullable_int_cast_basic.phpt b/Zend/tests/nullable_int_cast_basic.phpt new file mode 100644 index 0000000000000..af9a826b83f47 --- /dev/null +++ b/Zend/tests/nullable_int_cast_basic.phpt @@ -0,0 +1,22 @@ +--TEST-- +Nullable int cast: basic functionality +--FILE-- + +--EXPECTF-- +NULL +int(123) +int(456) + +Deprecated: Implicit conversion from float 78.9 to int loses precision in %s on line %d +int(78) +int(1) +int(0) diff --git a/Zend/tests/nullable_int_cast_invalid.phpt b/Zend/tests/nullable_int_cast_invalid.phpt new file mode 100644 index 0000000000000..bf1bc6c0ad1b5 --- /dev/null +++ b/Zend/tests/nullable_int_cast_invalid.phpt @@ -0,0 +1,28 @@ +--TEST-- +Nullable int cast: invalid string throws TypeError +--FILE-- +getMessage() . "\n"; +} + +try { + var_dump((?int) "abc"); +} catch (TypeError $e) { + echo "TypeError: " . $e->getMessage() . "\n"; +} + +try { + var_dump((?int) []); +} catch (TypeError $e) { + echo "TypeError: " . $e->getMessage() . "\n"; +} + +?> +--EXPECTF-- +TypeError: Cannot cast string to int +TypeError: Cannot cast string to int +TypeError: Cannot cast array to int diff --git a/Zend/tests/nullable_object_cast_basic.phpt b/Zend/tests/nullable_object_cast_basic.phpt new file mode 100644 index 0000000000000..00fd595af96af --- /dev/null +++ b/Zend/tests/nullable_object_cast_basic.phpt @@ -0,0 +1,25 @@ +--TEST-- +Nullable object cast: basic functionality +--FILE-- + "value"]); + +?> +--EXPECTF-- +NULL +object(Foo)#%d (1) { + ["bar"]=> + string(3) "baz" +} +object(stdClass)#%d (1) { + ["key"]=> + string(5) "value" +} diff --git a/Zend/tests/nullable_object_cast_invalid.phpt b/Zend/tests/nullable_object_cast_invalid.phpt new file mode 100644 index 0000000000000..edb5cb959e150 --- /dev/null +++ b/Zend/tests/nullable_object_cast_invalid.phpt @@ -0,0 +1,21 @@ +--TEST-- +Nullable object cast: invalid types throw TypeError +--FILE-- +getMessage() . "\n"; +} + +try { + var_dump((?object) "hello"); +} catch (TypeError $e) { + echo "TypeError: " . $e->getMessage() . "\n"; +} + +?> +--EXPECTF-- +TypeError: Cannot cast int to object +TypeError: Cannot cast string to object diff --git a/Zend/tests/nullable_string_cast_basic.phpt b/Zend/tests/nullable_string_cast_basic.phpt new file mode 100644 index 0000000000000..9b16dce43ec5e --- /dev/null +++ b/Zend/tests/nullable_string_cast_basic.phpt @@ -0,0 +1,20 @@ +--TEST-- +Nullable string cast: basic functionality +--FILE-- + +--EXPECT-- +NULL +string(5) "hello" +string(3) "123" +string(5) "45.67" +string(1) "1" +string(0) "" diff --git a/Zend/zend_ast.h b/Zend/zend_ast.h index fb48b187252b3..09d80e37c6265 100644 --- a/Zend/zend_ast.h +++ b/Zend/zend_ast.h @@ -85,6 +85,8 @@ enum _zend_ast_kind { ZEND_AST_UNARY_MINUS, ZEND_AST_CAST, ZEND_AST_CAST_VOID, + ZEND_AST_NULLABLE_CAST, + ZEND_AST_NONNULL_CAST, ZEND_AST_EMPTY, ZEND_AST_ISSET, ZEND_AST_SILENCE, @@ -415,6 +417,12 @@ static zend_always_inline zend_ast *zend_ast_create_assign_op(uint32_t opcode, z static zend_always_inline zend_ast *zend_ast_create_cast(uint32_t type, zend_ast *op0) { return zend_ast_create_ex(ZEND_AST_CAST, type, op0); } +static zend_always_inline zend_ast *zend_ast_create_nullable_cast(uint32_t type, zend_ast *op0) { + return zend_ast_create_ex(ZEND_AST_NULLABLE_CAST, type, op0); +} +static zend_always_inline zend_ast *zend_ast_create_nonnull_cast(uint32_t type, zend_ast *op0) { + return zend_ast_create_ex(ZEND_AST_NONNULL_CAST, type, op0); +} static zend_always_inline zend_ast *zend_ast_list_rtrim(zend_ast *ast) { zend_ast_list *list = zend_ast_get_list(ast); if (list->children && list->child[list->children - 1] == NULL) { diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index d61c2df0a3555..3aad133ef933b 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -10494,6 +10494,30 @@ static void zend_compile_cast(znode *result, zend_ast *ast) /* {{{ */ } /* }}} */ +static void zend_compile_nullable_cast(znode *result, zend_ast *ast) +{ + zend_ast *expr_ast = ast->child[0]; + znode expr_node; + zend_op *opline; + + zend_compile_expr(&expr_node, expr_ast); + + opline = zend_emit_op_tmp(result, ZEND_NULLABLE_CAST, &expr_node, NULL); + opline->extended_value = ast->attr; +} + +static void zend_compile_nonnull_cast(znode *result, zend_ast *ast) +{ + zend_ast *expr_ast = ast->child[0]; + znode expr_node; + zend_op *opline; + + zend_compile_expr(&expr_node, expr_ast); + + opline = zend_emit_op_tmp(result, ZEND_NONNULL_CAST, &expr_node, NULL); + opline->extended_value = ast->attr; +} + static void zend_compile_shorthand_conditional(znode *result, zend_ast *ast) /* {{{ */ { zend_ast *cond_ast = ast->child[0]; @@ -11625,6 +11649,13 @@ static void zend_compile_const_expr(zend_ast **ast_ptr, void *context) /* {{{ */ "Object casts are not supported in this context"); } break; + case ZEND_AST_NULLABLE_CAST: + case ZEND_AST_NONNULL_CAST: + if (ast->attr == IS_OBJECT && !ctx->allow_dynamic) { + zend_error_noreturn(E_COMPILE_ERROR, + "Object casts are not supported in this context"); + } + break; case ZEND_AST_NEW: if (!ctx->allow_dynamic) { zend_error_noreturn(E_COMPILE_ERROR, @@ -11890,6 +11921,12 @@ static void zend_compile_expr_inner(znode *result, zend_ast *ast) /* {{{ */ case ZEND_AST_CAST: zend_compile_cast(result, ast); return; + case ZEND_AST_NULLABLE_CAST: + zend_compile_nullable_cast(result, ast); + return; + case ZEND_AST_NONNULL_CAST: + zend_compile_nonnull_cast(result, ast); + return; case ZEND_AST_CONDITIONAL: zend_compile_conditional(result, ast); return; @@ -12386,6 +12423,11 @@ static void zend_eval_const_expr(zend_ast **ast_ptr) /* {{{ */ break; } return; + case ZEND_AST_NULLABLE_CAST: + case ZEND_AST_NONNULL_CAST: + /* Nullable and non-null casts require runtime validation, cannot be const-folded */ + zend_eval_const_expr(&ast->child[0]); + return; default: return; } diff --git a/Zend/zend_language_parser.y b/Zend/zend_language_parser.y index e4d61006fe12f..04765ff5fd0e1 100644 --- a/Zend/zend_language_parser.y +++ b/Zend/zend_language_parser.y @@ -78,7 +78,7 @@ static YYSIZE_T zend_yytnamerr(char*, const char*); %left '*' '/' '%' %precedence '!' %precedence T_INSTANCEOF -%precedence '~' T_INT_CAST T_DOUBLE_CAST T_STRING_CAST T_ARRAY_CAST T_OBJECT_CAST T_BOOL_CAST T_UNSET_CAST '@' +%precedence '~' T_INT_CAST T_DOUBLE_CAST T_STRING_CAST T_ARRAY_CAST T_OBJECT_CAST T_BOOL_CAST T_UNSET_CAST T_NULLABLE_INT_CAST T_NULLABLE_DOUBLE_CAST T_NULLABLE_STRING_CAST T_NULLABLE_ARRAY_CAST T_NULLABLE_OBJECT_CAST T_NULLABLE_BOOL_CAST T_NONNULL_INT_CAST T_NONNULL_DOUBLE_CAST T_NONNULL_STRING_CAST T_NONNULL_ARRAY_CAST T_NONNULL_OBJECT_CAST T_NONNULL_BOOL_CAST '@' %right T_POW %precedence T_CLONE @@ -219,6 +219,18 @@ static YYSIZE_T zend_yytnamerr(char*, const char*); %token T_BOOL_CAST "'(bool)'" %token T_UNSET_CAST "'(unset)'" %token T_VOID_CAST "'(void)'" +%token T_NULLABLE_INT_CAST "'(?int)'" +%token T_NULLABLE_DOUBLE_CAST "'(?float)'" +%token T_NULLABLE_STRING_CAST "'(?string)'" +%token T_NULLABLE_ARRAY_CAST "'(?array)'" +%token T_NULLABLE_OBJECT_CAST "'(?object)'" +%token T_NULLABLE_BOOL_CAST "'(?bool)'" +%token T_NONNULL_INT_CAST "'(!int)'" +%token T_NONNULL_DOUBLE_CAST "'(!float)'" +%token T_NONNULL_STRING_CAST "'(!string)'" +%token T_NONNULL_ARRAY_CAST "'(!array)'" +%token T_NONNULL_OBJECT_CAST "'(!object)'" +%token T_NONNULL_BOOL_CAST "'(!bool)'" %token T_OBJECT_OPERATOR "'->'" %token T_NULLSAFE_OBJECT_OPERATOR "'?->'" %token T_DOUBLE_ARROW "'=>'" @@ -1366,6 +1378,18 @@ expr: | T_OBJECT_CAST expr { $$ = zend_ast_create_cast(IS_OBJECT, $2); } | T_BOOL_CAST expr { $$ = zend_ast_create_cast(_IS_BOOL, $2); } | T_UNSET_CAST expr { $$ = zend_ast_create_cast(IS_NULL, $2); } + | T_NULLABLE_INT_CAST expr { $$ = zend_ast_create_nullable_cast(IS_LONG, $2); } + | T_NULLABLE_DOUBLE_CAST expr { $$ = zend_ast_create_nullable_cast(IS_DOUBLE, $2); } + | T_NULLABLE_STRING_CAST expr { $$ = zend_ast_create_nullable_cast(IS_STRING, $2); } + | T_NULLABLE_ARRAY_CAST expr { $$ = zend_ast_create_nullable_cast(IS_ARRAY, $2); } + | T_NULLABLE_OBJECT_CAST expr { $$ = zend_ast_create_nullable_cast(IS_OBJECT, $2); } + | T_NULLABLE_BOOL_CAST expr { $$ = zend_ast_create_nullable_cast(_IS_BOOL, $2); } + | T_NONNULL_INT_CAST expr { $$ = zend_ast_create_nonnull_cast(IS_LONG, $2); } + | T_NONNULL_DOUBLE_CAST expr { $$ = zend_ast_create_nonnull_cast(IS_DOUBLE, $2); } + | T_NONNULL_STRING_CAST expr { $$ = zend_ast_create_nonnull_cast(IS_STRING, $2); } + | T_NONNULL_ARRAY_CAST expr { $$ = zend_ast_create_nonnull_cast(IS_ARRAY, $2); } + | T_NONNULL_OBJECT_CAST expr { $$ = zend_ast_create_nonnull_cast(IS_OBJECT, $2); } + | T_NONNULL_BOOL_CAST expr { $$ = zend_ast_create_nonnull_cast(_IS_BOOL, $2); } | T_EXIT ctor_arguments { zend_ast *name = zend_ast_create_zval_from_str(ZSTR_KNOWN(ZEND_STR_EXIT)); name->attr = ZEND_NAME_FQ; diff --git a/Zend/zend_language_scanner.l b/Zend/zend_language_scanner.l index 3ecb2f8d0ee45..ce7de908333ae 100644 --- a/Zend/zend_language_scanner.l +++ b/Zend/zend_language_scanner.l @@ -1714,6 +1714,54 @@ OPTIONAL_WHITESPACE_OR_COMMENTS ({WHITESPACE}|{MULTI_LINE_COMMENT}|{SINGLE_LINE_ RETURN_TOKEN(T_VOID_CAST); } +"("{TABS_AND_SPACES}"?"{TABS_AND_SPACES}("int"){TABS_AND_SPACES}")" { + RETURN_TOKEN(T_NULLABLE_INT_CAST); +} + +"("{TABS_AND_SPACES}"?"{TABS_AND_SPACES}("float"){TABS_AND_SPACES}")" { + RETURN_TOKEN(T_NULLABLE_DOUBLE_CAST); +} + +"("{TABS_AND_SPACES}"?"{TABS_AND_SPACES}("string"){TABS_AND_SPACES}")" { + RETURN_TOKEN(T_NULLABLE_STRING_CAST); +} + +"("{TABS_AND_SPACES}"?"{TABS_AND_SPACES}("array"){TABS_AND_SPACES}")" { + RETURN_TOKEN(T_NULLABLE_ARRAY_CAST); +} + +"("{TABS_AND_SPACES}"?"{TABS_AND_SPACES}("object"){TABS_AND_SPACES}")" { + RETURN_TOKEN(T_NULLABLE_OBJECT_CAST); +} + +"("{TABS_AND_SPACES}"?"{TABS_AND_SPACES}("bool"){TABS_AND_SPACES}")" { + RETURN_TOKEN(T_NULLABLE_BOOL_CAST); +} + +"("{TABS_AND_SPACES}"!"{TABS_AND_SPACES}("int"){TABS_AND_SPACES}")" { + RETURN_TOKEN(T_NONNULL_INT_CAST); +} + +"("{TABS_AND_SPACES}"!"{TABS_AND_SPACES}("float"){TABS_AND_SPACES}")" { + RETURN_TOKEN(T_NONNULL_DOUBLE_CAST); +} + +"("{TABS_AND_SPACES}"!"{TABS_AND_SPACES}("string"){TABS_AND_SPACES}")" { + RETURN_TOKEN(T_NONNULL_STRING_CAST); +} + +"("{TABS_AND_SPACES}"!"{TABS_AND_SPACES}("array"){TABS_AND_SPACES}")" { + RETURN_TOKEN(T_NONNULL_ARRAY_CAST); +} + +"("{TABS_AND_SPACES}"!"{TABS_AND_SPACES}("object"){TABS_AND_SPACES}")" { + RETURN_TOKEN(T_NONNULL_OBJECT_CAST); +} + +"("{TABS_AND_SPACES}"!"{TABS_AND_SPACES}("bool"){TABS_AND_SPACES}")" { + RETURN_TOKEN(T_NONNULL_BOOL_CAST); +} + "eval" { RETURN_TOKEN_WITH_IDENT(T_EVAL); } diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index d71c06c0a1354..b1f6e036b1ff2 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -6522,6 +6522,207 @@ ZEND_VM_COLD_CONST_HANDLER(51, ZEND_CAST, CONST|TMP|VAR|CV, ANY, TYPE) ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +#define COPY_ZVAL_WITH_REFCOUNT(result, expr, op1_type) do { \ + ZVAL_COPY_VALUE(result, expr); \ + if ((op1_type) == IS_CONST && UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) { \ + Z_ADDREF_P(result); \ + } else if ((op1_type) != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(result)) { \ + Z_ADDREF_P(result); \ + } \ +} while (0) + +#define GET_TYPE_MASK_AND_TARGET(extended_value, type_mask_var, target_type_var) do { \ + switch (extended_value) { \ + case IS_LONG: type_mask_var = MAY_BE_LONG; target_type_var = IS_LONG; break; \ + case IS_DOUBLE: type_mask_var = MAY_BE_DOUBLE; target_type_var = IS_DOUBLE; break; \ + case IS_STRING: type_mask_var = MAY_BE_STRING; target_type_var = IS_STRING; break; \ + case _IS_BOOL: type_mask_var = MAY_BE_BOOL; target_type_var = IS_TRUE; break; \ + default: ZEND_UNREACHABLE(); \ + } \ +} while (0) + +ZEND_VM_COLD_CONST_HANDLER(211, ZEND_NULLABLE_CAST, CONST|TMP|VAR|CV, ANY, TYPE) +{ + USE_OPLINE + zval *expr; + zval *result = EX_VAR(opline->result.var); + + SAVE_OPLINE(); + expr = GET_OP1_ZVAL_PTR(BP_VAR_R); + + if (OP1_TYPE & (IS_VAR|IS_CV)) { + ZVAL_DEREF(expr); + } + + /* Check for null first - if null, return null unchanged */ + if (Z_TYPE_P(expr) == IS_NULL) { + ZVAL_NULL(result); + FREE_OP1(); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + + /* For non-null values, perform weak mode validation and coercion */ + switch (opline->extended_value) { + case IS_LONG: + case IS_DOUBLE: + case IS_STRING: + case _IS_BOOL: { + uint32_t type_mask; + uint8_t target_type; + GET_TYPE_MASK_AND_TARGET(opline->extended_value, type_mask, target_type); + + /* Copy value for validation */ + COPY_ZVAL_WITH_REFCOUNT(result, expr, OP1_TYPE); + + /* Check if already correct type */ + if (opline->extended_value == _IS_BOOL) { + if (Z_TYPE_P(result) == IS_TRUE || Z_TYPE_P(result) == IS_FALSE) { + break; /* Already a bool, no conversion needed */ + } + } else if (Z_TYPE_P(result) == target_type) { + break; /* Already correct type, no conversion needed */ + } + + /* Attempt weak mode type coercion */ + if (!zend_verify_weak_scalar_type_hint(type_mask, result)) { + zval_ptr_dtor(result); + FREE_OP1_IF_VAR(); + zend_type_error("Cannot cast %s to %s", + zend_zval_type_name(expr), + opline->extended_value == IS_LONG ? "int" : + opline->extended_value == IS_DOUBLE ? "float" : + opline->extended_value == IS_STRING ? "string" : "bool"); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + } + case IS_ARRAY: + if (Z_TYPE_P(expr) == IS_ARRAY) { + COPY_ZVAL_WITH_REFCOUNT(result, expr, OP1_TYPE); + } else if (Z_TYPE_P(expr) == IS_OBJECT) { + zend_cast_zval_to_array(result, expr, OP1_TYPE); + } else { + FREE_OP1_IF_VAR(); + zend_type_error("Cannot cast %s to array", zend_zval_type_name(expr)); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + case IS_OBJECT: + if (Z_TYPE_P(expr) == IS_OBJECT) { + COPY_ZVAL_WITH_REFCOUNT(result, expr, OP1_TYPE); + } else if (Z_TYPE_P(expr) == IS_ARRAY) { + zend_cast_zval_to_object(result, expr, OP1_TYPE); + } else { + FREE_OP1_IF_VAR(); + zend_type_error("Cannot cast %s to object", zend_zval_type_name(expr)); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + default: + ZEND_UNREACHABLE(); + } + + FREE_OP1(); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +ZEND_VM_COLD_CONST_HANDLER(212, ZEND_NONNULL_CAST, CONST|TMP|VAR|CV, ANY, TYPE) +{ + USE_OPLINE + zval *expr; + zval *result = EX_VAR(opline->result.var); + + SAVE_OPLINE(); + expr = GET_OP1_ZVAL_PTR(BP_VAR_R); + + if (OP1_TYPE & (IS_VAR|IS_CV)) { + ZVAL_DEREF(expr); + } + + /* Check for null - if null, throw TypeError */ + if (Z_TYPE_P(expr) == IS_NULL) { + FREE_OP1_IF_VAR(); + zend_type_error("Cannot cast null to %s", + opline->extended_value == IS_LONG ? "int" : + opline->extended_value == IS_DOUBLE ? "float" : + opline->extended_value == IS_STRING ? "string" : + opline->extended_value == _IS_BOOL ? "bool" : + opline->extended_value == IS_ARRAY ? "array" : "object"); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + + /* For non-null values, perform weak mode validation and coercion */ + switch (opline->extended_value) { + case IS_LONG: + case IS_DOUBLE: + case IS_STRING: + case _IS_BOOL: { + uint32_t type_mask; + uint8_t target_type; + GET_TYPE_MASK_AND_TARGET(opline->extended_value, type_mask, target_type); + + /* Copy value for validation */ + COPY_ZVAL_WITH_REFCOUNT(result, expr, OP1_TYPE); + + /* Check if already correct type */ + if (opline->extended_value == _IS_BOOL) { + if (Z_TYPE_P(result) == IS_TRUE || Z_TYPE_P(result) == IS_FALSE) { + break; /* Already a bool, no conversion needed */ + } + } else if (Z_TYPE_P(result) == target_type) { + break; /* Already correct type, no conversion needed */ + } + + /* Attempt weak mode type coercion */ + if (!zend_verify_weak_scalar_type_hint(type_mask, result)) { + zval_ptr_dtor(result); + FREE_OP1_IF_VAR(); + zend_type_error("Cannot cast %s to %s", + zend_zval_type_name(expr), + opline->extended_value == IS_LONG ? "int" : + opline->extended_value == IS_DOUBLE ? "float" : + opline->extended_value == IS_STRING ? "string" : "bool"); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + } + case IS_ARRAY: + if (Z_TYPE_P(expr) == IS_ARRAY) { + COPY_ZVAL_WITH_REFCOUNT(result, expr, OP1_TYPE); + } else if (Z_TYPE_P(expr) == IS_OBJECT) { + zend_cast_zval_to_array(result, expr, OP1_TYPE); + } else { + FREE_OP1_IF_VAR(); + zend_type_error("Cannot cast %s to array", zend_zval_type_name(expr)); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + case IS_OBJECT: + if (Z_TYPE_P(expr) == IS_OBJECT) { + COPY_ZVAL_WITH_REFCOUNT(result, expr, OP1_TYPE); + } else if (Z_TYPE_P(expr) == IS_ARRAY) { + zend_cast_zval_to_object(result, expr, OP1_TYPE); + } else { + FREE_OP1_IF_VAR(); + zend_type_error("Cannot cast %s to object", zend_zval_type_name(expr)); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + default: + ZEND_UNREACHABLE(); + } + + FREE_OP1(); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMPVAR|CV, ANY, EVAL, SPEC(OBSERVER)) { USE_OPLINE diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 50b65c864ed21..dd4803432a9f7 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -5359,6 +5359,215 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +#define COPY_ZVAL_WITH_REFCOUNT(result, expr, op1_type) do { \ + ZVAL_COPY_VALUE(result, expr); \ + if ((op1_type) == IS_CONST && UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) { \ + Z_ADDREF_P(result); \ + } else if ((op1_type) != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(result)) { \ + Z_ADDREF_P(result); \ + } \ +} while (0) + +#define GET_TYPE_MASK_AND_TARGET(extended_value, type_mask_var, target_type_var) do { \ + switch (extended_value) { \ + case IS_LONG: type_mask_var = MAY_BE_LONG; target_type_var = IS_LONG; break; \ + case IS_DOUBLE: type_mask_var = MAY_BE_DOUBLE; target_type_var = IS_DOUBLE; break; \ + case IS_STRING: type_mask_var = MAY_BE_STRING; target_type_var = IS_STRING; break; \ + case _IS_BOOL: type_mask_var = MAY_BE_BOOL; target_type_var = IS_TRUE; break; \ + default: ZEND_UNREACHABLE(); \ + } \ +} while (0) + +static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_NULLABLE_CAST_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *expr; + zval *result = EX_VAR(opline->result.var); + + SAVE_OPLINE(); + expr = RT_CONSTANT(opline, opline->op1); + + if (IS_CONST & (IS_VAR|IS_CV)) { + ZVAL_DEREF(expr); + } + + /* Check for null first - if null, return null unchanged */ + if (Z_TYPE_P(expr) == IS_NULL) { + ZVAL_NULL(result); + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + + /* For non-null values, perform weak mode validation and coercion */ + switch (opline->extended_value) { + case IS_LONG: + case IS_DOUBLE: + case IS_STRING: + case _IS_BOOL: { + uint32_t type_mask; + uint8_t target_type; + GET_TYPE_MASK_AND_TARGET(opline->extended_value, type_mask, target_type); + + /* Copy value for validation */ + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_CONST); + + /* Check if already correct type */ + if (opline->extended_value == _IS_BOOL) { + if (Z_TYPE_P(result) == IS_TRUE || Z_TYPE_P(result) == IS_FALSE) { + break; /* Already a bool, no conversion needed */ + } + } else if (Z_TYPE_P(result) == target_type) { + break; /* Already correct type, no conversion needed */ + } + + /* Attempt weak mode type coercion */ + if (!zend_verify_weak_scalar_type_hint(type_mask, result)) { + zval_ptr_dtor(result); + + + zend_type_error("Cannot cast %s to %s", + zend_zval_type_name(expr), + opline->extended_value == IS_LONG ? "int" : + opline->extended_value == IS_DOUBLE ? "float" : + opline->extended_value == IS_STRING ? "string" : "bool"); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + } + case IS_ARRAY: + if (Z_TYPE_P(expr) == IS_ARRAY) { + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_CONST); + } else if (Z_TYPE_P(expr) == IS_OBJECT) { + zend_cast_zval_to_array(result, expr, IS_CONST); + } else { + + + zend_type_error("Cannot cast %s to array", zend_zval_type_name(expr)); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + case IS_OBJECT: + if (Z_TYPE_P(expr) == IS_OBJECT) { + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_CONST); + } else if (Z_TYPE_P(expr) == IS_ARRAY) { + zend_cast_zval_to_object(result, expr, IS_CONST); + } else { + + + zend_type_error("Cannot cast %s to object", zend_zval_type_name(expr)); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + default: + ZEND_UNREACHABLE(); + } + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_NONNULL_CAST_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *expr; + zval *result = EX_VAR(opline->result.var); + + SAVE_OPLINE(); + expr = RT_CONSTANT(opline, opline->op1); + + if (IS_CONST & (IS_VAR|IS_CV)) { + ZVAL_DEREF(expr); + } + + /* Check for null - if null, throw TypeError */ + if (Z_TYPE_P(expr) == IS_NULL) { + + + zend_type_error("Cannot cast null to %s", + opline->extended_value == IS_LONG ? "int" : + opline->extended_value == IS_DOUBLE ? "float" : + opline->extended_value == IS_STRING ? "string" : + opline->extended_value == _IS_BOOL ? "bool" : + opline->extended_value == IS_ARRAY ? "array" : "object"); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + + /* For non-null values, perform weak mode validation and coercion */ + switch (opline->extended_value) { + case IS_LONG: + case IS_DOUBLE: + case IS_STRING: + case _IS_BOOL: { + uint32_t type_mask; + uint8_t target_type; + GET_TYPE_MASK_AND_TARGET(opline->extended_value, type_mask, target_type); + + /* Copy value for validation */ + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_CONST); + + /* Check if already correct type */ + if (opline->extended_value == _IS_BOOL) { + if (Z_TYPE_P(result) == IS_TRUE || Z_TYPE_P(result) == IS_FALSE) { + break; /* Already a bool, no conversion needed */ + } + } else if (Z_TYPE_P(result) == target_type) { + break; /* Already correct type, no conversion needed */ + } + + /* Attempt weak mode type coercion */ + if (!zend_verify_weak_scalar_type_hint(type_mask, result)) { + zval_ptr_dtor(result); + + + zend_type_error("Cannot cast %s to %s", + zend_zval_type_name(expr), + opline->extended_value == IS_LONG ? "int" : + opline->extended_value == IS_DOUBLE ? "float" : + opline->extended_value == IS_STRING ? "string" : "bool"); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + } + case IS_ARRAY: + if (Z_TYPE_P(expr) == IS_ARRAY) { + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_CONST); + } else if (Z_TYPE_P(expr) == IS_OBJECT) { + zend_cast_zval_to_array(result, expr, IS_CONST); + } else { + + + zend_type_error("Cannot cast %s to array", zend_zval_type_name(expr)); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + case IS_OBJECT: + if (Z_TYPE_P(expr) == IS_OBJECT) { + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_CONST); + } else if (Z_TYPE_P(expr) == IS_ARRAY) { + zend_cast_zval_to_object(result, expr, IS_CONST); + } else { + + + zend_type_error("Cannot cast %s to object", zend_zval_type_name(expr)); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + default: + ZEND_UNREACHABLE(); + } + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -20639,6 +20848,214 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CAST_SPEC_TMP ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +#define COPY_ZVAL_WITH_REFCOUNT(result, expr, op1_type) do { \ + ZVAL_COPY_VALUE(result, expr); \ + if ((op1_type) == IS_CONST && UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) { \ + Z_ADDREF_P(result); \ + } else if ((op1_type) != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(result)) { \ + Z_ADDREF_P(result); \ + } \ +} while (0) + +#define GET_TYPE_MASK_AND_TARGET(extended_value, type_mask_var, target_type_var) do { \ + switch (extended_value) { \ + case IS_LONG: type_mask_var = MAY_BE_LONG; target_type_var = IS_LONG; break; \ + case IS_DOUBLE: type_mask_var = MAY_BE_DOUBLE; target_type_var = IS_DOUBLE; break; \ + case IS_STRING: type_mask_var = MAY_BE_STRING; target_type_var = IS_STRING; break; \ + case _IS_BOOL: type_mask_var = MAY_BE_BOOL; target_type_var = IS_TRUE; break; \ + default: ZEND_UNREACHABLE(); \ + } \ +} while (0) + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_NULLABLE_CAST_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *expr; + zval *result = EX_VAR(opline->result.var); + + SAVE_OPLINE(); + expr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + + if (IS_TMP_VAR & (IS_VAR|IS_CV)) { + ZVAL_DEREF(expr); + } + + /* Check for null first - if null, return null unchanged */ + if (Z_TYPE_P(expr) == IS_NULL) { + ZVAL_NULL(result); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + + /* For non-null values, perform weak mode validation and coercion */ + switch (opline->extended_value) { + case IS_LONG: + case IS_DOUBLE: + case IS_STRING: + case _IS_BOOL: { + uint32_t type_mask; + uint8_t target_type; + GET_TYPE_MASK_AND_TARGET(opline->extended_value, type_mask, target_type); + + /* Copy value for validation */ + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_TMP_VAR); + + /* Check if already correct type */ + if (opline->extended_value == _IS_BOOL) { + if (Z_TYPE_P(result) == IS_TRUE || Z_TYPE_P(result) == IS_FALSE) { + break; /* Already a bool, no conversion needed */ + } + } else if (Z_TYPE_P(result) == target_type) { + break; /* Already correct type, no conversion needed */ + } + + /* Attempt weak mode type coercion */ + if (!zend_verify_weak_scalar_type_hint(type_mask, result)) { + zval_ptr_dtor(result); + + + zend_type_error("Cannot cast %s to %s", + zend_zval_type_name(expr), + opline->extended_value == IS_LONG ? "int" : + opline->extended_value == IS_DOUBLE ? "float" : + opline->extended_value == IS_STRING ? "string" : "bool"); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + } + case IS_ARRAY: + if (Z_TYPE_P(expr) == IS_ARRAY) { + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_TMP_VAR); + } else if (Z_TYPE_P(expr) == IS_OBJECT) { + zend_cast_zval_to_array(result, expr, IS_TMP_VAR); + } else { + + + zend_type_error("Cannot cast %s to array", zend_zval_type_name(expr)); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + case IS_OBJECT: + if (Z_TYPE_P(expr) == IS_OBJECT) { + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_TMP_VAR); + } else if (Z_TYPE_P(expr) == IS_ARRAY) { + zend_cast_zval_to_object(result, expr, IS_TMP_VAR); + } else { + + + zend_type_error("Cannot cast %s to object", zend_zval_type_name(expr)); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + default: + ZEND_UNREACHABLE(); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_NONNULL_CAST_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *expr; + zval *result = EX_VAR(opline->result.var); + + SAVE_OPLINE(); + expr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + + if (IS_TMP_VAR & (IS_VAR|IS_CV)) { + ZVAL_DEREF(expr); + } + + /* Check for null - if null, throw TypeError */ + if (Z_TYPE_P(expr) == IS_NULL) { + + + zend_type_error("Cannot cast null to %s", + opline->extended_value == IS_LONG ? "int" : + opline->extended_value == IS_DOUBLE ? "float" : + opline->extended_value == IS_STRING ? "string" : + opline->extended_value == _IS_BOOL ? "bool" : + opline->extended_value == IS_ARRAY ? "array" : "object"); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + + /* For non-null values, perform weak mode validation and coercion */ + switch (opline->extended_value) { + case IS_LONG: + case IS_DOUBLE: + case IS_STRING: + case _IS_BOOL: { + uint32_t type_mask; + uint8_t target_type; + GET_TYPE_MASK_AND_TARGET(opline->extended_value, type_mask, target_type); + + /* Copy value for validation */ + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_TMP_VAR); + + /* Check if already correct type */ + if (opline->extended_value == _IS_BOOL) { + if (Z_TYPE_P(result) == IS_TRUE || Z_TYPE_P(result) == IS_FALSE) { + break; /* Already a bool, no conversion needed */ + } + } else if (Z_TYPE_P(result) == target_type) { + break; /* Already correct type, no conversion needed */ + } + + /* Attempt weak mode type coercion */ + if (!zend_verify_weak_scalar_type_hint(type_mask, result)) { + zval_ptr_dtor(result); + + + zend_type_error("Cannot cast %s to %s", + zend_zval_type_name(expr), + opline->extended_value == IS_LONG ? "int" : + opline->extended_value == IS_DOUBLE ? "float" : + opline->extended_value == IS_STRING ? "string" : "bool"); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + } + case IS_ARRAY: + if (Z_TYPE_P(expr) == IS_ARRAY) { + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_TMP_VAR); + } else if (Z_TYPE_P(expr) == IS_OBJECT) { + zend_cast_zval_to_array(result, expr, IS_TMP_VAR); + } else { + + + zend_type_error("Cannot cast %s to array", zend_zval_type_name(expr)); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + case IS_OBJECT: + if (Z_TYPE_P(expr) == IS_OBJECT) { + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_TMP_VAR); + } else if (Z_TYPE_P(expr) == IS_ARRAY) { + zend_cast_zval_to_object(result, expr, IS_TMP_VAR); + } else { + + + zend_type_error("Cannot cast %s to object", zend_zval_type_name(expr)); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + default: + ZEND_UNREACHABLE(); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FE_RESET_R_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -23302,6 +23719,207 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CAST_SPEC_VAR ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +#define COPY_ZVAL_WITH_REFCOUNT(result, expr, op1_type) do { \ + ZVAL_COPY_VALUE(result, expr); \ + if ((op1_type) == IS_CONST && UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) { \ + Z_ADDREF_P(result); \ + } else if ((op1_type) != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(result)) { \ + Z_ADDREF_P(result); \ + } \ +} while (0) + +#define GET_TYPE_MASK_AND_TARGET(extended_value, type_mask_var, target_type_var) do { \ + switch (extended_value) { \ + case IS_LONG: type_mask_var = MAY_BE_LONG; target_type_var = IS_LONG; break; \ + case IS_DOUBLE: type_mask_var = MAY_BE_DOUBLE; target_type_var = IS_DOUBLE; break; \ + case IS_STRING: type_mask_var = MAY_BE_STRING; target_type_var = IS_STRING; break; \ + case _IS_BOOL: type_mask_var = MAY_BE_BOOL; target_type_var = IS_TRUE; break; \ + default: ZEND_UNREACHABLE(); \ + } \ +} while (0) + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_NULLABLE_CAST_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *expr; + zval *result = EX_VAR(opline->result.var); + + SAVE_OPLINE(); + expr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if (IS_VAR & (IS_VAR|IS_CV)) { + ZVAL_DEREF(expr); + } + + /* Check for null first - if null, return null unchanged */ + if (Z_TYPE_P(expr) == IS_NULL) { + ZVAL_NULL(result); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + + /* For non-null values, perform weak mode validation and coercion */ + switch (opline->extended_value) { + case IS_LONG: + case IS_DOUBLE: + case IS_STRING: + case _IS_BOOL: { + uint32_t type_mask; + uint8_t target_type; + GET_TYPE_MASK_AND_TARGET(opline->extended_value, type_mask, target_type); + + /* Copy value for validation */ + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_VAR); + + /* Check if already correct type */ + if (opline->extended_value == _IS_BOOL) { + if (Z_TYPE_P(result) == IS_TRUE || Z_TYPE_P(result) == IS_FALSE) { + break; /* Already a bool, no conversion needed */ + } + } else if (Z_TYPE_P(result) == target_type) { + break; /* Already correct type, no conversion needed */ + } + + /* Attempt weak mode type coercion */ + if (!zend_verify_weak_scalar_type_hint(type_mask, result)) { + zval_ptr_dtor(result); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + zend_type_error("Cannot cast %s to %s", + zend_zval_type_name(expr), + opline->extended_value == IS_LONG ? "int" : + opline->extended_value == IS_DOUBLE ? "float" : + opline->extended_value == IS_STRING ? "string" : "bool"); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + } + case IS_ARRAY: + if (Z_TYPE_P(expr) == IS_ARRAY) { + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_VAR); + } else if (Z_TYPE_P(expr) == IS_OBJECT) { + zend_cast_zval_to_array(result, expr, IS_VAR); + } else { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + zend_type_error("Cannot cast %s to array", zend_zval_type_name(expr)); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + case IS_OBJECT: + if (Z_TYPE_P(expr) == IS_OBJECT) { + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_VAR); + } else if (Z_TYPE_P(expr) == IS_ARRAY) { + zend_cast_zval_to_object(result, expr, IS_VAR); + } else { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + zend_type_error("Cannot cast %s to object", zend_zval_type_name(expr)); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + default: + ZEND_UNREACHABLE(); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_NONNULL_CAST_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *expr; + zval *result = EX_VAR(opline->result.var); + + SAVE_OPLINE(); + expr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if (IS_VAR & (IS_VAR|IS_CV)) { + ZVAL_DEREF(expr); + } + + /* Check for null - if null, throw TypeError */ + if (Z_TYPE_P(expr) == IS_NULL) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + zend_type_error("Cannot cast null to %s", + opline->extended_value == IS_LONG ? "int" : + opline->extended_value == IS_DOUBLE ? "float" : + opline->extended_value == IS_STRING ? "string" : + opline->extended_value == _IS_BOOL ? "bool" : + opline->extended_value == IS_ARRAY ? "array" : "object"); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + + /* For non-null values, perform weak mode validation and coercion */ + switch (opline->extended_value) { + case IS_LONG: + case IS_DOUBLE: + case IS_STRING: + case _IS_BOOL: { + uint32_t type_mask; + uint8_t target_type; + GET_TYPE_MASK_AND_TARGET(opline->extended_value, type_mask, target_type); + + /* Copy value for validation */ + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_VAR); + + /* Check if already correct type */ + if (opline->extended_value == _IS_BOOL) { + if (Z_TYPE_P(result) == IS_TRUE || Z_TYPE_P(result) == IS_FALSE) { + break; /* Already a bool, no conversion needed */ + } + } else if (Z_TYPE_P(result) == target_type) { + break; /* Already correct type, no conversion needed */ + } + + /* Attempt weak mode type coercion */ + if (!zend_verify_weak_scalar_type_hint(type_mask, result)) { + zval_ptr_dtor(result); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + zend_type_error("Cannot cast %s to %s", + zend_zval_type_name(expr), + opline->extended_value == IS_LONG ? "int" : + opline->extended_value == IS_DOUBLE ? "float" : + opline->extended_value == IS_STRING ? "string" : "bool"); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + } + case IS_ARRAY: + if (Z_TYPE_P(expr) == IS_ARRAY) { + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_VAR); + } else if (Z_TYPE_P(expr) == IS_OBJECT) { + zend_cast_zval_to_array(result, expr, IS_VAR); + } else { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + zend_type_error("Cannot cast %s to array", zend_zval_type_name(expr)); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + case IS_OBJECT: + if (Z_TYPE_P(expr) == IS_OBJECT) { + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_VAR); + } else if (Z_TYPE_P(expr) == IS_ARRAY) { + zend_cast_zval_to_object(result, expr, IS_VAR); + } else { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + zend_type_error("Cannot cast %s to object", zend_zval_type_name(expr)); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + default: + ZEND_UNREACHABLE(); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FE_RESET_R_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -41912,6 +42530,215 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CAST_SPEC_CV_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +#define COPY_ZVAL_WITH_REFCOUNT(result, expr, op1_type) do { \ + ZVAL_COPY_VALUE(result, expr); \ + if ((op1_type) == IS_CONST && UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) { \ + Z_ADDREF_P(result); \ + } else if ((op1_type) != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(result)) { \ + Z_ADDREF_P(result); \ + } \ +} while (0) + +#define GET_TYPE_MASK_AND_TARGET(extended_value, type_mask_var, target_type_var) do { \ + switch (extended_value) { \ + case IS_LONG: type_mask_var = MAY_BE_LONG; target_type_var = IS_LONG; break; \ + case IS_DOUBLE: type_mask_var = MAY_BE_DOUBLE; target_type_var = IS_DOUBLE; break; \ + case IS_STRING: type_mask_var = MAY_BE_STRING; target_type_var = IS_STRING; break; \ + case _IS_BOOL: type_mask_var = MAY_BE_BOOL; target_type_var = IS_TRUE; break; \ + default: ZEND_UNREACHABLE(); \ + } \ +} while (0) + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_NULLABLE_CAST_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *expr; + zval *result = EX_VAR(opline->result.var); + + SAVE_OPLINE(); + expr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); + + if (IS_CV & (IS_VAR|IS_CV)) { + ZVAL_DEREF(expr); + } + + /* Check for null first - if null, return null unchanged */ + if (Z_TYPE_P(expr) == IS_NULL) { + ZVAL_NULL(result); + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + + /* For non-null values, perform weak mode validation and coercion */ + switch (opline->extended_value) { + case IS_LONG: + case IS_DOUBLE: + case IS_STRING: + case _IS_BOOL: { + uint32_t type_mask; + uint8_t target_type; + GET_TYPE_MASK_AND_TARGET(opline->extended_value, type_mask, target_type); + + /* Copy value for validation */ + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_CV); + + /* Check if already correct type */ + if (opline->extended_value == _IS_BOOL) { + if (Z_TYPE_P(result) == IS_TRUE || Z_TYPE_P(result) == IS_FALSE) { + break; /* Already a bool, no conversion needed */ + } + } else if (Z_TYPE_P(result) == target_type) { + break; /* Already correct type, no conversion needed */ + } + + /* Attempt weak mode type coercion */ + if (!zend_verify_weak_scalar_type_hint(type_mask, result)) { + zval_ptr_dtor(result); + + + zend_type_error("Cannot cast %s to %s", + zend_zval_type_name(expr), + opline->extended_value == IS_LONG ? "int" : + opline->extended_value == IS_DOUBLE ? "float" : + opline->extended_value == IS_STRING ? "string" : "bool"); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + } + case IS_ARRAY: + if (Z_TYPE_P(expr) == IS_ARRAY) { + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_CV); + } else if (Z_TYPE_P(expr) == IS_OBJECT) { + zend_cast_zval_to_array(result, expr, IS_CV); + } else { + + + zend_type_error("Cannot cast %s to array", zend_zval_type_name(expr)); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + case IS_OBJECT: + if (Z_TYPE_P(expr) == IS_OBJECT) { + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_CV); + } else if (Z_TYPE_P(expr) == IS_ARRAY) { + zend_cast_zval_to_object(result, expr, IS_CV); + } else { + + + zend_type_error("Cannot cast %s to object", zend_zval_type_name(expr)); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + default: + ZEND_UNREACHABLE(); + } + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_NONNULL_CAST_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *expr; + zval *result = EX_VAR(opline->result.var); + + SAVE_OPLINE(); + expr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); + + if (IS_CV & (IS_VAR|IS_CV)) { + ZVAL_DEREF(expr); + } + + /* Check for null - if null, throw TypeError */ + if (Z_TYPE_P(expr) == IS_NULL) { + + + zend_type_error("Cannot cast null to %s", + opline->extended_value == IS_LONG ? "int" : + opline->extended_value == IS_DOUBLE ? "float" : + opline->extended_value == IS_STRING ? "string" : + opline->extended_value == _IS_BOOL ? "bool" : + opline->extended_value == IS_ARRAY ? "array" : "object"); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + + /* For non-null values, perform weak mode validation and coercion */ + switch (opline->extended_value) { + case IS_LONG: + case IS_DOUBLE: + case IS_STRING: + case _IS_BOOL: { + uint32_t type_mask; + uint8_t target_type; + GET_TYPE_MASK_AND_TARGET(opline->extended_value, type_mask, target_type); + + /* Copy value for validation */ + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_CV); + + /* Check if already correct type */ + if (opline->extended_value == _IS_BOOL) { + if (Z_TYPE_P(result) == IS_TRUE || Z_TYPE_P(result) == IS_FALSE) { + break; /* Already a bool, no conversion needed */ + } + } else if (Z_TYPE_P(result) == target_type) { + break; /* Already correct type, no conversion needed */ + } + + /* Attempt weak mode type coercion */ + if (!zend_verify_weak_scalar_type_hint(type_mask, result)) { + zval_ptr_dtor(result); + + + zend_type_error("Cannot cast %s to %s", + zend_zval_type_name(expr), + opline->extended_value == IS_LONG ? "int" : + opline->extended_value == IS_DOUBLE ? "float" : + opline->extended_value == IS_STRING ? "string" : "bool"); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + } + case IS_ARRAY: + if (Z_TYPE_P(expr) == IS_ARRAY) { + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_CV); + } else if (Z_TYPE_P(expr) == IS_OBJECT) { + zend_cast_zval_to_array(result, expr, IS_CV); + } else { + + + zend_type_error("Cannot cast %s to array", zend_zval_type_name(expr)); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + case IS_OBJECT: + if (Z_TYPE_P(expr) == IS_OBJECT) { + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_CV); + } else if (Z_TYPE_P(expr) == IS_ARRAY) { + zend_cast_zval_to_object(result, expr, IS_CV); + } else { + + + zend_type_error("Cannot cast %s to object", zend_zval_type_name(expr)); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + default: + ZEND_UNREACHABLE(); + } + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -60799,105 +61626,314 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CAST_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INCLUDE_OR_EVAL_SPEC_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +#define COPY_ZVAL_WITH_REFCOUNT(result, expr, op1_type) do { \ + ZVAL_COPY_VALUE(result, expr); \ + if ((op1_type) == IS_CONST && UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) { \ + Z_ADDREF_P(result); \ + } else if ((op1_type) != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(result)) { \ + Z_ADDREF_P(result); \ + } \ +} while (0) + +#define GET_TYPE_MASK_AND_TARGET(extended_value, type_mask_var, target_type_var) do { \ + switch (extended_value) { \ + case IS_LONG: type_mask_var = MAY_BE_LONG; target_type_var = IS_LONG; break; \ + case IS_DOUBLE: type_mask_var = MAY_BE_DOUBLE; target_type_var = IS_DOUBLE; break; \ + case IS_STRING: type_mask_var = MAY_BE_STRING; target_type_var = IS_STRING; break; \ + case _IS_BOOL: type_mask_var = MAY_BE_BOOL; target_type_var = IS_TRUE; break; \ + default: ZEND_UNREACHABLE(); \ + } \ +} while (0) + +static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_NULLABLE_CAST_SPEC_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_op_array *new_op_array; - zval *inc_filename; + zval *expr; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - inc_filename = RT_CONSTANT(opline, opline->op1); - new_op_array = zend_include_or_eval(inc_filename, opline->extended_value); - if (UNEXPECTED(EG(exception) != NULL)) { + expr = RT_CONSTANT(opline, opline->op1); + if (IS_CONST & (IS_VAR|IS_CV)) { + ZVAL_DEREF(expr); + } - if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) { - destroy_op_array(new_op_array); - efree_size(new_op_array, sizeof(zend_op_array)); - } - UNDEF_RESULT(); - HANDLE_EXCEPTION(); - } else if (new_op_array == ZEND_FAKE_OP_ARRAY) { - if (RETURN_VALUE_USED(opline)) { - ZVAL_TRUE(EX_VAR(opline->result.var)); - } - } else if (UNEXPECTED(new_op_array == NULL)) { - if (RETURN_VALUE_USED(opline)) { - ZVAL_FALSE(EX_VAR(opline->result.var)); - } - } else if (new_op_array->last == 1 - && new_op_array->opcodes[0].opcode == ZEND_RETURN - && new_op_array->opcodes[0].op1_type == IS_CONST - && EXPECTED(zend_execute_ex == execute_ex)) { - if (RETURN_VALUE_USED(opline)) { - const zend_op *op = new_op_array->opcodes; + /* Check for null first - if null, return null unchanged */ + if (Z_TYPE_P(expr) == IS_NULL) { + ZVAL_NULL(result); - ZVAL_COPY(EX_VAR(opline->result.var), RT_CONSTANT(op, op->op1)); - } - zend_destroy_static_vars(new_op_array); - destroy_op_array(new_op_array); - efree_size(new_op_array, sizeof(zend_op_array)); - } else { - zval *return_value = NULL; - zend_execute_data *call; - if (RETURN_VALUE_USED(opline)) { - return_value = EX_VAR(opline->result.var); - } - new_op_array->scope = EX(func)->op_array.scope; + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } - call = zend_vm_stack_push_call_frame( - (Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE, - (zend_function*)new_op_array, 0, - Z_PTR(EX(This))); + /* For non-null values, perform weak mode validation and coercion */ + switch (opline->extended_value) { + case IS_LONG: + case IS_DOUBLE: + case IS_STRING: + case _IS_BOOL: { + uint32_t type_mask; + uint8_t target_type; + GET_TYPE_MASK_AND_TARGET(opline->extended_value, type_mask, target_type); - if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) { - call->symbol_table = EX(symbol_table); - } else { - call->symbol_table = zend_rebuild_symbol_table(); + /* Copy value for validation */ + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_CONST); + + /* Check if already correct type */ + if (opline->extended_value == _IS_BOOL) { + if (Z_TYPE_P(result) == IS_TRUE || Z_TYPE_P(result) == IS_FALSE) { + break; /* Already a bool, no conversion needed */ + } + } else if (Z_TYPE_P(result) == target_type) { + break; /* Already correct type, no conversion needed */ + } + + /* Attempt weak mode type coercion */ + if (!zend_verify_weak_scalar_type_hint(type_mask, result)) { + zval_ptr_dtor(result); + + + zend_type_error("Cannot cast %s to %s", + zend_zval_type_name(expr), + opline->extended_value == IS_LONG ? "int" : + opline->extended_value == IS_DOUBLE ? "float" : + opline->extended_value == IS_STRING ? "string" : "bool"); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; } + case IS_ARRAY: + if (Z_TYPE_P(expr) == IS_ARRAY) { + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_CONST); + } else if (Z_TYPE_P(expr) == IS_OBJECT) { + zend_cast_zval_to_array(result, expr, IS_CONST); + } else { - call->prev_execute_data = execute_data; - i_init_code_execute_data(call, new_op_array, return_value); + zend_type_error("Cannot cast %s to array", zend_zval_type_name(expr)); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + case IS_OBJECT: + if (Z_TYPE_P(expr) == IS_OBJECT) { + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_CONST); + } else if (Z_TYPE_P(expr) == IS_ARRAY) { + zend_cast_zval_to_object(result, expr, IS_CONST); + } else { - if (EXPECTED(zend_execute_ex == execute_ex)) { + zend_type_error("Cannot cast %s to object", zend_zval_type_name(expr)); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + default: + ZEND_UNREACHABLE(); + } - ZEND_VM_ENTER(); - } else { - ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP); - zend_execute_ex(call); - zend_vm_stack_free_call_frame(call); - } - zend_destroy_static_vars(new_op_array); - destroy_op_array(new_op_array); - efree_size(new_op_array, sizeof(zend_op_array)); - if (UNEXPECTED(EG(exception) != NULL)) { - zend_rethrow_exception(execute_data); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} +static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_NONNULL_CAST_SPEC_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *expr; + zval *result = EX_VAR(opline->result.var); - UNDEF_RESULT(); - HANDLE_EXCEPTION(); + SAVE_OPLINE(); + expr = RT_CONSTANT(opline, opline->op1); + + if (IS_CONST & (IS_VAR|IS_CV)) { + ZVAL_DEREF(expr); + } + + /* Check for null - if null, throw TypeError */ + if (Z_TYPE_P(expr) == IS_NULL) { + + + zend_type_error("Cannot cast null to %s", + opline->extended_value == IS_LONG ? "int" : + opline->extended_value == IS_DOUBLE ? "float" : + opline->extended_value == IS_STRING ? "string" : + opline->extended_value == _IS_BOOL ? "bool" : + opline->extended_value == IS_ARRAY ? "array" : "object"); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + + /* For non-null values, perform weak mode validation and coercion */ + switch (opline->extended_value) { + case IS_LONG: + case IS_DOUBLE: + case IS_STRING: + case _IS_BOOL: { + uint32_t type_mask; + uint8_t target_type; + GET_TYPE_MASK_AND_TARGET(opline->extended_value, type_mask, target_type); + + /* Copy value for validation */ + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_CONST); + + /* Check if already correct type */ + if (opline->extended_value == _IS_BOOL) { + if (Z_TYPE_P(result) == IS_TRUE || Z_TYPE_P(result) == IS_FALSE) { + break; /* Already a bool, no conversion needed */ + } + } else if (Z_TYPE_P(result) == target_type) { + break; /* Already correct type, no conversion needed */ + } + + /* Attempt weak mode type coercion */ + if (!zend_verify_weak_scalar_type_hint(type_mask, result)) { + zval_ptr_dtor(result); + + + zend_type_error("Cannot cast %s to %s", + zend_zval_type_name(expr), + opline->extended_value == IS_LONG ? "int" : + opline->extended_value == IS_DOUBLE ? "float" : + opline->extended_value == IS_STRING ? "string" : "bool"); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; } + case IS_ARRAY: + if (Z_TYPE_P(expr) == IS_ARRAY) { + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_CONST); + } else if (Z_TYPE_P(expr) == IS_OBJECT) { + zend_cast_zval_to_array(result, expr, IS_CONST); + } else { + + + zend_type_error("Cannot cast %s to array", zend_zval_type_name(expr)); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + case IS_OBJECT: + if (Z_TYPE_P(expr) == IS_OBJECT) { + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_CONST); + } else if (Z_TYPE_P(expr) == IS_ARRAY) { + zend_cast_zval_to_object(result, expr, IS_CONST); + } else { + + + zend_type_error("Cannot cast %s to object", zend_zval_type_name(expr)); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + default: + ZEND_UNREACHABLE(); } - ZEND_VM_NEXT_OPCODE(); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INCLUDE_OR_EVAL_SPEC_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_op_array *new_op_array; zval *inc_filename; SAVE_OPLINE(); - inc_filename = get_zval_ptr(opline->op1_type, opline->op1, BP_VAR_R); + inc_filename = RT_CONSTANT(opline, opline->op1); new_op_array = zend_include_or_eval(inc_filename, opline->extended_value); if (UNEXPECTED(EG(exception) != NULL)) { - FREE_OP(opline->op1_type, opline->op1.var); + + + if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) { + destroy_op_array(new_op_array); + efree_size(new_op_array, sizeof(zend_op_array)); + } + UNDEF_RESULT(); + HANDLE_EXCEPTION(); + } else if (new_op_array == ZEND_FAKE_OP_ARRAY) { + if (RETURN_VALUE_USED(opline)) { + ZVAL_TRUE(EX_VAR(opline->result.var)); + } + } else if (UNEXPECTED(new_op_array == NULL)) { + if (RETURN_VALUE_USED(opline)) { + ZVAL_FALSE(EX_VAR(opline->result.var)); + } + } else if (new_op_array->last == 1 + && new_op_array->opcodes[0].opcode == ZEND_RETURN + && new_op_array->opcodes[0].op1_type == IS_CONST + && EXPECTED(zend_execute_ex == execute_ex)) { + if (RETURN_VALUE_USED(opline)) { + const zend_op *op = new_op_array->opcodes; + + ZVAL_COPY(EX_VAR(opline->result.var), RT_CONSTANT(op, op->op1)); + } + zend_destroy_static_vars(new_op_array); + destroy_op_array(new_op_array); + efree_size(new_op_array, sizeof(zend_op_array)); + } else { + zval *return_value = NULL; + zend_execute_data *call; + if (RETURN_VALUE_USED(opline)) { + return_value = EX_VAR(opline->result.var); + } + + new_op_array->scope = EX(func)->op_array.scope; + + call = zend_vm_stack_push_call_frame( + (Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE, + (zend_function*)new_op_array, 0, + Z_PTR(EX(This))); + + if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) { + call->symbol_table = EX(symbol_table); + } else { + call->symbol_table = zend_rebuild_symbol_table(); + } + + call->prev_execute_data = execute_data; + i_init_code_execute_data(call, new_op_array, return_value); + + + if (EXPECTED(zend_execute_ex == execute_ex)) { + + + ZEND_VM_ENTER(); + } else { + ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP); + zend_execute_ex(call); + zend_vm_stack_free_call_frame(call); + } + + zend_destroy_static_vars(new_op_array); + destroy_op_array(new_op_array); + efree_size(new_op_array, sizeof(zend_op_array)); + if (UNEXPECTED(EG(exception) != NULL)) { + zend_rethrow_exception(execute_data); + + + UNDEF_RESULT(); + HANDLE_EXCEPTION(); + } + } + + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_op_array *new_op_array; + zval *inc_filename; + + SAVE_OPLINE(); + inc_filename = get_zval_ptr(opline->op1_type, opline->op1, BP_VAR_R); + new_op_array = zend_include_or_eval(inc_filename, opline->extended_value); + if (UNEXPECTED(EG(exception) != NULL)) { + FREE_OP(opline->op1_type, opline->op1.var); if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) { destroy_op_array(new_op_array); efree_size(new_op_array, sizeof(zend_op_array)); @@ -75877,6 +76913,214 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CAST_SPEC_TMP_TAIL ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +#define COPY_ZVAL_WITH_REFCOUNT(result, expr, op1_type) do { \ + ZVAL_COPY_VALUE(result, expr); \ + if ((op1_type) == IS_CONST && UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) { \ + Z_ADDREF_P(result); \ + } else if ((op1_type) != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(result)) { \ + Z_ADDREF_P(result); \ + } \ +} while (0) + +#define GET_TYPE_MASK_AND_TARGET(extended_value, type_mask_var, target_type_var) do { \ + switch (extended_value) { \ + case IS_LONG: type_mask_var = MAY_BE_LONG; target_type_var = IS_LONG; break; \ + case IS_DOUBLE: type_mask_var = MAY_BE_DOUBLE; target_type_var = IS_DOUBLE; break; \ + case IS_STRING: type_mask_var = MAY_BE_STRING; target_type_var = IS_STRING; break; \ + case _IS_BOOL: type_mask_var = MAY_BE_BOOL; target_type_var = IS_TRUE; break; \ + default: ZEND_UNREACHABLE(); \ + } \ +} while (0) + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_NULLABLE_CAST_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *expr; + zval *result = EX_VAR(opline->result.var); + + SAVE_OPLINE(); + expr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + + if (IS_TMP_VAR & (IS_VAR|IS_CV)) { + ZVAL_DEREF(expr); + } + + /* Check for null first - if null, return null unchanged */ + if (Z_TYPE_P(expr) == IS_NULL) { + ZVAL_NULL(result); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + + /* For non-null values, perform weak mode validation and coercion */ + switch (opline->extended_value) { + case IS_LONG: + case IS_DOUBLE: + case IS_STRING: + case _IS_BOOL: { + uint32_t type_mask; + uint8_t target_type; + GET_TYPE_MASK_AND_TARGET(opline->extended_value, type_mask, target_type); + + /* Copy value for validation */ + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_TMP_VAR); + + /* Check if already correct type */ + if (opline->extended_value == _IS_BOOL) { + if (Z_TYPE_P(result) == IS_TRUE || Z_TYPE_P(result) == IS_FALSE) { + break; /* Already a bool, no conversion needed */ + } + } else if (Z_TYPE_P(result) == target_type) { + break; /* Already correct type, no conversion needed */ + } + + /* Attempt weak mode type coercion */ + if (!zend_verify_weak_scalar_type_hint(type_mask, result)) { + zval_ptr_dtor(result); + + + zend_type_error("Cannot cast %s to %s", + zend_zval_type_name(expr), + opline->extended_value == IS_LONG ? "int" : + opline->extended_value == IS_DOUBLE ? "float" : + opline->extended_value == IS_STRING ? "string" : "bool"); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + } + case IS_ARRAY: + if (Z_TYPE_P(expr) == IS_ARRAY) { + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_TMP_VAR); + } else if (Z_TYPE_P(expr) == IS_OBJECT) { + zend_cast_zval_to_array(result, expr, IS_TMP_VAR); + } else { + + + zend_type_error("Cannot cast %s to array", zend_zval_type_name(expr)); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + case IS_OBJECT: + if (Z_TYPE_P(expr) == IS_OBJECT) { + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_TMP_VAR); + } else if (Z_TYPE_P(expr) == IS_ARRAY) { + zend_cast_zval_to_object(result, expr, IS_TMP_VAR); + } else { + + + zend_type_error("Cannot cast %s to object", zend_zval_type_name(expr)); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + default: + ZEND_UNREACHABLE(); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_NONNULL_CAST_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *expr; + zval *result = EX_VAR(opline->result.var); + + SAVE_OPLINE(); + expr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + + if (IS_TMP_VAR & (IS_VAR|IS_CV)) { + ZVAL_DEREF(expr); + } + + /* Check for null - if null, throw TypeError */ + if (Z_TYPE_P(expr) == IS_NULL) { + + + zend_type_error("Cannot cast null to %s", + opline->extended_value == IS_LONG ? "int" : + opline->extended_value == IS_DOUBLE ? "float" : + opline->extended_value == IS_STRING ? "string" : + opline->extended_value == _IS_BOOL ? "bool" : + opline->extended_value == IS_ARRAY ? "array" : "object"); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + + /* For non-null values, perform weak mode validation and coercion */ + switch (opline->extended_value) { + case IS_LONG: + case IS_DOUBLE: + case IS_STRING: + case _IS_BOOL: { + uint32_t type_mask; + uint8_t target_type; + GET_TYPE_MASK_AND_TARGET(opline->extended_value, type_mask, target_type); + + /* Copy value for validation */ + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_TMP_VAR); + + /* Check if already correct type */ + if (opline->extended_value == _IS_BOOL) { + if (Z_TYPE_P(result) == IS_TRUE || Z_TYPE_P(result) == IS_FALSE) { + break; /* Already a bool, no conversion needed */ + } + } else if (Z_TYPE_P(result) == target_type) { + break; /* Already correct type, no conversion needed */ + } + + /* Attempt weak mode type coercion */ + if (!zend_verify_weak_scalar_type_hint(type_mask, result)) { + zval_ptr_dtor(result); + + + zend_type_error("Cannot cast %s to %s", + zend_zval_type_name(expr), + opline->extended_value == IS_LONG ? "int" : + opline->extended_value == IS_DOUBLE ? "float" : + opline->extended_value == IS_STRING ? "string" : "bool"); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + } + case IS_ARRAY: + if (Z_TYPE_P(expr) == IS_ARRAY) { + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_TMP_VAR); + } else if (Z_TYPE_P(expr) == IS_OBJECT) { + zend_cast_zval_to_array(result, expr, IS_TMP_VAR); + } else { + + + zend_type_error("Cannot cast %s to array", zend_zval_type_name(expr)); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + case IS_OBJECT: + if (Z_TYPE_P(expr) == IS_OBJECT) { + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_TMP_VAR); + } else if (Z_TYPE_P(expr) == IS_ARRAY) { + zend_cast_zval_to_object(result, expr, IS_TMP_VAR); + } else { + + + zend_type_error("Cannot cast %s to object", zend_zval_type_name(expr)); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + default: + ZEND_UNREACHABLE(); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FE_RESET_R_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -78540,6 +79784,207 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CAST_SPEC_VAR_TAIL ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +#define COPY_ZVAL_WITH_REFCOUNT(result, expr, op1_type) do { \ + ZVAL_COPY_VALUE(result, expr); \ + if ((op1_type) == IS_CONST && UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) { \ + Z_ADDREF_P(result); \ + } else if ((op1_type) != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(result)) { \ + Z_ADDREF_P(result); \ + } \ +} while (0) + +#define GET_TYPE_MASK_AND_TARGET(extended_value, type_mask_var, target_type_var) do { \ + switch (extended_value) { \ + case IS_LONG: type_mask_var = MAY_BE_LONG; target_type_var = IS_LONG; break; \ + case IS_DOUBLE: type_mask_var = MAY_BE_DOUBLE; target_type_var = IS_DOUBLE; break; \ + case IS_STRING: type_mask_var = MAY_BE_STRING; target_type_var = IS_STRING; break; \ + case _IS_BOOL: type_mask_var = MAY_BE_BOOL; target_type_var = IS_TRUE; break; \ + default: ZEND_UNREACHABLE(); \ + } \ +} while (0) + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_NULLABLE_CAST_SPEC_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *expr; + zval *result = EX_VAR(opline->result.var); + + SAVE_OPLINE(); + expr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if (IS_VAR & (IS_VAR|IS_CV)) { + ZVAL_DEREF(expr); + } + + /* Check for null first - if null, return null unchanged */ + if (Z_TYPE_P(expr) == IS_NULL) { + ZVAL_NULL(result); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + + /* For non-null values, perform weak mode validation and coercion */ + switch (opline->extended_value) { + case IS_LONG: + case IS_DOUBLE: + case IS_STRING: + case _IS_BOOL: { + uint32_t type_mask; + uint8_t target_type; + GET_TYPE_MASK_AND_TARGET(opline->extended_value, type_mask, target_type); + + /* Copy value for validation */ + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_VAR); + + /* Check if already correct type */ + if (opline->extended_value == _IS_BOOL) { + if (Z_TYPE_P(result) == IS_TRUE || Z_TYPE_P(result) == IS_FALSE) { + break; /* Already a bool, no conversion needed */ + } + } else if (Z_TYPE_P(result) == target_type) { + break; /* Already correct type, no conversion needed */ + } + + /* Attempt weak mode type coercion */ + if (!zend_verify_weak_scalar_type_hint(type_mask, result)) { + zval_ptr_dtor(result); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + zend_type_error("Cannot cast %s to %s", + zend_zval_type_name(expr), + opline->extended_value == IS_LONG ? "int" : + opline->extended_value == IS_DOUBLE ? "float" : + opline->extended_value == IS_STRING ? "string" : "bool"); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + } + case IS_ARRAY: + if (Z_TYPE_P(expr) == IS_ARRAY) { + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_VAR); + } else if (Z_TYPE_P(expr) == IS_OBJECT) { + zend_cast_zval_to_array(result, expr, IS_VAR); + } else { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + zend_type_error("Cannot cast %s to array", zend_zval_type_name(expr)); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + case IS_OBJECT: + if (Z_TYPE_P(expr) == IS_OBJECT) { + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_VAR); + } else if (Z_TYPE_P(expr) == IS_ARRAY) { + zend_cast_zval_to_object(result, expr, IS_VAR); + } else { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + zend_type_error("Cannot cast %s to object", zend_zval_type_name(expr)); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + default: + ZEND_UNREACHABLE(); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_NONNULL_CAST_SPEC_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *expr; + zval *result = EX_VAR(opline->result.var); + + SAVE_OPLINE(); + expr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if (IS_VAR & (IS_VAR|IS_CV)) { + ZVAL_DEREF(expr); + } + + /* Check for null - if null, throw TypeError */ + if (Z_TYPE_P(expr) == IS_NULL) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + zend_type_error("Cannot cast null to %s", + opline->extended_value == IS_LONG ? "int" : + opline->extended_value == IS_DOUBLE ? "float" : + opline->extended_value == IS_STRING ? "string" : + opline->extended_value == _IS_BOOL ? "bool" : + opline->extended_value == IS_ARRAY ? "array" : "object"); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + + /* For non-null values, perform weak mode validation and coercion */ + switch (opline->extended_value) { + case IS_LONG: + case IS_DOUBLE: + case IS_STRING: + case _IS_BOOL: { + uint32_t type_mask; + uint8_t target_type; + GET_TYPE_MASK_AND_TARGET(opline->extended_value, type_mask, target_type); + + /* Copy value for validation */ + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_VAR); + + /* Check if already correct type */ + if (opline->extended_value == _IS_BOOL) { + if (Z_TYPE_P(result) == IS_TRUE || Z_TYPE_P(result) == IS_FALSE) { + break; /* Already a bool, no conversion needed */ + } + } else if (Z_TYPE_P(result) == target_type) { + break; /* Already correct type, no conversion needed */ + } + + /* Attempt weak mode type coercion */ + if (!zend_verify_weak_scalar_type_hint(type_mask, result)) { + zval_ptr_dtor(result); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + zend_type_error("Cannot cast %s to %s", + zend_zval_type_name(expr), + opline->extended_value == IS_LONG ? "int" : + opline->extended_value == IS_DOUBLE ? "float" : + opline->extended_value == IS_STRING ? "string" : "bool"); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + } + case IS_ARRAY: + if (Z_TYPE_P(expr) == IS_ARRAY) { + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_VAR); + } else if (Z_TYPE_P(expr) == IS_OBJECT) { + zend_cast_zval_to_array(result, expr, IS_VAR); + } else { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + zend_type_error("Cannot cast %s to array", zend_zval_type_name(expr)); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + case IS_OBJECT: + if (Z_TYPE_P(expr) == IS_OBJECT) { + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_VAR); + } else if (Z_TYPE_P(expr) == IS_ARRAY) { + zend_cast_zval_to_object(result, expr, IS_VAR); + } else { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + zend_type_error("Cannot cast %s to object", zend_zval_type_name(expr)); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + default: + ZEND_UNREACHABLE(); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FE_RESET_R_SPEC_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -97150,6 +98595,215 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CAST_SPEC_CV_TAILC ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +#define COPY_ZVAL_WITH_REFCOUNT(result, expr, op1_type) do { \ + ZVAL_COPY_VALUE(result, expr); \ + if ((op1_type) == IS_CONST && UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) { \ + Z_ADDREF_P(result); \ + } else if ((op1_type) != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(result)) { \ + Z_ADDREF_P(result); \ + } \ +} while (0) + +#define GET_TYPE_MASK_AND_TARGET(extended_value, type_mask_var, target_type_var) do { \ + switch (extended_value) { \ + case IS_LONG: type_mask_var = MAY_BE_LONG; target_type_var = IS_LONG; break; \ + case IS_DOUBLE: type_mask_var = MAY_BE_DOUBLE; target_type_var = IS_DOUBLE; break; \ + case IS_STRING: type_mask_var = MAY_BE_STRING; target_type_var = IS_STRING; break; \ + case _IS_BOOL: type_mask_var = MAY_BE_BOOL; target_type_var = IS_TRUE; break; \ + default: ZEND_UNREACHABLE(); \ + } \ +} while (0) + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_NULLABLE_CAST_SPEC_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *expr; + zval *result = EX_VAR(opline->result.var); + + SAVE_OPLINE(); + expr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); + + if (IS_CV & (IS_VAR|IS_CV)) { + ZVAL_DEREF(expr); + } + + /* Check for null first - if null, return null unchanged */ + if (Z_TYPE_P(expr) == IS_NULL) { + ZVAL_NULL(result); + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + + /* For non-null values, perform weak mode validation and coercion */ + switch (opline->extended_value) { + case IS_LONG: + case IS_DOUBLE: + case IS_STRING: + case _IS_BOOL: { + uint32_t type_mask; + uint8_t target_type; + GET_TYPE_MASK_AND_TARGET(opline->extended_value, type_mask, target_type); + + /* Copy value for validation */ + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_CV); + + /* Check if already correct type */ + if (opline->extended_value == _IS_BOOL) { + if (Z_TYPE_P(result) == IS_TRUE || Z_TYPE_P(result) == IS_FALSE) { + break; /* Already a bool, no conversion needed */ + } + } else if (Z_TYPE_P(result) == target_type) { + break; /* Already correct type, no conversion needed */ + } + + /* Attempt weak mode type coercion */ + if (!zend_verify_weak_scalar_type_hint(type_mask, result)) { + zval_ptr_dtor(result); + + + zend_type_error("Cannot cast %s to %s", + zend_zval_type_name(expr), + opline->extended_value == IS_LONG ? "int" : + opline->extended_value == IS_DOUBLE ? "float" : + opline->extended_value == IS_STRING ? "string" : "bool"); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + } + case IS_ARRAY: + if (Z_TYPE_P(expr) == IS_ARRAY) { + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_CV); + } else if (Z_TYPE_P(expr) == IS_OBJECT) { + zend_cast_zval_to_array(result, expr, IS_CV); + } else { + + + zend_type_error("Cannot cast %s to array", zend_zval_type_name(expr)); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + case IS_OBJECT: + if (Z_TYPE_P(expr) == IS_OBJECT) { + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_CV); + } else if (Z_TYPE_P(expr) == IS_ARRAY) { + zend_cast_zval_to_object(result, expr, IS_CV); + } else { + + + zend_type_error("Cannot cast %s to object", zend_zval_type_name(expr)); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + default: + ZEND_UNREACHABLE(); + } + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_NONNULL_CAST_SPEC_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *expr; + zval *result = EX_VAR(opline->result.var); + + SAVE_OPLINE(); + expr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); + + if (IS_CV & (IS_VAR|IS_CV)) { + ZVAL_DEREF(expr); + } + + /* Check for null - if null, throw TypeError */ + if (Z_TYPE_P(expr) == IS_NULL) { + + + zend_type_error("Cannot cast null to %s", + opline->extended_value == IS_LONG ? "int" : + opline->extended_value == IS_DOUBLE ? "float" : + opline->extended_value == IS_STRING ? "string" : + opline->extended_value == _IS_BOOL ? "bool" : + opline->extended_value == IS_ARRAY ? "array" : "object"); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + + /* For non-null values, perform weak mode validation and coercion */ + switch (opline->extended_value) { + case IS_LONG: + case IS_DOUBLE: + case IS_STRING: + case _IS_BOOL: { + uint32_t type_mask; + uint8_t target_type; + GET_TYPE_MASK_AND_TARGET(opline->extended_value, type_mask, target_type); + + /* Copy value for validation */ + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_CV); + + /* Check if already correct type */ + if (opline->extended_value == _IS_BOOL) { + if (Z_TYPE_P(result) == IS_TRUE || Z_TYPE_P(result) == IS_FALSE) { + break; /* Already a bool, no conversion needed */ + } + } else if (Z_TYPE_P(result) == target_type) { + break; /* Already correct type, no conversion needed */ + } + + /* Attempt weak mode type coercion */ + if (!zend_verify_weak_scalar_type_hint(type_mask, result)) { + zval_ptr_dtor(result); + + + zend_type_error("Cannot cast %s to %s", + zend_zval_type_name(expr), + opline->extended_value == IS_LONG ? "int" : + opline->extended_value == IS_DOUBLE ? "float" : + opline->extended_value == IS_STRING ? "string" : "bool"); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + } + case IS_ARRAY: + if (Z_TYPE_P(expr) == IS_ARRAY) { + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_CV); + } else if (Z_TYPE_P(expr) == IS_OBJECT) { + zend_cast_zval_to_array(result, expr, IS_CV); + } else { + + + zend_type_error("Cannot cast %s to array", zend_zval_type_name(expr)); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + case IS_OBJECT: + if (Z_TYPE_P(expr) == IS_OBJECT) { + COPY_ZVAL_WITH_REFCOUNT(result, expr, IS_CV); + } else if (Z_TYPE_P(expr) == IS_ARRAY) { + zend_cast_zval_to_object(result, expr, IS_CV); + } else { + + + zend_type_error("Cannot cast %s to object", zend_zval_type_name(expr)); + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + break; + default: + ZEND_UNREACHABLE(); + } + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INCLUDE_OR_EVAL_SPEC_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -114801,6 +116455,16 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_JMP_FRAMELESS_SPEC_CONST_LABEL, (void*)&&ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED_LABEL, (void*)&&ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST_LABEL, + (void*)&&ZEND_NULLABLE_CAST_SPEC_CONST_LABEL, + (void*)&&ZEND_NULLABLE_CAST_SPEC_TMP_LABEL, + (void*)&&ZEND_NULLABLE_CAST_SPEC_VAR_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULLABLE_CAST_SPEC_CV_LABEL, + (void*)&&ZEND_NONNULL_CAST_SPEC_CONST_LABEL, + (void*)&&ZEND_NONNULL_CAST_SPEC_TMP_LABEL, + (void*)&&ZEND_NONNULL_CAST_SPEC_VAR_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NONNULL_CAST_SPEC_CV_LABEL, (void*)&&ZEND_INIT_FCALL_OFFSET_SPEC_CONST_LABEL, (void*)&&ZEND_RECV_NOTYPE_SPEC_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -116489,6 +118153,16 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_CAST_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_CAST_SPEC_CONST) HYBRID_BREAK(); + HYBRID_CASE(ZEND_NULLABLE_CAST_SPEC_CONST): + VM_TRACE(ZEND_NULLABLE_CAST_SPEC_CONST) + ZEND_NULLABLE_CAST_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_NULLABLE_CAST_SPEC_CONST) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_NONNULL_CAST_SPEC_CONST): + VM_TRACE(ZEND_NONNULL_CAST_SPEC_CONST) + ZEND_NONNULL_CAST_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_NONNULL_CAST_SPEC_CONST) + HYBRID_BREAK(); HYBRID_CASE(ZEND_INCLUDE_OR_EVAL_SPEC_CONST): VM_TRACE(ZEND_INCLUDE_OR_EVAL_SPEC_CONST) ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -118413,6 +120087,16 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_CAST_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_CAST_SPEC_TMP) HYBRID_BREAK(); + HYBRID_CASE(ZEND_NULLABLE_CAST_SPEC_TMP): + VM_TRACE(ZEND_NULLABLE_CAST_SPEC_TMP) + ZEND_NULLABLE_CAST_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_NULLABLE_CAST_SPEC_TMP) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_NONNULL_CAST_SPEC_TMP): + VM_TRACE(ZEND_NONNULL_CAST_SPEC_TMP) + ZEND_NONNULL_CAST_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_NONNULL_CAST_SPEC_TMP) + HYBRID_BREAK(); HYBRID_CASE(ZEND_FE_RESET_R_SPEC_TMP): VM_TRACE(ZEND_FE_RESET_R_SPEC_TMP) ZEND_FE_RESET_R_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -118782,6 +120466,16 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_CAST_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_CAST_SPEC_VAR) HYBRID_BREAK(); + HYBRID_CASE(ZEND_NULLABLE_CAST_SPEC_VAR): + VM_TRACE(ZEND_NULLABLE_CAST_SPEC_VAR) + ZEND_NULLABLE_CAST_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_NULLABLE_CAST_SPEC_VAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_NONNULL_CAST_SPEC_VAR): + VM_TRACE(ZEND_NONNULL_CAST_SPEC_VAR) + ZEND_NONNULL_CAST_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_NONNULL_CAST_SPEC_VAR) + HYBRID_BREAK(); HYBRID_CASE(ZEND_FE_RESET_R_SPEC_VAR): VM_TRACE(ZEND_FE_RESET_R_SPEC_VAR) ZEND_FE_RESET_R_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -120216,6 +121910,16 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_CAST_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_CAST_SPEC_CV) HYBRID_BREAK(); + HYBRID_CASE(ZEND_NULLABLE_CAST_SPEC_CV): + VM_TRACE(ZEND_NULLABLE_CAST_SPEC_CV) + ZEND_NULLABLE_CAST_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_NULLABLE_CAST_SPEC_CV) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_NONNULL_CAST_SPEC_CV): + VM_TRACE(ZEND_NONNULL_CAST_SPEC_CV) + ZEND_NONNULL_CAST_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_NONNULL_CAST_SPEC_CV) + HYBRID_BREAK(); HYBRID_CASE(ZEND_INCLUDE_OR_EVAL_SPEC_CV): VM_TRACE(ZEND_INCLUDE_OR_EVAL_SPEC_CV) ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -124052,6 +125756,16 @@ void zend_vm_init(void) ZEND_JMP_FRAMELESS_SPEC_CONST_HANDLER, ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED_HANDLER, ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST_HANDLER, + ZEND_NULLABLE_CAST_SPEC_CONST_HANDLER, + ZEND_NULLABLE_CAST_SPEC_TMP_HANDLER, + ZEND_NULLABLE_CAST_SPEC_VAR_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULLABLE_CAST_SPEC_CV_HANDLER, + ZEND_NONNULL_CAST_SPEC_CONST_HANDLER, + ZEND_NONNULL_CAST_SPEC_TMP_HANDLER, + ZEND_NONNULL_CAST_SPEC_VAR_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NONNULL_CAST_SPEC_CV_HANDLER, ZEND_INIT_FCALL_OFFSET_SPEC_CONST_HANDLER, ZEND_RECV_NOTYPE_SPEC_HANDLER, ZEND_NULL_HANDLER, @@ -127549,6 +129263,16 @@ void zend_vm_init(void) ZEND_JMP_FRAMELESS_SPEC_CONST_TAILCALL_HANDLER, ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED_TAILCALL_HANDLER, ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST_TAILCALL_HANDLER, + ZEND_NULLABLE_CAST_SPEC_CONST_TAILCALL_HANDLER, + ZEND_NULLABLE_CAST_SPEC_TMP_TAILCALL_HANDLER, + ZEND_NULLABLE_CAST_SPEC_VAR_TAILCALL_HANDLER, + ZEND_NULL_TAILCALL_HANDLER, + ZEND_NULLABLE_CAST_SPEC_CV_TAILCALL_HANDLER, + ZEND_NONNULL_CAST_SPEC_CONST_TAILCALL_HANDLER, + ZEND_NONNULL_CAST_SPEC_TMP_TAILCALL_HANDLER, + ZEND_NONNULL_CAST_SPEC_VAR_TAILCALL_HANDLER, + ZEND_NULL_TAILCALL_HANDLER, + ZEND_NONNULL_CAST_SPEC_CV_TAILCALL_HANDLER, ZEND_INIT_FCALL_OFFSET_SPEC_CONST_TAILCALL_HANDLER, ZEND_RECV_NOTYPE_SPEC_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -128517,7 +130241,7 @@ void zend_vm_init(void) 1255, 1256 | SPEC_RULE_OP1, 1261 | SPEC_RULE_OP1, - 3493, + 3503, 1266 | SPEC_RULE_OP1, 1271 | SPEC_RULE_OP1, 1276 | SPEC_RULE_OP2, @@ -128551,7 +130275,7 @@ void zend_vm_init(void) 1559 | SPEC_RULE_OP1 | SPEC_RULE_OP2, 1584 | SPEC_RULE_OP1, 1589, - 3493, + 3503, 1590 | SPEC_RULE_OP1, 1595 | SPEC_RULE_OP1 | SPEC_RULE_OP2, 1620 | SPEC_RULE_OP1 | SPEC_RULE_OP2, @@ -128683,51 +130407,51 @@ void zend_vm_init(void) 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, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, + 2578 | SPEC_RULE_OP1, + 2583 | SPEC_RULE_OP1, + 3503, + 3503, + 3503, + 3503, + 3503, + 3503, + 3503, + 3503, + 3503, + 3503, + 3503, + 3503, + 3503, + 3503, + 3503, + 3503, + 3503, + 3503, + 3503, + 3503, + 3503, + 3503, + 3503, + 3503, + 3503, + 3503, + 3503, + 3503, + 3503, + 3503, + 3503, + 3503, + 3503, + 3503, + 3503, + 3503, + 3503, + 3503, + 3503, + 3503, + 3503, + 3503, + 3503, }; #if 0 #elif (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID) @@ -128904,7 +130628,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 = 2586 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2596 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -128912,7 +130636,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 = 2611 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2621 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -128920,7 +130644,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 = 2636 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2646 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -128931,17 +130655,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 = 2661 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2671 | 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 = 2686 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2696 | 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 = 2711 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2721 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_MUL: @@ -128952,17 +130676,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 = 2736 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2746 | 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 = 2761 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2771 | 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 = 2786 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2796 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_IDENTICAL: @@ -128973,16 +130697,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 = 2811 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2821 | 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 = 2886 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2896 | 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 = 3111 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3121 | 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 = 3117 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3127 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_IDENTICAL: @@ -128993,16 +130717,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 = 2961 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2971 | 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 = 3036 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3046 | 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 = 3114 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3124 | 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 = 3122 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3132 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_EQUAL: @@ -129013,12 +130737,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 = 2811 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2821 | 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 = 2886 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2896 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_EQUAL: @@ -129029,12 +130753,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 = 2961 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2971 | 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 = 3036 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3046 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_SMALLER: @@ -129042,12 +130766,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 = 3127 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3137 | 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 = 3202 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3212 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_IS_SMALLER_OR_EQUAL: @@ -129055,79 +130779,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 = 3277 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3287 | 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 = 3352 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3362 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_QM_ASSIGN: if (op1_info == MAY_BE_LONG) { - spec = 3439 | SPEC_RULE_OP1; + spec = 3449 | SPEC_RULE_OP1; } else if (op1_info == MAY_BE_DOUBLE) { - spec = 3444 | SPEC_RULE_OP1; + spec = 3454 | 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 = 3449 | SPEC_RULE_OP1; + spec = 3459 | SPEC_RULE_OP1; } break; case ZEND_PRE_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3427 | SPEC_RULE_RETVAL; + spec = 3437 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3429 | SPEC_RULE_RETVAL; + spec = 3439 | SPEC_RULE_RETVAL; } break; case ZEND_PRE_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3431 | SPEC_RULE_RETVAL; + spec = 3441 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3433 | SPEC_RULE_RETVAL; + spec = 3443 | SPEC_RULE_RETVAL; } break; case ZEND_POST_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3435; + spec = 3445; } else if (op1_info == MAY_BE_LONG) { - spec = 3436; + spec = 3446; } break; case ZEND_POST_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3437; + spec = 3447; } else if (op1_info == MAY_BE_LONG) { - spec = 3438; + spec = 3448; } break; case ZEND_JMP: if (OP_JMP_ADDR(op, op->op1) > op) { - spec = 2585; + spec = 2595; } break; case ZEND_INIT_FCALL: if (Z_EXTRA_P(RT_CONSTANT(op, op->op2)) != 0) { - spec = 2578; + spec = 2588; } break; case ZEND_RECV: if (op->op2.num == MAY_BE_ANY) { - spec = 2579; + spec = 2589; } 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 = 3489; + spec = 3499; } 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 = 3484 | SPEC_RULE_OP1; + spec = 3494 | 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 = 3491 | SPEC_RULE_RETVAL; + spec = 3501 | SPEC_RULE_RETVAL; } break; case ZEND_FETCH_DIM_R: @@ -129135,22 +130859,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 = 3454 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 3464 | 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 = 3490; + spec = 3500; } break; case ZEND_SEND_VAR: if (op->op2_type == IS_UNUSED && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3479 | SPEC_RULE_OP1; + spec = 3489 | SPEC_RULE_OP1; } break; case ZEND_COUNT: if ((op1_info & (MAY_BE_ANY|MAY_BE_UNDEF|MAY_BE_REF)) == MAY_BE_ARRAY) { - spec = 2580 | SPEC_RULE_OP1; + spec = 2590 | SPEC_RULE_OP1; } break; case ZEND_BW_OR: diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h index 33d951141550e..12ec0b082f510 100644 --- a/Zend/zend_vm_handlers.h +++ b/Zend/zend_vm_handlers.h @@ -1373,508 +1373,516 @@ _(2575, ZEND_JMP_FRAMELESS_SPEC_CONST) \ _(2576, ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED) \ _(2577, ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST) \ - _(2578, ZEND_INIT_FCALL_OFFSET_SPEC_CONST) \ - _(2579, ZEND_RECV_NOTYPE_SPEC) \ - _(2581, ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED) \ - _(2582, ZEND_COUNT_ARRAY_SPEC_TMPVAR_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) \ - _(2600, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2578, ZEND_NULLABLE_CAST_SPEC_CONST) \ + _(2579, ZEND_NULLABLE_CAST_SPEC_TMP) \ + _(2580, ZEND_NULLABLE_CAST_SPEC_VAR) \ + _(2582, ZEND_NULLABLE_CAST_SPEC_CV) \ + _(2583, ZEND_NONNULL_CAST_SPEC_CONST) \ + _(2584, ZEND_NONNULL_CAST_SPEC_TMP) \ + _(2585, ZEND_NONNULL_CAST_SPEC_VAR) \ + _(2587, ZEND_NONNULL_CAST_SPEC_CV) \ + _(2588, ZEND_INIT_FCALL_OFFSET_SPEC_CONST) \ + _(2589, ZEND_RECV_NOTYPE_SPEC) \ + _(2591, ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED) \ + _(2592, ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED) \ + _(2594, ZEND_COUNT_ARRAY_SPEC_CV_UNUSED) \ + _(2595, ZEND_JMP_FORWARD_SPEC) \ + _(2601, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2602, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2603, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2605, 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) \ - _(2625, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2616, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2617, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2618, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2620, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2626, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2627, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2628, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2630, 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) \ - _(2650, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2641, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2642, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2643, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2645, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2651, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2652, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2653, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2655, 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) \ - _(2675, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2666, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2667, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2668, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2670, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2672, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2673, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2675, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2676, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2677, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2678, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2680, 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) \ - _(2700, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2691, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2692, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2693, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2695, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2697, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2698, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2700, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2701, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2702, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2703, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2705, 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) \ - _(2725, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2716, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2717, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2718, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2720, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2722, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2723, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2725, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2726, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2727, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2728, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2730, 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) \ - _(2750, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2741, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2742, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2743, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2745, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2751, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2752, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2753, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2755, 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) \ - _(2775, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2766, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2767, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2768, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2770, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2776, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2777, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2778, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2780, 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) \ - _(2800, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2791, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2792, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2793, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2795, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2801, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2802, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2803, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2805, 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_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) \ - _(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) \ - _(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_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) \ - _(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) \ - _(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_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) \ - _(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) \ - _(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_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) \ - _(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_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_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_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) \ - _(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) \ - _(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_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_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) \ - _(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) \ - _(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_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_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) \ - _(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) \ - _(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_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_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) \ - _(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_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) + _(2816, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2817, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2818, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2820, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2836, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2837, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2838, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2839, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2840, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2841, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2842, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2843, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2844, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2848, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2849, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2850, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2851, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2852, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2853, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2854, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2855, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2856, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2857, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2858, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2859, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2863, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2864, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2865, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2881, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2882, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2883, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2884, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2885, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2886, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2887, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2888, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2889, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2893, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2894, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2895, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2911, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2912, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2913, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2914, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2915, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2916, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2917, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2918, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2919, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2923, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2924, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2925, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2926, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2927, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2928, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2929, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2930, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2931, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2932, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2933, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2934, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2938, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2939, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2940, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2956, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2957, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2958, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2959, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2960, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2961, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2962, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2963, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2964, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2968, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2969, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2970, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2986, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2987, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2988, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2989, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2990, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2991, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2992, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2993, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2994, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2998, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2999, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3000, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3001, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3002, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3003, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3004, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3005, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3006, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3007, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3008, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3009, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3013, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3014, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3015, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3031, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3032, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3033, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3034, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3035, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3036, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3037, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3038, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3039, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3043, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3044, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3045, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3061, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3062, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3063, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3064, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3065, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3066, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3067, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3068, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3069, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3073, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3074, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3075, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3076, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3077, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3078, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3079, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3080, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3081, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3082, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3083, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3084, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3088, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3089, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3090, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3106, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3107, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3108, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3109, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3110, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3111, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3112, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3113, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3114, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3118, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3119, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3120, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3121, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST) \ + _(3122, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3123, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3124, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST) \ + _(3125, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3126, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3127, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3131, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3132, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3136, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3140, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3141, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3142, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3143, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3144, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3145, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3149, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3150, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3151, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3152, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3153, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3154, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3155, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3156, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3157, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3158, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3159, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3160, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3164, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3165, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3166, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3167, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3168, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3169, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3170, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3171, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3172, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3173, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3174, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3175, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3179, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3180, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3181, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3197, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3198, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3199, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3200, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3201, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3202, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3203, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3204, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3205, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3209, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3210, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3211, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3215, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3216, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3217, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3218, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3219, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3220, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3224, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3225, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3226, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3227, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3228, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3229, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3230, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3231, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3232, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3233, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3234, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3235, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3239, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3240, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3241, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3242, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3243, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3244, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3245, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3246, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3247, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3248, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3249, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3250, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3254, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3255, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3256, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3272, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3273, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3274, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3275, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3276, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3277, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3278, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3279, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3280, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3284, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3285, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3286, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3290, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3291, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3292, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3293, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3294, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3295, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3299, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3300, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3301, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3302, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3303, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3304, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3305, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3306, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3307, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3308, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3309, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3310, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3314, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3315, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3316, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3317, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3318, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3319, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3320, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3321, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3322, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3323, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3324, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3325, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3329, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3330, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3331, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3347, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3348, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3349, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3350, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3351, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3352, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3353, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3354, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3355, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3359, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3360, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3361, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3365, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3366, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3367, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3368, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3369, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3370, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3374, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3375, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3376, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3377, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3378, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3379, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3380, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3381, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3382, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3383, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3384, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3385, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3389, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3390, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3391, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3392, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3393, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3394, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3395, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3396, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3397, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3398, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3399, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3400, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3404, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3405, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3406, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3422, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3423, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3424, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3425, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3426, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3427, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3428, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3429, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3430, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3434, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3435, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3436, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3437, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3438, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3439, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3440, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ + _(3441, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3442, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3443, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3444, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ + _(3445, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3446, ZEND_POST_INC_LONG_SPEC_CV) \ + _(3447, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3448, ZEND_POST_DEC_LONG_SPEC_CV) \ + _(3449, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ + _(3450, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3451, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3453, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3454, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ + _(3455, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3456, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3458, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3459, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ + _(3460, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3461, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3463, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3465, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3466, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3468, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3469, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3470, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3471, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3473, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3474, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3475, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3476, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3478, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3484, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ + _(3485, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3486, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3488, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3491, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ + _(3493, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ + _(3496, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ + _(3498, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ + _(3499, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ + _(3500, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ + _(3501, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ + _(3502, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ + _(3502+1, ZEND_NULL) diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c index 936a96e55e41f..e7eea62d2c1cb 100644 --- a/Zend/zend_vm_opcodes.c +++ b/Zend/zend_vm_opcodes.c @@ -22,7 +22,7 @@ #include #include -static const char *zend_vm_opcodes_names[211] = { +static const char *zend_vm_opcodes_names[213] = { "ZEND_NOP", "ZEND_ADD", "ZEND_SUB", @@ -234,9 +234,11 @@ static const char *zend_vm_opcodes_names[211] = { "ZEND_JMP_FRAMELESS", "ZEND_INIT_PARENT_PROPERTY_HOOK_CALL", "ZEND_DECLARE_ATTRIBUTED_CONST", + "ZEND_NULLABLE_CAST", + "ZEND_NONNULL_CAST", }; -static uint32_t zend_vm_opcodes_flags[211] = { +static uint32_t zend_vm_opcodes_flags[213] = { 0x00000000, 0x00000b0b, 0x00000b0b, @@ -448,6 +450,8 @@ static uint32_t zend_vm_opcodes_flags[211] = { 0x01042003, 0x01001103, 0x00000303, + 0x07000003, + 0x07000003, }; 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 287dec375f3a9..3aec9467e2f20 100644 --- a/Zend/zend_vm_opcodes.h +++ b/Zend/zend_vm_opcodes.h @@ -330,7 +330,9 @@ END_EXTERN_C() #define ZEND_JMP_FRAMELESS 208 #define ZEND_INIT_PARENT_PROPERTY_HOOK_CALL 209 #define ZEND_DECLARE_ATTRIBUTED_CONST 210 +#define ZEND_NULLABLE_CAST 211 +#define ZEND_NONNULL_CAST 212 -#define ZEND_VM_LAST_OPCODE 210 +#define ZEND_VM_LAST_OPCODE 212 #endif diff --git a/ext/tokenizer/tokenizer_data.c b/ext/tokenizer/tokenizer_data.c index 0900c51d3d95a..ce96d62eb67d2 100644 --- a/ext/tokenizer/tokenizer_data.c +++ b/ext/tokenizer/tokenizer_data.c @@ -154,6 +154,18 @@ char *get_token_type_name(int token_type) case T_BOOL_CAST: return "T_BOOL_CAST"; case T_UNSET_CAST: return "T_UNSET_CAST"; case T_VOID_CAST: return "T_VOID_CAST"; + case T_NULLABLE_INT_CAST: return "T_NULLABLE_INT_CAST"; + case T_NULLABLE_DOUBLE_CAST: return "T_NULLABLE_DOUBLE_CAST"; + case T_NULLABLE_STRING_CAST: return "T_NULLABLE_STRING_CAST"; + case T_NULLABLE_ARRAY_CAST: return "T_NULLABLE_ARRAY_CAST"; + case T_NULLABLE_OBJECT_CAST: return "T_NULLABLE_OBJECT_CAST"; + case T_NULLABLE_BOOL_CAST: return "T_NULLABLE_BOOL_CAST"; + case T_NONNULL_INT_CAST: return "T_NONNULL_INT_CAST"; + case T_NONNULL_DOUBLE_CAST: return "T_NONNULL_DOUBLE_CAST"; + case T_NONNULL_STRING_CAST: return "T_NONNULL_STRING_CAST"; + case T_NONNULL_ARRAY_CAST: return "T_NONNULL_ARRAY_CAST"; + case T_NONNULL_OBJECT_CAST: return "T_NONNULL_OBJECT_CAST"; + case T_NONNULL_BOOL_CAST: return "T_NONNULL_BOOL_CAST"; case T_OBJECT_OPERATOR: return "T_OBJECT_OPERATOR"; case T_NULLSAFE_OBJECT_OPERATOR: return "T_NULLSAFE_OBJECT_OPERATOR"; case T_DOUBLE_ARROW: return "T_DOUBLE_ARROW"; diff --git a/ext/tokenizer/tokenizer_data.stub.php b/ext/tokenizer/tokenizer_data.stub.php index 57c8edad8acb6..0d0d4b4636655 100644 --- a/ext/tokenizer/tokenizer_data.stub.php +++ b/ext/tokenizer/tokenizer_data.stub.php @@ -647,6 +647,66 @@ * @cvalue T_VOID_CAST */ const T_VOID_CAST = UNKNOWN; +/** + * @var int + * @cvalue T_NULLABLE_INT_CAST + */ +const T_NULLABLE_INT_CAST = UNKNOWN; +/** + * @var int + * @cvalue T_NULLABLE_DOUBLE_CAST + */ +const T_NULLABLE_DOUBLE_CAST = UNKNOWN; +/** + * @var int + * @cvalue T_NULLABLE_STRING_CAST + */ +const T_NULLABLE_STRING_CAST = UNKNOWN; +/** + * @var int + * @cvalue T_NULLABLE_ARRAY_CAST + */ +const T_NULLABLE_ARRAY_CAST = UNKNOWN; +/** + * @var int + * @cvalue T_NULLABLE_OBJECT_CAST + */ +const T_NULLABLE_OBJECT_CAST = UNKNOWN; +/** + * @var int + * @cvalue T_NULLABLE_BOOL_CAST + */ +const T_NULLABLE_BOOL_CAST = UNKNOWN; +/** + * @var int + * @cvalue T_NONNULL_INT_CAST + */ +const T_NONNULL_INT_CAST = UNKNOWN; +/** + * @var int + * @cvalue T_NONNULL_DOUBLE_CAST + */ +const T_NONNULL_DOUBLE_CAST = UNKNOWN; +/** + * @var int + * @cvalue T_NONNULL_STRING_CAST + */ +const T_NONNULL_STRING_CAST = UNKNOWN; +/** + * @var int + * @cvalue T_NONNULL_ARRAY_CAST + */ +const T_NONNULL_ARRAY_CAST = UNKNOWN; +/** + * @var int + * @cvalue T_NONNULL_OBJECT_CAST + */ +const T_NONNULL_OBJECT_CAST = UNKNOWN; +/** + * @var int + * @cvalue T_NONNULL_BOOL_CAST + */ +const T_NONNULL_BOOL_CAST = UNKNOWN; /** * @var int * @cvalue T_OBJECT_OPERATOR diff --git a/ext/tokenizer/tokenizer_data_arginfo.h b/ext/tokenizer/tokenizer_data_arginfo.h index 3a3cdaa468133..683d92041be7a 100644 --- a/ext/tokenizer/tokenizer_data_arginfo.h +++ b/ext/tokenizer/tokenizer_data_arginfo.h @@ -1,5 +1,5 @@ /* This is a generated file, edit the .stub.php file instead. - * Stub hash: c5235344b7c651d27c2c33c90696a418a9c96837 */ + * Stub hash: 5b58ff8e2312783674d2cdd415655db18832f61a */ static void register_tokenizer_data_symbols(int module_number) { @@ -132,6 +132,18 @@ static void register_tokenizer_data_symbols(int module_number) REGISTER_LONG_CONSTANT("T_BOOL_CAST", T_BOOL_CAST, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_UNSET_CAST", T_UNSET_CAST, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_VOID_CAST", T_VOID_CAST, CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("T_NULLABLE_INT_CAST", T_NULLABLE_INT_CAST, CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("T_NULLABLE_DOUBLE_CAST", T_NULLABLE_DOUBLE_CAST, CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("T_NULLABLE_STRING_CAST", T_NULLABLE_STRING_CAST, CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("T_NULLABLE_ARRAY_CAST", T_NULLABLE_ARRAY_CAST, CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("T_NULLABLE_OBJECT_CAST", T_NULLABLE_OBJECT_CAST, CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("T_NULLABLE_BOOL_CAST", T_NULLABLE_BOOL_CAST, CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("T_NONNULL_INT_CAST", T_NONNULL_INT_CAST, CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("T_NONNULL_DOUBLE_CAST", T_NONNULL_DOUBLE_CAST, CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("T_NONNULL_STRING_CAST", T_NONNULL_STRING_CAST, CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("T_NONNULL_ARRAY_CAST", T_NONNULL_ARRAY_CAST, CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("T_NONNULL_OBJECT_CAST", T_NONNULL_OBJECT_CAST, CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("T_NONNULL_BOOL_CAST", T_NONNULL_BOOL_CAST, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_OBJECT_OPERATOR", T_OBJECT_OPERATOR, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_NULLSAFE_OBJECT_OPERATOR", T_NULLSAFE_OBJECT_OPERATOR, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_DOUBLE_ARROW", T_DOUBLE_ARROW, CONST_PERSISTENT);