From 9ecc0a4f296cf5c72572e75a9734b40d941e2427 Mon Sep 17 00:00:00 2001 From: Joe Watkins Date: Tue, 11 Jun 2019 12:53:34 +0200 Subject: [PATCH 1/3] use XFAILIF rather than XFAIL to avoid warnings [ci skip] --- sapi/phpdbg/tests/watch_001.phpt | 8 ++++++-- sapi/phpdbg/tests/watch_002.phpt | 8 ++++++-- sapi/phpdbg/tests/watch_003.phpt | 8 ++++++-- sapi/phpdbg/tests/watch_004.phpt | 8 ++++++-- sapi/phpdbg/tests/watch_005.phpt | 8 ++++++-- sapi/phpdbg/tests/watch_006.phpt | 8 ++++++-- 6 files changed, 36 insertions(+), 12 deletions(-) diff --git a/sapi/phpdbg/tests/watch_001.phpt b/sapi/phpdbg/tests/watch_001.phpt index 17e27da81a8..05eb8331284 100644 --- a/sapi/phpdbg/tests/watch_001.phpt +++ b/sapi/phpdbg/tests/watch_001.phpt @@ -1,5 +1,11 @@ --TEST-- Test simple recursive watchpoint +--SKIPIF-- + --INI-- opcache.optimization_level=0 --PHPDBG-- @@ -45,5 +51,3 @@ $b = [$a]; unset($b); $b = 2; ---XFAIL-- -There may be flaws in the implementation of watchpoints that cause failures diff --git a/sapi/phpdbg/tests/watch_002.phpt b/sapi/phpdbg/tests/watch_002.phpt index 5d977635b27..c0d9536e9d1 100644 --- a/sapi/phpdbg/tests/watch_002.phpt +++ b/sapi/phpdbg/tests/watch_002.phpt @@ -1,5 +1,11 @@ --TEST-- Test simple array watchpoint with replace +--SKIPIF-- + --PHPDBG-- b 6 r @@ -30,5 +36,3 @@ $a[0] = 1; $a[0] = 2; $a = [0 => 3, 1 => 4]; ---XFAIL-- -There may be flaws in the implementation of watchpoints that cause failures diff --git a/sapi/phpdbg/tests/watch_003.phpt b/sapi/phpdbg/tests/watch_003.phpt index 173d9b2e44b..5bc560e7498 100644 --- a/sapi/phpdbg/tests/watch_003.phpt +++ b/sapi/phpdbg/tests/watch_003.phpt @@ -1,5 +1,11 @@ --TEST-- Test simple watchpoint with replace +--SKIPIF-- + --PHPDBG-- b 6 r @@ -37,5 +43,3 @@ $a[0] = 1; $a[0] = 2; $a = [0 => 3, 1 => 4]; ---XFAIL-- -There may be flaws in the implementation of watchpoints that cause failures diff --git a/sapi/phpdbg/tests/watch_004.phpt b/sapi/phpdbg/tests/watch_004.phpt index 2781fbe30ac..e21c1dceb6b 100644 --- a/sapi/phpdbg/tests/watch_004.phpt +++ b/sapi/phpdbg/tests/watch_004.phpt @@ -1,5 +1,11 @@ --TEST-- Test detection of inline string manipulations on zval watch +--SKIPIF-- + --INI-- opcache.optimization_level=0 --PHPDBG-- @@ -36,5 +42,3 @@ prompt> $b = "a"; $a = $b.$b; $a[1] = "b"; ---XFAIL-- -There may be flaws in the implementation of watchpoints that cause failures diff --git a/sapi/phpdbg/tests/watch_005.phpt b/sapi/phpdbg/tests/watch_005.phpt index c36b519e79a..7d479b5548f 100644 --- a/sapi/phpdbg/tests/watch_005.phpt +++ b/sapi/phpdbg/tests/watch_005.phpt @@ -1,5 +1,11 @@ --TEST-- Test proper watch comparisons when having multiple levels of indirection from a zval to its value +--SKIPIF-- + --PHPDBG-- b 3 r @@ -46,5 +52,3 @@ $c = &$a; $a[1] = "b"; exit; ---XFAIL-- -There may be flaws in the implementation of watchpoints that cause failures diff --git a/sapi/phpdbg/tests/watch_006.phpt b/sapi/phpdbg/tests/watch_006.phpt index bfcfca5fd2d..f9a1f2c86cc 100644 --- a/sapi/phpdbg/tests/watch_006.phpt +++ b/sapi/phpdbg/tests/watch_006.phpt @@ -1,5 +1,11 @@ --TEST-- Test multiple watch elements pointing to the same watchpoint +--SKIPIF-- + --PHPDBG-- b 4 r @@ -69,5 +75,3 @@ $a[0] = 2; $a[1] = 3; $c = [1]; $b = &$c; ---XFAIL-- -There may be flaws in the implementation of watchpoints that cause failures From 89b2d88659b8a561769f51dfab1fa325e7fc0603 Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Fri, 24 May 2019 14:28:44 +0200 Subject: [PATCH 2/3] Register class before fetching parent We want the class declaration to be available while compiling the parent class. --- Zend/zend_compile.c | 41 +- Zend/zend_compile.h | 6 +- Zend/zend_inheritance.c | 5 +- Zend/zend_inheritance.h | 2 +- Zend/zend_opcode.c | 2 - Zend/zend_vm_def.h | 63 +- Zend/zend_vm_execute.h | 273 ++-- Zend/zend_vm_handlers.h | 1460 +++++++++++----------- Zend/zend_vm_opcodes.c | 12 +- Zend/zend_vm_opcodes.h | 410 +++--- ext/opcache/Optimizer/block_pass.c | 1 - ext/opcache/Optimizer/compact_literals.c | 10 +- ext/opcache/Optimizer/dfa_pass.c | 1 - ext/opcache/Optimizer/sccp.c | 5 +- ext/opcache/Optimizer/zend_cfg.c | 2 - ext/opcache/Optimizer/zend_inference.c | 1 - ext/opcache/Optimizer/zend_optimizer.c | 4 - ext/opcache/ZendAccelerator.c | 5 +- ext/opcache/zend_file_cache.c | 2 - ext/opcache/zend_persist.c | 1 - ext/spl/tests/bug73423.phpt | 13 +- sapi/phpdbg/phpdbg.c | 6 +- tests/classes/autoload_011.phpt | 5 +- tests/classes/bug75765.phpt | 8 +- 24 files changed, 1077 insertions(+), 1261 deletions(-) diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index 7023f3a5896..aa7125cfe1f 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -1043,7 +1043,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; @@ -1070,7 +1070,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; } /* }}} */ @@ -1113,7 +1113,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; } @@ -1136,11 +1136,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; } @@ -6437,15 +6436,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 */ @@ -6461,22 +6454,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 7745daf47ea..3f2ec6ba07b 100644 --- a/Zend/zend_compile.h +++ b/Zend/zend_compile.h @@ -291,7 +291,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 | | */ /* | | | */ /* method flag (bc only), any method that has this | | | */ @@ -745,7 +745,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); @@ -1032,7 +1032,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_inheritance.c b/Zend/zend_inheritance.c index 8541a22df0a..738e528308d 100644 --- a/Zend/zend_inheritance.c +++ b/Zend/zend_inheritance.c @@ -2130,10 +2130,11 @@ void zend_verify_abstract_class(zend_class_entry *ce) /* {{{ */ } /* }}} */ -ZEND_API void zend_do_link_class(zend_class_entry *ce, zend_class_entry *parent) /* {{{ */ +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, 0); zend_do_inheritance(ce, parent); } if (ce->ce_flags & ZEND_ACC_IMPLEMENT_TRAITS) { diff --git a/Zend/zend_inheritance.h b/Zend/zend_inheritance.h index a35a4c66389..e2e37b82529 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_check_deprecated_constructor(const zend_class_entry *ce); diff --git a/Zend/zend_opcode.c b/Zend/zend_opcode.c index 980b40b5868..ae70dee0ce0 100644 --- a/Zend/zend_opcode.c +++ b/Zend/zend_opcode.c @@ -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_vm_def.h b/Zend/zend_vm_def.h index bfcd715aece..2745908ac24 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -7026,45 +7026,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(); } @@ -7085,36 +7060,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(); } @@ -7310,7 +7256,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 1394bde30b2..dff34587ff5 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -2116,7 +2116,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(); } @@ -2263,7 +2263,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: @@ -4028,7 +4027,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(); } @@ -6136,74 +6149,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 @@ -54130,7 +54075,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, @@ -54138,7 +54082,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, @@ -54493,7 +54437,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, @@ -56153,6 +56096,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); @@ -56377,18 +56324,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); @@ -63849,7 +63784,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, @@ -63857,7 +63791,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, @@ -64212,7 +64146,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, @@ -65474,37 +65407,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, @@ -65513,37 +65448,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; @@ -65750,7 +65683,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); } @@ -65758,7 +65691,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); } @@ -65766,7 +65699,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); } @@ -65777,17 +65710,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: @@ -65798,17 +65731,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: @@ -65819,12 +65752,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: @@ -65835,12 +65768,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: @@ -65848,12 +65781,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: @@ -65861,75 +65794,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: @@ -65937,17 +65870,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 0627d201b60..a8aae733fd8 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 6496f544024..70d9fbcc194 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 ce2e020bc7e..67fb30fbc97 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 8ed75e65d59..e0d44dd5cc2 100644 --- a/ext/opcache/Optimizer/block_pass.c +++ b/ext/opcache/Optimizer/block_pass.c @@ -1001,7 +1001,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 a841563f842..ad5497f8d40 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 7cffa45ddbc..c9528918e3c 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 0c336b67afd..ab202d2ead0 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: @@ -1951,7 +1949,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 489a3f1f7e0..d956f6dfbd4 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 0fbeb39a44a..28e0128bd15 100644 --- a/ext/opcache/Optimizer/zend_inference.c +++ b/ext/opcache/Optimizer/zend_inference.c @@ -3166,7 +3166,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 dceb8c9fd9c..bf7aa614d48 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)]); @@ -1212,7 +1210,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: @@ -1301,7 +1298,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 d75d1766302..016fc4c1d55 100644 --- a/ext/opcache/ZendAccelerator.c +++ b/ext/opcache/ZendAccelerator.c @@ -3569,7 +3569,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; @@ -3672,8 +3672,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/zend_file_cache.c b/ext/opcache/zend_file_cache.c index 9cd48ed26aa..816acf15d99 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: @@ -1178,7 +1177,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 f32644f4c60..f5e1c457383 100644 --- a/ext/opcache/zend_persist.c +++ b/ext/opcache/zend_persist.c @@ -450,7 +450,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 965b63318e1..177da624bed 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 b9149287bae..2d9639de464 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 630cbf3208f..aaea38c6f0e 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 d24f62db805..213d514dea5 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 From 8f8fcbbd397370b407dc2552c4bd6ee4ccb0e93b Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Mon, 27 May 2019 11:39:56 +0200 Subject: [PATCH 3/3] Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state. --- UPGRADING | 4 +- Zend/tests/bug30922.phpt | 2 +- .../variance/class_order_autoload1.phpt | 37 ++ .../variance/class_order_autoload2.phpt | 38 ++ .../variance/class_order_autoload3.phpt | 45 +++ .../variance/class_order_autoload4.phpt | 44 +++ .../variance/class_order_autoload5.phpt | 60 +++ ....phpt => class_order_autoload_error1.phpt} | 10 +- .../variance/class_order_autoload_error2.phpt | 27 ++ .../variance/class_order_autoload_error3.phpt | 38 ++ .../variance/class_order_autoload_error4.phpt | 39 ++ .../variance/class_order_autoload_error5.phpt | 52 +++ .../variance/class_order_autoload_error6.phpt | 39 ++ ...lass_order.phpt => class_order_error.phpt} | 0 Zend/zend_API.c | 2 +- Zend/zend_compile.c | 14 + Zend/zend_compile.h | 11 +- Zend/zend_execute_API.c | 4 +- Zend/zend_globals.h | 3 + Zend/zend_inheritance.c | 350 +++++++++++++++--- Zend/zend_interfaces.c | 4 +- Zend/zend_opcode.c | 4 +- Zend/zend_operators.c | 4 +- 23 files changed, 762 insertions(+), 69 deletions(-) create mode 100644 Zend/tests/type_declarations/variance/class_order_autoload1.phpt create mode 100644 Zend/tests/type_declarations/variance/class_order_autoload2.phpt create mode 100644 Zend/tests/type_declarations/variance/class_order_autoload3.phpt create mode 100644 Zend/tests/type_declarations/variance/class_order_autoload4.phpt create mode 100644 Zend/tests/type_declarations/variance/class_order_autoload5.phpt rename Zend/tests/type_declarations/variance/{class_order_autoload.phpt => class_order_autoload_error1.phpt} (59%) create mode 100644 Zend/tests/type_declarations/variance/class_order_autoload_error2.phpt create mode 100644 Zend/tests/type_declarations/variance/class_order_autoload_error3.phpt create mode 100644 Zend/tests/type_declarations/variance/class_order_autoload_error4.phpt create mode 100644 Zend/tests/type_declarations/variance/class_order_autoload_error5.phpt create mode 100644 Zend/tests/type_declarations/variance/class_order_autoload_error6.phpt rename Zend/tests/type_declarations/variance/{class_order.phpt => class_order_error.phpt} (100%) diff --git a/UPGRADING b/UPGRADING index 6c610858342..eceb9b6f0ad 100644 --- a/UPGRADING +++ b/UPGRADING @@ -163,7 +163,9 @@ PHP 7.4 UPGRADE NOTES public function method(): B {} } - This feature is currently restricted to non-cyclic type references only. + Full variance support is only available if autoloading is used. Inside a + single file only non-cyclic type references are possible, because all + classes need to be available before they are referenced. RFC: https://wiki.php.net/rfc/covariant-returns-and-contravariant-parameters . Added support for coalesce assign (??=) operator. For example: diff --git a/Zend/tests/bug30922.phpt b/Zend/tests/bug30922.phpt index 0d5d8ae8385..001845a7cb3 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 00000000000..d68d2e8afaf --- /dev/null +++ b/Zend/tests/type_declarations/variance/class_order_autoload1.phpt @@ -0,0 +1,37 @@ +--TEST-- +Class order allowed with autoloading (1) +--FILE-- + +===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 00000000000..f6229d39958 --- /dev/null +++ b/Zend/tests/type_declarations/variance/class_order_autoload2.phpt @@ -0,0 +1,38 @@ +--TEST-- +Class order allowed with autoloading (2) +--FILE-- + +===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 00000000000..d09f2a9c45b --- /dev/null +++ b/Zend/tests/type_declarations/variance/class_order_autoload3.phpt @@ -0,0 +1,45 @@ +--TEST-- +Class order allowed with autoloading (3) +--FILE-- + +===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 00000000000..37070b444c6 --- /dev/null +++ b/Zend/tests/type_declarations/variance/class_order_autoload4.phpt @@ -0,0 +1,44 @@ +--TEST-- +Class order allowed with autoloading (4) +--FILE-- + +===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 00000000000..77e9a0a9ec5 --- /dev/null +++ b/Zend/tests/type_declarations/variance/class_order_autoload5.phpt @@ -0,0 +1,60 @@ +--TEST-- +Class order allowed with autoloading (5) +--FILE-- + +===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 similarity index 59% rename from Zend/tests/type_declarations/variance/class_order_autoload.phpt rename to Zend/tests/type_declarations/variance/class_order_autoload_error1.phpt index a4ea534577f..9af40416041 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-- --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 00000000000..48d2e0b9561 --- /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-- + +--EXPECTF-- +Warning: Declaration of B::method(C $x) should 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 00000000000..23b60b4584f --- /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-- + +--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 00000000000..6acf9313f4d --- /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-- + +--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 00000000000..a6a46f84a23 --- /dev/null +++ b/Zend/tests/type_declarations/variance/class_order_autoload_error5.phpt @@ -0,0 +1,52 @@ +--TEST-- +Variance error in the presence of autoloading (5) +--FILE-- + +--EXPECTF-- +object(A)#2 (0) { +} +object(X)#2 (0) { +} + +Warning: Declaration of Y::method(Z $a) should be compatible with X::method(Y $a) in %s on line %d +object(Z)#2 (0) { +} +object(Y)#2 (0) { +} +object(B)#2 (0) { +} +object(B)#2 (0) { +} 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 00000000000..4b54c9554dc --- /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-- + +--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 similarity index 100% rename from Zend/tests/type_declarations/variance/class_order.phpt rename to Zend/tests/type_declarations/variance/class_order_error.phpt diff --git a/Zend/zend_API.c b/Zend/zend_API.c index f88fc2caf83..13c661699fa 100644 --- a/Zend/zend_API.c +++ b/Zend/zend_API.c @@ -2649,7 +2649,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 aa7125cfe1f..85c0bf8cd5a 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; + } } /* }}} */ diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h index 3f2ec6ba07b..b47d762a748 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) | | | */ /* ============== | | | */ @@ -852,6 +858,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) diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c index 431031acba8..e0cc560d4be 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 #endif @@ -916,7 +917,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 c95faef22b6..d88fdabcf7f 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 738e528308d..ba1612c189c 100644 --- a/Zend/zend_inheritance.c +++ b/Zend/zend_inheritance.c @@ -26,6 +26,11 @@ #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, + zend_bool always_error); + static void overridden_ptr_dtor(zval *zv) /* {{{ */ { efree_size(Z_PTR_P(zv), sizeof(zend_function)); @@ -174,7 +179,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 +204,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 +309,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 +489,17 @@ 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, zend_bool always_error) { + inheritance_status status = zend_do_perform_implementation_check( + unresolved_class, fe, proto); + if (status == INHERITANCE_UNRESOLVED) { + add_compatibility_obligation(ce, fe, proto, always_error); + } + 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 +661,13 @@ 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( - int error_level, const char *error_verb, zend_function *child, zend_function *parent, + int error_level, const char *error_verb, + 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); @@ -623,6 +684,28 @@ static void ZEND_COLD emit_incompatible_method_error( zend_string_efree(parent_prototype); } +static void ZEND_COLD emit_incompatible_method_error_or_warning( + const zend_function *child, const zend_function *parent, + inheritance_status status, zend_string *unresolved_class, zend_bool always_error) { + int error_level; + const char *error_verb; + if (always_error || + (child->common.prototype && + (child->common.prototype->common.fn_flags & ZEND_ACC_ABSTRACT)) || + ((parent->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) && + (!(child->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) || + zend_perform_covariant_type_check(&unresolved_class, child, child->common.arg_info - 1, parent, parent->common.arg_info - 1) != INHERITANCE_SUCCESS)) + ) { + error_level = E_COMPILE_ERROR; + error_verb = "must"; + } else { + error_level = E_WARNING; + error_verb = "should"; + } + emit_incompatible_method_error( + error_level, error_verb, child, parent, status, unresolved_class); +} + static void do_inheritance_check_on_method(zend_function *child, zend_function *parent, zend_class_entry *ce, zval *child_zv) /* {{{ */ { uint32_t child_flags; @@ -707,26 +790,11 @@ 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 (UNEXPECTED(status != INHERITANCE_SUCCESS)) { - int error_level; - const char *error_verb; - if (child->common.prototype && ( - child->common.prototype->common.fn_flags & ZEND_ACC_ABSTRACT - )) { - error_level = E_COMPILE_ERROR; - error_verb = "must"; - } else if ((parent->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) && - (!(child->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) || - zend_perform_covariant_type_check(&unresolved_class, child, child->common.arg_info - 1, parent, parent->common.arg_info - 1) != INHERITANCE_SUCCESS)) { - error_level = E_COMPILE_ERROR; - error_verb = "must"; - } else { - error_level = E_WARNING; - error_verb = "should"; - } - emit_incompatible_method_error( - error_level, error_verb, child, parent, status, unresolved_class); + status = perform_delayable_implementation_check( + &unresolved_class, ce, child, parent, /*always_error*/0); + if (status == INHERITANCE_ERROR) { + emit_incompatible_method_error_or_warning( + child, parent, status, unresolved_class, /*always_error*/0); } } } while (0); @@ -904,6 +972,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) { @@ -1005,6 +1074,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) { @@ -1314,10 +1384,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); @@ -1354,6 +1425,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++) { @@ -1454,18 +1526,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, /*always_error*/ 1); + if (status == INHERITANCE_ERROR) { emit_incompatible_method_error( E_COMPILE_ERROR, "must", 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, /*always_error*/ 1); + if (status == INHERITANCE_ERROR) { emit_incompatible_method_error( E_COMPILE_ERROR, "must", existing_fn, fn, status, unresolved_class); } @@ -1481,15 +1553,17 @@ 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, /*always_error*/ 1); + if (status == INHERITANCE_ERROR) { emit_incompatible_method_error( E_COMPILE_ERROR, "must", 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, /*always_error*/ 1); + if (status == INHERITANCE_ERROR) { emit_incompatible_method_error( E_COMPILE_ERROR, "must", existing_fn, fn, status, unresolved_class); } @@ -2130,11 +2204,172 @@ void zend_verify_abstract_class(zend_class_entry *ce) /* {{{ */ } /* }}} */ +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; + zend_bool always_error; + }; + }; +} 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, + zend_bool always_error) { + 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; + obligation->always_error = always_error; + 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_or_warning( + obligation->child_fn, obligation->parent_fn, status, unresolved_class, + obligation->always_error); + } + /* 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_or_warning( + obligation->child_fn, obligation->parent_fn, + status, unresolved_class, obligation->always_error); + } 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 (ce->parent_name) { - zend_class_entry *parent = zend_fetch_class_by_name(ce->parent_name, NULL, 0); + 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) { @@ -2148,8 +2383,19 @@ ZEND_API void zend_do_link_class(zend_class_entry *ce) /* {{{ */ } 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_interfaces.c b/Zend/zend_interfaces.c index 4d58a9898a2..ff6784be31b 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 ae70dee0ce0..6c8ff85b10c 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++) { diff --git a/Zend/zend_operators.c b/Zend/zend_operators.c index a2da9d1fe3f..6033fafebe1 100644 --- a/Zend/zend_operators.c +++ b/Zend/zend_operators.c @@ -2303,7 +2303,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; @@ -2331,7 +2331,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;