diff options
44 files changed, 1792 insertions, 1312 deletions
diff --git a/Zend/tests/bug30922.phpt b/Zend/tests/bug30922.phpt index 0d5d8ae838..001845a7cb 100644 --- a/Zend/tests/bug30922.phpt +++ b/Zend/tests/bug30922.phpt @@ -10,4 +10,4 @@ var_dump($a instanceOf A); echo "ok\n"; ?> --EXPECTF-- -Fatal error: Interface 'RecurisiveFooFar' not found in %sbug30922.php on line %d +Fatal error: Interface RecurisiveFooFar cannot implement itself in %s on line %d diff --git a/Zend/tests/type_declarations/variance/class_order_autoload1.phpt b/Zend/tests/type_declarations/variance/class_order_autoload1.phpt new file mode 100644 index 0000000000..d68d2e8afa --- /dev/null +++ b/Zend/tests/type_declarations/variance/class_order_autoload1.phpt @@ -0,0 +1,37 @@ +--TEST-- +Class order allowed with autoloading (1) +--FILE-- +<?php + +spl_autoload_register(function($class) { + if ($class === 'A') { + class A { + public function method() : B {} + } + var_dump(new A); + } else if ($class == 'B') { + class B extends A { + public function method() : C {} + } + var_dump(new B); + } else { + class C extends B { + } + var_dump(new C); + } +}); + +var_dump(new C); + +?> +===DONE=== +--EXPECT-- +object(A)#2 (0) { +} +object(B)#2 (0) { +} +object(C)#2 (0) { +} +object(C)#2 (0) { +} +===DONE=== diff --git a/Zend/tests/type_declarations/variance/class_order_autoload2.phpt b/Zend/tests/type_declarations/variance/class_order_autoload2.phpt new file mode 100644 index 0000000000..f6229d3995 --- /dev/null +++ b/Zend/tests/type_declarations/variance/class_order_autoload2.phpt @@ -0,0 +1,38 @@ +--TEST-- +Class order allowed with autoloading (2) +--FILE-- +<?php + +spl_autoload_register(function($class) { + if ($class === 'A') { + class A { + public function method() : B {} + } + var_dump(new A); + } else if ($class == 'B') { + class B extends A { + public function method() : C {} + } + var_dump(new B); + } else { + class C extends B { + } + var_dump(new C); + } +}); + +// Same as autoload1 test case, but with a different autoloading root +var_dump(new B); + +?> +===DONE=== +--EXPECT-- +object(A)#2 (0) { +} +object(C)#2 (0) { +} +object(B)#2 (0) { +} +object(B)#2 (0) { +} +===DONE=== diff --git a/Zend/tests/type_declarations/variance/class_order_autoload3.phpt b/Zend/tests/type_declarations/variance/class_order_autoload3.phpt new file mode 100644 index 0000000000..d09f2a9c45 --- /dev/null +++ b/Zend/tests/type_declarations/variance/class_order_autoload3.phpt @@ -0,0 +1,45 @@ +--TEST-- +Class order allowed with autoloading (3) +--FILE-- +<?php + +spl_autoload_register(function($class) { + if ($class == 'A') { + class A { + public function method(): X {} + } + var_dump(new A); + } else if ($class == 'B') { + class B extends A { + public function method(): Y {} + } + var_dump(new B); + } else if ($class == 'X') { + class X { + public function method(): A {} + } + var_dump(new X); + } else if ($class == 'Y') { + class Y extends X { + public function method(): B {} + } + var_dump(new Y); + } +}); + +var_dump(new B); + +?> +===DONE=== +--EXPECT-- +object(A)#2 (0) { +} +object(X)#2 (0) { +} +object(Y)#2 (0) { +} +object(B)#2 (0) { +} +object(B)#2 (0) { +} +===DONE=== diff --git a/Zend/tests/type_declarations/variance/class_order_autoload4.phpt b/Zend/tests/type_declarations/variance/class_order_autoload4.phpt new file mode 100644 index 0000000000..37070b444c --- /dev/null +++ b/Zend/tests/type_declarations/variance/class_order_autoload4.phpt @@ -0,0 +1,44 @@ +--TEST-- +Class order allowed with autoloading (4) +--FILE-- +<?php + +// Same as autoload3 test case, but with X, Y being interfaces. +spl_autoload_register(function($class) { + if ($class == 'A') { + class A { + public function method(): X {} + } + var_dump(new A); + } else if ($class == 'B') { + class B extends A { + public function method(): Y {} + } + var_dump(new B); + } else if ($class == 'X') { + interface X { + public function method(): A; + } + var_dump(interface_exists('X')); + } else if ($class == 'Y') { + interface Y extends X { + public function method(): B; + } + var_dump(interface_exists('Y')); + } +}); + +var_dump(new B); + +?> +===DONE=== +--EXPECT-- +object(A)#2 (0) { +} +bool(true) +bool(true) +object(B)#2 (0) { +} +object(B)#2 (0) { +} +===DONE=== diff --git a/Zend/tests/type_declarations/variance/class_order_autoload5.phpt b/Zend/tests/type_declarations/variance/class_order_autoload5.phpt new file mode 100644 index 0000000000..77e9a0a9ec --- /dev/null +++ b/Zend/tests/type_declarations/variance/class_order_autoload5.phpt @@ -0,0 +1,60 @@ +--TEST-- +Class order allowed with autoloading (5) +--FILE-- +<?php + +// Similar to variance3, but one more class hierarchy in the cycle +spl_autoload_register(function($class) { + if ($class == 'A') { + class A { + public function method(): X {} + } + var_dump(new A); + } else if ($class == 'B') { + class B extends A { + public function method(): Y {} + } + var_dump(new B); + } else if ($class == 'X') { + class X { + public function method(): Q {} + } + var_dump(new X); + } else if ($class == 'Y') { + class Y extends X { + public function method(): R {} + } + var_dump(new Y); + } else if ($class == 'Q') { + class Q { + public function method(): A {} + } + var_dump(new Q); + } else if ($class == 'R') { + class R extends Q { + public function method(): B {} + } + var_dump(new R); + } +}); + +var_dump(new B); + +?> +===DONE=== +--EXPECT-- +object(A)#2 (0) { +} +object(X)#2 (0) { +} +object(Q)#2 (0) { +} +object(R)#2 (0) { +} +object(Y)#2 (0) { +} +object(B)#2 (0) { +} +object(B)#2 (0) { +} +===DONE=== diff --git a/Zend/tests/type_declarations/variance/class_order_autoload.phpt b/Zend/tests/type_declarations/variance/class_order_autoload_error1.phpt index a4ea534577..9af4041604 100644 --- a/Zend/tests/type_declarations/variance/class_order_autoload.phpt +++ b/Zend/tests/type_declarations/variance/class_order_autoload_error1.phpt @@ -1,16 +1,16 @@ --TEST-- -Returns are covariant, but we don't allow the code due to class ordering (autoload variation) +Variance error in the presence of autoloading (1) --FILE-- <?php spl_autoload_register(function($class) { if ($class === 'A') { class A { - public function method() : B {} + public function method() : C {} } } else if ($class == 'B') { class B extends A { - public function method() : C {} + public function method() : B {} } } else { class C extends B { @@ -18,8 +18,8 @@ spl_autoload_register(function($class) { } }); -$c = new C; +$b = new B; ?> --EXPECTF-- -Fatal error: Could not check compatibility between B::method(): C and A::method(): B, because class C is not available in %s on line %d +Fatal error: Declaration of B::method(): B must be compatible with A::method(): C in %s on line %d diff --git a/Zend/tests/type_declarations/variance/class_order_autoload_error2.phpt b/Zend/tests/type_declarations/variance/class_order_autoload_error2.phpt new file mode 100644 index 0000000000..4cb4d655d6 --- /dev/null +++ b/Zend/tests/type_declarations/variance/class_order_autoload_error2.phpt @@ -0,0 +1,27 @@ +--TEST-- +Variance error in the presence of autoloading (2) +--FILE-- +<?php + +// Same as autoload_error1, but for argument types. +spl_autoload_register(function($class) { + if ($class === 'A') { + class A { + public function method(B $x) {} + } + } else if ($class == 'B') { + class B extends A { + public function method(C $x) {} + } + } else { + class C extends B { + } + } +}); + +$b = new B; +$c = new C; + +?> +--EXPECTF-- +Fatal error: Declaration of B::method(C $x) must be compatible with A::method(B $x) in %s on line %d diff --git a/Zend/tests/type_declarations/variance/class_order_autoload_error3.phpt b/Zend/tests/type_declarations/variance/class_order_autoload_error3.phpt new file mode 100644 index 0000000000..23b60b4584 --- /dev/null +++ b/Zend/tests/type_declarations/variance/class_order_autoload_error3.phpt @@ -0,0 +1,38 @@ +--TEST-- +Variance error in the presence of autoloading (3) +--FILE-- +<?php + +spl_autoload_register(function($class) { + if ($class == 'A') { + class A { + public function method(): X {} + } + } else if ($class == 'B') { + class B extends A { + public function method(): Y {} + } + } else if ($class == 'X') { + class X { + public function method(): Q {} + } + } else if ($class == 'Y') { + class Y extends X { + public function method(): R {} + } + } else if ($class == 'Q') { + class Q { + public function method(): B {} + } + } else if ($class == 'R') { + class R extends Q { + public function method(): A {} + } + } +}); + +$b = new B; + +?> +--EXPECTF-- +Fatal error: Declaration of R::method(): A must be compatible with Q::method(): B in %s on line %d diff --git a/Zend/tests/type_declarations/variance/class_order_autoload_error4.phpt b/Zend/tests/type_declarations/variance/class_order_autoload_error4.phpt new file mode 100644 index 0000000000..6acf9313f4 --- /dev/null +++ b/Zend/tests/type_declarations/variance/class_order_autoload_error4.phpt @@ -0,0 +1,39 @@ +--TEST-- +Variance error in the presence of autoloading (4) +--FILE-- +<?php + +spl_autoload_register(function($class) { + if ($class == 'A') { + class A { + public function method(): X {} + } + var_dump(new A); + } else if ($class == 'B') { + class B extends A { + public function method(): Y {} + } + var_dump(new B); + } else if ($class == 'X') { + class X { + public function method(): B {} + } + var_dump(new X); + } else if ($class == 'Y') { + class Y extends X { + public function method(): A {} + } + var_dump(new Y); + } +}); + +var_dump(new B); + +?> +--EXPECTF-- +object(A)#2 (0) { +} +object(X)#2 (0) { +} + +Fatal error: Declaration of Y::method(): A must be compatible with X::method(): B in %s on line %d diff --git a/Zend/tests/type_declarations/variance/class_order_autoload_error5.phpt b/Zend/tests/type_declarations/variance/class_order_autoload_error5.phpt new file mode 100644 index 0000000000..ef7032e4a0 --- /dev/null +++ b/Zend/tests/type_declarations/variance/class_order_autoload_error5.phpt @@ -0,0 +1,44 @@ +--TEST-- +Variance error in the presence of autoloading (5) +--FILE-- +<?php + +spl_autoload_register(function($class) { + if ($class == 'A') { + class A { + public function method(): X {} + } + var_dump(new A); + } else if ($class == 'B') { + class B extends A { + public function method(): Y {} + } + var_dump(new B); + } else if ($class == 'X') { + class X { + public function method(Y $a) {} + } + var_dump(new X); + } else if ($class == 'Y') { + class Y extends X { + public function method(Z $a) {} + } + var_dump(new Y); + } else if ($class == 'Z') { + class Z extends Y { + public function method($a) {} + } + var_dump(new Z); + } +}); + +var_dump(new B); + +?> +--EXPECTF-- +object(A)#2 (0) { +} +object(X)#2 (0) { +} + +Fatal error: Declaration of Y::method(Z $a) must be compatible with X::method(Y $a) in %s on line %d diff --git a/Zend/tests/type_declarations/variance/class_order_autoload_error6.phpt b/Zend/tests/type_declarations/variance/class_order_autoload_error6.phpt new file mode 100644 index 0000000000..4b54c9554d --- /dev/null +++ b/Zend/tests/type_declarations/variance/class_order_autoload_error6.phpt @@ -0,0 +1,39 @@ +--TEST-- +Variance error in the presence of autoloading (6) +--FILE-- +<?php + +spl_autoload_register(function($class) { + if ($class == 'A') { + class A { + public function method(): X {} + } + var_dump(new A); + } else if ($class == 'B') { + class B extends A { + public function method(): Y {} + } + var_dump(new B); + } else if ($class == 'X') { + class X { + public function method(): X {} + } + var_dump(new X); + } else if ($class == 'Y') { + class Y extends X { + public function method(): Unknown {} + } + var_dump(new Y); + } +}); + +var_dump(new B); + +?> +--EXPECTF-- +object(A)#2 (0) { +} +object(X)#2 (0) { +} + +Fatal error: Could not check compatibility between Y::method(): Unknown and X::method(): X, because class Unknown is not available in %s on line %d diff --git a/Zend/tests/type_declarations/variance/class_order.phpt b/Zend/tests/type_declarations/variance/class_order_error.phpt index df66e78b78..df66e78b78 100644 --- a/Zend/tests/type_declarations/variance/class_order.phpt +++ b/Zend/tests/type_declarations/variance/class_order_error.phpt diff --git a/Zend/zend_API.c b/Zend/zend_API.c index b638f5c46c..37a002f003 100644 --- a/Zend/zend_API.c +++ b/Zend/zend_API.c @@ -2506,7 +2506,7 @@ static zend_class_entry *do_register_internal_class(zend_class_entry *orig_class class_entry->type = ZEND_INTERNAL_CLASS; zend_initialize_class_data(class_entry, 0); - class_entry->ce_flags = ce_flags | ZEND_ACC_CONSTANTS_UPDATED | ZEND_ACC_LINKED; + class_entry->ce_flags = ce_flags | ZEND_ACC_CONSTANTS_UPDATED | ZEND_ACC_LINKED | ZEND_ACC_RESOLVED_PARENT | ZEND_ACC_RESOLVED_INTERFACES; class_entry->info.internal.module = EG(current_module); if (class_entry->info.internal.builtin_functions) { diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index 73a32b80c9..4771dff775 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -370,6 +370,9 @@ void init_compiler(void) /* {{{ */ zend_hash_init(&CG(filenames_table), 8, NULL, ZVAL_PTR_DTOR, 0); zend_llist_init(&CG(open_files), sizeof(zend_file_handle), (void (*)(void *)) file_handle_dtor, 0); CG(unclean_shutdown) = 0; + + CG(delayed_variance_obligations) = NULL; + CG(delayed_autoloads) = NULL; } /* }}} */ @@ -379,6 +382,17 @@ void shutdown_compiler(void) /* {{{ */ zend_stack_destroy(&CG(delayed_oplines_stack)); zend_hash_destroy(&CG(filenames_table)); zend_arena_destroy(CG(arena)); + + if (CG(delayed_variance_obligations)) { + zend_hash_destroy(CG(delayed_variance_obligations)); + FREE_HASHTABLE(CG(delayed_variance_obligations)); + CG(delayed_variance_obligations) = NULL; + } + if (CG(delayed_autoloads)) { + zend_hash_destroy(CG(delayed_autoloads)); + FREE_HASHTABLE(CG(delayed_autoloads)); + CG(delayed_autoloads) = NULL; + } } /* }}} */ @@ -1033,7 +1047,7 @@ ZEND_API int do_bind_function(zval *lcname) /* {{{ */ } /* }}} */ -ZEND_API int do_bind_class(zval *lcname, zend_class_entry *parent_ce) /* {{{ */ +ZEND_API int do_bind_class(zval *lcname) /* {{{ */ { zend_class_entry *ce; zval *rtd_key, *zv; @@ -1060,7 +1074,7 @@ ZEND_API int do_bind_class(zval *lcname, zend_class_entry *parent_ce) /* {{{ */ return FAILURE; } - zend_do_link_class(ce, parent_ce); + zend_do_link_class(ce); return SUCCESS; } /* }}} */ @@ -1103,7 +1117,7 @@ ZEND_API uint32_t zend_build_delayed_early_binding_list(const zend_op_array *op_ zend_op *end = opline + op_array->last; while (opline < end) { - if (opline->opcode == ZEND_DECLARE_INHERITED_CLASS_DELAYED) { + if (opline->opcode == ZEND_DECLARE_CLASS_DELAYED) { *prev_opline_num = opline - op_array->opcodes; prev_opline_num = &opline->result.opline_num; } @@ -1126,11 +1140,10 @@ ZEND_API void zend_do_delayed_early_binding(const zend_op_array *op_array, uint3 while (opline_num != (uint32_t)-1) { const zend_op *opline = &op_array->opcodes[opline_num]; zval *lcname = RT_CONSTANT(opline, opline->op1); - zval *parent_name = RT_CONSTANT(opline, opline->op2); zend_class_entry *ce = zend_hash_find_ptr(EG(class_table), Z_STR_P(lcname + 1)); - zend_class_entry *parent_ce = zend_lookup_class_ex(Z_STR_P(parent_name), Z_STR_P(parent_name + 1), 0); + zend_class_entry *parent_ce = zend_lookup_class(ce->parent_name); if (ce && parent_ce && zend_can_early_bind(ce, parent_ce)) { - do_bind_class(lcname, parent_ce); + do_bind_class(lcname); } opline_num = op_array->opcodes[opline_num].result.opline_num; } @@ -6321,15 +6334,9 @@ zend_op *zend_compile_class_decl(zend_ast *ast, zend_bool toplevel) /* {{{ */ LITERAL_STR(opline->op1, lcname); if (decl->flags & ZEND_ACC_ANON_CLASS) { + opline->opcode = ZEND_DECLARE_ANON_CLASS; opline->result_type = IS_VAR; opline->result.var = get_temporary_variable(); - if (extends_ast) { - opline->opcode = ZEND_DECLARE_ANON_INHERITED_CLASS; - opline->op2_type = IS_CONST; - opline->op2.constant = zend_add_class_name_literal(zend_string_copy(ce->parent_name)); - } else { - opline->opcode = ZEND_DECLARE_ANON_CLASS; - } if (!zend_hash_add_ptr(CG(class_table), lcname, ce)) { /* this anonymous class has been included */ @@ -6345,22 +6352,16 @@ zend_op *zend_compile_class_decl(zend_ast *ast, zend_bool toplevel) /* {{{ */ zend_add_literal_string(&key); zend_hash_update_ptr(CG(class_table), key, ce); - if (extends_ast) { - if (toplevel + opline->opcode = ZEND_DECLARE_CLASS; + if (extends_ast && toplevel && (CG(compiler_options) & ZEND_COMPILE_DELAYED_BINDING) /* We currently don't early-bind classes that implement interfaces or use traits */ - && !(ce->ce_flags & (ZEND_ACC_IMPLEMENT_INTERFACES|ZEND_ACC_IMPLEMENT_TRAITS))) { - CG(active_op_array)->fn_flags |= ZEND_ACC_EARLY_BINDING; - opline->opcode = ZEND_DECLARE_INHERITED_CLASS_DELAYED; - opline->result_type = IS_UNUSED; - opline->result.opline_num = -1; - } else { - opline->opcode = ZEND_DECLARE_INHERITED_CLASS; - } - opline->op2_type = IS_CONST; - opline->op2.constant = zend_add_class_name_literal(zend_string_copy(ce->parent_name)); - } else { - opline->opcode = ZEND_DECLARE_CLASS; + && !(ce->ce_flags & (ZEND_ACC_IMPLEMENT_INTERFACES|ZEND_ACC_IMPLEMENT_TRAITS)) + ) { + CG(active_op_array)->fn_flags |= ZEND_ACC_EARLY_BINDING; + opline->opcode = ZEND_DECLARE_CLASS_DELAYED; + opline->result_type = IS_UNUSED; + opline->result.opline_num = -1; } } return opline; diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h index 388780934d..e8911f732a 100644 --- a/Zend/zend_compile.h +++ b/Zend/zend_compile.h @@ -269,8 +269,14 @@ typedef struct _zend_oparray_context { /* Children must reuse parent get_iterator() | | | */ #define ZEND_ACC_REUSE_GET_ITERATOR (1 << 18) /* X | | | */ /* | | | */ -/* Class is being linked. Don't free strings. | | | */ -#define ZEND_ACC_LINKING_IN_PROGRESS (1 << 19) /* X | | | */ +/* Parent class is resolved (CE). | | | */ +#define ZEND_ACC_RESOLVED_PARENT (1 << 19) /* X | | | */ +/* | | | */ +/* Interfaces are resolved (CEs). | | | */ +#define ZEND_ACC_RESOLVED_INTERFACES (1 << 20) /* X | | | */ +/* | | | */ +/* Class has unresolved variance obligations. | | | */ +#define ZEND_ACC_UNRESOLVED_VARIANCE (1 << 21) /* X | | | */ /* | | | */ /* Function Flags (unused: 28...30) | | | */ /* ============== | | | */ @@ -291,7 +297,7 @@ typedef struct _zend_oparray_context { #define ZEND_ACC_HAS_FINALLY_BLOCK (1 << 15) /* | X | | */ /* | | | */ /* "main" op_array with | | | */ -/* ZEND_DECLARE_INHERITED_CLASS_DELAYED opcodes | | | */ +/* ZEND_DECLARE_CLASS_DELAYED opcodes | | | */ #define ZEND_ACC_EARLY_BINDING (1 << 16) /* | X | | */ /* | | | */ /* call through user function trampoline. e.g. | | | */ @@ -741,7 +747,7 @@ zend_bool zend_handle_encoding_declaration(zend_ast *ast); void zend_do_free(znode *op1); ZEND_API int do_bind_function(zval *lcname); -ZEND_API int do_bind_class(zval *lcname, zend_class_entry *parent_ce); +ZEND_API int do_bind_class(zval *lcname); ZEND_API uint32_t zend_build_delayed_early_binding_list(const zend_op_array *op_array); ZEND_API void zend_do_delayed_early_binding(const zend_op_array *op_array, uint32_t first_early_binding_opline); @@ -848,6 +854,7 @@ void zend_assert_valid_class_name(const zend_string *const_name); #define ZEND_FETCH_CLASS_NO_AUTOLOAD 0x80 #define ZEND_FETCH_CLASS_SILENT 0x0100 #define ZEND_FETCH_CLASS_EXCEPTION 0x0200 +#define ZEND_FETCH_CLASS_ALLOW_UNLINKED 0x0400 #define ZEND_PARAM_REF (1<<0) #define ZEND_PARAM_VARIADIC (1<<1) @@ -1024,7 +1031,7 @@ END_EXTERN_C() * may apper in run-time */ #define ZEND_COMPILE_IGNORE_INTERNAL_CLASSES (1<<4) -/* generate ZEND_DECLARE_INHERITED_CLASS_DELAYED opcode to delay early binding */ +/* generate ZEND_DECLARE_CLASS_DELAYED opcode to delay early binding */ #define ZEND_COMPILE_DELAYED_BINDING (1<<5) /* disable constant substitution at compile-time */ diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c index 4963e7406c..4ad19d6764 100644 --- a/Zend/zend_execute_API.c +++ b/Zend/zend_execute_API.c @@ -34,6 +34,7 @@ #include "zend_vm.h" #include "zend_float.h" #include "zend_weakrefs.h" +#include "zend_inheritance.h" #ifdef HAVE_SYS_TIME_H #include <sys/time.h> #endif @@ -862,7 +863,8 @@ ZEND_API zend_class_entry *zend_lookup_class_ex(zend_string *name, zend_string * zend_string_release_ex(lc_name, 0); } ce = (zend_class_entry*)Z_PTR_P(zv); - if (UNEXPECTED(!(ce->ce_flags & ZEND_ACC_LINKED))) { + if (UNEXPECTED(!(ce->ce_flags & ZEND_ACC_LINKED)) && + !(flags & ZEND_FETCH_CLASS_ALLOW_UNLINKED)) { return NULL; } return ce; diff --git a/Zend/zend_globals.h b/Zend/zend_globals.h index 6644e735ca..27ea9d4a8e 100644 --- a/Zend/zend_globals.h +++ b/Zend/zend_globals.h @@ -124,6 +124,9 @@ struct _zend_compiler_globals { void *map_ptr_base; size_t map_ptr_size; size_t map_ptr_last; + + HashTable *delayed_variance_obligations; + HashTable *delayed_autoloads; }; diff --git a/Zend/zend_inheritance.c b/Zend/zend_inheritance.c index e34057d03e..cda838d837 100644 --- a/Zend/zend_inheritance.c +++ b/Zend/zend_inheritance.c @@ -26,6 +26,10 @@ #include "zend_smart_str.h" #include "zend_operators.h" +static void add_dependency_obligation(zend_class_entry *ce, zend_class_entry *dependency_ce); +static void add_compatibility_obligation( + zend_class_entry *ce, const zend_function *child_fn, const zend_function *parent_fn); + static void overridden_ptr_dtor(zval *zv) /* {{{ */ { efree_size(Z_PTR_P(zv), sizeof(zend_function)); @@ -174,7 +178,7 @@ static zend_string *resolve_class_name(const zend_function *fe, zend_string *nam zend_class_entry *ce = fe->common.scope; ZEND_ASSERT(ce); if (zend_string_equals_literal_ci(name, "parent") && ce->parent) { - if (ce->ce_flags & (ZEND_ACC_LINKED|ZEND_ACC_LINKING_IN_PROGRESS)) { + if (ce->ce_flags & ZEND_ACC_RESOLVED_PARENT) { return ce->parent->name; } else { return ce->parent_name; @@ -199,32 +203,75 @@ static zend_bool class_visible(zend_class_entry *ce) { static zend_class_entry *lookup_class(const zend_function *fe, zend_string *name) { zend_class_entry *ce; if (!CG(in_compilation)) { - ce = zend_lookup_class(name); + uint32_t flags = ZEND_FETCH_CLASS_ALLOW_UNLINKED | ZEND_FETCH_CLASS_NO_AUTOLOAD; + ce = zend_lookup_class_ex(name, NULL, flags); if (ce) { return ce; } + + /* We'll autoload this class and process delayed variance obligations later. */ + if (!CG(delayed_autoloads)) { + ALLOC_HASHTABLE(CG(delayed_autoloads)); + zend_hash_init(CG(delayed_autoloads), 0, NULL, NULL, 0); + } + zend_hash_add_empty_element(CG(delayed_autoloads), name); } else { ce = zend_lookup_class_ex(name, NULL, ZEND_FETCH_CLASS_NO_AUTOLOAD); if (ce && class_visible(ce)) { return ce; } - } - /* The current class may not be registered yet, so check for it explicitly. */ - if (zend_string_equals_ci(fe->common.scope->name, name)) { - return fe->common.scope; + /* The current class may not be registered yet, so check for it explicitly. */ + if (zend_string_equals_ci(fe->common.scope->name, name)) { + return fe->common.scope; + } } return NULL; } -/* Instanceof that's safe to use on unlinked classes. For the unlinked case, we only handle - * class identity here. */ +/* Instanceof that's safe to use on unlinked classes. */ static zend_bool unlinked_instanceof(zend_class_entry *ce1, zend_class_entry *ce2) { - if ((ce1->ce_flags & (ZEND_ACC_LINKED|ZEND_ACC_LINKING_IN_PROGRESS))) { + zend_class_entry *ce; + + if (ce1 == ce2) { + return 1; + } + + if (ce1->ce_flags & (ZEND_ACC_LINKED|ZEND_ACC_RESOLVED_INTERFACES)) { return instanceof_function(ce1, ce2); } - return ce1 == ce2; + + ce = ce1; + while (ce->parent) { + if (ce->ce_flags & ZEND_ACC_RESOLVED_PARENT) { + ce = ce->parent; + } else { + ce = zend_lookup_class_ex(ce->parent_name, NULL, + ZEND_FETCH_CLASS_ALLOW_UNLINKED | ZEND_FETCH_CLASS_NO_AUTOLOAD); + if (!ce) { + break; + } + } + if (ce == ce2) { + return 1; + } + } + + if (ce1->num_interfaces) { + uint32_t i; + ZEND_ASSERT(!(ce->ce_flags & ZEND_ACC_RESOLVED_INTERFACES)); + for (i = 0; i < ce1->num_interfaces; i++) { + ce = zend_lookup_class_ex( + ce1->interface_names[i].name, ce1->interface_names[i].lc_name, + ZEND_FETCH_CLASS_ALLOW_UNLINKED | ZEND_FETCH_CLASS_NO_AUTOLOAD); + if (ce && unlinked_instanceof(ce, ce2)) { + return 1; + } + } + } + + return 0; } /* Unresolved means that class declarations that are currently not available are needed to @@ -261,13 +308,14 @@ static inheritance_status zend_perform_covariant_type_check( return INHERITANCE_SUCCESS; } + /* Make sure to always load both classes, to avoid only registering one of them as + * a delayed autoload. */ fe_ce = lookup_class(fe, fe_class_name); + proto_ce = lookup_class(proto, proto_class_name); if (!fe_ce) { *unresolved_class = fe_class_name; return INHERITANCE_UNRESOLVED; } - - proto_ce = lookup_class(proto, proto_class_name); if (!proto_ce) { *unresolved_class = proto_class_name; return INHERITANCE_UNRESOLVED; @@ -440,6 +488,16 @@ static inheritance_status zend_do_perform_implementation_check( } /* }}} */ +static inheritance_status perform_delayable_implementation_check( + zend_string **unresolved_class, zend_class_entry *ce, + const zend_function *fe, const zend_function *proto) { + inheritance_status status = zend_do_perform_implementation_check(unresolved_class, fe, proto); + if (status == INHERITANCE_UNRESOLVED) { + add_compatibility_obligation(ce, fe, proto); + } + return status; +} + static ZEND_COLD void zend_append_type_hint(smart_str *str, const zend_function *fptr, zend_arg_info *arg_info, int return_hint) /* {{{ */ { @@ -601,12 +659,12 @@ static ZEND_COLD zend_string *zend_get_function_declaration(const zend_function } /* }}} */ -static zend_always_inline uint32_t func_lineno(zend_function *fn) { +static zend_always_inline uint32_t func_lineno(const zend_function *fn) { return fn->common.type == ZEND_USER_FUNCTION ? fn->op_array.line_start : 0; } static void ZEND_COLD emit_incompatible_method_error( - zend_function *child, zend_function *parent, + const zend_function *child, const zend_function *parent, inheritance_status status, zend_string *unresolved_class) { zend_string *parent_prototype = zend_get_function_declaration(parent); zend_string *child_prototype = zend_get_function_declaration(child); @@ -707,8 +765,8 @@ static void do_inheritance_check_on_method(zend_function *child, zend_function * ZEND_FN_SCOPE_NAME(child), ZSTR_VAL(child->common.function_name), zend_visibility_string(parent_flags), ZEND_FN_SCOPE_NAME(parent), (parent_flags&ZEND_ACC_PUBLIC) ? "" : " or weaker"); } - status = zend_do_perform_implementation_check(&unresolved_class, child, parent); - if (status != INHERITANCE_SUCCESS) { + status = perform_delayable_implementation_check(&unresolved_class, ce, child, parent); + if (status == INHERITANCE_ERROR) { emit_incompatible_method_error(child, parent, status, unresolved_class); } } @@ -887,6 +945,7 @@ static void zend_do_inherit_interfaces(zend_class_entry *ce, const zend_class_en ce->interfaces[ce->num_interfaces++] = entry; } } + ce->ce_flags |= ZEND_ACC_RESOLVED_INTERFACES; /* and now call the implementing handlers */ while (ce_num < ce->num_interfaces) { @@ -988,6 +1047,7 @@ ZEND_API void zend_do_inheritance(zend_class_entry *ce, zend_class_entry *parent zend_string_release_ex(ce->parent_name, 0); } ce->parent = parent_ce; + ce->ce_flags |= ZEND_ACC_RESOLVED_PARENT; /* Inherit interfaces */ if (parent_ce->num_interfaces) { @@ -1297,10 +1357,11 @@ static void zend_do_implement_interfaces(zend_class_entry *ce) /* {{{ */ } for (i = 0; i < ce->num_interfaces; i++) { - iface = zend_fetch_class_by_name(ce->interface_names[i].name, - ce->interface_names[i].lc_name, ZEND_FETCH_CLASS_INTERFACE); - if (UNEXPECTED(iface == NULL)) { - return; + iface = zend_fetch_class_by_name( + ce->interface_names[i].name, ce->interface_names[i].lc_name, + ZEND_FETCH_CLASS_INTERFACE|ZEND_FETCH_CLASS_ALLOW_UNLINKED); + if (!(iface->ce_flags & ZEND_ACC_LINKED)) { + add_dependency_obligation(ce, iface); } if (UNEXPECTED(!(iface->ce_flags & ZEND_ACC_INTERFACE))) { efree(interfaces); @@ -1337,6 +1398,7 @@ static void zend_do_implement_interfaces(zend_class_entry *ce) /* {{{ */ ce->num_interfaces = num_interfaces; ce->interfaces = interfaces; + ce->ce_flags |= ZEND_ACC_RESOLVED_INTERFACES; i = ce->parent ? ce->parent->num_interfaces : 0; for (; i < ce->num_interfaces; i++) { @@ -1423,18 +1485,18 @@ static void zend_add_trait_method(zend_class_entry *ce, const char *name, zend_s if ((existing_fn = zend_hash_find_ptr(*overridden, key)) != NULL) { if (existing_fn->common.fn_flags & ZEND_ACC_ABSTRACT) { /* Make sure the trait method is compatible with previosly declared abstract method */ - status = zend_do_perform_implementation_check( - &unresolved_class, fn, existing_fn); - if (status != INHERITANCE_SUCCESS) { + status = perform_delayable_implementation_check( + &unresolved_class, ce, fn, existing_fn); + if (status == INHERITANCE_ERROR) { emit_incompatible_method_error( fn, existing_fn, status, unresolved_class); } } if (fn->common.fn_flags & ZEND_ACC_ABSTRACT) { /* Make sure the abstract declaration is compatible with previous declaration */ - status = zend_do_perform_implementation_check( - &unresolved_class, existing_fn, fn); - if (status != INHERITANCE_SUCCESS) { + status = perform_delayable_implementation_check( + &unresolved_class, ce, existing_fn, fn); + if (status == INHERITANCE_ERROR) { emit_incompatible_method_error( existing_fn, fn, status, unresolved_class); } @@ -1450,14 +1512,14 @@ static void zend_add_trait_method(zend_class_entry *ce, const char *name, zend_s } else if (existing_fn->common.fn_flags & ZEND_ACC_ABSTRACT && (existing_fn->common.scope->ce_flags & ZEND_ACC_INTERFACE) == 0) { /* Make sure the trait method is compatible with previosly declared abstract method */ - status = zend_do_perform_implementation_check(&unresolved_class, fn, existing_fn); - if (status != INHERITANCE_SUCCESS) { + status = perform_delayable_implementation_check(&unresolved_class, ce, fn, existing_fn); + if (status == INHERITANCE_ERROR) { emit_incompatible_method_error(fn, existing_fn, status, unresolved_class); } } else if (fn->common.fn_flags & ZEND_ACC_ABSTRACT) { /* Make sure the abstract declaration is compatible with previous declaration */ - status = zend_do_perform_implementation_check(&unresolved_class, existing_fn, fn); - if (status != INHERITANCE_SUCCESS) { + status = perform_delayable_implementation_check(&unresolved_class, ce, existing_fn, fn); + if (status == INHERITANCE_ERROR) { emit_incompatible_method_error(existing_fn, fn, status, unresolved_class); } return; @@ -2071,10 +2133,167 @@ void zend_verify_abstract_class(zend_class_entry *ce) /* {{{ */ } /* }}} */ -ZEND_API void zend_do_link_class(zend_class_entry *ce, zend_class_entry *parent) /* {{{ */ +typedef struct { + enum { OBLIGATION_DEPENDENCY, OBLIGATION_COMPATIBILITY } type; + union { + zend_class_entry *dependency_ce; + struct { + const zend_function *parent_fn; + const zend_function *child_fn; + }; + }; +} variance_obligation; + +static void variance_obligation_dtor(zval *zv) { + efree(Z_PTR_P(zv)); +} + +static void variance_obligation_ht_dtor(zval *zv) { + zend_hash_destroy(Z_PTR_P(zv)); + FREE_HASHTABLE(Z_PTR_P(zv)); +} + +static HashTable *get_or_init_obligations_for_class(zend_class_entry *ce) { + HashTable *ht; + zend_ulong key; + if (!CG(delayed_variance_obligations)) { + ALLOC_HASHTABLE(CG(delayed_variance_obligations)); + zend_hash_init(CG(delayed_variance_obligations), 0, NULL, variance_obligation_ht_dtor, 0); + } + + key = (zend_ulong) (uintptr_t) ce; + ht = zend_hash_index_find_ptr(CG(delayed_variance_obligations), key); + if (ht) { + return ht; + } + + ALLOC_HASHTABLE(ht); + zend_hash_init(ht, 0, NULL, variance_obligation_dtor, 0); + zend_hash_index_add_new_ptr(CG(delayed_variance_obligations), key, ht); + ce->ce_flags |= ZEND_ACC_UNRESOLVED_VARIANCE; + return ht; +} + +static void add_dependency_obligation(zend_class_entry *ce, zend_class_entry *dependency_ce) { + HashTable *obligations = get_or_init_obligations_for_class(ce); + variance_obligation *obligation = emalloc(sizeof(variance_obligation)); + obligation->type = OBLIGATION_DEPENDENCY; + obligation->dependency_ce = dependency_ce; + zend_hash_next_index_insert_ptr(obligations, obligation); +} + +static void add_compatibility_obligation( + zend_class_entry *ce, const zend_function *child_fn, const zend_function *parent_fn) { + HashTable *obligations = get_or_init_obligations_for_class(ce); + variance_obligation *obligation = emalloc(sizeof(variance_obligation)); + obligation->type = OBLIGATION_COMPATIBILITY; + obligation->child_fn = child_fn; + obligation->parent_fn = parent_fn; + zend_hash_next_index_insert_ptr(obligations, obligation); +} + +static void resolve_delayed_variance_obligations(zend_class_entry *ce); + +static int check_variance_obligation(zval *zv) { + variance_obligation *obligation = Z_PTR_P(zv); + if (obligation->type == OBLIGATION_DEPENDENCY) { + zend_class_entry *dependency_ce = obligation->dependency_ce; + if (dependency_ce->ce_flags & ZEND_ACC_UNRESOLVED_VARIANCE) { + resolve_delayed_variance_obligations(dependency_ce); + } + if (!(dependency_ce->ce_flags & ZEND_ACC_LINKED)) { + return ZEND_HASH_APPLY_KEEP; + } + } else { + zend_string *unresolved_class; + inheritance_status status = zend_do_perform_implementation_check( + &unresolved_class, obligation->child_fn, obligation->parent_fn); + if (status == INHERITANCE_UNRESOLVED) { + return ZEND_HASH_APPLY_KEEP; + } + if (status == INHERITANCE_ERROR) { + emit_incompatible_method_error( + obligation->child_fn, obligation->parent_fn, status, unresolved_class); + } + /* Either the compatibility check was successful or only threw a warning. */ + } + return ZEND_HASH_APPLY_REMOVE; +} + +static void load_delayed_classes() { + HashTable *delayed_autoloads = CG(delayed_autoloads); + zend_string *name; + + if (!delayed_autoloads) { + return; + } + + /* Take ownership of this HT, to avoid concurrent modification during autoloading. */ + CG(delayed_autoloads) = NULL; + + ZEND_HASH_FOREACH_STR_KEY(delayed_autoloads, name) { + zend_lookup_class(name); + } ZEND_HASH_FOREACH_END(); + + zend_hash_destroy(delayed_autoloads); + FREE_HASHTABLE(delayed_autoloads); +} + +static void resolve_delayed_variance_obligations(zend_class_entry *ce) { + HashTable *all_obligations = CG(delayed_variance_obligations), *obligations; + zend_ulong num_key = (zend_ulong) (uintptr_t) ce; + + ZEND_ASSERT(all_obligations != NULL); + obligations = zend_hash_index_find_ptr(all_obligations, num_key); + ZEND_ASSERT(obligations != NULL); + + zend_hash_apply(obligations, check_variance_obligation); + if (zend_hash_num_elements(obligations) == 0) { + ce->ce_flags &= ~ZEND_ACC_UNRESOLVED_VARIANCE; + ce->ce_flags |= ZEND_ACC_LINKED; + zend_hash_index_del(all_obligations, num_key); + } +} + +static void report_variance_errors(zend_class_entry *ce) { + HashTable *all_obligations = CG(delayed_variance_obligations), *obligations; + variance_obligation *obligation; + zend_ulong num_key = (zend_ulong) (uintptr_t) ce; + + ZEND_ASSERT(all_obligations != NULL); + obligations = zend_hash_index_find_ptr(all_obligations, num_key); + ZEND_ASSERT(obligations != NULL); + + ZEND_HASH_FOREACH_PTR(obligations, obligation) { + inheritance_status status; + zend_string *unresolved_class; + + /* There should not be any unresolved parents at this point. */ + ZEND_ASSERT(obligation->type == OBLIGATION_COMPATIBILITY); + + /* Just used to fetch the unresolved_class in this case. */ + status = zend_do_perform_implementation_check( + &unresolved_class, obligation->child_fn, obligation->parent_fn); + ZEND_ASSERT(status == INHERITANCE_UNRESOLVED); + emit_incompatible_method_error( + obligation->child_fn, obligation->parent_fn, status, unresolved_class); + } ZEND_HASH_FOREACH_END(); + + /* Only warnings were thrown above -- that means that there are incompatibilities, but only + * ones that we permit. Mark all classes with open obligations as fully linked. */ + ce->ce_flags &= ~ZEND_ACC_UNRESOLVED_VARIANCE; + ce->ce_flags |= ZEND_ACC_LINKED; + zend_hash_index_del(all_obligations, num_key); +} + +ZEND_API void zend_do_link_class(zend_class_entry *ce) /* {{{ */ { - ce->ce_flags |= ZEND_ACC_LINKING_IN_PROGRESS; - if (parent) { + if (ce->parent_name) { + zend_class_entry *parent = zend_fetch_class_by_name( + ce->parent_name, NULL, ZEND_FETCH_CLASS_ALLOW_UNLINKED); + if (!(parent->ce_flags & ZEND_ACC_LINKED)) { + add_dependency_obligation(ce, parent); + } zend_do_inheritance(ce, parent); } if (ce->ce_flags & ZEND_ACC_IMPLEMENT_TRAITS) { @@ -2088,8 +2307,19 @@ ZEND_API void zend_do_link_class(zend_class_entry *ce, zend_class_entry *parent) } zend_build_properties_info_table(ce); - ce->ce_flags &= ~ZEND_ACC_LINKING_IN_PROGRESS; - ce->ce_flags |= ZEND_ACC_LINKED; + + if (!(ce->ce_flags & ZEND_ACC_UNRESOLVED_VARIANCE)) { + ce->ce_flags |= ZEND_ACC_LINKED; + return; + } + + load_delayed_classes(); + if (ce->ce_flags & ZEND_ACC_UNRESOLVED_VARIANCE) { + resolve_delayed_variance_obligations(ce); + if (!(ce->ce_flags & ZEND_ACC_LINKED)) { + report_variance_errors(ce); + } + } } /* Check whether early binding is prevented due to unresolved types in inheritance checks. */ diff --git a/Zend/zend_inheritance.h b/Zend/zend_inheritance.h index cba8efe50b..6b39cb9c35 100644 --- a/Zend/zend_inheritance.h +++ b/Zend/zend_inheritance.h @@ -27,7 +27,7 @@ BEGIN_EXTERN_C() ZEND_API void zend_do_implement_interface(zend_class_entry *ce, zend_class_entry *iface); ZEND_API void zend_do_inheritance(zend_class_entry *ce, zend_class_entry *parent_ce); -ZEND_API void zend_do_link_class(zend_class_entry *ce, zend_class_entry *parent_ce); +ZEND_API void zend_do_link_class(zend_class_entry *ce); void zend_verify_abstract_class(zend_class_entry *ce); void zend_build_properties_info_table(zend_class_entry *ce); diff --git a/Zend/zend_interfaces.c b/Zend/zend_interfaces.c index 1c051db000..da8f4aae60 100644 --- a/Zend/zend_interfaces.c +++ b/Zend/zend_interfaces.c @@ -292,7 +292,7 @@ static int zend_implement_traversable(zend_class_entry *interface, zend_class_en return SUCCESS; } if (class_type->num_interfaces) { - ZEND_ASSERT(class_type->ce_flags & (ZEND_ACC_LINKED|ZEND_ACC_LINKING_IN_PROGRESS)); + ZEND_ASSERT(class_type->ce_flags & ZEND_ACC_RESOLVED_INTERFACES); for (i = 0; i < class_type->num_interfaces; i++) { if (class_type->interfaces[i] == zend_ce_aggregate || class_type->interfaces[i] == zend_ce_iterator) { return SUCCESS; @@ -322,7 +322,7 @@ static int zend_implement_aggregate(zend_class_entry *interface, zend_class_entr } else if (class_type->get_iterator != zend_user_it_get_new_iterator) { /* c-level get_iterator cannot be changed (exception being only Traversable is implemented) */ if (class_type->num_interfaces) { - ZEND_ASSERT(class_type->ce_flags & (ZEND_ACC_LINKED|ZEND_ACC_LINKING_IN_PROGRESS)); + ZEND_ASSERT(class_type->ce_flags & ZEND_ACC_RESOLVED_INTERFACES); for (i = 0; i < class_type->num_interfaces; i++) { if (class_type->interfaces[i] == zend_ce_iterator) { zend_error_noreturn(E_ERROR, "Class %s cannot implement both %s and %s at the same time", diff --git a/Zend/zend_opcode.c b/Zend/zend_opcode.c index 5c954b6c30..041a598fdf 100644 --- a/Zend/zend_opcode.c +++ b/Zend/zend_opcode.c @@ -238,7 +238,7 @@ ZEND_API void destroy_zend_class(zval *zv) } switch (ce->type) { case ZEND_USER_CLASS: - if (ce->parent_name && !(ce->ce_flags & (ZEND_ACC_LINKED|ZEND_ACC_LINKING_IN_PROGRESS))) { + if (ce->parent_name && !(ce->ce_flags & ZEND_ACC_RESOLVED_PARENT)) { zend_string_release_ex(ce->parent_name, 0); } if (ce->default_properties_table) { @@ -298,7 +298,7 @@ ZEND_API void destroy_zend_class(zval *zv) } zend_hash_destroy(&ce->constants_table); if (ce->num_interfaces > 0) { - if (!(ce->ce_flags & (ZEND_ACC_LINKED|ZEND_ACC_LINKING_IN_PROGRESS))) { + if (!(ce->ce_flags & ZEND_ACC_RESOLVED_INTERFACES)) { uint32_t i; for (i = 0; i < ce->num_interfaces; i++) { @@ -585,7 +585,6 @@ static void emit_live_range( /* Classes don't have to be destroyed. */ case ZEND_FETCH_CLASS: case ZEND_DECLARE_ANON_CLASS: - case ZEND_DECLARE_ANON_INHERITED_CLASS: /* FAST_CALLs don't have to be destroyed. */ case ZEND_FAST_CALL: return; @@ -957,7 +956,6 @@ ZEND_API int pass_two(zend_op_array *op_array) break; } case ZEND_DECLARE_ANON_CLASS: - case ZEND_DECLARE_ANON_INHERITED_CLASS: case ZEND_FE_FETCH_R: case ZEND_FE_FETCH_RW: /* absolute index to relative offset */ diff --git a/Zend/zend_operators.c b/Zend/zend_operators.c index dc04548757..575a68d0d5 100644 --- a/Zend/zend_operators.c +++ b/Zend/zend_operators.c @@ -2265,7 +2265,7 @@ static zend_bool ZEND_FASTCALL instanceof_interface_only(const zend_class_entry uint32_t i; if (instance_ce->num_interfaces) { - ZEND_ASSERT(instance_ce->ce_flags & (ZEND_ACC_LINKED|ZEND_ACC_LINKING_IN_PROGRESS)); + ZEND_ASSERT(instance_ce->ce_flags & ZEND_ACC_RESOLVED_INTERFACES); for (i = 0; i < instance_ce->num_interfaces; i++) { if (instanceof_interface_only(instance_ce->interfaces[i], ce)) { return 1; @@ -2293,7 +2293,7 @@ static zend_bool ZEND_FASTCALL instanceof_interface(const zend_class_entry *inst uint32_t i; if (instance_ce->num_interfaces) { - ZEND_ASSERT(instance_ce->ce_flags & (ZEND_ACC_LINKED|ZEND_ACC_LINKING_IN_PROGRESS)); + ZEND_ASSERT(instance_ce->ce_flags & ZEND_ACC_RESOLVED_INTERFACES); for (i = 0; i < instance_ce->num_interfaces; i++) { if (instanceof_interface(instance_ce->interfaces[i], ce)) { return 1; diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index f88fb602cd..9f9c8a4026 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -7122,45 +7122,20 @@ ZEND_VM_HANDLER(139, ZEND_DECLARE_CLASS, CONST, ANY) USE_OPLINE SAVE_OPLINE(); - do_bind_class(RT_CONSTANT(opline, opline->op1), NULL); + do_bind_class(RT_CONSTANT(opline, opline->op1)); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -ZEND_VM_HANDLER(140, ZEND_DECLARE_INHERITED_CLASS, CONST, CONST) -{ - zend_class_entry *parent; - USE_OPLINE - - SAVE_OPLINE(); - parent = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), - Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), - ZEND_FETCH_CLASS_EXCEPTION); - if (UNEXPECTED(parent == NULL)) { - ZEND_ASSERT(EG(exception)); - HANDLE_EXCEPTION(); - } - do_bind_class(RT_CONSTANT(opline, opline->op1), parent); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - -ZEND_VM_HANDLER(145, ZEND_DECLARE_INHERITED_CLASS_DELAYED, CONST, CONST) +ZEND_VM_HANDLER(145, ZEND_DECLARE_CLASS_DELAYED, CONST, ANY) { USE_OPLINE zval *zce, *orig_zce; - zend_class_entry *parent; SAVE_OPLINE(); if ((zce = zend_hash_find_ex(EG(class_table), Z_STR_P(RT_CONSTANT(opline, opline->op1)), 1)) == NULL || ((orig_zce = zend_hash_find_ex(EG(class_table), Z_STR_P(RT_CONSTANT(opline, opline->op1)+1), 1)) != NULL && Z_CE_P(zce) != Z_CE_P(orig_zce))) { - parent = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), - Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), - ZEND_FETCH_CLASS_EXCEPTION); - if (UNEXPECTED(parent == NULL)) { - ZEND_ASSERT(EG(exception)); - HANDLE_EXCEPTION(); - } - do_bind_class(RT_CONSTANT(opline, opline->op1), parent); + do_bind_class(RT_CONSTANT(opline, opline->op1)); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -7181,36 +7156,7 @@ ZEND_VM_HANDLER(171, ZEND_DECLARE_ANON_CLASS, ANY, ANY, JMP_ADDR) ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value); ZEND_VM_CONTINUE(); } - zend_do_link_class(ce, NULL); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - -ZEND_VM_HANDLER(172, ZEND_DECLARE_ANON_INHERITED_CLASS, CONST, CONST, JMP_ADDR) -{ - zval *zv; - zend_class_entry *ce, *parent; - USE_OPLINE - - SAVE_OPLINE(); - zv = zend_hash_find_ex(EG(class_table), Z_STR_P(RT_CONSTANT(opline, opline->op1)), 1); - ZEND_ASSERT(zv != NULL); - ce = Z_CE_P(zv); - Z_CE_P(EX_VAR(opline->result.var)) = ce; - - if (ce->ce_flags & ZEND_ACC_LINKED) { - ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value); - ZEND_VM_CONTINUE(); - } - - parent = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), - Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), - ZEND_FETCH_CLASS_EXCEPTION); - if (UNEXPECTED(parent == NULL)) { - ZEND_ASSERT(EG(exception)); - HANDLE_EXCEPTION(); - } - - zend_do_link_class(ce, parent); + zend_do_link_class(ce); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -7406,7 +7352,6 @@ ZEND_VM_HANDLER(149, ZEND_HANDLE_EXCEPTION, ANY, ANY) case ZEND_FETCH_CLASS: case ZEND_DECLARE_ANON_CLASS: - case ZEND_DECLARE_ANON_INHERITED_CLASS: break; /* return value is zend_class_entry pointer */ default: diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 5e0875f303..8af242b3dc 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -2090,7 +2090,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_ANON_CLASS_SPEC_HANDLE ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value); ZEND_VM_CONTINUE(); } - zend_do_link_class(ce, NULL); + zend_do_link_class(ce); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -2237,7 +2237,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_HANDLE_EXCEPTION_SPEC_HANDLER( case ZEND_FETCH_CLASS: case ZEND_DECLARE_ANON_CLASS: - case ZEND_DECLARE_ANON_INHERITED_CLASS: break; /* return value is zend_class_entry pointer */ default: @@ -4011,7 +4010,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_CLASS_SPEC_CONST_HANDL USE_OPLINE SAVE_OPLINE(); - do_bind_class(RT_CONSTANT(opline, opline->op1), NULL); + do_bind_class(RT_CONSTANT(opline, opline->op1)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *zce, *orig_zce; + + SAVE_OPLINE(); + if ((zce = zend_hash_find_ex(EG(class_table), Z_STR_P(RT_CONSTANT(opline, opline->op1)), 1)) == NULL || + ((orig_zce = zend_hash_find_ex(EG(class_table), Z_STR_P(RT_CONSTANT(opline, opline->op1)+1), 1)) != NULL && + Z_CE_P(zce) != Z_CE_P(orig_zce))) { + do_bind_class(RT_CONSTANT(opline, opline->op1)); + } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -6141,74 +6154,6 @@ array_key_exists_array: } /* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */ -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_INHERITED_CLASS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - zend_class_entry *parent; - USE_OPLINE - - SAVE_OPLINE(); - parent = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), - Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), - ZEND_FETCH_CLASS_EXCEPTION); - if (UNEXPECTED(parent == NULL)) { - ZEND_ASSERT(EG(exception)); - HANDLE_EXCEPTION(); - } - do_bind_class(RT_CONSTANT(opline, opline->op1), parent); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *zce, *orig_zce; - zend_class_entry *parent; - - SAVE_OPLINE(); - if ((zce = zend_hash_find_ex(EG(class_table), Z_STR_P(RT_CONSTANT(opline, opline->op1)), 1)) == NULL || - ((orig_zce = zend_hash_find_ex(EG(class_table), Z_STR_P(RT_CONSTANT(opline, opline->op1)+1), 1)) != NULL && - Z_CE_P(zce) != Z_CE_P(orig_zce))) { - parent = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), - Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), - ZEND_FETCH_CLASS_EXCEPTION); - if (UNEXPECTED(parent == NULL)) { - ZEND_ASSERT(EG(exception)); - HANDLE_EXCEPTION(); - } - do_bind_class(RT_CONSTANT(opline, opline->op1), parent); - } - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - zval *zv; - zend_class_entry *ce, *parent; - USE_OPLINE - - SAVE_OPLINE(); - zv = zend_hash_find_ex(EG(class_table), Z_STR_P(RT_CONSTANT(opline, opline->op1)), 1); - ZEND_ASSERT(zv != NULL); - ce = Z_CE_P(zv); - Z_CE_P(EX_VAR(opline->result.var)) = ce; - - if (ce->ce_flags & ZEND_ACC_LINKED) { - ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value); - ZEND_VM_CONTINUE(); - } - - parent = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), - Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), - ZEND_FETCH_CLASS_EXCEPTION); - if (UNEXPECTED(parent == NULL)) { - ZEND_ASSERT(EG(exception)); - HANDLE_EXCEPTION(); - } - - zend_do_link_class(ce, parent); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -55682,7 +55627,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_INSTANCEOF_SPEC_CV_UNUSED_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_DECLARE_CLASS_SPEC_CONST_LABEL, - (void*)&&ZEND_DECLARE_INHERITED_CLASS_SPEC_CONST_CONST_LABEL, (void*)&&ZEND_DECLARE_FUNCTION_SPEC_LABEL, (void*)&&ZEND_YIELD_FROM_SPEC_CONST_LABEL, (void*)&&ZEND_YIELD_FROM_SPEC_TMP_LABEL, @@ -55690,7 +55634,7 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_YIELD_FROM_SPEC_CV_LABEL, (void*)&&ZEND_DECLARE_CONST_SPEC_CONST_CONST_LABEL, - (void*)&&ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_CONST_CONST_LABEL, + (void*)&&ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -56045,7 +55989,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_SPACESHIP_SPEC_CV_CV_LABEL, (void*)&&ZEND_DECLARE_ANON_CLASS_SPEC_LABEL, - (void*)&&ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_CONST_CONST_LABEL, (void*)&&ZEND_FETCH_STATIC_PROP_R_SPEC_LABEL, (void*)&&ZEND_FETCH_STATIC_PROP_W_SPEC_LABEL, (void*)&&ZEND_FETCH_STATIC_PROP_RW_SPEC_LABEL, @@ -57705,6 +57648,10 @@ zend_leave_helper_SPEC_LABEL: VM_TRACE(ZEND_DECLARE_CLASS_SPEC_CONST) ZEND_DECLARE_CLASS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST): + VM_TRACE(ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST) + ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_YIELD_FROM_SPEC_CONST): VM_TRACE(ZEND_YIELD_FROM_SPEC_CONST) ZEND_YIELD_FROM_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -57929,18 +57876,6 @@ zend_leave_helper_SPEC_LABEL: VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_DECLARE_INHERITED_CLASS_SPEC_CONST_CONST): - VM_TRACE(ZEND_DECLARE_INHERITED_CLASS_SPEC_CONST_CONST) - ZEND_DECLARE_INHERITED_CLASS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); - HYBRID_CASE(ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_CONST_CONST): - VM_TRACE(ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_CONST_CONST) - ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); - HYBRID_CASE(ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_CONST_CONST): - VM_TRACE(ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_CONST_CONST) - ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_DECLARE_CONST_SPEC_CONST_CONST): VM_TRACE(ZEND_DECLARE_CONST_SPEC_CONST_CONST) ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -65401,7 +65336,6 @@ void zend_vm_init(void) ZEND_INSTANCEOF_SPEC_CV_UNUSED_HANDLER, ZEND_NULL_HANDLER, ZEND_DECLARE_CLASS_SPEC_CONST_HANDLER, - ZEND_DECLARE_INHERITED_CLASS_SPEC_CONST_CONST_HANDLER, ZEND_DECLARE_FUNCTION_SPEC_HANDLER, ZEND_YIELD_FROM_SPEC_CONST_HANDLER, ZEND_YIELD_FROM_SPEC_TMP_HANDLER, @@ -65409,7 +65343,7 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_YIELD_FROM_SPEC_CV_HANDLER, ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER, - ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_CONST_CONST_HANDLER, + ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, @@ -65764,7 +65698,6 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_SPACESHIP_SPEC_CV_CV_HANDLER, ZEND_DECLARE_ANON_CLASS_SPEC_HANDLER, - ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_CONST_CONST_HANDLER, ZEND_FETCH_STATIC_PROP_R_SPEC_HANDLER, ZEND_FETCH_STATIC_PROP_W_SPEC_HANDLER, ZEND_FETCH_STATIC_PROP_RW_SPEC_HANDLER, @@ -67026,37 +66959,39 @@ void zend_vm_init(void) 2673, 2674 | SPEC_RULE_OP1 | SPEC_RULE_OP2, 2699, + 4180, 2700, - 2701, - 2702 | SPEC_RULE_OP1, + 2701 | SPEC_RULE_OP1, + 2706, + 4180, 2707, - 4182, - 2708, - 4182, - 2709 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA, - 2834 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 4180, + 2708 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA, + 2833 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2858, 2859, 2860, - 2861, - 2862 | SPEC_RULE_OP1, + 2861 | SPEC_RULE_OP1, + 2866, + 4180, + 4180, 2867, - 4182, - 4182, 2868, 2869, 2870, - 2871, - 2872 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2897 | SPEC_RULE_OP1, + 2871 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2896 | SPEC_RULE_OP1, + 2901, 2902, 2903, 2904, - 2905, - 2906 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2931 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_DIM_OBJ, - 3031, - 3032 | SPEC_RULE_OP1, - 3037 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2905 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2930 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_DIM_OBJ, + 3030, + 3031 | SPEC_RULE_OP1, + 3036 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 3061, + 4180, 3062, 3063, 3064, @@ -67065,37 +67000,35 @@ void zend_vm_init(void) 3067, 3068, 3069, - 3070, - 3071, - 3072 | SPEC_RULE_OP1, + 3070 | SPEC_RULE_OP1, + 3075, + 3076, 3077, 3078, 3079, - 3080, - 3081, - 3082 | SPEC_RULE_OP1, - 3087 | SPEC_RULE_OP1, - 3092 | SPEC_RULE_OP1, - 3097 | SPEC_RULE_OP1, - 3102 | SPEC_RULE_OP1, - 3107, - 3108 | SPEC_RULE_OP1, - 3113, - 3114 | SPEC_RULE_OP1, - 3119, - 3120 | SPEC_RULE_ISSET, - 3122 | SPEC_RULE_OP2, - 3127 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 3152 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA, - 3277 | SPEC_RULE_OP_DATA, + 3080 | SPEC_RULE_OP1, + 3085 | SPEC_RULE_OP1, + 3090 | SPEC_RULE_OP1, + 3095 | SPEC_RULE_OP1, + 3100 | SPEC_RULE_OP1, + 3105, + 3106 | SPEC_RULE_OP1, + 3111, + 3112 | SPEC_RULE_OP1, + 3117, + 3118 | SPEC_RULE_ISSET, + 3120 | SPEC_RULE_OP2, + 3125 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 3150 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA, + 3275 | SPEC_RULE_OP_DATA, + 3280, + 3281, 3282, 3283, 3284, 3285, 3286, - 3287, - 3288, - 4182 + 4180 }; #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID) zend_opcode_handler_funcs = labels; @@ -67302,7 +67235,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 = 3290 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3288 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -67310,7 +67243,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 = 3315 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3313 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -67318,7 +67251,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 = 3340 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3338 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -67329,17 +67262,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 = 3365 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 3363 | 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 = 3390 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 3388 | 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 = 3415 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 3413 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_MUL: @@ -67350,17 +67283,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 = 3440 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3438 | 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 = 3465 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3463 | 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 = 3490 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3488 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_EQUAL: @@ -67371,12 +67304,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 = 3515 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3513 | 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 = 3590 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3588 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_EQUAL: @@ -67387,12 +67320,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 = 3665 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3663 | 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 = 3740 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3738 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_SMALLER: @@ -67400,12 +67333,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 = 3815 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3813 | 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 = 3890 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3888 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_IS_SMALLER_OR_EQUAL: @@ -67413,75 +67346,75 @@ 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 = 3965 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3963 | 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 = 4040 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 4038 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_QM_ASSIGN: if (op1_info == MAY_BE_DOUBLE) { - spec = 4133 | SPEC_RULE_OP1; + spec = 4131 | 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 = 4138 | SPEC_RULE_OP1; + spec = 4136 | SPEC_RULE_OP1; } break; case ZEND_PRE_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 4115 | SPEC_RULE_RETVAL; + spec = 4113 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 4117 | SPEC_RULE_RETVAL; + spec = 4115 | SPEC_RULE_RETVAL; } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) { - spec = 4119 | SPEC_RULE_RETVAL; + spec = 4117 | SPEC_RULE_RETVAL; } break; case ZEND_PRE_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 4121 | SPEC_RULE_RETVAL; + spec = 4119 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 4123 | SPEC_RULE_RETVAL; + spec = 4121 | SPEC_RULE_RETVAL; } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) { - spec = 4125 | SPEC_RULE_RETVAL; + spec = 4123 | SPEC_RULE_RETVAL; } break; case ZEND_POST_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 4127; + spec = 4125; } else if (op1_info == MAY_BE_LONG) { - spec = 4128; + spec = 4126; } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) { - spec = 4129; + spec = 4127; } break; case ZEND_POST_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 4130; + spec = 4128; } else if (op1_info == MAY_BE_LONG) { - spec = 4131; + spec = 4129; } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) { - spec = 4132; + spec = 4130; } break; case ZEND_JMP: if (OP_JMP_ADDR(op, op->op1) > op) { - spec = 3289; + spec = 3287; } break; case ZEND_SEND_VAL: if (op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 4178; + spec = 4176; } break; case ZEND_SEND_VAR_EX: if (op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 4173 | SPEC_RULE_OP1; + spec = 4171 | SPEC_RULE_OP1; } break; case ZEND_FE_FETCH_R: if (op->op2_type == IS_CV && (op1_info & (MAY_BE_UNDEF|MAY_BE_ANY|MAY_BE_REF)) == MAY_BE_ARRAY) { - spec = 4180 | SPEC_RULE_RETVAL; + spec = 4178 | SPEC_RULE_RETVAL; } break; case ZEND_FETCH_DIM_R: @@ -67489,17 +67422,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 = 4143 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 4141 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_SEND_VAL_EX: if (op->op2.num <= MAX_ARG_FLAG_NUM && op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 4179; + spec = 4177; } break; case ZEND_SEND_VAR: if ((op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 4168 | SPEC_RULE_OP1; + spec = 4166 | SPEC_RULE_OP1; } break; case ZEND_BW_OR: diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h index 0627d201b6..a8aae733fd 100644 --- a/Zend/zend_vm_handlers.h +++ b/Zend/zend_vm_handlers.h @@ -1416,796 +1416,794 @@ _(2696, ZEND_INSTANCEOF_SPEC_CV_VAR) \ _(2697, ZEND_INSTANCEOF_SPEC_CV_UNUSED) \ _(2699, ZEND_DECLARE_CLASS_SPEC_CONST) \ - _(2700, ZEND_DECLARE_INHERITED_CLASS_SPEC_CONST_CONST) \ - _(2701, ZEND_DECLARE_FUNCTION_SPEC) \ - _(2702, ZEND_YIELD_FROM_SPEC_CONST) \ - _(2703, ZEND_YIELD_FROM_SPEC_TMP) \ - _(2704, ZEND_YIELD_FROM_SPEC_VAR) \ - _(2706, ZEND_YIELD_FROM_SPEC_CV) \ - _(2707, ZEND_DECLARE_CONST_SPEC_CONST_CONST) \ - _(2708, ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_CONST_CONST) \ - _(2759, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST) \ - _(2760, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP) \ - _(2761, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR) \ - _(2763, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV) \ - _(2764, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST) \ - _(2765, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP) \ - _(2766, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR) \ - _(2768, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV) \ - _(2769, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST) \ - _(2770, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP) \ - _(2771, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR) \ - _(2773, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV) \ - _(2774, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST) \ - _(2775, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP) \ - _(2776, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR) \ - _(2778, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV) \ - _(2779, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST) \ - _(2780, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP) \ - _(2781, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR) \ - _(2783, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV) \ - _(2809, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST) \ - _(2810, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP) \ - _(2811, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR) \ - _(2813, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV) \ - _(2814, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST) \ - _(2815, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP) \ - _(2816, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR) \ - _(2818, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV) \ - _(2819, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST) \ - _(2820, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP) \ - _(2821, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR) \ - _(2823, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV) \ - _(2824, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST) \ - _(2825, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP) \ - _(2826, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR) \ - _(2828, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV) \ - _(2829, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST) \ - _(2830, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP) \ - _(2831, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR) \ - _(2833, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV) \ - _(2834, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST) \ + _(2700, ZEND_DECLARE_FUNCTION_SPEC) \ + _(2701, ZEND_YIELD_FROM_SPEC_CONST) \ + _(2702, ZEND_YIELD_FROM_SPEC_TMP) \ + _(2703, ZEND_YIELD_FROM_SPEC_VAR) \ + _(2705, ZEND_YIELD_FROM_SPEC_CV) \ + _(2706, ZEND_DECLARE_CONST_SPEC_CONST_CONST) \ + _(2707, ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST) \ + _(2758, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST) \ + _(2759, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP) \ + _(2760, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR) \ + _(2762, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV) \ + _(2763, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST) \ + _(2764, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP) \ + _(2765, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR) \ + _(2767, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV) \ + _(2768, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST) \ + _(2769, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP) \ + _(2770, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR) \ + _(2772, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV) \ + _(2773, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST) \ + _(2774, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP) \ + _(2775, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR) \ + _(2777, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV) \ + _(2778, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST) \ + _(2779, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP) \ + _(2780, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR) \ + _(2782, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV) \ + _(2808, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST) \ + _(2809, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP) \ + _(2810, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR) \ + _(2812, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV) \ + _(2813, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST) \ + _(2814, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP) \ + _(2815, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR) \ + _(2817, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV) \ + _(2818, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST) \ + _(2819, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP) \ + _(2820, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR) \ + _(2822, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV) \ + _(2823, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST) \ + _(2824, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP) \ + _(2825, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR) \ + _(2827, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV) \ + _(2828, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST) \ + _(2829, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP) \ + _(2830, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR) \ + _(2832, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV) \ + _(2833, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST) \ + _(2834, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \ _(2835, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \ - _(2836, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \ - _(2838, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV) \ - _(2839, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ + _(2837, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV) \ + _(2838, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ + _(2839, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ _(2840, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2841, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2843, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ - _(2844, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ + _(2842, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ + _(2843, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ + _(2844, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ _(2845, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2846, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2848, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ - _(2849, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST) \ + _(2847, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ + _(2848, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST) \ + _(2849, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ _(2850, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2851, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2853, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV) \ - _(2854, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST) \ + _(2852, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV) \ + _(2853, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST) \ + _(2854, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ _(2855, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ - _(2856, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ - _(2858, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV) \ - _(2859, ZEND_HANDLE_EXCEPTION_SPEC) \ - _(2860, ZEND_USER_OPCODE_SPEC) \ - _(2861, ZEND_ASSERT_CHECK_SPEC) \ - _(2862, ZEND_JMP_SET_SPEC_CONST) \ - _(2863, ZEND_JMP_SET_SPEC_TMP) \ - _(2864, ZEND_JMP_SET_SPEC_VAR) \ - _(2866, ZEND_JMP_SET_SPEC_CV) \ - _(2867, ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED) \ - _(2868, ZEND_SEPARATE_SPEC_VAR_UNUSED) \ - _(2869, ZEND_FETCH_CLASS_NAME_SPEC_UNUSED) \ - _(2870, ZEND_CALL_TRAMPOLINE_SPEC) \ - _(2871, ZEND_DISCARD_EXCEPTION_SPEC) \ - _(2872, ZEND_YIELD_SPEC_CONST_CONST) \ - _(2873, ZEND_YIELD_SPEC_CONST_TMP) \ - _(2874, ZEND_YIELD_SPEC_CONST_VAR) \ - _(2875, ZEND_YIELD_SPEC_CONST_UNUSED) \ - _(2876, ZEND_YIELD_SPEC_CONST_CV) \ - _(2877, ZEND_YIELD_SPEC_TMP_CONST) \ - _(2878, ZEND_YIELD_SPEC_TMP_TMP) \ - _(2879, ZEND_YIELD_SPEC_TMP_VAR) \ - _(2880, ZEND_YIELD_SPEC_TMP_UNUSED) \ - _(2881, ZEND_YIELD_SPEC_TMP_CV) \ - _(2882, ZEND_YIELD_SPEC_VAR_CONST) \ - _(2883, ZEND_YIELD_SPEC_VAR_TMP) \ - _(2884, ZEND_YIELD_SPEC_VAR_VAR) \ - _(2885, ZEND_YIELD_SPEC_VAR_UNUSED) \ - _(2886, ZEND_YIELD_SPEC_VAR_CV) \ - _(2887, ZEND_YIELD_SPEC_UNUSED_CONST) \ - _(2888, ZEND_YIELD_SPEC_UNUSED_TMP) \ - _(2889, ZEND_YIELD_SPEC_UNUSED_VAR) \ - _(2890, ZEND_YIELD_SPEC_UNUSED_UNUSED) \ - _(2891, ZEND_YIELD_SPEC_UNUSED_CV) \ - _(2892, ZEND_YIELD_SPEC_CV_CONST) \ - _(2893, ZEND_YIELD_SPEC_CV_TMP) \ - _(2894, ZEND_YIELD_SPEC_CV_VAR) \ - _(2895, ZEND_YIELD_SPEC_CV_UNUSED) \ - _(2896, ZEND_YIELD_SPEC_CV_CV) \ - _(2897, ZEND_GENERATOR_RETURN_SPEC_CONST) \ - _(2898, ZEND_GENERATOR_RETURN_SPEC_TMP) \ - _(2899, ZEND_GENERATOR_RETURN_SPEC_VAR) \ - _(2901, ZEND_GENERATOR_RETURN_SPEC_CV) \ - _(2902, ZEND_FAST_CALL_SPEC) \ - _(2903, ZEND_FAST_RET_SPEC) \ - _(2904, ZEND_RECV_VARIADIC_SPEC_UNUSED) \ - _(2905, ZEND_SEND_UNPACK_SPEC) \ - _(2906, ZEND_POW_SPEC_CONST_CONST) \ + _(2857, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV) \ + _(2858, ZEND_HANDLE_EXCEPTION_SPEC) \ + _(2859, ZEND_USER_OPCODE_SPEC) \ + _(2860, ZEND_ASSERT_CHECK_SPEC) \ + _(2861, ZEND_JMP_SET_SPEC_CONST) \ + _(2862, ZEND_JMP_SET_SPEC_TMP) \ + _(2863, ZEND_JMP_SET_SPEC_VAR) \ + _(2865, ZEND_JMP_SET_SPEC_CV) \ + _(2866, ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED) \ + _(2867, ZEND_SEPARATE_SPEC_VAR_UNUSED) \ + _(2868, ZEND_FETCH_CLASS_NAME_SPEC_UNUSED) \ + _(2869, ZEND_CALL_TRAMPOLINE_SPEC) \ + _(2870, ZEND_DISCARD_EXCEPTION_SPEC) \ + _(2871, ZEND_YIELD_SPEC_CONST_CONST) \ + _(2872, ZEND_YIELD_SPEC_CONST_TMP) \ + _(2873, ZEND_YIELD_SPEC_CONST_VAR) \ + _(2874, ZEND_YIELD_SPEC_CONST_UNUSED) \ + _(2875, ZEND_YIELD_SPEC_CONST_CV) \ + _(2876, ZEND_YIELD_SPEC_TMP_CONST) \ + _(2877, ZEND_YIELD_SPEC_TMP_TMP) \ + _(2878, ZEND_YIELD_SPEC_TMP_VAR) \ + _(2879, ZEND_YIELD_SPEC_TMP_UNUSED) \ + _(2880, ZEND_YIELD_SPEC_TMP_CV) \ + _(2881, ZEND_YIELD_SPEC_VAR_CONST) \ + _(2882, ZEND_YIELD_SPEC_VAR_TMP) \ + _(2883, ZEND_YIELD_SPEC_VAR_VAR) \ + _(2884, ZEND_YIELD_SPEC_VAR_UNUSED) \ + _(2885, ZEND_YIELD_SPEC_VAR_CV) \ + _(2886, ZEND_YIELD_SPEC_UNUSED_CONST) \ + _(2887, ZEND_YIELD_SPEC_UNUSED_TMP) \ + _(2888, ZEND_YIELD_SPEC_UNUSED_VAR) \ + _(2889, ZEND_YIELD_SPEC_UNUSED_UNUSED) \ + _(2890, ZEND_YIELD_SPEC_UNUSED_CV) \ + _(2891, ZEND_YIELD_SPEC_CV_CONST) \ + _(2892, ZEND_YIELD_SPEC_CV_TMP) \ + _(2893, ZEND_YIELD_SPEC_CV_VAR) \ + _(2894, ZEND_YIELD_SPEC_CV_UNUSED) \ + _(2895, ZEND_YIELD_SPEC_CV_CV) \ + _(2896, ZEND_GENERATOR_RETURN_SPEC_CONST) \ + _(2897, ZEND_GENERATOR_RETURN_SPEC_TMP) \ + _(2898, ZEND_GENERATOR_RETURN_SPEC_VAR) \ + _(2900, ZEND_GENERATOR_RETURN_SPEC_CV) \ + _(2901, ZEND_FAST_CALL_SPEC) \ + _(2902, ZEND_FAST_RET_SPEC) \ + _(2903, ZEND_RECV_VARIADIC_SPEC_UNUSED) \ + _(2904, ZEND_SEND_UNPACK_SPEC) \ + _(2905, ZEND_POW_SPEC_CONST_CONST) \ + _(2906, ZEND_POW_SPEC_CONST_TMPVAR) \ _(2907, ZEND_POW_SPEC_CONST_TMPVAR) \ - _(2908, ZEND_POW_SPEC_CONST_TMPVAR) \ - _(2910, ZEND_POW_SPEC_CONST_CV) \ - _(2911, ZEND_POW_SPEC_TMPVAR_CONST) \ + _(2909, ZEND_POW_SPEC_CONST_CV) \ + _(2910, ZEND_POW_SPEC_TMPVAR_CONST) \ + _(2911, ZEND_POW_SPEC_TMPVAR_TMPVAR) \ _(2912, ZEND_POW_SPEC_TMPVAR_TMPVAR) \ - _(2913, ZEND_POW_SPEC_TMPVAR_TMPVAR) \ - _(2915, ZEND_POW_SPEC_TMPVAR_CV) \ - _(2916, ZEND_POW_SPEC_TMPVAR_CONST) \ + _(2914, ZEND_POW_SPEC_TMPVAR_CV) \ + _(2915, ZEND_POW_SPEC_TMPVAR_CONST) \ + _(2916, ZEND_POW_SPEC_TMPVAR_TMPVAR) \ _(2917, ZEND_POW_SPEC_TMPVAR_TMPVAR) \ - _(2918, ZEND_POW_SPEC_TMPVAR_TMPVAR) \ - _(2920, ZEND_POW_SPEC_TMPVAR_CV) \ - _(2926, ZEND_POW_SPEC_CV_CONST) \ + _(2919, ZEND_POW_SPEC_TMPVAR_CV) \ + _(2925, ZEND_POW_SPEC_CV_CONST) \ + _(2926, ZEND_POW_SPEC_CV_TMPVAR) \ _(2927, ZEND_POW_SPEC_CV_TMPVAR) \ - _(2928, ZEND_POW_SPEC_CV_TMPVAR) \ - _(2930, ZEND_POW_SPEC_CV_CV) \ - _(2934, ZEND_ASSIGN_POW_SPEC_STATIC_PROP) \ - _(2938, ZEND_ASSIGN_POW_SPEC_STATIC_PROP) \ - _(2942, ZEND_ASSIGN_POW_SPEC_STATIC_PROP) \ - _(2946, ZEND_ASSIGN_POW_SPEC_STATIC_PROP) \ - _(2954, ZEND_ASSIGN_POW_SPEC_STATIC_PROP) \ - _(2958, ZEND_ASSIGN_POW_SPEC_STATIC_PROP) \ - _(2962, ZEND_ASSIGN_POW_SPEC_STATIC_PROP) \ - _(2966, ZEND_ASSIGN_POW_SPEC_STATIC_PROP) \ - _(2971, ZEND_ASSIGN_POW_SPEC_VAR_CONST) \ - _(2972, ZEND_ASSIGN_POW_SPEC_VAR_CONST_DIM) \ - _(2973, ZEND_ASSIGN_POW_SPEC_VAR_CONST_OBJ) \ - _(2974, ZEND_ASSIGN_POW_SPEC_STATIC_PROP) \ - _(2975, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR) \ - _(2976, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_DIM) \ - _(2977, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_OBJ) \ - _(2978, ZEND_ASSIGN_POW_SPEC_STATIC_PROP) \ - _(2979, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR) \ - _(2980, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_DIM) \ - _(2981, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_OBJ) \ - _(2982, ZEND_ASSIGN_POW_SPEC_STATIC_PROP) \ - _(2984, ZEND_ASSIGN_POW_SPEC_VAR_UNUSED_DIM) \ - _(2986, ZEND_ASSIGN_POW_SPEC_STATIC_PROP) \ - _(2987, ZEND_ASSIGN_POW_SPEC_VAR_CV) \ - _(2988, ZEND_ASSIGN_POW_SPEC_VAR_CV_DIM) \ - _(2989, ZEND_ASSIGN_POW_SPEC_VAR_CV_OBJ) \ - _(2993, ZEND_ASSIGN_POW_SPEC_UNUSED_CONST_OBJ) \ - _(2997, ZEND_ASSIGN_POW_SPEC_UNUSED_TMPVAR_OBJ) \ - _(3001, ZEND_ASSIGN_POW_SPEC_UNUSED_TMPVAR_OBJ) \ - _(3009, ZEND_ASSIGN_POW_SPEC_UNUSED_CV_OBJ) \ - _(3011, ZEND_ASSIGN_POW_SPEC_CV_CONST) \ - _(3012, ZEND_ASSIGN_POW_SPEC_CV_CONST_DIM) \ - _(3013, ZEND_ASSIGN_POW_SPEC_CV_CONST_OBJ) \ - _(3014, ZEND_ASSIGN_POW_SPEC_STATIC_PROP) \ - _(3015, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR) \ - _(3016, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_DIM) \ - _(3017, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_OBJ) \ - _(3018, ZEND_ASSIGN_POW_SPEC_STATIC_PROP) \ - _(3019, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR) \ - _(3020, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_DIM) \ - _(3021, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_OBJ) \ - _(3022, ZEND_ASSIGN_POW_SPEC_STATIC_PROP) \ - _(3024, ZEND_ASSIGN_POW_SPEC_CV_UNUSED_DIM) \ - _(3026, ZEND_ASSIGN_POW_SPEC_STATIC_PROP) \ - _(3027, ZEND_ASSIGN_POW_SPEC_CV_CV) \ - _(3028, ZEND_ASSIGN_POW_SPEC_CV_CV_DIM) \ - _(3029, ZEND_ASSIGN_POW_SPEC_CV_CV_OBJ) \ - _(3031, ZEND_BIND_GLOBAL_SPEC_CV_CONST) \ - _(3032, ZEND_COALESCE_SPEC_CONST) \ + _(2929, ZEND_POW_SPEC_CV_CV) \ + _(2933, ZEND_ASSIGN_POW_SPEC_STATIC_PROP) \ + _(2937, ZEND_ASSIGN_POW_SPEC_STATIC_PROP) \ + _(2941, ZEND_ASSIGN_POW_SPEC_STATIC_PROP) \ + _(2945, ZEND_ASSIGN_POW_SPEC_STATIC_PROP) \ + _(2953, ZEND_ASSIGN_POW_SPEC_STATIC_PROP) \ + _(2957, ZEND_ASSIGN_POW_SPEC_STATIC_PROP) \ + _(2961, ZEND_ASSIGN_POW_SPEC_STATIC_PROP) \ + _(2965, ZEND_ASSIGN_POW_SPEC_STATIC_PROP) \ + _(2970, ZEND_ASSIGN_POW_SPEC_VAR_CONST) \ + _(2971, ZEND_ASSIGN_POW_SPEC_VAR_CONST_DIM) \ + _(2972, ZEND_ASSIGN_POW_SPEC_VAR_CONST_OBJ) \ + _(2973, ZEND_ASSIGN_POW_SPEC_STATIC_PROP) \ + _(2974, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR) \ + _(2975, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_DIM) \ + _(2976, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_OBJ) \ + _(2977, ZEND_ASSIGN_POW_SPEC_STATIC_PROP) \ + _(2978, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR) \ + _(2979, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_DIM) \ + _(2980, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_OBJ) \ + _(2981, ZEND_ASSIGN_POW_SPEC_STATIC_PROP) \ + _(2983, ZEND_ASSIGN_POW_SPEC_VAR_UNUSED_DIM) \ + _(2985, ZEND_ASSIGN_POW_SPEC_STATIC_PROP) \ + _(2986, ZEND_ASSIGN_POW_SPEC_VAR_CV) \ + _(2987, ZEND_ASSIGN_POW_SPEC_VAR_CV_DIM) \ + _(2988, ZEND_ASSIGN_POW_SPEC_VAR_CV_OBJ) \ + _(2992, ZEND_ASSIGN_POW_SPEC_UNUSED_CONST_OBJ) \ + _(2996, ZEND_ASSIGN_POW_SPEC_UNUSED_TMPVAR_OBJ) \ + _(3000, ZEND_ASSIGN_POW_SPEC_UNUSED_TMPVAR_OBJ) \ + _(3008, ZEND_ASSIGN_POW_SPEC_UNUSED_CV_OBJ) \ + _(3010, ZEND_ASSIGN_POW_SPEC_CV_CONST) \ + _(3011, ZEND_ASSIGN_POW_SPEC_CV_CONST_DIM) \ + _(3012, ZEND_ASSIGN_POW_SPEC_CV_CONST_OBJ) \ + _(3013, ZEND_ASSIGN_POW_SPEC_STATIC_PROP) \ + _(3014, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR) \ + _(3015, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_DIM) \ + _(3016, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_OBJ) \ + _(3017, ZEND_ASSIGN_POW_SPEC_STATIC_PROP) \ + _(3018, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR) \ + _(3019, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_DIM) \ + _(3020, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_OBJ) \ + _(3021, ZEND_ASSIGN_POW_SPEC_STATIC_PROP) \ + _(3023, ZEND_ASSIGN_POW_SPEC_CV_UNUSED_DIM) \ + _(3025, ZEND_ASSIGN_POW_SPEC_STATIC_PROP) \ + _(3026, ZEND_ASSIGN_POW_SPEC_CV_CV) \ + _(3027, ZEND_ASSIGN_POW_SPEC_CV_CV_DIM) \ + _(3028, ZEND_ASSIGN_POW_SPEC_CV_CV_OBJ) \ + _(3030, ZEND_BIND_GLOBAL_SPEC_CV_CONST) \ + _(3031, ZEND_COALESCE_SPEC_CONST) \ + _(3032, ZEND_COALESCE_SPEC_TMPVAR) \ _(3033, ZEND_COALESCE_SPEC_TMPVAR) \ - _(3034, ZEND_COALESCE_SPEC_TMPVAR) \ - _(3036, ZEND_COALESCE_SPEC_CV) \ - _(3037, ZEND_SPACESHIP_SPEC_CONST_CONST) \ + _(3035, ZEND_COALESCE_SPEC_CV) \ + _(3036, ZEND_SPACESHIP_SPEC_CONST_CONST) \ + _(3037, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ _(3038, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ - _(3039, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ - _(3041, ZEND_SPACESHIP_SPEC_CONST_CV) \ - _(3042, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ + _(3040, ZEND_SPACESHIP_SPEC_CONST_CV) \ + _(3041, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ + _(3042, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ _(3043, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(3044, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(3046, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ - _(3047, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ + _(3045, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ + _(3046, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ + _(3047, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ _(3048, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(3049, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(3051, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ - _(3057, ZEND_SPACESHIP_SPEC_CV_CONST) \ + _(3050, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ + _(3056, ZEND_SPACESHIP_SPEC_CV_CONST) \ + _(3057, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ _(3058, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ - _(3059, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ - _(3061, ZEND_SPACESHIP_SPEC_CV_CV) \ - _(3062, ZEND_DECLARE_ANON_CLASS_SPEC) \ - _(3063, ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_CONST_CONST) \ - _(3064, ZEND_FETCH_STATIC_PROP_R_SPEC) \ - _(3065, ZEND_FETCH_STATIC_PROP_W_SPEC) \ - _(3066, ZEND_FETCH_STATIC_PROP_RW_SPEC) \ - _(3067, ZEND_FETCH_STATIC_PROP_IS_SPEC) \ - _(3068, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC) \ - _(3069, ZEND_FETCH_STATIC_PROP_UNSET_SPEC) \ - _(3070, ZEND_UNSET_STATIC_PROP_SPEC) \ - _(3071, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC) \ - _(3072, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) \ - _(3074, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) \ - _(3075, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST) \ - _(3077, ZEND_BIND_LEXICAL_SPEC_TMP_CV) \ - _(3078, ZEND_BIND_STATIC_SPEC_CV_UNUSED) \ - _(3079, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED) \ - _(3080, ZEND_SEND_FUNC_ARG_SPEC_VAR) \ - _(3081, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED) \ - _(3082, ZEND_SWITCH_LONG_SPEC_CONST_CONST) \ - _(3083, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(3060, ZEND_SPACESHIP_SPEC_CV_CV) \ + _(3061, ZEND_DECLARE_ANON_CLASS_SPEC) \ + _(3062, ZEND_FETCH_STATIC_PROP_R_SPEC) \ + _(3063, ZEND_FETCH_STATIC_PROP_W_SPEC) \ + _(3064, ZEND_FETCH_STATIC_PROP_RW_SPEC) \ + _(3065, ZEND_FETCH_STATIC_PROP_IS_SPEC) \ + _(3066, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC) \ + _(3067, ZEND_FETCH_STATIC_PROP_UNSET_SPEC) \ + _(3068, ZEND_UNSET_STATIC_PROP_SPEC) \ + _(3069, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC) \ + _(3070, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) \ + _(3072, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) \ + _(3073, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST) \ + _(3075, ZEND_BIND_LEXICAL_SPEC_TMP_CV) \ + _(3076, ZEND_BIND_STATIC_SPEC_CV_UNUSED) \ + _(3077, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED) \ + _(3078, ZEND_SEND_FUNC_ARG_SPEC_VAR) \ + _(3079, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED) \ + _(3080, ZEND_SWITCH_LONG_SPEC_CONST_CONST) \ + _(3081, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(3082, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ _(3084, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(3086, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(3087, ZEND_SWITCH_STRING_SPEC_CONST_CONST) \ - _(3088, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(3085, ZEND_SWITCH_STRING_SPEC_CONST_CONST) \ + _(3086, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(3087, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ _(3089, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(3091, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(3092, ZEND_IN_ARRAY_SPEC_CONST_CONST) \ - _(3093, ZEND_IN_ARRAY_SPEC_TMP_CONST) \ - _(3094, ZEND_IN_ARRAY_SPEC_VAR_CONST) \ - _(3096, ZEND_IN_ARRAY_SPEC_CV_CONST) \ - _(3097, ZEND_COUNT_SPEC_CONST_UNUSED) \ - _(3098, ZEND_COUNT_SPEC_TMP_UNUSED) \ - _(3099, ZEND_COUNT_SPEC_VAR_UNUSED) \ - _(3101, ZEND_COUNT_SPEC_CV_UNUSED) \ - _(3102, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \ - _(3103, ZEND_GET_CLASS_SPEC_TMP_UNUSED) \ - _(3104, ZEND_GET_CLASS_SPEC_VAR_UNUSED) \ - _(3105, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED) \ - _(3106, ZEND_GET_CLASS_SPEC_CV_UNUSED) \ - _(3107, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED) \ - _(3108, ZEND_GET_TYPE_SPEC_CONST_UNUSED) \ - _(3109, ZEND_GET_TYPE_SPEC_TMP_UNUSED) \ - _(3110, ZEND_GET_TYPE_SPEC_VAR_UNUSED) \ - _(3112, ZEND_GET_TYPE_SPEC_CV_UNUSED) \ - _(3113, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED) \ - _(3114, ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED) \ - _(3117, ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED) \ - _(3119, ZEND_UNSET_CV_SPEC_CV_UNUSED) \ - _(3120, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET) \ - _(3121, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY) \ - _(3122, ZEND_FETCH_LIST_W_SPEC_VAR_CONST) \ - _(3123, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ - _(3124, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ - _(3126, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \ - _(3127, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \ - _(3128, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ - _(3129, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ - _(3131, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \ - _(3132, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ - _(3133, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(3134, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(3136, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ - _(3137, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ - _(3138, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(3139, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(3141, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ - _(3147, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \ - _(3148, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ - _(3149, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ - _(3151, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \ - _(3204, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR) \ - _(3206, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV) \ - _(3209, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR) \ - _(3211, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV) \ - _(3214, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR) \ - _(3216, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV) \ - _(3224, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR) \ - _(3226, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV) \ - _(3229, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR) \ - _(3231, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV) \ - _(3234, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR) \ - _(3236, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV) \ - _(3239, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR) \ - _(3241, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV) \ - _(3249, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR) \ - _(3251, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV) \ - _(3254, ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR) \ - _(3256, ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV) \ - _(3259, ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR) \ - _(3261, ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV) \ - _(3264, ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR) \ - _(3266, ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV) \ - _(3274, ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR) \ - _(3276, ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV) \ - _(3277, ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST) \ - _(3278, ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP) \ - _(3279, ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR) \ - _(3281, ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV) \ - _(3282, ZEND_ASSIGN_STATIC_PROP_REF_SPEC) \ - _(3283, ZEND_PRE_INC_STATIC_PROP_SPEC) \ - _(3284, ZEND_PRE_DEC_STATIC_PROP_SPEC) \ - _(3285, ZEND_POST_INC_STATIC_PROP_SPEC) \ - _(3286, ZEND_POST_DEC_STATIC_PROP_SPEC) \ - _(3287, ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED) \ - _(3288, ZEND_ADD_ARRAY_UNPACK_SPEC) \ - _(3289, ZEND_JMP_FORWARD_SPEC) \ - _(3295, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(3296, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3090, ZEND_IN_ARRAY_SPEC_CONST_CONST) \ + _(3091, ZEND_IN_ARRAY_SPEC_TMP_CONST) \ + _(3092, ZEND_IN_ARRAY_SPEC_VAR_CONST) \ + _(3094, ZEND_IN_ARRAY_SPEC_CV_CONST) \ + _(3095, ZEND_COUNT_SPEC_CONST_UNUSED) \ + _(3096, ZEND_COUNT_SPEC_TMP_UNUSED) \ + _(3097, ZEND_COUNT_SPEC_VAR_UNUSED) \ + _(3099, ZEND_COUNT_SPEC_CV_UNUSED) \ + _(3100, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \ + _(3101, ZEND_GET_CLASS_SPEC_TMP_UNUSED) \ + _(3102, ZEND_GET_CLASS_SPEC_VAR_UNUSED) \ + _(3103, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED) \ + _(3104, ZEND_GET_CLASS_SPEC_CV_UNUSED) \ + _(3105, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED) \ + _(3106, ZEND_GET_TYPE_SPEC_CONST_UNUSED) \ + _(3107, ZEND_GET_TYPE_SPEC_TMP_UNUSED) \ + _(3108, ZEND_GET_TYPE_SPEC_VAR_UNUSED) \ + _(3110, ZEND_GET_TYPE_SPEC_CV_UNUSED) \ + _(3111, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED) \ + _(3112, ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED) \ + _(3115, ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED) \ + _(3117, ZEND_UNSET_CV_SPEC_CV_UNUSED) \ + _(3118, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET) \ + _(3119, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY) \ + _(3120, ZEND_FETCH_LIST_W_SPEC_VAR_CONST) \ + _(3121, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ + _(3122, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ + _(3124, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \ + _(3125, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \ + _(3126, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ + _(3127, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ + _(3129, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \ + _(3130, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ + _(3131, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(3132, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(3134, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ + _(3135, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ + _(3136, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(3137, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(3139, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ + _(3145, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \ + _(3146, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ + _(3147, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ + _(3149, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \ + _(3202, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR) \ + _(3204, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV) \ + _(3207, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR) \ + _(3209, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV) \ + _(3212, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR) \ + _(3214, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV) \ + _(3222, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR) \ + _(3224, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV) \ + _(3227, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR) \ + _(3229, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV) \ + _(3232, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR) \ + _(3234, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV) \ + _(3237, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR) \ + _(3239, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV) \ + _(3247, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR) \ + _(3249, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV) \ + _(3252, ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR) \ + _(3254, ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV) \ + _(3257, ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR) \ + _(3259, ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV) \ + _(3262, ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR) \ + _(3264, ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV) \ + _(3272, ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR) \ + _(3274, ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV) \ + _(3275, ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST) \ + _(3276, ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP) \ + _(3277, ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR) \ + _(3279, ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV) \ + _(3280, ZEND_ASSIGN_STATIC_PROP_REF_SPEC) \ + _(3281, ZEND_PRE_INC_STATIC_PROP_SPEC) \ + _(3282, ZEND_PRE_DEC_STATIC_PROP_SPEC) \ + _(3283, ZEND_POST_INC_STATIC_PROP_SPEC) \ + _(3284, ZEND_POST_DEC_STATIC_PROP_SPEC) \ + _(3285, ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED) \ + _(3286, ZEND_ADD_ARRAY_UNPACK_SPEC) \ + _(3287, ZEND_JMP_FORWARD_SPEC) \ + _(3293, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(3294, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3295, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(3297, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3298, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(3299, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3300, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(3301, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3300, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(3302, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3304, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3310, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(3311, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3308, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(3309, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3310, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(3312, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3314, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3320, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(3321, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3318, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(3319, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3320, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(3322, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3323, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ _(3324, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3325, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(3326, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3325, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(3327, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3329, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3335, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(3336, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3333, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(3334, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3335, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(3337, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3339, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3345, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3346, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3343, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3344, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3345, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(3347, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3348, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ _(3349, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3350, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3351, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3350, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(3352, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3354, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3360, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3361, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3358, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3359, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3360, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(3362, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3364, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3366, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(3364, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(3365, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ _(3367, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(3369, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(3370, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(3371, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3368, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(3369, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3370, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(3372, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3373, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(3374, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3375, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(3376, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3375, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(3377, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3379, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3385, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(3386, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3383, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(3384, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3385, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(3387, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3389, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3391, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(3389, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(3390, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ _(3392, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(3394, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(3395, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(3396, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3393, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(3394, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3395, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(3397, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3398, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ _(3399, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3400, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(3401, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3400, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(3402, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3404, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3410, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(3411, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3408, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(3409, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3410, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(3412, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3414, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3416, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3414, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3415, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ _(3417, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3419, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3420, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3421, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3418, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3419, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3420, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(3422, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3423, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ _(3424, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3425, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3426, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3425, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(3427, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3429, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3435, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3436, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3433, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3434, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3435, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(3437, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3439, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3445, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(3446, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3443, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(3444, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3445, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(3447, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3448, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(3449, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3450, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(3451, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3450, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(3452, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3454, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3460, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(3461, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3458, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(3459, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3460, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(3462, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3464, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3470, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(3471, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3468, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(3469, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3470, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(3472, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3473, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ _(3474, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3475, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(3476, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3475, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(3477, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3479, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3485, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(3486, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3483, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(3484, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3485, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(3487, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3489, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3495, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3496, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3493, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3494, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3495, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(3497, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3498, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ _(3499, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3500, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3501, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3500, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(3502, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3504, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3510, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3511, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3508, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3509, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3510, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(3512, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3514, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3530, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3531, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3532, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3533, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3534, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3535, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3536, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3537, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3538, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3542, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3543, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3544, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3545, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3546, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3547, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3548, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3549, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3550, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3551, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3552, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3553, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3557, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3558, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3559, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3575, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3576, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3577, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3578, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3579, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3580, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3581, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3582, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3583, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3587, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3588, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3589, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3605, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3606, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3607, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3608, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3609, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3610, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3611, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3612, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3613, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3617, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3618, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3619, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3620, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3621, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3622, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3623, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3624, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3625, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3626, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3627, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3628, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3632, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3633, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3634, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3650, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3651, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3652, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3653, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3654, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3655, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3656, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3657, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3658, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3662, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3663, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3664, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3680, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3681, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3682, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3683, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3684, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3685, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3686, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3687, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3688, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3692, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3693, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3694, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3695, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3696, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3697, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3698, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3699, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3700, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3701, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3702, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3703, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3707, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3708, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3709, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3725, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3726, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3727, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3728, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3729, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3730, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3731, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3732, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3733, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3737, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3738, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3739, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3755, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3756, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3757, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3758, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3759, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3760, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3761, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3762, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3763, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3767, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3768, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3769, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3770, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3771, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3772, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3773, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3774, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3775, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3776, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3777, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3778, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3782, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3783, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3784, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3800, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3801, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3802, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3803, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3804, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3805, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3806, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3807, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3808, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3812, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3813, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3814, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3818, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3819, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3820, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3821, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3822, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3823, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3827, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3828, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3829, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3830, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3831, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3832, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3833, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3834, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3835, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3836, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3837, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3838, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3842, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3843, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3844, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3845, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3846, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3847, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3848, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3849, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3850, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3851, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3852, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3853, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3857, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3858, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3859, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3875, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3876, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3877, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3878, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3879, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3880, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3881, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3882, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3883, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3887, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3888, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3889, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3893, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3894, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3895, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3896, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3897, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3898, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3902, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3903, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3904, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3905, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3906, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3907, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3908, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3909, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3910, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3911, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3912, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3913, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3917, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3918, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3919, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3920, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3921, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3922, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3923, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3924, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3925, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3926, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3927, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3928, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3932, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3933, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3934, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3950, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3951, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3952, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3953, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3954, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3955, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3956, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3957, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3958, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3962, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3963, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3964, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3968, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3969, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3970, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3971, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3972, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3973, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3977, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3978, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3979, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3980, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3981, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3982, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3983, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3984, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3985, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3986, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3987, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3988, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3992, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3993, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3994, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3995, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3996, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3997, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3998, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3999, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4000, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4001, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4002, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4003, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4007, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4008, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4009, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4025, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(4026, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(4027, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(4028, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4029, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4030, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4031, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4032, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4033, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4037, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4038, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4039, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4043, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(4044, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(4045, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(4046, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(4047, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(4048, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(4052, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(4053, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(4054, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(4055, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(4056, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(4057, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(4058, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4059, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4060, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4061, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4062, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4063, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4067, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4068, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4069, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4070, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(4071, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(4072, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(4073, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4074, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4075, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4076, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4077, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4078, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4082, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4083, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4084, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4100, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(4101, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(4102, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(4103, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4104, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4105, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4106, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4107, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4108, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4112, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4113, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4114, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4115, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED) \ - _(4116, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED) \ - _(4117, ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED) \ - _(4118, ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_USED) \ - _(4119, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED) \ - _(4120, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED) \ - _(4121, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED) \ - _(4122, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED) \ - _(4123, ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED) \ - _(4124, ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_USED) \ - _(4125, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED) \ - _(4126, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED) \ - _(4127, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV) \ - _(4128, ZEND_POST_INC_LONG_SPEC_TMPVARCV) \ - _(4129, ZEND_POST_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV) \ - _(4130, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV) \ - _(4131, ZEND_POST_DEC_LONG_SPEC_TMPVARCV) \ - _(4132, ZEND_POST_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV) \ - _(4133, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ - _(4134, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3528, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3529, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3530, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3531, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3532, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3533, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3534, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3535, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3536, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3540, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3541, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3542, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3543, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3544, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3545, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3546, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3547, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3548, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3549, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3550, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3551, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3555, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3556, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3557, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3573, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3574, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3575, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3576, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3577, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3578, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3579, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3580, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3581, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3585, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3586, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3587, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3603, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3604, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3605, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3606, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3607, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3608, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3609, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3610, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3611, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3615, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3616, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3617, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3618, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3619, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3620, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3621, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3622, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3623, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3624, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3625, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3626, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3630, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3631, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3632, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3648, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3649, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3650, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3651, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3652, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3653, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3654, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3655, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3656, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3660, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3661, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3662, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3678, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3679, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3680, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3681, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3682, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3683, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3684, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3685, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3686, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3690, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3691, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3692, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3693, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3694, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3695, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3696, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3697, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3698, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3699, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3700, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3701, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3705, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3706, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3707, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3723, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3724, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3725, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3726, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3727, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3728, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3729, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3730, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3731, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3735, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3736, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3737, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3753, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3754, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3755, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3756, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3757, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3758, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3759, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3760, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3761, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3765, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3766, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3767, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3768, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3769, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3770, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3771, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3772, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3773, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3774, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3775, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3776, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3780, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3781, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3782, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3798, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3799, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3800, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3801, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3802, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3803, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3804, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3805, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3806, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3810, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3811, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3812, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3816, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3817, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3818, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3819, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3820, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3821, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3825, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3826, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3827, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3828, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3829, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3830, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3831, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3832, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3833, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3834, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3835, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3836, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3840, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3841, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3842, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3843, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3844, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3845, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3846, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3847, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3848, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3849, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3850, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3851, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3855, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3856, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3857, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3873, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3874, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3875, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3876, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3877, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3878, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3879, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3880, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3881, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3885, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3886, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3887, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3891, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3892, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3893, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3894, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3895, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3896, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3900, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3901, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3902, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3903, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3904, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3905, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3906, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3907, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3908, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3909, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3910, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3911, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3915, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3916, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3917, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3918, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3919, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3920, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3921, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3922, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3923, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3924, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3925, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3926, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3930, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3931, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3932, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3948, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3949, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3950, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3951, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3952, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3953, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3954, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3955, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3956, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3960, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3961, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3962, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3966, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3967, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3968, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3969, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3970, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3971, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3975, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3976, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3977, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3978, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3979, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3980, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3981, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3982, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3983, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3984, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3985, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3986, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3990, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3991, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3992, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3993, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3994, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3995, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3996, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3997, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3998, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3999, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4000, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4001, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4005, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4006, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4007, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4023, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(4024, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(4025, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(4026, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4027, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4028, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4029, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4030, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4031, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4035, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4036, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4037, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4041, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(4042, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(4043, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(4044, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(4045, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(4046, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(4050, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(4051, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(4052, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(4053, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(4054, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(4055, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(4056, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4057, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4058, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4059, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4060, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4061, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4065, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4066, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4067, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4068, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(4069, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(4070, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(4071, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4072, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4073, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4074, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4075, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4076, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4080, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4081, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4082, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4098, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(4099, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(4100, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(4101, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4102, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4103, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4104, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4105, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4106, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4110, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4111, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4112, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4113, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED) \ + _(4114, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED) \ + _(4115, ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED) \ + _(4116, ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_USED) \ + _(4117, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED) \ + _(4118, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED) \ + _(4119, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED) \ + _(4120, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED) \ + _(4121, ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED) \ + _(4122, ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_USED) \ + _(4123, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED) \ + _(4124, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED) \ + _(4125, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV) \ + _(4126, ZEND_POST_INC_LONG_SPEC_TMPVARCV) \ + _(4127, ZEND_POST_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV) \ + _(4128, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV) \ + _(4129, ZEND_POST_DEC_LONG_SPEC_TMPVARCV) \ + _(4130, ZEND_POST_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV) \ + _(4131, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ + _(4132, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(4133, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ _(4135, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(4137, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(4138, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ - _(4139, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(4136, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ + _(4137, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(4138, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ _(4140, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(4142, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(4144, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(4142, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(4143, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ _(4145, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(4147, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(4148, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(4149, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(4146, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(4147, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(4148, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ _(4150, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(4151, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ _(4152, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(4153, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(4154, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(4153, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ _(4155, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(4157, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(4163, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ - _(4164, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(4161, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ + _(4162, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(4163, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ _(4165, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(4167, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(4170, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ - _(4172, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ - _(4175, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR) \ - _(4177, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV) \ - _(4178, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ - _(4179, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ - _(4180, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ - _(4181, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ - _(4181+1, ZEND_NULL) + _(4168, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ + _(4170, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ + _(4173, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR) \ + _(4175, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV) \ + _(4176, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ + _(4177, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ + _(4178, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ + _(4179, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ + _(4179+1, ZEND_NULL) diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c index 6496f54402..70d9fbcc19 100644 --- a/Zend/zend_vm_opcodes.c +++ b/Zend/zend_vm_opcodes.c @@ -163,12 +163,12 @@ static const char *zend_vm_opcodes_names[209] = { "ZEND_OP_DATA", "ZEND_INSTANCEOF", "ZEND_DECLARE_CLASS", - "ZEND_DECLARE_INHERITED_CLASS", + NULL, "ZEND_DECLARE_FUNCTION", "ZEND_YIELD_FROM", "ZEND_DECLARE_CONST", NULL, - "ZEND_DECLARE_INHERITED_CLASS_DELAYED", + "ZEND_DECLARE_CLASS_DELAYED", NULL, "ZEND_ASSIGN_DIM", "ZEND_ISSET_ISEMPTY_PROP_OBJ", @@ -195,7 +195,7 @@ static const char *zend_vm_opcodes_names[209] = { "ZEND_COALESCE", "ZEND_SPACESHIP", "ZEND_DECLARE_ANON_CLASS", - "ZEND_DECLARE_ANON_INHERITED_CLASS", + NULL, "ZEND_FETCH_STATIC_PROP_R", "ZEND_FETCH_STATIC_PROP_W", "ZEND_FETCH_STATIC_PROP_RW", @@ -375,12 +375,12 @@ static uint32_t zend_vm_opcodes_flags[209] = { 0x00000000, 0x00047305, 0x00000003, - 0x00000303, + 0x00000000, 0x00000000, 0x00000003, 0x00000303, 0x00000000, - 0x00000303, + 0x00000003, 0x00000000, 0x00006701, 0x00060757, @@ -407,7 +407,7 @@ static uint32_t zend_vm_opcodes_flags[209] = { 0x00002007, 0x00000707, 0x03000000, - 0x03000303, + 0x00000000, 0x00047000, 0x00647000, 0x00047000, diff --git a/Zend/zend_vm_opcodes.h b/Zend/zend_vm_opcodes.h index ce2e020bc7..67fb30fbc9 100644 --- a/Zend/zend_vm_opcodes.h +++ b/Zend/zend_vm_opcodes.h @@ -76,212 +76,210 @@ ZEND_API uint32_t ZEND_FASTCALL zend_get_opcode_flags(zend_uchar opcode); END_EXTERN_C() -#define ZEND_NOP 0 -#define ZEND_ADD 1 -#define ZEND_SUB 2 -#define ZEND_MUL 3 -#define ZEND_DIV 4 -#define ZEND_MOD 5 -#define ZEND_SL 6 -#define ZEND_SR 7 -#define ZEND_CONCAT 8 -#define ZEND_BW_OR 9 -#define ZEND_BW_AND 10 -#define ZEND_BW_XOR 11 -#define ZEND_BW_NOT 12 -#define ZEND_BOOL_NOT 13 -#define ZEND_BOOL_XOR 14 -#define ZEND_IS_IDENTICAL 15 -#define ZEND_IS_NOT_IDENTICAL 16 -#define ZEND_IS_EQUAL 17 -#define ZEND_IS_NOT_EQUAL 18 -#define ZEND_IS_SMALLER 19 -#define ZEND_IS_SMALLER_OR_EQUAL 20 -#define ZEND_CAST 21 -#define ZEND_QM_ASSIGN 22 -#define ZEND_ASSIGN_ADD 23 -#define ZEND_ASSIGN_SUB 24 -#define ZEND_ASSIGN_MUL 25 -#define ZEND_ASSIGN_DIV 26 -#define ZEND_ASSIGN_MOD 27 -#define ZEND_ASSIGN_SL 28 -#define ZEND_ASSIGN_SR 29 -#define ZEND_ASSIGN_CONCAT 30 -#define ZEND_ASSIGN_BW_OR 31 -#define ZEND_ASSIGN_BW_AND 32 -#define ZEND_ASSIGN_BW_XOR 33 -#define ZEND_PRE_INC 34 -#define ZEND_PRE_DEC 35 -#define ZEND_POST_INC 36 -#define ZEND_POST_DEC 37 -#define ZEND_ASSIGN 38 -#define ZEND_ASSIGN_REF 39 -#define ZEND_ECHO 40 -#define ZEND_GENERATOR_CREATE 41 -#define ZEND_JMP 42 -#define ZEND_JMPZ 43 -#define ZEND_JMPNZ 44 -#define ZEND_JMPZNZ 45 -#define ZEND_JMPZ_EX 46 -#define ZEND_JMPNZ_EX 47 -#define ZEND_CASE 48 -#define ZEND_CHECK_VAR 49 -#define ZEND_SEND_VAR_NO_REF_EX 50 -#define ZEND_MAKE_REF 51 -#define ZEND_BOOL 52 -#define ZEND_FAST_CONCAT 53 -#define ZEND_ROPE_INIT 54 -#define ZEND_ROPE_ADD 55 -#define ZEND_ROPE_END 56 -#define ZEND_BEGIN_SILENCE 57 -#define ZEND_END_SILENCE 58 -#define ZEND_INIT_FCALL_BY_NAME 59 -#define ZEND_DO_FCALL 60 -#define ZEND_INIT_FCALL 61 -#define ZEND_RETURN 62 -#define ZEND_RECV 63 -#define ZEND_RECV_INIT 64 -#define ZEND_SEND_VAL 65 -#define ZEND_SEND_VAR_EX 66 -#define ZEND_SEND_REF 67 -#define ZEND_NEW 68 -#define ZEND_INIT_NS_FCALL_BY_NAME 69 -#define ZEND_FREE 70 -#define ZEND_INIT_ARRAY 71 -#define ZEND_ADD_ARRAY_ELEMENT 72 -#define ZEND_INCLUDE_OR_EVAL 73 -#define ZEND_UNSET_VAR 74 -#define ZEND_UNSET_DIM 75 -#define ZEND_UNSET_OBJ 76 -#define ZEND_FE_RESET_R 77 -#define ZEND_FE_FETCH_R 78 -#define ZEND_EXIT 79 -#define ZEND_FETCH_R 80 -#define ZEND_FETCH_DIM_R 81 -#define ZEND_FETCH_OBJ_R 82 -#define ZEND_FETCH_W 83 -#define ZEND_FETCH_DIM_W 84 -#define ZEND_FETCH_OBJ_W 85 -#define ZEND_FETCH_RW 86 -#define ZEND_FETCH_DIM_RW 87 -#define ZEND_FETCH_OBJ_RW 88 -#define ZEND_FETCH_IS 89 -#define ZEND_FETCH_DIM_IS 90 -#define ZEND_FETCH_OBJ_IS 91 -#define ZEND_FETCH_FUNC_ARG 92 -#define ZEND_FETCH_DIM_FUNC_ARG 93 -#define ZEND_FETCH_OBJ_FUNC_ARG 94 -#define ZEND_FETCH_UNSET 95 -#define ZEND_FETCH_DIM_UNSET 96 -#define ZEND_FETCH_OBJ_UNSET 97 -#define ZEND_FETCH_LIST_R 98 -#define ZEND_FETCH_CONSTANT 99 -#define ZEND_CHECK_FUNC_ARG 100 -#define ZEND_EXT_STMT 101 -#define ZEND_EXT_FCALL_BEGIN 102 -#define ZEND_EXT_FCALL_END 103 -#define ZEND_EXT_NOP 104 -#define ZEND_TICKS 105 -#define ZEND_SEND_VAR_NO_REF 106 -#define ZEND_CATCH 107 -#define ZEND_THROW 108 -#define ZEND_FETCH_CLASS 109 -#define ZEND_CLONE 110 -#define ZEND_RETURN_BY_REF 111 -#define ZEND_INIT_METHOD_CALL 112 -#define ZEND_INIT_STATIC_METHOD_CALL 113 -#define ZEND_ISSET_ISEMPTY_VAR 114 -#define ZEND_ISSET_ISEMPTY_DIM_OBJ 115 -#define ZEND_SEND_VAL_EX 116 -#define ZEND_SEND_VAR 117 -#define ZEND_INIT_USER_CALL 118 -#define ZEND_SEND_ARRAY 119 -#define ZEND_SEND_USER 120 -#define ZEND_STRLEN 121 -#define ZEND_DEFINED 122 -#define ZEND_TYPE_CHECK 123 -#define ZEND_VERIFY_RETURN_TYPE 124 -#define ZEND_FE_RESET_RW 125 -#define ZEND_FE_FETCH_RW 126 -#define ZEND_FE_FREE 127 -#define ZEND_INIT_DYNAMIC_CALL 128 -#define ZEND_DO_ICALL 129 -#define ZEND_DO_UCALL 130 -#define ZEND_DO_FCALL_BY_NAME 131 -#define ZEND_PRE_INC_OBJ 132 -#define ZEND_PRE_DEC_OBJ 133 -#define ZEND_POST_INC_OBJ 134 -#define ZEND_POST_DEC_OBJ 135 -#define ZEND_ASSIGN_OBJ 136 -#define ZEND_OP_DATA 137 -#define ZEND_INSTANCEOF 138 -#define ZEND_DECLARE_CLASS 139 -#define ZEND_DECLARE_INHERITED_CLASS 140 -#define ZEND_DECLARE_FUNCTION 141 -#define ZEND_YIELD_FROM 142 -#define ZEND_DECLARE_CONST 143 -#define ZEND_DECLARE_INHERITED_CLASS_DELAYED 145 -#define ZEND_ASSIGN_DIM 147 -#define ZEND_ISSET_ISEMPTY_PROP_OBJ 148 -#define ZEND_HANDLE_EXCEPTION 149 -#define ZEND_USER_OPCODE 150 -#define ZEND_ASSERT_CHECK 151 -#define ZEND_JMP_SET 152 -#define ZEND_DECLARE_LAMBDA_FUNCTION 153 -#define ZEND_SEPARATE 156 -#define ZEND_FETCH_CLASS_NAME 157 -#define ZEND_CALL_TRAMPOLINE 158 -#define ZEND_DISCARD_EXCEPTION 159 -#define ZEND_YIELD 160 -#define ZEND_GENERATOR_RETURN 161 -#define ZEND_FAST_CALL 162 -#define ZEND_FAST_RET 163 -#define ZEND_RECV_VARIADIC 164 -#define ZEND_SEND_UNPACK 165 -#define ZEND_POW 166 -#define ZEND_ASSIGN_POW 167 -#define ZEND_BIND_GLOBAL 168 -#define ZEND_COALESCE 169 -#define ZEND_SPACESHIP 170 -#define ZEND_DECLARE_ANON_CLASS 171 -#define ZEND_DECLARE_ANON_INHERITED_CLASS 172 -#define ZEND_FETCH_STATIC_PROP_R 173 -#define ZEND_FETCH_STATIC_PROP_W 174 -#define ZEND_FETCH_STATIC_PROP_RW 175 -#define ZEND_FETCH_STATIC_PROP_IS 176 -#define ZEND_FETCH_STATIC_PROP_FUNC_ARG 177 -#define ZEND_FETCH_STATIC_PROP_UNSET 178 -#define ZEND_UNSET_STATIC_PROP 179 -#define ZEND_ISSET_ISEMPTY_STATIC_PROP 180 -#define ZEND_FETCH_CLASS_CONSTANT 181 -#define ZEND_BIND_LEXICAL 182 -#define ZEND_BIND_STATIC 183 -#define ZEND_FETCH_THIS 184 -#define ZEND_SEND_FUNC_ARG 185 -#define ZEND_ISSET_ISEMPTY_THIS 186 -#define ZEND_SWITCH_LONG 187 -#define ZEND_SWITCH_STRING 188 -#define ZEND_IN_ARRAY 189 -#define ZEND_COUNT 190 -#define ZEND_GET_CLASS 191 -#define ZEND_GET_CALLED_CLASS 192 -#define ZEND_GET_TYPE 193 -#define ZEND_FUNC_NUM_ARGS 194 -#define ZEND_FUNC_GET_ARGS 195 -#define ZEND_UNSET_CV 196 -#define ZEND_ISSET_ISEMPTY_CV 197 -#define ZEND_FETCH_LIST_W 198 -#define ZEND_ARRAY_KEY_EXISTS 199 -#define ZEND_ASSIGN_OBJ_REF 200 -#define ZEND_ASSIGN_STATIC_PROP 201 -#define ZEND_ASSIGN_STATIC_PROP_REF 202 -#define ZEND_PRE_INC_STATIC_PROP 203 -#define ZEND_PRE_DEC_STATIC_PROP 204 -#define ZEND_POST_INC_STATIC_PROP 205 -#define ZEND_POST_DEC_STATIC_PROP 206 -#define ZEND_COPY_TMP 207 -#define ZEND_ADD_ARRAY_UNPACK 208 +#define ZEND_NOP 0 +#define ZEND_ADD 1 +#define ZEND_SUB 2 +#define ZEND_MUL 3 +#define ZEND_DIV 4 +#define ZEND_MOD 5 +#define ZEND_SL 6 +#define ZEND_SR 7 +#define ZEND_CONCAT 8 +#define ZEND_BW_OR 9 +#define ZEND_BW_AND 10 +#define ZEND_BW_XOR 11 +#define ZEND_BW_NOT 12 +#define ZEND_BOOL_NOT 13 +#define ZEND_BOOL_XOR 14 +#define ZEND_IS_IDENTICAL 15 +#define ZEND_IS_NOT_IDENTICAL 16 +#define ZEND_IS_EQUAL 17 +#define ZEND_IS_NOT_EQUAL 18 +#define ZEND_IS_SMALLER 19 +#define ZEND_IS_SMALLER_OR_EQUAL 20 +#define ZEND_CAST 21 +#define ZEND_QM_ASSIGN 22 +#define ZEND_ASSIGN_ADD 23 +#define ZEND_ASSIGN_SUB 24 +#define ZEND_ASSIGN_MUL 25 +#define ZEND_ASSIGN_DIV 26 +#define ZEND_ASSIGN_MOD 27 +#define ZEND_ASSIGN_SL 28 +#define ZEND_ASSIGN_SR 29 +#define ZEND_ASSIGN_CONCAT 30 +#define ZEND_ASSIGN_BW_OR 31 +#define ZEND_ASSIGN_BW_AND 32 +#define ZEND_ASSIGN_BW_XOR 33 +#define ZEND_PRE_INC 34 +#define ZEND_PRE_DEC 35 +#define ZEND_POST_INC 36 +#define ZEND_POST_DEC 37 +#define ZEND_ASSIGN 38 +#define ZEND_ASSIGN_REF 39 +#define ZEND_ECHO 40 +#define ZEND_GENERATOR_CREATE 41 +#define ZEND_JMP 42 +#define ZEND_JMPZ 43 +#define ZEND_JMPNZ 44 +#define ZEND_JMPZNZ 45 +#define ZEND_JMPZ_EX 46 +#define ZEND_JMPNZ_EX 47 +#define ZEND_CASE 48 +#define ZEND_CHECK_VAR 49 +#define ZEND_SEND_VAR_NO_REF_EX 50 +#define ZEND_MAKE_REF 51 +#define ZEND_BOOL 52 +#define ZEND_FAST_CONCAT 53 +#define ZEND_ROPE_INIT 54 +#define ZEND_ROPE_ADD 55 +#define ZEND_ROPE_END 56 +#define ZEND_BEGIN_SILENCE 57 +#define ZEND_END_SILENCE 58 +#define ZEND_INIT_FCALL_BY_NAME 59 +#define ZEND_DO_FCALL 60 +#define ZEND_INIT_FCALL 61 +#define ZEND_RETURN 62 +#define ZEND_RECV 63 +#define ZEND_RECV_INIT 64 +#define ZEND_SEND_VAL 65 +#define ZEND_SEND_VAR_EX 66 +#define ZEND_SEND_REF 67 +#define ZEND_NEW 68 +#define ZEND_INIT_NS_FCALL_BY_NAME 69 +#define ZEND_FREE 70 +#define ZEND_INIT_ARRAY 71 +#define ZEND_ADD_ARRAY_ELEMENT 72 +#define ZEND_INCLUDE_OR_EVAL 73 +#define ZEND_UNSET_VAR 74 +#define ZEND_UNSET_DIM 75 +#define ZEND_UNSET_OBJ 76 +#define ZEND_FE_RESET_R 77 +#define ZEND_FE_FETCH_R 78 +#define ZEND_EXIT 79 +#define ZEND_FETCH_R 80 +#define ZEND_FETCH_DIM_R 81 +#define ZEND_FETCH_OBJ_R 82 +#define ZEND_FETCH_W 83 +#define ZEND_FETCH_DIM_W 84 +#define ZEND_FETCH_OBJ_W 85 +#define ZEND_FETCH_RW 86 +#define ZEND_FETCH_DIM_RW 87 +#define ZEND_FETCH_OBJ_RW 88 +#define ZEND_FETCH_IS 89 +#define ZEND_FETCH_DIM_IS 90 +#define ZEND_FETCH_OBJ_IS 91 +#define ZEND_FETCH_FUNC_ARG 92 +#define ZEND_FETCH_DIM_FUNC_ARG 93 +#define ZEND_FETCH_OBJ_FUNC_ARG 94 +#define ZEND_FETCH_UNSET 95 +#define ZEND_FETCH_DIM_UNSET 96 +#define ZEND_FETCH_OBJ_UNSET 97 +#define ZEND_FETCH_LIST_R 98 +#define ZEND_FETCH_CONSTANT 99 +#define ZEND_CHECK_FUNC_ARG 100 +#define ZEND_EXT_STMT 101 +#define ZEND_EXT_FCALL_BEGIN 102 +#define ZEND_EXT_FCALL_END 103 +#define ZEND_EXT_NOP 104 +#define ZEND_TICKS 105 +#define ZEND_SEND_VAR_NO_REF 106 +#define ZEND_CATCH 107 +#define ZEND_THROW 108 +#define ZEND_FETCH_CLASS 109 +#define ZEND_CLONE 110 +#define ZEND_RETURN_BY_REF 111 +#define ZEND_INIT_METHOD_CALL 112 +#define ZEND_INIT_STATIC_METHOD_CALL 113 +#define ZEND_ISSET_ISEMPTY_VAR 114 +#define ZEND_ISSET_ISEMPTY_DIM_OBJ 115 +#define ZEND_SEND_VAL_EX 116 +#define ZEND_SEND_VAR 117 +#define ZEND_INIT_USER_CALL 118 +#define ZEND_SEND_ARRAY 119 +#define ZEND_SEND_USER 120 +#define ZEND_STRLEN 121 +#define ZEND_DEFINED 122 +#define ZEND_TYPE_CHECK 123 +#define ZEND_VERIFY_RETURN_TYPE 124 +#define ZEND_FE_RESET_RW 125 +#define ZEND_FE_FETCH_RW 126 +#define ZEND_FE_FREE 127 +#define ZEND_INIT_DYNAMIC_CALL 128 +#define ZEND_DO_ICALL 129 +#define ZEND_DO_UCALL 130 +#define ZEND_DO_FCALL_BY_NAME 131 +#define ZEND_PRE_INC_OBJ 132 +#define ZEND_PRE_DEC_OBJ 133 +#define ZEND_POST_INC_OBJ 134 +#define ZEND_POST_DEC_OBJ 135 +#define ZEND_ASSIGN_OBJ 136 +#define ZEND_OP_DATA 137 +#define ZEND_INSTANCEOF 138 +#define ZEND_DECLARE_CLASS 139 +#define ZEND_DECLARE_FUNCTION 141 +#define ZEND_YIELD_FROM 142 +#define ZEND_DECLARE_CONST 143 +#define ZEND_DECLARE_CLASS_DELAYED 145 +#define ZEND_ASSIGN_DIM 147 +#define ZEND_ISSET_ISEMPTY_PROP_OBJ 148 +#define ZEND_HANDLE_EXCEPTION 149 +#define ZEND_USER_OPCODE 150 +#define ZEND_ASSERT_CHECK 151 +#define ZEND_JMP_SET 152 +#define ZEND_DECLARE_LAMBDA_FUNCTION 153 +#define ZEND_SEPARATE 156 +#define ZEND_FETCH_CLASS_NAME 157 +#define ZEND_CALL_TRAMPOLINE 158 +#define ZEND_DISCARD_EXCEPTION 159 +#define ZEND_YIELD 160 +#define ZEND_GENERATOR_RETURN 161 +#define ZEND_FAST_CALL 162 +#define ZEND_FAST_RET 163 +#define ZEND_RECV_VARIADIC 164 +#define ZEND_SEND_UNPACK 165 +#define ZEND_POW 166 +#define ZEND_ASSIGN_POW 167 +#define ZEND_BIND_GLOBAL 168 +#define ZEND_COALESCE 169 +#define ZEND_SPACESHIP 170 +#define ZEND_DECLARE_ANON_CLASS 171 +#define ZEND_FETCH_STATIC_PROP_R 173 +#define ZEND_FETCH_STATIC_PROP_W 174 +#define ZEND_FETCH_STATIC_PROP_RW 175 +#define ZEND_FETCH_STATIC_PROP_IS 176 +#define ZEND_FETCH_STATIC_PROP_FUNC_ARG 177 +#define ZEND_FETCH_STATIC_PROP_UNSET 178 +#define ZEND_UNSET_STATIC_PROP 179 +#define ZEND_ISSET_ISEMPTY_STATIC_PROP 180 +#define ZEND_FETCH_CLASS_CONSTANT 181 +#define ZEND_BIND_LEXICAL 182 +#define ZEND_BIND_STATIC 183 +#define ZEND_FETCH_THIS 184 +#define ZEND_SEND_FUNC_ARG 185 +#define ZEND_ISSET_ISEMPTY_THIS 186 +#define ZEND_SWITCH_LONG 187 +#define ZEND_SWITCH_STRING 188 +#define ZEND_IN_ARRAY 189 +#define ZEND_COUNT 190 +#define ZEND_GET_CLASS 191 +#define ZEND_GET_CALLED_CLASS 192 +#define ZEND_GET_TYPE 193 +#define ZEND_FUNC_NUM_ARGS 194 +#define ZEND_FUNC_GET_ARGS 195 +#define ZEND_UNSET_CV 196 +#define ZEND_ISSET_ISEMPTY_CV 197 +#define ZEND_FETCH_LIST_W 198 +#define ZEND_ARRAY_KEY_EXISTS 199 +#define ZEND_ASSIGN_OBJ_REF 200 +#define ZEND_ASSIGN_STATIC_PROP 201 +#define ZEND_ASSIGN_STATIC_PROP_REF 202 +#define ZEND_PRE_INC_STATIC_PROP 203 +#define ZEND_PRE_DEC_STATIC_PROP 204 +#define ZEND_POST_INC_STATIC_PROP 205 +#define ZEND_POST_DEC_STATIC_PROP 206 +#define ZEND_COPY_TMP 207 +#define ZEND_ADD_ARRAY_UNPACK 208 -#define ZEND_VM_LAST_OPCODE 208 +#define ZEND_VM_LAST_OPCODE 208 #endif diff --git a/ext/opcache/Optimizer/block_pass.c b/ext/opcache/Optimizer/block_pass.c index c4580dddec..001e9d3360 100644 --- a/ext/opcache/Optimizer/block_pass.c +++ b/ext/opcache/Optimizer/block_pass.c @@ -990,7 +990,6 @@ static void assemble_code_blocks(zend_cfg *cfg, zend_op_array *op_array, zend_op } break; case ZEND_DECLARE_ANON_CLASS: - case ZEND_DECLARE_ANON_INHERITED_CLASS: case ZEND_FE_FETCH_R: case ZEND_FE_FETCH_RW: opline->extended_value = ZEND_OPLINE_TO_OFFSET(opline, new_opcodes + blocks[b->successors[0]].start); diff --git a/ext/opcache/Optimizer/compact_literals.c b/ext/opcache/Optimizer/compact_literals.c index 70d51fc832..ec80d5e553 100644 --- a/ext/opcache/Optimizer/compact_literals.c +++ b/ext/opcache/Optimizer/compact_literals.c @@ -271,17 +271,9 @@ literals_handle_static_prop: break; case ZEND_DECLARE_FUNCTION: case ZEND_DECLARE_CLASS: + case ZEND_DECLARE_CLASS_DELAYED: LITERAL_INFO(opline->op1.constant, LITERAL_VALUE, 2); break; - case ZEND_DECLARE_INHERITED_CLASS: - case ZEND_DECLARE_INHERITED_CLASS_DELAYED: - LITERAL_INFO(opline->op1.constant, LITERAL_VALUE, 2); - LITERAL_INFO(opline->op2.constant, LITERAL_VALUE, 2); - break; - case ZEND_DECLARE_ANON_INHERITED_CLASS: - LITERAL_INFO(opline->op1.constant, LITERAL_VALUE, 1); - LITERAL_INFO(opline->op2.constant, LITERAL_VALUE, 2); - break; case ZEND_ISSET_ISEMPTY_DIM_OBJ: case ZEND_ASSIGN_DIM: case ZEND_UNSET_DIM: diff --git a/ext/opcache/Optimizer/dfa_pass.c b/ext/opcache/Optimizer/dfa_pass.c index 7cffa45ddb..c9528918e3 100644 --- a/ext/opcache/Optimizer/dfa_pass.c +++ b/ext/opcache/Optimizer/dfa_pass.c @@ -608,7 +608,6 @@ static void zend_ssa_replace_control_link(zend_op_array *op_array, zend_ssa *ssa } break; case ZEND_DECLARE_ANON_CLASS: - case ZEND_DECLARE_ANON_INHERITED_CLASS: case ZEND_FE_FETCH_R: case ZEND_FE_FETCH_RW: if (ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, opline->extended_value) == old->start) { diff --git a/ext/opcache/Optimizer/sccp.c b/ext/opcache/Optimizer/sccp.c index 1d960ab6dc..da829e2860 100644 --- a/ext/opcache/Optimizer/sccp.c +++ b/ext/opcache/Optimizer/sccp.c @@ -287,9 +287,7 @@ static zend_bool can_replace_op2( const zend_op_array *op_array, zend_op *opline, zend_ssa_op *ssa_op) { switch (opline->opcode) { /* Do not accept CONST */ - case ZEND_DECLARE_INHERITED_CLASS: - case ZEND_DECLARE_INHERITED_CLASS_DELAYED: - case ZEND_DECLARE_ANON_INHERITED_CLASS: + case ZEND_DECLARE_CLASS_DELAYED: case ZEND_BIND_LEXICAL: case ZEND_FE_FETCH_R: case ZEND_FE_FETCH_RW: @@ -1948,7 +1946,6 @@ static void sccp_mark_feasible_successors( case ZEND_ASSERT_CHECK: case ZEND_CATCH: case ZEND_DECLARE_ANON_CLASS: - case ZEND_DECLARE_ANON_INHERITED_CLASS: case ZEND_FE_FETCH_R: case ZEND_FE_FETCH_RW: scdf_mark_edge_feasible(scdf, block_num, block->successors[0]); diff --git a/ext/opcache/Optimizer/zend_cfg.c b/ext/opcache/Optimizer/zend_cfg.c index 489a3f1f7e..d956f6dfbd 100644 --- a/ext/opcache/Optimizer/zend_cfg.c +++ b/ext/opcache/Optimizer/zend_cfg.c @@ -376,7 +376,6 @@ int zend_build_cfg(zend_arena **arena, const zend_op_array *op_array, uint32_t b BB_START(i + 1); break; case ZEND_DECLARE_ANON_CLASS: - case ZEND_DECLARE_ANON_INHERITED_CLASS: case ZEND_FE_FETCH_R: case ZEND_FE_FETCH_RW: BB_START(ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, opline->extended_value)); @@ -537,7 +536,6 @@ int zend_build_cfg(zend_arena **arena, const zend_op_array *op_array, uint32_t b } break; case ZEND_DECLARE_ANON_CLASS: - case ZEND_DECLARE_ANON_INHERITED_CLASS: case ZEND_FE_FETCH_R: case ZEND_FE_FETCH_RW: block->successors_count = 2; diff --git a/ext/opcache/Optimizer/zend_inference.c b/ext/opcache/Optimizer/zend_inference.c index f17d9e8b01..62a509dc6d 100644 --- a/ext/opcache/Optimizer/zend_inference.c +++ b/ext/opcache/Optimizer/zend_inference.c @@ -3164,7 +3164,6 @@ static int zend_update_type_info(const zend_op_array *op_array, break; } case ZEND_DECLARE_ANON_CLASS: - case ZEND_DECLARE_ANON_INHERITED_CLASS: UPDATE_SSA_TYPE(MAY_BE_CLASS, ssa_ops[i].result_def); if (script && (ce = zend_hash_find_ptr(&script->class_table, Z_STR_P(CRT_CONSTANT_EX(op_array, opline, opline->op1, ssa->rt_constants)))) != NULL) { UPDATE_SSA_OBJ_TYPE(ce, 0, ssa_ops[i].result_def); diff --git a/ext/opcache/Optimizer/zend_optimizer.c b/ext/opcache/Optimizer/zend_optimizer.c index 8b75ec7d49..1ed57ce3d8 100644 --- a/ext/opcache/Optimizer/zend_optimizer.c +++ b/ext/opcache/Optimizer/zend_optimizer.c @@ -773,7 +773,6 @@ void zend_optimizer_migrate_jump(zend_op_array *op_array, zend_op *new_opline, z ZEND_SET_OP_JMP_ADDR(new_opline, new_opline->op2, ZEND_OP2_JMP_ADDR(opline)); break; case ZEND_DECLARE_ANON_CLASS: - case ZEND_DECLARE_ANON_INHERITED_CLASS: case ZEND_FE_FETCH_R: case ZEND_FE_FETCH_RW: new_opline->extended_value = ZEND_OPLINE_NUM_TO_OFFSET(op_array, new_opline, ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, opline->extended_value)); @@ -824,7 +823,6 @@ void zend_optimizer_shift_jump(zend_op_array *op_array, zend_op *opline, uint32_ } break; case ZEND_DECLARE_ANON_CLASS: - case ZEND_DECLARE_ANON_INHERITED_CLASS: case ZEND_FE_FETCH_R: case ZEND_FE_FETCH_RW: opline->extended_value = ZEND_OPLINE_NUM_TO_OFFSET(op_array, opline, ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, opline->extended_value) - shiftlist[ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, opline->extended_value)]); @@ -1206,7 +1204,6 @@ static void zend_redo_pass_two(zend_op_array *op_array) } break; case ZEND_DECLARE_ANON_CLASS: - case ZEND_DECLARE_ANON_INHERITED_CLASS: case ZEND_FE_FETCH_R: case ZEND_FE_FETCH_RW: case ZEND_SWITCH_LONG: @@ -1295,7 +1292,6 @@ static void zend_redo_pass_two_ex(zend_op_array *op_array, zend_ssa *ssa) } break; case ZEND_DECLARE_ANON_CLASS: - case ZEND_DECLARE_ANON_INHERITED_CLASS: case ZEND_FE_FETCH_R: case ZEND_FE_FETCH_RW: case ZEND_SWITCH_LONG: diff --git a/ext/opcache/ZendAccelerator.c b/ext/opcache/ZendAccelerator.c index e90f91c2dc..1dd862fc3b 100644 --- a/ext/opcache/ZendAccelerator.c +++ b/ext/opcache/ZendAccelerator.c @@ -3623,7 +3623,7 @@ static void preload_link(void) } else { CG(zend_lineno) = ce->info.user.line_start; } - zend_do_link_class(ce, parent); + zend_do_link_class(ce); CG(in_compilation) = 0; CG(compiled_filename) = NULL; @@ -3726,8 +3726,7 @@ static void preload_link(void) while (opline != end) { switch (opline->opcode) { case ZEND_DECLARE_CLASS: - case ZEND_DECLARE_INHERITED_CLASS: - case ZEND_DECLARE_INHERITED_CLASS_DELAYED: + case ZEND_DECLARE_CLASS_DELAYED: key = Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1); if (!zend_hash_exists(&script->script.class_table, key)) { MAKE_NOP(opline); diff --git a/ext/opcache/jit/zend_jit.c b/ext/opcache/jit/zend_jit.c index c6849cd3ac..4b94f967bb 100644 --- a/ext/opcache/jit/zend_jit.c +++ b/ext/opcache/jit/zend_jit.c @@ -2510,7 +2510,6 @@ static int zend_jit(zend_op_array *op_array, zend_ssa *ssa, const zend_op *rt_op case ZEND_FE_FETCH_R: case ZEND_FE_FETCH_RW: case ZEND_DECLARE_ANON_CLASS: - case ZEND_DECLARE_ANON_INHERITED_CLASS: if (!zend_jit_handler(&dasm_state, opline, zend_may_throw(opline, op_array, ssa)) || !zend_jit_cond_jmp(&dasm_state, opline + 1, ssa->cfg.blocks[b].successors[0])) { goto jit_failure; diff --git a/ext/opcache/jit/zend_jit_x86.dasc b/ext/opcache/jit/zend_jit_x86.dasc index d74a350bf6..18bdb06e93 100644 --- a/ext/opcache/jit/zend_jit_x86.dasc +++ b/ext/opcache/jit/zend_jit_x86.dasc @@ -7156,7 +7156,6 @@ static int zend_jit_needs_call_chain(zend_call_info *call_info, uint32_t b, zend case ZEND_ASSERT_CHECK: case ZEND_CATCH: case ZEND_DECLARE_ANON_CLASS: - case ZEND_DECLARE_ANON_INHERITED_CLASS: case ZEND_FE_FETCH_R: case ZEND_FE_FETCH_RW: return 1; diff --git a/ext/opcache/zend_file_cache.c b/ext/opcache/zend_file_cache.c index f9c8fde5cc..a2fd2c4614 100644 --- a/ext/opcache/zend_file_cache.c +++ b/ext/opcache/zend_file_cache.c @@ -467,7 +467,6 @@ static void zend_file_cache_serialize_op_array(zend_op_array *op_arra } break; case ZEND_DECLARE_ANON_CLASS: - case ZEND_DECLARE_ANON_INHERITED_CLASS: case ZEND_FE_FETCH_R: case ZEND_FE_FETCH_RW: case ZEND_SWITCH_LONG: @@ -1185,7 +1184,6 @@ static void zend_file_cache_unserialize_op_array(zend_op_array *op_arr } break; case ZEND_DECLARE_ANON_CLASS: - case ZEND_DECLARE_ANON_INHERITED_CLASS: case ZEND_FE_FETCH_R: case ZEND_FE_FETCH_RW: case ZEND_SWITCH_LONG: diff --git a/ext/opcache/zend_persist.c b/ext/opcache/zend_persist.c index 16d07e689f..f4df9a301b 100644 --- a/ext/opcache/zend_persist.c +++ b/ext/opcache/zend_persist.c @@ -454,7 +454,6 @@ static void zend_persist_op_array_ex(zend_op_array *op_array, zend_persistent_sc } break; case ZEND_DECLARE_ANON_CLASS: - case ZEND_DECLARE_ANON_INHERITED_CLASS: case ZEND_FE_FETCH_R: case ZEND_FE_FETCH_RW: case ZEND_SWITCH_LONG: diff --git a/ext/spl/tests/bug73423.phpt b/ext/spl/tests/bug73423.phpt index 965b63318e..177da624be 100644 --- a/ext/spl/tests/bug73423.phpt +++ b/ext/spl/tests/bug73423.phpt @@ -68,15 +68,4 @@ foreach (new \RecursiveIteratorIterator (new fooIterator ($foo)) as $bar) ; ?> --EXPECTF-- -Fatal error: Uncaught Error: Class 'NotExists' not found in %sbug73423.php(%d) : eval()'d code:1 -Stack trace: -#0 %sbug73423.php(%d): eval() -#1 %sbug73423.php(%d): fooIterator->__destruct() -#2 {main} - -Next Error: Class 'NotExists' not found in %sbug73423.php(%d) : eval()'d code:1 -Stack trace: -#0 %sbug73423.php(%d): eval() -#1 %sbug73423.php(%d): fooIterator->__destruct() -#2 {main} - thrown in %sbug73423.php(%d) : eval()'d code on line 1 +Fatal error: Class 'NotExists' not found in %s(%d) : eval()'d code on line 1 diff --git a/sapi/phpdbg/phpdbg.c b/sapi/phpdbg/phpdbg.c index b9149287ba..2d9639de46 100644 --- a/sapi/phpdbg/phpdbg.c +++ b/sapi/phpdbg/phpdbg.c @@ -480,9 +480,9 @@ static PHP_FUNCTION(phpdbg_start_oplog) static zend_always_inline zend_bool phpdbg_is_ignored_opcode(zend_uchar opcode) { return opcode == ZEND_NOP || opcode == ZEND_OP_DATA || opcode == ZEND_FE_FREE || opcode == ZEND_FREE || opcode == ZEND_ASSERT_CHECK || opcode == ZEND_VERIFY_RETURN_TYPE - || opcode == ZEND_DECLARE_CONST || opcode == ZEND_DECLARE_CLASS || opcode == ZEND_DECLARE_INHERITED_CLASS || opcode == ZEND_DECLARE_FUNCTION - || opcode == ZEND_DECLARE_INHERITED_CLASS_DELAYED - || opcode == ZEND_DECLARE_ANON_CLASS || opcode == ZEND_DECLARE_ANON_INHERITED_CLASS || opcode == ZEND_FAST_RET || opcode == ZEND_TICKS + || opcode == ZEND_DECLARE_CONST || opcode == ZEND_DECLARE_CLASS || opcode == ZEND_DECLARE_FUNCTION + || opcode == ZEND_DECLARE_CLASS_DELAYED + || opcode == ZEND_DECLARE_ANON_CLASS || opcode == ZEND_FAST_RET || opcode == ZEND_TICKS || opcode == ZEND_EXT_STMT || opcode == ZEND_EXT_FCALL_BEGIN || opcode == ZEND_EXT_FCALL_END || opcode == ZEND_EXT_NOP || opcode == ZEND_BIND_GLOBAL ; } diff --git a/tests/classes/autoload_011.phpt b/tests/classes/autoload_011.phpt index 630cbf3208..aaea38c6f0 100644 --- a/tests/classes/autoload_011.phpt +++ b/tests/classes/autoload_011.phpt @@ -14,7 +14,4 @@ class C extends UndefBase --EXPECTF-- In autoload: string(9) "UndefBase" -Fatal error: Uncaught Error: Class 'UndefBase' not found in %s:%d -Stack trace: -#0 {main} - thrown in %sautoload_011.php on line %d +Fatal error: Class 'UndefBase' not found in %s on line %d diff --git a/tests/classes/bug75765.phpt b/tests/classes/bug75765.phpt index d24f62db80..213d514dea 100644 --- a/tests/classes/bug75765.phpt +++ b/tests/classes/bug75765.phpt @@ -13,10 +13,4 @@ try { ?> --EXPECTF-- -bool(false) -bool(false) - -Fatal error: Uncaught Error: Class 'B' not found in %sbug75765.php:%d -Stack trace: -#0 {main} - thrown in %sbug75765.php on line %d +Fatal error: Class 'B' not found in %s on line %d |