From 6a73552074759232e0fdd8b2c0a8f0c8c30fea46 Mon Sep 17 00:00:00 2001 From: Levi Morrison Date: Fri, 10 Jul 2020 12:09:13 -0600 Subject: [PATCH 01/53] Add zend_observer API --- Zend/zend.c | 7 +++ Zend/zend_closures.c | 2 + Zend/zend_execute.c | 5 +++ Zend/zend_execute_API.c | 7 +++ Zend/zend_observer.c | 98 +++++++++++++++++++++++++++++++++++++++++ Zend/zend_observer.h | 54 +++++++++++++++++++++++ Zend/zend_vm_def.h | 36 +++++++++++++++ Zend/zend_vm_execute.h | 72 ++++++++++++++++++++++++++++++ configure.ac | 3 +- main/main.c | 4 ++ win32/build/config.w32 | 2 +- 11 files changed, 288 insertions(+), 2 deletions(-) create mode 100644 Zend/zend_observer.c create mode 100644 Zend/zend_observer.h diff --git a/Zend/zend.c b/Zend/zend.c index 2765f8c3ead22..8012fb8c07c14 100644 --- a/Zend/zend.c +++ b/Zend/zend.c @@ -1170,6 +1170,10 @@ ZEND_API const char *get_zend_version(void) /* {{{ */ } /* }}} */ + +ZEND_API void zend_observer_activate(void); +ZEND_API void zend_observer_deactivate(void); + ZEND_API void zend_activate(void) /* {{{ */ { #ifdef ZTS @@ -1182,6 +1186,7 @@ ZEND_API void zend_activate(void) /* {{{ */ if (CG(map_ptr_last)) { memset(ZEND_MAP_PTR_REAL_BASE(CG(map_ptr_base)), 0, CG(map_ptr_last) * sizeof(void*)); } + zend_observer_activate(); } /* }}} */ @@ -1198,6 +1203,8 @@ ZEND_API void zend_deactivate(void) /* {{{ */ /* we're no longer executing anything */ EG(current_execute_data) = NULL; + zend_observer_deactivate(); + zend_try { shutdown_scanner(); } zend_end_try(); diff --git a/Zend/zend_closures.c b/Zend/zend_closures.c index 6acd1e48182b8..ff83d3ba487c8 100644 --- a/Zend/zend_closures.c +++ b/Zend/zend_closures.c @@ -25,6 +25,7 @@ #include "zend_interfaces.h" #include "zend_objects.h" #include "zend_objects_API.h" +#include "zend_observer.h" #include "zend_globals.h" #include "zend_closures_arginfo.h" @@ -693,6 +694,7 @@ ZEND_API void zend_create_closure(zval *res, zend_function *func, zend_class_ent ZEND_MAP_PTR_SET(closure->func.op_array.run_time_cache, ptr); } memset(ptr, 0, func->op_array.cache_size); + zend_observer_fcall_install(&closure->func); } zend_string_addref(closure->func.op_array.function_name); if (closure->func.op_array.refcount) { diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c index b7dce3614cb61..ac435c9f51400 100644 --- a/Zend/zend_execute.c +++ b/Zend/zend_execute.c @@ -35,11 +35,13 @@ #include "zend_interfaces.h" #include "zend_closures.h" #include "zend_generators.h" +#include "zend_observer.h" #include "zend_vm.h" #include "zend_dtrace.h" #include "zend_inheritance.h" #include "zend_type_info.h" #include "zend_smart_str.h" +#include "zend_observer.h" /* Virtual current working directory support */ #include "zend_virtual_cwd.h" @@ -3550,6 +3552,7 @@ static zend_always_inline void init_func_run_time_cache_i(zend_op_array *op_arra run_time_cache = zend_arena_alloc(&CG(arena), op_array->cache_size); memset(run_time_cache, 0, op_array->cache_size); ZEND_MAP_PTR_SET(op_array->run_time_cache, run_time_cache); + zend_observer_fcall_install((zend_function*) op_array); } /* }}} */ @@ -3615,6 +3618,8 @@ static zend_always_inline void i_init_code_execute_data(zend_execute_data *execu ptr = (char*)ptr + sizeof(void*); ZEND_MAP_PTR_SET(op_array->run_time_cache, ptr); memset(ptr, 0, op_array->cache_size); + + zend_observer_fcall_install((zend_function*)op_array); } EX(run_time_cache) = RUN_TIME_CACHE(op_array); diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c index 998eb495dc511..7f1c8f8774777 100644 --- a/Zend/zend_execute_API.c +++ b/Zend/zend_execute_API.c @@ -35,6 +35,7 @@ #include "zend_float.h" #include "zend_weakrefs.h" #include "zend_inheritance.h" +#include "zend_observer.h" #ifdef HAVE_SYS_TIME_H #include #endif @@ -782,6 +783,12 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache) / uint32_t orig_jit_trace_num = EG(jit_trace_num); zend_init_func_execute_data(call, &func->op_array, fci->retval); + if (zend_observer_fcall_op_array_extension != -1 && !(func->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE))) { + void *observer_handlers = ZEND_OP_ARRAY_EXTENSION(&func->op_array, zend_observer_fcall_op_array_extension); + if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { + zend_observe_fcall_begin(observer_handlers, call); + } + } zend_execute_ex(call); EG(jit_trace_num) = orig_jit_trace_num; EG(opline_before_exception) = current_opline_before_exception; diff --git a/Zend/zend_observer.c b/Zend/zend_observer.c new file mode 100644 index 0000000000000..688646a2414aa --- /dev/null +++ b/Zend/zend_observer.c @@ -0,0 +1,98 @@ +#include "zend_observer.h" + +#include "zend_extensions.h" +#include "zend_llist.h" + +zend_llist zend_observers_fcall_list; +int zend_observer_fcall_op_array_extension = -1; + +ZEND_TLS zend_arena *fcall_handlers_arena = NULL; + +// Call during minit/startup ONLY +ZEND_API void zend_observer_fcall_register(zend_observer_fcall_init init) { + /* We don't want to get an extension handle unless an ext installs an observer */ + if (zend_observer_fcall_op_array_extension == -1) { + zend_observer_fcall_op_array_extension = zend_get_op_array_extension_handle(); + } + zend_llist_add_element(&zend_observers_fcall_list, &init); +} + +// Called by engine before MINITs +ZEND_API void zend_observer_startup(void) { + zend_llist_init(&zend_observers_fcall_list, sizeof(zend_observer_fcall_init), NULL, 1); +} + +ZEND_API void zend_observer_activate(void) { + /* todo: how to size the arena? */ + if (zend_observer_fcall_op_array_extension != -1) { + fcall_handlers_arena = zend_arena_create(1024); + } +} + +ZEND_API void zend_observer_deactivate(void) { + if (fcall_handlers_arena) { + zend_arena_destroy(fcall_handlers_arena); + } +} + +ZEND_API void zend_observer_shutdown(void) { + zend_llist_destroy(&zend_observers_fcall_list); +} + +ZEND_API void zend_observer_fcall_install(zend_function *function) { + zend_llist_element *element; + zend_llist *list = &zend_observers_fcall_list; + zend_op_array *op_array = &function->op_array; + + if (fcall_handlers_arena == NULL) { + return; + } + + ZEND_ASSERT(function->type != ZEND_INTERNAL_FUNCTION); + + zend_llist handlers_list; + zend_llist_init(&handlers_list, sizeof(zend_observer_fcall), NULL, 0); + for (element = list->head; element; element = element->next) { + zend_observer_fcall_init init; + memcpy(&init, element->data, sizeof init); + zend_observer_fcall handlers = init(function); + if (handlers.begin || handlers.end) { + zend_llist_add_element(&handlers_list, &handlers); + } + } + + ZEND_ASSERT(RUN_TIME_CACHE(op_array)); + void *ext; + if (handlers_list.count) { + size_t size = sizeof(zend_observer_fcall_cache) + (handlers_list.count - 1) * sizeof(zend_observer_fcall); + zend_observer_fcall_cache *cache = zend_arena_alloc(&fcall_handlers_arena, size); + zend_observer_fcall *handler = cache->handlers; + for (element = handlers_list.head; element; element = element->next) { + memcpy(handler++, element->data, sizeof *handler); + } + cache->end = handler; + ext = cache; + } else { + ext = ZEND_OBSERVER_NOT_OBSERVED; + } + + ZEND_OP_ARRAY_EXTENSION(op_array, zend_observer_fcall_op_array_extension) = ext; + zend_llist_destroy(&handlers_list); +} + +void zend_observe_fcall_begin( + zend_observer_fcall_cache *cache, + zend_execute_data *execute_data) +{ + zend_observer_fcall *handler, *end = cache->end; + for (handler = cache->handlers; handler != end; ++handler) { + handler->begin(execute_data); + } +} + +void zend_observe_fcall_end( + zend_observer_fcall_cache *cache, + zend_execute_data *execute_data, + zval *return_value) {} + + diff --git a/Zend/zend_observer.h b/Zend/zend_observer.h new file mode 100644 index 0000000000000..c474c14f80097 --- /dev/null +++ b/Zend/zend_observer.h @@ -0,0 +1,54 @@ +// todo: license garbage + +#ifndef ZEND_OBSERVER_H +#define ZEND_OBSERVER_H + +#include "php.h" +#include "zend_llist.h" + +BEGIN_EXTERN_C() + +extern int zend_observer_fcall_op_array_extension; + +#define ZEND_OBSERVER_NOT_OBSERVED ((void *) 2) + +struct zend_observer_fcall { + void (*begin)(zend_execute_data *execute_data); + void (*end)(zend_execute_data *execute_data, zval *retval); +}; +typedef struct zend_observer_fcall zend_observer_fcall; + +struct zend_observer_fcall_cache { + // points after the last handler + zend_observer_fcall *end; + // a variadic array using "struct hack" + zend_observer_fcall handlers[1]; +}; +typedef struct zend_observer_fcall_cache zend_observer_fcall_cache; + +/* If the fn should not be observed then return {NULL, NULL} */ +typedef zend_observer_fcall(*zend_observer_fcall_init)(zend_function *func); + +// Call during minit/startup ONLY +ZEND_API void zend_observer_fcall_register(zend_observer_fcall_init init); + +ZEND_API void zend_observer_startup(void); // Called by engine before MINITs +ZEND_API void zend_observer_activate(void); +ZEND_API void zend_observer_deactivate(void); +ZEND_API void zend_observer_shutdown(void); + +ZEND_API void zend_observer_fcall_install(zend_function *function); + +void zend_observe_fcall_begin( + zend_observer_fcall_cache *cache, + zend_execute_data *execute_data); + +void zend_observe_fcall_end( + zend_observer_fcall_cache *cache, + zend_execute_data *execute_data, + zval *return_value); + + +END_EXTERN_C() + +#endif /* ZEND_OBSERVER_H */ diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 10266f479222f..477ad6d442d40 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -3929,6 +3929,14 @@ ZEND_VM_HOT_HANDLER(130, ZEND_DO_UCALL, ANY, ANY, SPEC(RETVAL)) call->prev_execute_data = execute_data; execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); + + if (zend_observer_fcall_op_array_extension != -1 && !(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE))) { + void *observer_handlers = ZEND_OP_ARRAY_EXTENSION(&fbc->op_array, zend_observer_fcall_op_array_extension); + if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { + zend_observe_fcall_begin(observer_handlers, call); + } + } + LOAD_OPLINE_EX(); ZEND_VM_ENTER_EX(); @@ -3953,6 +3961,14 @@ ZEND_VM_HOT_HANDLER(131, ZEND_DO_FCALL_BY_NAME, ANY, ANY, SPEC(RETVAL)) call->prev_execute_data = execute_data; execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); + + if (zend_observer_fcall_op_array_extension != -1 && !(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE))) { + void *observer_handlers = ZEND_OP_ARRAY_EXTENSION(&fbc->op_array, zend_observer_fcall_op_array_extension); + if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { + zend_observe_fcall_begin(observer_handlers, call); + } + } + LOAD_OPLINE_EX(); ZEND_VM_ENTER_EX(); @@ -4035,6 +4051,14 @@ ZEND_VM_HOT_HANDLER(60, ZEND_DO_FCALL, ANY, ANY, SPEC(RETVAL)) execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 1 EXECUTE_DATA_CC); + if (zend_observer_fcall_op_array_extension != -1) { + void *observer_handlers = ZEND_OP_ARRAY_EXTENSION(&fbc->op_array, zend_observer_fcall_op_array_extension); + ZEND_ASSERT(observer_handlers); + if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { + zend_observe_fcall_begin(observer_handlers, call); + } + } + if (EXPECTED(zend_execute_ex == execute_ex)) { LOAD_OPLINE_EX(); ZEND_VM_ENTER_EX(); @@ -5874,6 +5898,12 @@ ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMPVAR|CV, ANY, EVAL) call->prev_execute_data = execute_data; i_init_code_execute_data(call, new_op_array, return_value); + + if (zend_observer_fcall_op_array_extension != -1) { + void *observer_handlers = ZEND_OP_ARRAY_EXTENSION(new_op_array, zend_observer_fcall_op_array_extension); + ZEND_ASSERT(observer_handlers); + } + if (EXPECTED(zend_execute_ex == execute_ex)) { ZEND_VM_ENTER(); } else { @@ -8124,6 +8154,12 @@ ZEND_VM_HANDLER(158, ZEND_CALL_TRAMPOLINE, ANY, ANY) } execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); + + if (zend_observer_fcall_op_array_extension != -1) { + void *observer_handlers = ZEND_OP_ARRAY_EXTENSION(&fbc->op_array, zend_observer_fcall_op_array_extension); + ZEND_ASSERT(observer_handlers); + } + if (EXPECTED(zend_execute_ex == execute_ex)) { LOAD_OPLINE_EX(); ZEND_VM_ENTER_EX(); diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index de4b37e9c37b9..a24a0d378bdf5 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -1324,6 +1324,14 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_RETV call->prev_execute_data = execute_data; execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); + + if (zend_observer_fcall_op_array_extension != -1 && !(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE))) { + void *observer_handlers = ZEND_OP_ARRAY_EXTENSION(&fbc->op_array, zend_observer_fcall_op_array_extension); + if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { + zend_observe_fcall_begin(observer_handlers, call); + } + } + LOAD_OPLINE_EX(); ZEND_VM_ENTER_EX(); @@ -1347,6 +1355,14 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_RETV call->prev_execute_data = execute_data; execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); + + if (zend_observer_fcall_op_array_extension != -1 && !(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE))) { + void *observer_handlers = ZEND_OP_ARRAY_EXTENSION(&fbc->op_array, zend_observer_fcall_op_array_extension); + if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { + zend_observe_fcall_begin(observer_handlers, call); + } + } + LOAD_OPLINE_EX(); ZEND_VM_ENTER_EX(); @@ -1371,6 +1387,14 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_S call->prev_execute_data = execute_data; execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); + + if (zend_observer_fcall_op_array_extension != -1 && !(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE))) { + void *observer_handlers = ZEND_OP_ARRAY_EXTENSION(&fbc->op_array, zend_observer_fcall_op_array_extension); + if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { + zend_observe_fcall_begin(observer_handlers, call); + } + } + LOAD_OPLINE_EX(); ZEND_VM_ENTER_EX(); @@ -1452,6 +1476,14 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_S call->prev_execute_data = execute_data; execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); + + if (zend_observer_fcall_op_array_extension != -1 && !(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE))) { + void *observer_handlers = ZEND_OP_ARRAY_EXTENSION(&fbc->op_array, zend_observer_fcall_op_array_extension); + if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { + zend_observe_fcall_begin(observer_handlers, call); + } + } + LOAD_OPLINE_EX(); ZEND_VM_ENTER_EX(); @@ -1534,6 +1566,14 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETV execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 1 EXECUTE_DATA_CC); + if (zend_observer_fcall_op_array_extension != -1) { + void *observer_handlers = ZEND_OP_ARRAY_EXTENSION(&fbc->op_array, zend_observer_fcall_op_array_extension); + ZEND_ASSERT(observer_handlers); + if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { + zend_observe_fcall_begin(observer_handlers, call); + } + } + if (EXPECTED(zend_execute_ex == execute_ex)) { LOAD_OPLINE_EX(); ZEND_VM_ENTER_EX(); @@ -1632,6 +1672,14 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETV execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 1 EXECUTE_DATA_CC); + if (zend_observer_fcall_op_array_extension != -1) { + void *observer_handlers = ZEND_OP_ARRAY_EXTENSION(&fbc->op_array, zend_observer_fcall_op_array_extension); + ZEND_ASSERT(observer_handlers); + if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { + zend_observe_fcall_begin(observer_handlers, call); + } + } + if (EXPECTED(zend_execute_ex == execute_ex)) { LOAD_OPLINE_EX(); ZEND_VM_ENTER_EX(); @@ -2744,6 +2792,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CALL_TRAMPOLINE_SPEC_HANDLER(Z } execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); + + if (zend_observer_fcall_op_array_extension != -1) { + void *observer_handlers = ZEND_OP_ARRAY_EXTENSION(&fbc->op_array, zend_observer_fcall_op_array_extension); + ZEND_ASSERT(observer_handlers); + } + if (EXPECTED(zend_execute_ex == execute_ex)) { LOAD_OPLINE_EX(); ZEND_VM_ENTER_EX(); @@ -4014,6 +4068,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HAN call->prev_execute_data = execute_data; i_init_code_execute_data(call, new_op_array, return_value); + + if (zend_observer_fcall_op_array_extension != -1) { + void *observer_handlers = ZEND_OP_ARRAY_EXTENSION(new_op_array, zend_observer_fcall_op_array_extension); + ZEND_ASSERT(observer_handlers); + } + if (EXPECTED(zend_execute_ex == execute_ex)) { ZEND_VM_ENTER(); } else { @@ -13239,6 +13299,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HA call->prev_execute_data = execute_data; i_init_code_execute_data(call, new_op_array, return_value); + + if (zend_observer_fcall_op_array_extension != -1) { + void *observer_handlers = ZEND_OP_ARRAY_EXTENSION(new_op_array, zend_observer_fcall_op_array_extension); + ZEND_ASSERT(observer_handlers); + } + if (EXPECTED(zend_execute_ex == execute_ex)) { ZEND_VM_ENTER(); } else { @@ -36452,6 +36518,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLE call->prev_execute_data = execute_data; i_init_code_execute_data(call, new_op_array, return_value); + + if (zend_observer_fcall_op_array_extension != -1) { + void *observer_handlers = ZEND_OP_ARRAY_EXTENSION(new_op_array, zend_observer_fcall_op_array_extension); + ZEND_ASSERT(observer_handlers); + } + if (EXPECTED(zend_execute_ex == execute_ex)) { ZEND_VM_ENTER(); } else { diff --git a/configure.ac b/configure.ac index 3e438c5fefeee..0efeb1e58e4ba 100644 --- a/configure.ac +++ b/configure.ac @@ -1460,7 +1460,8 @@ PHP_ADD_SOURCES(Zend, \ zend_iterators.c zend_interfaces.c zend_exceptions.c zend_strtod.c zend_gc.c \ zend_closures.c zend_weakrefs.c zend_float.c zend_string.c zend_signal.c zend_generators.c \ zend_virtual_cwd.c zend_ast.c zend_objects.c zend_object_handlers.c zend_objects_API.c \ - zend_default_classes.c zend_inheritance.c zend_smart_str.c zend_cpuinfo.c zend_gdb.c, \ + zend_default_classes.c zend_inheritance.c zend_smart_str.c zend_cpuinfo.c zend_gdb.c \ + zend_observer.c, \ -DZEND_ENABLE_STATIC_TSRMLS_CACHE=1) PHP_ADD_BUILD_DIR(main main/streams) diff --git a/main/main.c b/main/main.c index 3b052d8b6e3be..6d821dc57650b 100644 --- a/main/main.c +++ b/main/main.c @@ -71,6 +71,7 @@ #include "zend_extensions.h" #include "zend_ini.h" #include "zend_dtrace.h" +#include "zend_observer.h" #include "php_content_types.h" #include "php_ticks.h" @@ -2245,6 +2246,7 @@ int php_module_startup(sapi_module_struct *sf, zend_module_entry *additional_mod ahead of all other internals */ php_ini_register_extensions(); + zend_observer_startup(); zend_startup_modules(); /* start Zend extensions */ @@ -2444,6 +2446,8 @@ void php_module_shutdown(void) _set_invalid_parameter_handler(old_invalid_parameter_handler); } #endif + + zend_observer_shutdown(); } /* }}} */ diff --git a/win32/build/config.w32 b/win32/build/config.w32 index 9b5e44c37d760..94e4cbe1c5fbf 100644 --- a/win32/build/config.w32 +++ b/win32/build/config.w32 @@ -237,7 +237,7 @@ ADD_SOURCES("Zend", "zend_language_parser.c zend_language_scanner.c \ zend_object_handlers.c zend_objects_API.c \ zend_default_classes.c zend_execute.c zend_strtod.c zend_gc.c zend_closures.c zend_weakrefs.c \ zend_float.c zend_string.c zend_generators.c zend_virtual_cwd.c zend_ast.c \ - zend_inheritance.c zend_smart_str.c zend_cpuinfo.c"); + zend_inheritance.c zend_smart_str.c zend_cpuinfo.c zend_observer.c"); ADD_FLAG("CFLAGS_BD_ZEND", "/D ZEND_ENABLE_STATIC_TSRMLS_CACHE=1"); if (VS_TOOLSET && VCVERS >= 1914) { From 45a85403196e19157b996f1d4324480edc6fc832 Mon Sep 17 00:00:00 2001 From: Levi Morrison Date: Mon, 13 Jul 2020 08:09:06 -0600 Subject: [PATCH 02/53] Add temporary observer extension --- ext/observer/config.m4 | 94 +++++++++++++++++++++++++++++++++ ext/observer/config.w32 | 7 +++ ext/observer/observer.c | 93 ++++++++++++++++++++++++++++++++ ext/observer/observer.stub.php | 6 +++ ext/observer/observer_arginfo.h | 14 +++++ ext/observer/php_observer.h | 15 ++++++ 6 files changed, 229 insertions(+) create mode 100644 ext/observer/config.m4 create mode 100644 ext/observer/config.w32 create mode 100644 ext/observer/observer.c create mode 100644 ext/observer/observer.stub.php create mode 100644 ext/observer/observer_arginfo.h create mode 100644 ext/observer/php_observer.h diff --git a/ext/observer/config.m4 b/ext/observer/config.m4 new file mode 100644 index 0000000000000..0c2a99c957458 --- /dev/null +++ b/ext/observer/config.m4 @@ -0,0 +1,94 @@ +dnl config.m4 for extension observer + +dnl Comments in this file start with the string 'dnl'. +dnl Remove where necessary. + +dnl If your extension references something external, use 'with': + +dnl PHP_ARG_WITH([observer], +dnl [for observer support], +dnl [AS_HELP_STRING([--with-observer], +dnl [Include observer support])]) + +dnl Otherwise use 'enable': + +PHP_ARG_ENABLE([observer], + [whether to enable observer support], + [AS_HELP_STRING([--enable-observer], + [Enable observer support])], + [no]) + +if test "$PHP_OBSERVER" != "no"; then + dnl Write more examples of tests here... + + dnl Remove this code block if the library does not support pkg-config. + dnl PKG_CHECK_MODULES([LIBFOO], [foo]) + dnl PHP_EVAL_INCLINE($LIBFOO_CFLAGS) + dnl PHP_EVAL_LIBLINE($LIBFOO_LIBS, OBSERVER_SHARED_LIBADD) + + dnl If you need to check for a particular library version using PKG_CHECK_MODULES, + dnl you can use comparison operators. For example: + dnl PKG_CHECK_MODULES([LIBFOO], [foo >= 1.2.3]) + dnl PKG_CHECK_MODULES([LIBFOO], [foo < 3.4]) + dnl PKG_CHECK_MODULES([LIBFOO], [foo = 1.2.3]) + + dnl Remove this code block if the library supports pkg-config. + dnl --with-observer -> check with-path + dnl SEARCH_PATH="/usr/local /usr" # you might want to change this + dnl SEARCH_FOR="/include/observer.h" # you most likely want to change this + dnl if test -r $PHP_OBSERVER/$SEARCH_FOR; then # path given as parameter + dnl OBSERVER_DIR=$PHP_OBSERVER + dnl else # search default path list + dnl AC_MSG_CHECKING([for observer files in default path]) + dnl for i in $SEARCH_PATH ; do + dnl if test -r $i/$SEARCH_FOR; then + dnl OBSERVER_DIR=$i + dnl AC_MSG_RESULT(found in $i) + dnl fi + dnl done + dnl fi + dnl + dnl if test -z "$OBSERVER_DIR"; then + dnl AC_MSG_RESULT([not found]) + dnl AC_MSG_ERROR([Please reinstall the observer distribution]) + dnl fi + + dnl Remove this code block if the library supports pkg-config. + dnl --with-observer -> add include path + dnl PHP_ADD_INCLUDE($OBSERVER_DIR/include) + + dnl Remove this code block if the library supports pkg-config. + dnl --with-observer -> check for lib and symbol presence + dnl LIBNAME=OBSERVER # you may want to change this + dnl LIBSYMBOL=OBSERVER # you most likely want to change this + + dnl If you need to check for a particular library function (e.g. a conditional + dnl or version-dependent feature) and you are using pkg-config: + dnl PHP_CHECK_LIBRARY($LIBNAME, $LIBSYMBOL, + dnl [ + dnl AC_DEFINE(HAVE_OBSERVER_FEATURE, 1, [ ]) + dnl ],[ + dnl AC_MSG_ERROR([FEATURE not supported by your observer library.]) + dnl ], [ + dnl $LIBFOO_LIBS + dnl ]) + + dnl If you need to check for a particular library function (e.g. a conditional + dnl or version-dependent feature) and you are not using pkg-config: + dnl PHP_CHECK_LIBRARY($LIBNAME, $LIBSYMBOL, + dnl [ + dnl PHP_ADD_LIBRARY_WITH_PATH($LIBNAME, $OBSERVER_DIR/$PHP_LIBDIR, OBSERVER_SHARED_LIBADD) + dnl AC_DEFINE(HAVE_OBSERVER_FEATURE, 1, [ ]) + dnl ],[ + dnl AC_MSG_ERROR([FEATURE not supported by your observer library.]) + dnl ],[ + dnl -L$OBSERVER_DIR/$PHP_LIBDIR -lm + dnl ]) + dnl + dnl PHP_SUBST(OBSERVER_SHARED_LIBADD) + + dnl In case of no dependencies + AC_DEFINE(HAVE_OBSERVER, 1, [ Have observer support ]) + + PHP_NEW_EXTENSION(observer, observer.c, $ext_shared) +fi diff --git a/ext/observer/config.w32 b/ext/observer/config.w32 new file mode 100644 index 0000000000000..70165a4bb80dc --- /dev/null +++ b/ext/observer/config.w32 @@ -0,0 +1,7 @@ +ARG_ENABLE('observer', 'observer support', 'no'); + +if (PHP_OBSERVER != 'no') { + AC_DEFINE('HAVE_OBSERVER', 1, 'observer support enabled'); + + EXTENSION('observer', 'observer.c', null, '/DZEND_ENABLE_STATIC_TSRMLS_CACHE=1'); +} diff --git a/ext/observer/observer.c b/ext/observer/observer.c new file mode 100644 index 0000000000000..e02f94ec8b253 --- /dev/null +++ b/ext/observer/observer.c @@ -0,0 +1,93 @@ +/* observer extension for PHP */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "php.h" +#include "ext/standard/info.h" +#include "php_observer.h" +#include "observer_arginfo.h" + +#include "zend_observer.h" + +/* For compatibility with older PHP versions */ +#ifndef ZEND_PARSE_PARAMETERS_NONE +#define ZEND_PARSE_PARAMETERS_NONE() \ + ZEND_PARSE_PARAMETERS_START(0, 0) \ + ZEND_PARSE_PARAMETERS_END() +#endif + +int zend_observer_fcall_op_array_extension; + +PHP_FUNCTION(observer_op_array_extension_handle) +{ + ZEND_PARSE_PARAMETERS_NONE(); + + RETVAL_LONG(zend_observer_fcall_op_array_extension); +} + +static void observer_begin(zend_execute_data *execute_data) +{ + if (getenv("OBSERVER_DEBUG") && execute_data->func->common.function_name) { + php_printf("BEGIN (%s)\n", ZSTR_VAL(execute_data->func->common.function_name)); + } +} + +static zend_observer_fcall observer_fcall_init(zend_function *fbc) +{ + return (zend_observer_fcall){observer_begin, NULL}; +} + +PHP_MINIT_FUNCTION(observer) +{ + zend_observer_fcall_register(observer_fcall_init); + return SUCCESS; +} + +PHP_MSHUTDOWN_FUNCTION(observer) { return SUCCESS; } + +/* {{{ PHP_RINIT_FUNCTION + */ +PHP_RINIT_FUNCTION(observer) +{ +#if defined(ZTS) && defined(COMPILE_DL_OBSERVER) + ZEND_TSRMLS_CACHE_UPDATE(); +#endif + + return SUCCESS; +} +/* }}} */ + +/* {{{ PHP_MINFO_FUNCTION + */ +PHP_MINFO_FUNCTION(observer) +{ + php_info_print_table_start(); + php_info_print_table_header(2, "observer support", "enabled"); + php_info_print_table_end(); +} +/* }}} */ + +/* {{{ observer_module_entry + */ +zend_module_entry observer_module_entry = { + STANDARD_MODULE_HEADER, + "observer", /* Extension name */ + ext_functions, /* zend_function_entry */ + PHP_MINIT(observer), /* PHP_MINIT - Module initialization */ + PHP_MSHUTDOWN(observer), /* PHP_MSHUTDOWN - Module shutdown */ + PHP_RINIT(observer), /* PHP_RINIT - Request initialization */ + NULL, /* PHP_RSHUTDOWN - Request shutdown */ + PHP_MINFO(observer), /* PHP_MINFO - Module info */ + PHP_OBSERVER_VERSION, /* Version */ + STANDARD_MODULE_PROPERTIES +}; +/* }}} */ + +#ifdef COMPILE_DL_OBSERVER +# ifdef ZTS +ZEND_TSRMLS_CACHE_DEFINE() +# endif +ZEND_GET_MODULE(observer) +#endif diff --git a/ext/observer/observer.stub.php b/ext/observer/observer.stub.php new file mode 100644 index 0000000000000..a28fcefe1b99a --- /dev/null +++ b/ext/observer/observer.stub.php @@ -0,0 +1,6 @@ + Date: Mon, 13 Jul 2020 16:27:26 +0200 Subject: [PATCH 03/53] Fix some issues --- Zend/zend_closures.c | 1 + Zend/zend_compile.c | 5 +++++ Zend/zend_observer.h | 2 +- Zend/zend_vm_def.h | 2 +- Zend/zend_vm_execute.h | 4 ++-- ext/opcache/jit/zend_jit_helpers.c | 3 +++ 6 files changed, 13 insertions(+), 4 deletions(-) diff --git a/Zend/zend_closures.c b/Zend/zend_closures.c index ff83d3ba487c8..1b43a7c4aeee1 100644 --- a/Zend/zend_closures.c +++ b/Zend/zend_closures.c @@ -159,6 +159,7 @@ ZEND_METHOD(Closure, call) ptr = (char*)ptr + sizeof(void*); ZEND_MAP_PTR_SET(my_function.op_array.run_time_cache, ptr); memset(ptr, 0, my_function.op_array.cache_size); + zend_observer_fcall_install(&my_function); } } diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index 118c9681d22d8..089dbd5fa0f73 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -32,6 +32,10 @@ #include "zend_language_scanner.h" #include "zend_inheritance.h" #include "zend_vm.h" +//#include "zend_observer.h" + +// TODO +ZEND_API void zend_observer_fcall_install(zend_function *function); #define SET_NODE(target, src) do { \ target ## _type = (src)->op_type; \ @@ -1326,6 +1330,7 @@ ZEND_API void zend_do_delayed_early_binding(zend_op_array *op_array, uint32_t fi ptr = (char*)ptr + sizeof(void*); ZEND_MAP_PTR_SET(op_array->run_time_cache, ptr); memset(ptr, 0, op_array->cache_size); + zend_observer_fcall_install((zend_function*)op_array); } run_time_cache = RUN_TIME_CACHE(op_array); diff --git a/Zend/zend_observer.h b/Zend/zend_observer.h index c474c14f80097..b5da3a6c21498 100644 --- a/Zend/zend_observer.h +++ b/Zend/zend_observer.h @@ -3,7 +3,7 @@ #ifndef ZEND_OBSERVER_H #define ZEND_OBSERVER_H -#include "php.h" +#include "zend.h" #include "zend_llist.h" BEGIN_EXTERN_C() diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 477ad6d442d40..3c47b118338ba 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -4051,7 +4051,7 @@ ZEND_VM_HOT_HANDLER(60, ZEND_DO_FCALL, ANY, ANY, SPEC(RETVAL)) execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 1 EXECUTE_DATA_CC); - if (zend_observer_fcall_op_array_extension != -1) { + if (zend_observer_fcall_op_array_extension != -1 && !(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE))) { void *observer_handlers = ZEND_OP_ARRAY_EXTENSION(&fbc->op_array, zend_observer_fcall_op_array_extension); ZEND_ASSERT(observer_handlers); if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index a24a0d378bdf5..d29f14d13cd1c 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -1566,7 +1566,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETV execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 1 EXECUTE_DATA_CC); - if (zend_observer_fcall_op_array_extension != -1) { + if (zend_observer_fcall_op_array_extension != -1 && !(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE))) { void *observer_handlers = ZEND_OP_ARRAY_EXTENSION(&fbc->op_array, zend_observer_fcall_op_array_extension); ZEND_ASSERT(observer_handlers); if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { @@ -1672,7 +1672,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETV execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 1 EXECUTE_DATA_CC); - if (zend_observer_fcall_op_array_extension != -1) { + if (zend_observer_fcall_op_array_extension != -1 && !(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE))) { void *observer_handlers = ZEND_OP_ARRAY_EXTENSION(&fbc->op_array, zend_observer_fcall_op_array_extension); ZEND_ASSERT(observer_handlers); if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { diff --git a/ext/opcache/jit/zend_jit_helpers.c b/ext/opcache/jit/zend_jit_helpers.c index 681b095a18f0f..42276153f7bd7 100644 --- a/ext/opcache/jit/zend_jit_helpers.c +++ b/ext/opcache/jit/zend_jit_helpers.c @@ -17,6 +17,7 @@ */ #include "Zend/zend_API.h" +#include "Zend/zend_observer.h" static ZEND_COLD void undef_result_after_exception() { const zend_op *opline = EG(opline_before_exception); @@ -34,6 +35,7 @@ static zend_never_inline zend_function* ZEND_FASTCALL _zend_jit_init_func_run_ti run_time_cache = zend_arena_alloc(&CG(arena), op_array->cache_size); memset(run_time_cache, 0, op_array->cache_size); ZEND_MAP_PTR_SET(op_array->run_time_cache, run_time_cache); + zend_observer_fcall_install((zend_function*) op_array); return (zend_function*)op_array; } /* }}} */ @@ -46,6 +48,7 @@ static zend_never_inline zend_op_array* ZEND_FASTCALL zend_jit_init_func_run_tim run_time_cache = zend_arena_alloc(&CG(arena), op_array->cache_size); memset(run_time_cache, 0, op_array->cache_size); ZEND_MAP_PTR_SET(op_array->run_time_cache, run_time_cache); + zend_observer_fcall_install((zend_function*) op_array); } return op_array; } From 1e7c59d2bb9081fa7b015330fcbb5726e05c7c66 Mon Sep 17 00:00:00 2001 From: Levi Morrison Date: Mon, 13 Jul 2020 15:36:06 -0600 Subject: [PATCH 04/53] Guard observer begin handler and start adding end handler --- Zend/zend_observer.c | 14 ++++- Zend/zend_vm_def.h | 30 +++++++++ Zend/zend_vm_execute.h | 135 +++++++++++++++++++++++++++++++++++++++++ 3 files changed, 177 insertions(+), 2 deletions(-) diff --git a/Zend/zend_observer.c b/Zend/zend_observer.c index 688646a2414aa..9831d715d7cd4 100644 --- a/Zend/zend_observer.c +++ b/Zend/zend_observer.c @@ -86,13 +86,23 @@ void zend_observe_fcall_begin( { zend_observer_fcall *handler, *end = cache->end; for (handler = cache->handlers; handler != end; ++handler) { - handler->begin(execute_data); + if (handler->begin) { + handler->begin(execute_data); + } } } void zend_observe_fcall_end( zend_observer_fcall_cache *cache, zend_execute_data *execute_data, - zval *return_value) {} + zval *return_value) +{ + zend_observer_fcall *handler = cache->end, *end = cache->handlers; + while (handler-- != end) { + if (handler->end) { + handler->end(execute_data, return_value); + } + } +} diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 3c47b118338ba..933b8e8d76df8 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -4272,6 +4272,21 @@ ZEND_VM_INLINE_HANDLER(62, ZEND_RETURN, CONST|TMP|VAR|CV, ANY) } } } + + // todo: should this go in the leave helper? + zend_function *func = EG(current_execute_data)->func; + if (zend_observer_fcall_op_array_extension != -1 + && func + && !(func->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE)) + ) { + void *observer_handlers = + ZEND_OP_ARRAY_EXTENSION(&func->op_array, zend_observer_fcall_op_array_extension); + if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { + zend_observe_fcall_end(observer_handlers, EG(current_execute_data), return_value); + } + + } + ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper); } @@ -7362,6 +7377,21 @@ ZEND_VM_HELPER(zend_dispatch_try_catch_finally_helper, ANY, ANY, uint32_t try_ca } /* Uncaught exception */ + + zend_function *func = execute_data->func; + if (zend_observer_fcall_op_array_extension != -1 + && func + && !(func->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE)) + ) { + void *observer_handlers = + ZEND_OP_ARRAY_EXTENSION(&func->op_array, zend_observer_fcall_op_array_extension); + if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { + zval undef; + ZVAL_UNDEF(&undef); + zend_observe_fcall_end(observer_handlers, execute_data, &undef); + } + + } cleanup_live_vars(execute_data, op_num, 0); if (UNEXPECTED((EX_CALL_INFO() & ZEND_CALL_GENERATOR) != 0)) { zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C); diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index d29f14d13cd1c..6f29afe56489c 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -2564,6 +2564,21 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_dispatch_try } /* Uncaught exception */ + + zend_function *func = execute_data->func; + if (zend_observer_fcall_op_array_extension != -1 + && func + && !(func->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE)) + ) { + void *observer_handlers = + ZEND_OP_ARRAY_EXTENSION(&func->op_array, zend_observer_fcall_op_array_extension); + if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { + zval undef; + ZVAL_UNDEF(&undef); + zend_observe_fcall_end(observer_handlers, execute_data, &undef); + } + + } cleanup_live_vars(execute_data, op_num, 0); if (UNEXPECTED((EX_CALL_INFO() & ZEND_CALL_GENERATOR) != 0)) { zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C); @@ -3571,6 +3586,21 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_CONST_ } } } + + // todo: should this go in the leave helper? + zend_function *func = EG(current_execute_data)->func; + if (zend_observer_fcall_op_array_extension != -1 + && func + && !(func->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE)) + ) { + void *observer_handlers = + ZEND_OP_ARRAY_EXTENSION(&func->op_array, zend_observer_fcall_op_array_extension); + if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { + zend_observe_fcall_end(observer_handlers, EG(current_execute_data), return_value); + } + + } + ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } @@ -17532,6 +17562,21 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_TMP_HA } } } + + // todo: should this go in the leave helper? + zend_function *func = EG(current_execute_data)->func; + if (zend_observer_fcall_op_array_extension != -1 + && func + && !(func->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE)) + ) { + void *observer_handlers = + ZEND_OP_ARRAY_EXTENSION(&func->op_array, zend_observer_fcall_op_array_extension); + if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { + zend_observe_fcall_end(observer_handlers, EG(current_execute_data), return_value); + } + + } + ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } @@ -20018,6 +20063,21 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_VAR_HA } } } + + // todo: should this go in the leave helper? + zend_function *func = EG(current_execute_data)->func; + if (zend_observer_fcall_op_array_extension != -1 + && func + && !(func->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE)) + ) { + void *observer_handlers = + ZEND_OP_ARRAY_EXTENSION(&func->op_array, zend_observer_fcall_op_array_extension); + if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { + zend_observe_fcall_end(observer_handlers, EG(current_execute_data), return_value); + } + + } + ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } @@ -35983,6 +36043,21 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_CV_HAN } } } + + // todo: should this go in the leave helper? + zend_function *func = EG(current_execute_data)->func; + if (zend_observer_fcall_op_array_extension != -1 + && func + && !(func->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE)) + ) { + void *observer_handlers = + ZEND_OP_ARRAY_EXTENSION(&func->op_array, zend_observer_fcall_op_array_extension); + if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { + zend_observe_fcall_end(observer_handlers, EG(current_execute_data), return_value); + } + + } + ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } @@ -52579,6 +52654,21 @@ ZEND_API void execute_ex(zend_execute_data *ex) } } } + + // todo: should this go in the leave helper? + zend_function *func = EG(current_execute_data)->func; + if (zend_observer_fcall_op_array_extension != -1 + && func + && !(func->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE)) + ) { + void *observer_handlers = + ZEND_OP_ARRAY_EXTENSION(&func->op_array, zend_observer_fcall_op_array_extension); + if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { + zend_observe_fcall_end(observer_handlers, EG(current_execute_data), return_value); + } + + } + goto zend_leave_helper_SPEC_LABEL; } @@ -54080,6 +54170,21 @@ ZEND_API void execute_ex(zend_execute_data *ex) } } } + + // todo: should this go in the leave helper? + zend_function *func = EG(current_execute_data)->func; + if (zend_observer_fcall_op_array_extension != -1 + && func + && !(func->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE)) + ) { + void *observer_handlers = + ZEND_OP_ARRAY_EXTENSION(&func->op_array, zend_observer_fcall_op_array_extension); + if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { + zend_observe_fcall_end(observer_handlers, EG(current_execute_data), return_value); + } + + } + goto zend_leave_helper_SPEC_LABEL; } @@ -54373,6 +54478,21 @@ ZEND_API void execute_ex(zend_execute_data *ex) } } } + + // todo: should this go in the leave helper? + zend_function *func = EG(current_execute_data)->func; + if (zend_observer_fcall_op_array_extension != -1 + && func + && !(func->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE)) + ) { + void *observer_handlers = + ZEND_OP_ARRAY_EXTENSION(&func->op_array, zend_observer_fcall_op_array_extension); + if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { + zend_observe_fcall_end(observer_handlers, EG(current_execute_data), return_value); + } + + } + goto zend_leave_helper_SPEC_LABEL; } @@ -55454,6 +55574,21 @@ ZEND_API void execute_ex(zend_execute_data *ex) } } } + + // todo: should this go in the leave helper? + zend_function *func = EG(current_execute_data)->func; + if (zend_observer_fcall_op_array_extension != -1 + && func + && !(func->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE)) + ) { + void *observer_handlers = + ZEND_OP_ARRAY_EXTENSION(&func->op_array, zend_observer_fcall_op_array_extension); + if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { + zend_observe_fcall_end(observer_handlers, EG(current_execute_data), return_value); + } + + } + goto zend_leave_helper_SPEC_LABEL; } From 01308fd967b4b9e70651c83e65095ac55fde8c81 Mon Sep 17 00:00:00 2001 From: Levi Morrison Date: Wed, 15 Jul 2020 08:18:07 -0600 Subject: [PATCH 05/53] WIP .end handler --- Zend/zend_observer.h | 20 +++++- Zend/zend_vm_def.h | 42 ++++------- Zend/zend_vm_execute.h | 153 +++++++++------------------------------- ext/observer/observer.c | 79 ++++++++++++++++++++- 4 files changed, 140 insertions(+), 154 deletions(-) diff --git a/Zend/zend_observer.h b/Zend/zend_observer.h index b5da3a6c21498..fcb4677290cf7 100644 --- a/Zend/zend_observer.h +++ b/Zend/zend_observer.h @@ -4,7 +4,7 @@ #define ZEND_OBSERVER_H #include "zend.h" -#include "zend_llist.h" +#include "zend_compile.h" BEGIN_EXTERN_C() @@ -48,6 +48,24 @@ void zend_observe_fcall_end( zend_execute_data *execute_data, zval *return_value); +ZEND_API zend_always_inline void zend_observer_maybe_fcall_call_end( + zend_execute_data *execute_data, + zval *return_value) +{ + if (zend_observer_fcall_op_array_extension == -1) { + return; + } + + zend_function *func = execute_data->func; + if (!(func->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE))) { + void *observer_handlers = + ZEND_OP_ARRAY_EXTENSION(&func->op_array, zend_observer_fcall_op_array_extension); + if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { + zend_observer_fcall_cache *cache = observer_handlers; + zend_observe_fcall_end(cache, execute_data, return_value); + } + } +} END_EXTERN_C() diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 933b8e8d76df8..b8d3c77c1bfd6 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -3926,6 +3926,8 @@ ZEND_VM_HOT_HANDLER(130, ZEND_DO_UCALL, ANY, ANY, SPEC(RETVAL)) ret = EX_VAR(opline->result.var); } + LOAD_OPLINE_EX(); + call->prev_execute_data = execute_data; execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); @@ -3937,8 +3939,6 @@ ZEND_VM_HOT_HANDLER(130, ZEND_DO_UCALL, ANY, ANY, SPEC(RETVAL)) } } - LOAD_OPLINE_EX(); - ZEND_VM_ENTER_EX(); } @@ -4274,18 +4274,7 @@ ZEND_VM_INLINE_HANDLER(62, ZEND_RETURN, CONST|TMP|VAR|CV, ANY) } // todo: should this go in the leave helper? - zend_function *func = EG(current_execute_data)->func; - if (zend_observer_fcall_op_array_extension != -1 - && func - && !(func->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE)) - ) { - void *observer_handlers = - ZEND_OP_ARRAY_EXTENSION(&func->op_array, zend_observer_fcall_op_array_extension); - if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { - zend_observe_fcall_end(observer_handlers, EG(current_execute_data), return_value); - } - - } + zend_observer_maybe_fcall_call_end(execute_data, return_value); ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper); } @@ -5878,6 +5867,8 @@ ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMPVAR|CV, ANY, EVAL) SAVE_OPLINE(); inc_filename = GET_OP1_ZVAL_PTR(BP_VAR_R); new_op_array = zend_include_or_eval(inc_filename, opline->extended_value); + + // todo: uh... I think we can't free this yet. Observers may want to know it? FREE_OP1(); if (UNEXPECTED(EG(exception) != NULL)) { if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) { @@ -5914,9 +5905,11 @@ ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMPVAR|CV, ANY, EVAL) call->prev_execute_data = execute_data; i_init_code_execute_data(call, new_op_array, return_value); - if (zend_observer_fcall_op_array_extension != -1) { + if (zend_observer_fcall_op_array_extension != -1 && new_op_array != ZEND_FAKE_OP_ARRAY) { void *observer_handlers = ZEND_OP_ARRAY_EXTENSION(new_op_array, zend_observer_fcall_op_array_extension); - ZEND_ASSERT(observer_handlers); + if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { + zend_observe_fcall_begin(observer_handlers, execute_data); + } } if (EXPECTED(zend_execute_ex == execute_ex)) { @@ -7377,21 +7370,8 @@ ZEND_VM_HELPER(zend_dispatch_try_catch_finally_helper, ANY, ANY, uint32_t try_ca } /* Uncaught exception */ + zend_observer_maybe_fcall_call_end(execute_data, &EG(uninitialized_zval)); - zend_function *func = execute_data->func; - if (zend_observer_fcall_op_array_extension != -1 - && func - && !(func->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE)) - ) { - void *observer_handlers = - ZEND_OP_ARRAY_EXTENSION(&func->op_array, zend_observer_fcall_op_array_extension); - if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { - zval undef; - ZVAL_UNDEF(&undef); - zend_observe_fcall_end(observer_handlers, execute_data, &undef); - } - - } cleanup_live_vars(execute_data, op_num, 0); if (UNEXPECTED((EX_CALL_INFO() & ZEND_CALL_GENERATOR) != 0)) { zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C); @@ -8185,10 +8165,12 @@ ZEND_VM_HANDLER(158, ZEND_CALL_TRAMPOLINE, ANY, ANY) execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); +/* if (zend_observer_fcall_op_array_extension != -1) { void *observer_handlers = ZEND_OP_ARRAY_EXTENSION(&fbc->op_array, zend_observer_fcall_op_array_extension); ZEND_ASSERT(observer_handlers); } +*/ if (EXPECTED(zend_execute_ex == execute_ex)) { LOAD_OPLINE_EX(); diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 6f29afe56489c..c748d6c2e49b8 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -1321,6 +1321,8 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_RETV ret = EX_VAR(opline->result.var); } + LOAD_OPLINE_EX(); + call->prev_execute_data = execute_data; execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); @@ -1332,8 +1334,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_RETV } } - LOAD_OPLINE_EX(); - ZEND_VM_ENTER_EX(); } @@ -1352,6 +1352,8 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_RETV ret = EX_VAR(opline->result.var); } + LOAD_OPLINE_EX(); + call->prev_execute_data = execute_data; execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); @@ -1363,8 +1365,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_RETV } } - LOAD_OPLINE_EX(); - ZEND_VM_ENTER_EX(); } @@ -2564,21 +2564,8 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_dispatch_try } /* Uncaught exception */ + zend_observer_maybe_fcall_call_end(execute_data, &EG(uninitialized_zval)); - zend_function *func = execute_data->func; - if (zend_observer_fcall_op_array_extension != -1 - && func - && !(func->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE)) - ) { - void *observer_handlers = - ZEND_OP_ARRAY_EXTENSION(&func->op_array, zend_observer_fcall_op_array_extension); - if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { - zval undef; - ZVAL_UNDEF(&undef); - zend_observe_fcall_end(observer_handlers, execute_data, &undef); - } - - } cleanup_live_vars(execute_data, op_num, 0); if (UNEXPECTED((EX_CALL_INFO() & ZEND_CALL_GENERATOR) != 0)) { zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C); @@ -2808,10 +2795,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CALL_TRAMPOLINE_SPEC_HANDLER(Z execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); +/* if (zend_observer_fcall_op_array_extension != -1) { void *observer_handlers = ZEND_OP_ARRAY_EXTENSION(&fbc->op_array, zend_observer_fcall_op_array_extension); ZEND_ASSERT(observer_handlers); } +*/ if (EXPECTED(zend_execute_ex == execute_ex)) { LOAD_OPLINE_EX(); @@ -3588,18 +3577,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_CONST_ } // todo: should this go in the leave helper? - zend_function *func = EG(current_execute_data)->func; - if (zend_observer_fcall_op_array_extension != -1 - && func - && !(func->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE)) - ) { - void *observer_handlers = - ZEND_OP_ARRAY_EXTENSION(&func->op_array, zend_observer_fcall_op_array_extension); - if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { - zend_observe_fcall_end(observer_handlers, EG(current_execute_data), return_value); - } - - } + zend_observer_maybe_fcall_call_end(execute_data, return_value); ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } @@ -4064,6 +4042,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HAN inc_filename = RT_CONSTANT(opline, opline->op1); new_op_array = zend_include_or_eval(inc_filename, opline->extended_value); + // todo: uh... I think we can't free this yet. Observers may want to know it? + if (UNEXPECTED(EG(exception) != NULL)) { if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) { destroy_op_array(new_op_array); @@ -4099,9 +4079,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HAN call->prev_execute_data = execute_data; i_init_code_execute_data(call, new_op_array, return_value); - if (zend_observer_fcall_op_array_extension != -1) { + if (zend_observer_fcall_op_array_extension != -1 && new_op_array != ZEND_FAKE_OP_ARRAY) { void *observer_handlers = ZEND_OP_ARRAY_EXTENSION(new_op_array, zend_observer_fcall_op_array_extension); - ZEND_ASSERT(observer_handlers); + if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { + zend_observe_fcall_begin(observer_handlers, execute_data); + } } if (EXPECTED(zend_execute_ex == execute_ex)) { @@ -13294,6 +13276,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HA SAVE_OPLINE(); inc_filename = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); new_op_array = zend_include_or_eval(inc_filename, opline->extended_value); + + // todo: uh... I think we can't free this yet. Observers may want to know it? zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); if (UNEXPECTED(EG(exception) != NULL)) { if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) { @@ -13330,9 +13314,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HA call->prev_execute_data = execute_data; i_init_code_execute_data(call, new_op_array, return_value); - if (zend_observer_fcall_op_array_extension != -1) { + if (zend_observer_fcall_op_array_extension != -1 && new_op_array != ZEND_FAKE_OP_ARRAY) { void *observer_handlers = ZEND_OP_ARRAY_EXTENSION(new_op_array, zend_observer_fcall_op_array_extension); - ZEND_ASSERT(observer_handlers); + if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { + zend_observe_fcall_begin(observer_handlers, execute_data); + } } if (EXPECTED(zend_execute_ex == execute_ex)) { @@ -17564,18 +17550,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_TMP_HA } // todo: should this go in the leave helper? - zend_function *func = EG(current_execute_data)->func; - if (zend_observer_fcall_op_array_extension != -1 - && func - && !(func->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE)) - ) { - void *observer_handlers = - ZEND_OP_ARRAY_EXTENSION(&func->op_array, zend_observer_fcall_op_array_extension); - if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { - zend_observe_fcall_end(observer_handlers, EG(current_execute_data), return_value); - } - - } + zend_observer_maybe_fcall_call_end(execute_data, return_value); ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } @@ -20065,18 +20040,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_VAR_HA } // todo: should this go in the leave helper? - zend_function *func = EG(current_execute_data)->func; - if (zend_observer_fcall_op_array_extension != -1 - && func - && !(func->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE)) - ) { - void *observer_handlers = - ZEND_OP_ARRAY_EXTENSION(&func->op_array, zend_observer_fcall_op_array_extension); - if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { - zend_observe_fcall_end(observer_handlers, EG(current_execute_data), return_value); - } - - } + zend_observer_maybe_fcall_call_end(execute_data, return_value); ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } @@ -36045,18 +36009,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_CV_HAN } // todo: should this go in the leave helper? - zend_function *func = EG(current_execute_data)->func; - if (zend_observer_fcall_op_array_extension != -1 - && func - && !(func->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE)) - ) { - void *observer_handlers = - ZEND_OP_ARRAY_EXTENSION(&func->op_array, zend_observer_fcall_op_array_extension); - if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { - zend_observe_fcall_end(observer_handlers, EG(current_execute_data), return_value); - } - - } + zend_observer_maybe_fcall_call_end(execute_data, return_value); ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } @@ -36559,6 +36512,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLE inc_filename = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); new_op_array = zend_include_or_eval(inc_filename, opline->extended_value); + // todo: uh... I think we can't free this yet. Observers may want to know it? + if (UNEXPECTED(EG(exception) != NULL)) { if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) { destroy_op_array(new_op_array); @@ -36594,9 +36549,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLE call->prev_execute_data = execute_data; i_init_code_execute_data(call, new_op_array, return_value); - if (zend_observer_fcall_op_array_extension != -1) { + if (zend_observer_fcall_op_array_extension != -1 && new_op_array != ZEND_FAKE_OP_ARRAY) { void *observer_handlers = ZEND_OP_ARRAY_EXTENSION(new_op_array, zend_observer_fcall_op_array_extension); - ZEND_ASSERT(observer_handlers); + if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { + zend_observe_fcall_begin(observer_handlers, execute_data); + } } if (EXPECTED(zend_execute_ex == execute_ex)) { @@ -52656,18 +52613,7 @@ ZEND_API void execute_ex(zend_execute_data *ex) } // todo: should this go in the leave helper? - zend_function *func = EG(current_execute_data)->func; - if (zend_observer_fcall_op_array_extension != -1 - && func - && !(func->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE)) - ) { - void *observer_handlers = - ZEND_OP_ARRAY_EXTENSION(&func->op_array, zend_observer_fcall_op_array_extension); - if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { - zend_observe_fcall_end(observer_handlers, EG(current_execute_data), return_value); - } - - } + zend_observer_maybe_fcall_call_end(execute_data, return_value); goto zend_leave_helper_SPEC_LABEL; } @@ -54172,18 +54118,7 @@ ZEND_API void execute_ex(zend_execute_data *ex) } // todo: should this go in the leave helper? - zend_function *func = EG(current_execute_data)->func; - if (zend_observer_fcall_op_array_extension != -1 - && func - && !(func->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE)) - ) { - void *observer_handlers = - ZEND_OP_ARRAY_EXTENSION(&func->op_array, zend_observer_fcall_op_array_extension); - if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { - zend_observe_fcall_end(observer_handlers, EG(current_execute_data), return_value); - } - - } + zend_observer_maybe_fcall_call_end(execute_data, return_value); goto zend_leave_helper_SPEC_LABEL; } @@ -54480,18 +54415,7 @@ ZEND_API void execute_ex(zend_execute_data *ex) } // todo: should this go in the leave helper? - zend_function *func = EG(current_execute_data)->func; - if (zend_observer_fcall_op_array_extension != -1 - && func - && !(func->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE)) - ) { - void *observer_handlers = - ZEND_OP_ARRAY_EXTENSION(&func->op_array, zend_observer_fcall_op_array_extension); - if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { - zend_observe_fcall_end(observer_handlers, EG(current_execute_data), return_value); - } - - } + zend_observer_maybe_fcall_call_end(execute_data, return_value); goto zend_leave_helper_SPEC_LABEL; } @@ -55576,18 +55500,7 @@ ZEND_API void execute_ex(zend_execute_data *ex) } // todo: should this go in the leave helper? - zend_function *func = EG(current_execute_data)->func; - if (zend_observer_fcall_op_array_extension != -1 - && func - && !(func->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE)) - ) { - void *observer_handlers = - ZEND_OP_ARRAY_EXTENSION(&func->op_array, zend_observer_fcall_op_array_extension); - if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { - zend_observe_fcall_end(observer_handlers, EG(current_execute_data), return_value); - } - - } + zend_observer_maybe_fcall_call_end(execute_data, return_value); goto zend_leave_helper_SPEC_LABEL; } diff --git a/ext/observer/observer.c b/ext/observer/observer.c index e02f94ec8b253..d169b57bed66e 100644 --- a/ext/observer/observer.c +++ b/ext/observer/observer.c @@ -19,6 +19,7 @@ #endif int zend_observer_fcall_op_array_extension; +ZEND_TLS unsigned int nesting_depth = 1; PHP_FUNCTION(observer_op_array_extension_handle) { @@ -27,16 +28,88 @@ PHP_FUNCTION(observer_op_array_extension_handle) RETVAL_LONG(zend_observer_fcall_op_array_extension); } +static char *observer_get_filename(zend_execute_data *execute_data) { + const zend_op *opline = execute_data->opline; + uint32_t extended_value = opline->extended_value; + ZEND_ASSERT(opline->opcode == ZEND_INCLUDE_OR_EVAL); + ZEND_ASSERT( + extended_value == ZEND_INCLUDE + || extended_value == ZEND_INCLUDE_ONCE + || extended_value == ZEND_REQUIRE + || extended_value == ZEND_REQUIRE_ONCE + ); + + zval *op = zend_get_zval_ptr(opline, opline->op1_type, &opline->op1, execute_data, BP_VAR_R); + return (op && Z_TYPE_P(op) == IS_STRING) ? Z_STRVAL_P(op) : NULL; +} + +static char *include_pretty_name[] = { + [ZEND_EVAL] = "eval", + [ZEND_INCLUDE] = "include", + [ZEND_INCLUDE_ONCE] = "include_once", + [ZEND_REQUIRE] = "require", + [ZEND_REQUIRE_ONCE] = "require_once", +}; + static void observer_begin(zend_execute_data *execute_data) { - if (getenv("OBSERVER_DEBUG") && execute_data->func->common.function_name) { - php_printf("BEGIN (%s)\n", ZSTR_VAL(execute_data->func->common.function_name)); + + if (getenv("OBSERVER_DEBUG")) { + if (execute_data->func && execute_data->func->common.function_name) { + printf("%*s<%s>\n", 2 * nesting_depth, "", ZSTR_VAL(execute_data->func->common.function_name)); + } else if (execute_data->opline->opcode == ZEND_INCLUDE_OR_EVAL) { + uint32_t extended_value = execute_data->opline->extended_value; + switch (extended_value) { + case ZEND_INCLUDE: + case ZEND_INCLUDE_ONCE: + case ZEND_REQUIRE: + case ZEND_REQUIRE_ONCE: { + char *filename = observer_get_filename(execute_data); + printf("%*s<%s filename=\"%s\">\n", 2 * nesting_depth, "", include_pretty_name[extended_value], filename ?: "(unknown)"); + } + break; + + case ZEND_EVAL: + printf("%*s\n", 2 * nesting_depth, ""); + } + } + + ++nesting_depth; + } +} + +static void observer_end(zend_execute_data *execute_data, zval *retval) { + if (getenv("OBSERVER_DEBUG")) { + --nesting_depth; + + if (execute_data->func && execute_data->func->common.function_name) { + printf("%*s\n", 2 * nesting_depth, "", ZSTR_VAL(execute_data->func->common.function_name)); + } else if (execute_data->opline->opcode == ZEND_INCLUDE_OR_EVAL) { + uint32_t extended_value = execute_data->opline->extended_value; + switch (extended_value) { + case ZEND_INCLUDE: + case ZEND_INCLUDE_ONCE: + case ZEND_REQUIRE: + case ZEND_REQUIRE_ONCE: { + printf("%*s\n", 2 * nesting_depth, "", include_pretty_name[extended_value]); + } + break; + + case ZEND_EVAL: + printf("%*s\n", 2 * nesting_depth, ""); + + default: + ZEND_ASSERT(0 ); + } + } else { + ZEND_ASSERT(0); + } } } static zend_observer_fcall observer_fcall_init(zend_function *fbc) { - return (zend_observer_fcall){observer_begin, NULL}; + return (zend_observer_fcall){observer_begin, observer_end}; } PHP_MINIT_FUNCTION(observer) From dc74744ea6dddb79d4bce92219fca42b02bbe47d Mon Sep 17 00:00:00 2001 From: Levi Morrison Date: Wed, 15 Jul 2020 08:20:23 -0600 Subject: [PATCH 06/53] Update for zend_get_zval_ptr changes --- ext/observer/observer.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ext/observer/observer.c b/ext/observer/observer.c index d169b57bed66e..c8bd0cdded060 100644 --- a/ext/observer/observer.c +++ b/ext/observer/observer.c @@ -39,7 +39,7 @@ static char *observer_get_filename(zend_execute_data *execute_data) { || extended_value == ZEND_REQUIRE_ONCE ); - zval *op = zend_get_zval_ptr(opline, opline->op1_type, &opline->op1, execute_data, BP_VAR_R); + zval *op = zend_get_zval_ptr(opline, opline->op1_type, &opline->op1, execute_data); return (op && Z_TYPE_P(op) == IS_STRING) ? Z_STRVAL_P(op) : NULL; } From 23b7d37fe66954748dd743b8b5619c3d4853fde8 Mon Sep 17 00:00:00 2001 From: Levi Morrison Date: Wed, 15 Jul 2020 09:09:39 -0600 Subject: [PATCH 07/53] Expand ternary short-hand for Windows --- ext/observer/observer.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ext/observer/observer.c b/ext/observer/observer.c index c8bd0cdded060..c13088980bd47 100644 --- a/ext/observer/observer.c +++ b/ext/observer/observer.c @@ -65,7 +65,7 @@ static void observer_begin(zend_execute_data *execute_data) case ZEND_REQUIRE: case ZEND_REQUIRE_ONCE: { char *filename = observer_get_filename(execute_data); - printf("%*s<%s filename=\"%s\">\n", 2 * nesting_depth, "", include_pretty_name[extended_value], filename ?: "(unknown)"); + printf("%*s<%s filename=\"%s\">\n", 2 * nesting_depth, "", include_pretty_name[extended_value], filename ? filename : "(unknown)"); } break; From 15533367da43691d839b52a3dab8a62afe649b78 Mon Sep 17 00:00:00 2001 From: Levi Morrison Date: Wed, 15 Jul 2020 15:51:53 -0600 Subject: [PATCH 08/53] Try fixing missing symbol --- Zend/zend_observer.c | 4 ++++ Zend/zend_observer.h | 2 +- 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/Zend/zend_observer.c b/Zend/zend_observer.c index 9831d715d7cd4..d8d6335217a9e 100644 --- a/Zend/zend_observer.c +++ b/Zend/zend_observer.c @@ -8,6 +8,10 @@ int zend_observer_fcall_op_array_extension = -1; ZEND_TLS zend_arena *fcall_handlers_arena = NULL; +ZEND_API extern inline void zend_observer_maybe_fcall_call_end( + zend_execute_data *execute_data, + zval *return_value); + // Call during minit/startup ONLY ZEND_API void zend_observer_fcall_register(zend_observer_fcall_init init) { /* We don't want to get an extension handle unless an ext installs an observer */ diff --git a/Zend/zend_observer.h b/Zend/zend_observer.h index fcb4677290cf7..a99f87aea11ea 100644 --- a/Zend/zend_observer.h +++ b/Zend/zend_observer.h @@ -48,7 +48,7 @@ void zend_observe_fcall_end( zend_execute_data *execute_data, zval *return_value); -ZEND_API zend_always_inline void zend_observer_maybe_fcall_call_end( +ZEND_API inline void zend_observer_maybe_fcall_call_end( zend_execute_data *execute_data, zval *return_value) { From 947c955621650a674bf2559aac5266fffa9679b6 Mon Sep 17 00:00:00 2001 From: Levi Morrison Date: Fri, 24 Jul 2020 12:21:29 -0600 Subject: [PATCH 09/53] Free OP1 of INCLUDE_OR_EVAL later so observers can look at it Also clean up ext/observer's .end handling --- Zend/zend_vm_def.h | 5 +++-- Zend/zend_vm_execute.h | 15 +++++++++------ ext/observer/observer.c | 22 +++++++++++----------- 3 files changed, 23 insertions(+), 19 deletions(-) diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index b8d3c77c1bfd6..42b06aa2c7a4b 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -5868,9 +5868,8 @@ ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMPVAR|CV, ANY, EVAL) inc_filename = GET_OP1_ZVAL_PTR(BP_VAR_R); new_op_array = zend_include_or_eval(inc_filename, opline->extended_value); - // todo: uh... I think we can't free this yet. Observers may want to know it? - FREE_OP1(); if (UNEXPECTED(EG(exception) != NULL)) { + FREE_OP1(); if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) { destroy_op_array(new_op_array); efree_size(new_op_array, sizeof(zend_op_array)); @@ -5924,12 +5923,14 @@ ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMPVAR|CV, ANY, EVAL) efree_size(new_op_array, sizeof(zend_op_array)); if (UNEXPECTED(EG(exception) != NULL)) { zend_rethrow_exception(execute_data); + FREE_OP1(); UNDEF_RESULT(); HANDLE_EXCEPTION(); } } else if (RETURN_VALUE_USED(opline)) { ZVAL_FALSE(EX_VAR(opline->result.var)); } + FREE_OP1(); ZEND_VM_NEXT_OPCODE(); } diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index c748d6c2e49b8..6ede6d8c3453d 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -4042,9 +4042,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HAN inc_filename = RT_CONSTANT(opline, opline->op1); new_op_array = zend_include_or_eval(inc_filename, opline->extended_value); - // todo: uh... I think we can't free this yet. Observers may want to know it? - if (UNEXPECTED(EG(exception) != NULL)) { + if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) { destroy_op_array(new_op_array); efree_size(new_op_array, sizeof(zend_op_array)); @@ -4098,12 +4097,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HAN efree_size(new_op_array, sizeof(zend_op_array)); if (UNEXPECTED(EG(exception) != NULL)) { zend_rethrow_exception(execute_data); + UNDEF_RESULT(); HANDLE_EXCEPTION(); } } else if (RETURN_VALUE_USED(opline)) { ZVAL_FALSE(EX_VAR(opline->result.var)); } + ZEND_VM_NEXT_OPCODE(); } @@ -13277,9 +13278,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HA inc_filename = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); new_op_array = zend_include_or_eval(inc_filename, opline->extended_value); - // todo: uh... I think we can't free this yet. Observers may want to know it? - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); if (UNEXPECTED(EG(exception) != NULL)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) { destroy_op_array(new_op_array); efree_size(new_op_array, sizeof(zend_op_array)); @@ -13333,12 +13333,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HA efree_size(new_op_array, sizeof(zend_op_array)); if (UNEXPECTED(EG(exception) != NULL)) { zend_rethrow_exception(execute_data); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); UNDEF_RESULT(); HANDLE_EXCEPTION(); } } else if (RETURN_VALUE_USED(opline)) { ZVAL_FALSE(EX_VAR(opline->result.var)); } + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); ZEND_VM_NEXT_OPCODE(); } @@ -36512,9 +36514,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLE inc_filename = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); new_op_array = zend_include_or_eval(inc_filename, opline->extended_value); - // todo: uh... I think we can't free this yet. Observers may want to know it? - if (UNEXPECTED(EG(exception) != NULL)) { + if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) { destroy_op_array(new_op_array); efree_size(new_op_array, sizeof(zend_op_array)); @@ -36568,12 +36569,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLE efree_size(new_op_array, sizeof(zend_op_array)); if (UNEXPECTED(EG(exception) != NULL)) { zend_rethrow_exception(execute_data); + UNDEF_RESULT(); HANDLE_EXCEPTION(); } } else if (RETURN_VALUE_USED(opline)) { ZVAL_FALSE(EX_VAR(opline->result.var)); } + ZEND_VM_NEXT_OPCODE(); } diff --git a/ext/observer/observer.c b/ext/observer/observer.c index c13088980bd47..a9b5147069613 100644 --- a/ext/observer/observer.c +++ b/ext/observer/observer.c @@ -19,7 +19,7 @@ #endif int zend_observer_fcall_op_array_extension; -ZEND_TLS unsigned int nesting_depth = 1; +ZEND_TLS int nesting_depth = 0; PHP_FUNCTION(observer_op_array_extension_handle) { @@ -80,29 +80,29 @@ static void observer_begin(zend_execute_data *execute_data) static void observer_end(zend_execute_data *execute_data, zval *retval) { if (getenv("OBSERVER_DEBUG")) { - --nesting_depth; + --nesting_depth; if (execute_data->func && execute_data->func->common.function_name) { printf("%*s\n", 2 * nesting_depth, "", ZSTR_VAL(execute_data->func->common.function_name)); - } else if (execute_data->opline->opcode == ZEND_INCLUDE_OR_EVAL) { - uint32_t extended_value = execute_data->opline->extended_value; + return; + } + zend_execute_data *prev_execute_data = execute_data->prev_execute_data; + if (prev_execute_data && prev_execute_data->opline->opcode == ZEND_INCLUDE_OR_EVAL) { + uint32_t extended_value = prev_execute_data->opline->extended_value; switch (extended_value) { case ZEND_INCLUDE: case ZEND_INCLUDE_ONCE: case ZEND_REQUIRE: - case ZEND_REQUIRE_ONCE: { + case ZEND_REQUIRE_ONCE: printf("%*s\n", 2 * nesting_depth, "", include_pretty_name[extended_value]); - } - break; + break; case ZEND_EVAL: printf("%*s\n", 2 * nesting_depth, ""); - + break; default: - ZEND_ASSERT(0 ); + ZEND_ASSERT(0); } - } else { - ZEND_ASSERT(0); } } } From fe6b4470952babf2c3f076ff131d9230722b1475 Mon Sep 17 00:00:00 2001 From: Sammy Powers Date: Fri, 24 Jul 2020 17:55:20 -0700 Subject: [PATCH 10/53] Move observer arena allocation for call handers to first-time register Also add a wrapper to the runtime cache getter --- Zend/zend.c | 6 +----- Zend/zend_execute_API.c | 3 ++- Zend/zend_observer.c | 9 ++------- Zend/zend_observer.h | 8 +++++--- Zend/zend_vm_def.h | 13 ++++++++----- Zend/zend_vm_execute.h | 27 +++++++++++++++++---------- 6 files changed, 35 insertions(+), 31 deletions(-) diff --git a/Zend/zend.c b/Zend/zend.c index 8012fb8c07c14..0206bd13cdddc 100644 --- a/Zend/zend.c +++ b/Zend/zend.c @@ -33,6 +33,7 @@ #include "zend_smart_string.h" #include "zend_cpuinfo.h" #include "zend_attributes.h" +#include "zend_observer.h" static size_t global_map_ptr_last = 0; @@ -1170,10 +1171,6 @@ ZEND_API const char *get_zend_version(void) /* {{{ */ } /* }}} */ - -ZEND_API void zend_observer_activate(void); -ZEND_API void zend_observer_deactivate(void); - ZEND_API void zend_activate(void) /* {{{ */ { #ifdef ZTS @@ -1186,7 +1183,6 @@ ZEND_API void zend_activate(void) /* {{{ */ if (CG(map_ptr_last)) { memset(ZEND_MAP_PTR_REAL_BASE(CG(map_ptr_base)), 0, CG(map_ptr_last) * sizeof(void*)); } - zend_observer_activate(); } /* }}} */ diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c index 7f1c8f8774777..c4402dbe4230e 100644 --- a/Zend/zend_execute_API.c +++ b/Zend/zend_execute_API.c @@ -784,7 +784,8 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache) / zend_init_func_execute_data(call, &func->op_array, fci->retval); if (zend_observer_fcall_op_array_extension != -1 && !(func->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE))) { - void *observer_handlers = ZEND_OP_ARRAY_EXTENSION(&func->op_array, zend_observer_fcall_op_array_extension); + void *observer_handlers = ZEND_OBSERVER_HANDLERS(&func->op_array); + ZEND_ASSERT(observer_handlers); if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { zend_observe_fcall_begin(observer_handlers, call); } diff --git a/Zend/zend_observer.c b/Zend/zend_observer.c index d8d6335217a9e..21193bcb8d442 100644 --- a/Zend/zend_observer.c +++ b/Zend/zend_observer.c @@ -17,6 +17,8 @@ ZEND_API void zend_observer_fcall_register(zend_observer_fcall_init init) { /* We don't want to get an extension handle unless an ext installs an observer */ if (zend_observer_fcall_op_array_extension == -1) { zend_observer_fcall_op_array_extension = zend_get_op_array_extension_handle(); + /* todo: how to size the arena? */ + fcall_handlers_arena = zend_arena_create(1024); } zend_llist_add_element(&zend_observers_fcall_list, &init); } @@ -26,13 +28,6 @@ ZEND_API void zend_observer_startup(void) { zend_llist_init(&zend_observers_fcall_list, sizeof(zend_observer_fcall_init), NULL, 1); } -ZEND_API void zend_observer_activate(void) { - /* todo: how to size the arena? */ - if (zend_observer_fcall_op_array_extension != -1) { - fcall_handlers_arena = zend_arena_create(1024); - } -} - ZEND_API void zend_observer_deactivate(void) { if (fcall_handlers_arena) { zend_arena_destroy(fcall_handlers_arena); diff --git a/Zend/zend_observer.h b/Zend/zend_observer.h index a99f87aea11ea..6aabebddb9dc1 100644 --- a/Zend/zend_observer.h +++ b/Zend/zend_observer.h @@ -10,6 +10,9 @@ BEGIN_EXTERN_C() extern int zend_observer_fcall_op_array_extension; +#define ZEND_OBSERVER_HANDLERS(op_array) \ + ZEND_OP_ARRAY_EXTENSION(op_array, zend_observer_fcall_op_array_extension) + #define ZEND_OBSERVER_NOT_OBSERVED ((void *) 2) struct zend_observer_fcall { @@ -33,7 +36,6 @@ typedef zend_observer_fcall(*zend_observer_fcall_init)(zend_function *func); ZEND_API void zend_observer_fcall_register(zend_observer_fcall_init init); ZEND_API void zend_observer_startup(void); // Called by engine before MINITs -ZEND_API void zend_observer_activate(void); ZEND_API void zend_observer_deactivate(void); ZEND_API void zend_observer_shutdown(void); @@ -58,8 +60,8 @@ ZEND_API inline void zend_observer_maybe_fcall_call_end( zend_function *func = execute_data->func; if (!(func->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE))) { - void *observer_handlers = - ZEND_OP_ARRAY_EXTENSION(&func->op_array, zend_observer_fcall_op_array_extension); + void *observer_handlers = ZEND_OBSERVER_HANDLERS(&func->op_array); + ZEND_ASSERT(observer_handlers); if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { zend_observer_fcall_cache *cache = observer_handlers; zend_observe_fcall_end(cache, execute_data, return_value); diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 42b06aa2c7a4b..a06f62c5f9369 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -3933,7 +3933,8 @@ ZEND_VM_HOT_HANDLER(130, ZEND_DO_UCALL, ANY, ANY, SPEC(RETVAL)) i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); if (zend_observer_fcall_op_array_extension != -1 && !(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE))) { - void *observer_handlers = ZEND_OP_ARRAY_EXTENSION(&fbc->op_array, zend_observer_fcall_op_array_extension); + void *observer_handlers = ZEND_OBSERVER_HANDLERS(&fbc->op_array); + ZEND_ASSERT(observer_handlers); if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { zend_observe_fcall_begin(observer_handlers, call); } @@ -3963,7 +3964,8 @@ ZEND_VM_HOT_HANDLER(131, ZEND_DO_FCALL_BY_NAME, ANY, ANY, SPEC(RETVAL)) i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); if (zend_observer_fcall_op_array_extension != -1 && !(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE))) { - void *observer_handlers = ZEND_OP_ARRAY_EXTENSION(&fbc->op_array, zend_observer_fcall_op_array_extension); + void *observer_handlers = ZEND_OBSERVER_HANDLERS(&fbc->op_array); + ZEND_ASSERT(observer_handlers); if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { zend_observe_fcall_begin(observer_handlers, call); } @@ -4052,7 +4054,7 @@ ZEND_VM_HOT_HANDLER(60, ZEND_DO_FCALL, ANY, ANY, SPEC(RETVAL)) i_init_func_execute_data(&fbc->op_array, ret, 1 EXECUTE_DATA_CC); if (zend_observer_fcall_op_array_extension != -1 && !(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE))) { - void *observer_handlers = ZEND_OP_ARRAY_EXTENSION(&fbc->op_array, zend_observer_fcall_op_array_extension); + void *observer_handlers = ZEND_OBSERVER_HANDLERS(&fbc->op_array); ZEND_ASSERT(observer_handlers); if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { zend_observe_fcall_begin(observer_handlers, call); @@ -5905,7 +5907,8 @@ ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMPVAR|CV, ANY, EVAL) i_init_code_execute_data(call, new_op_array, return_value); if (zend_observer_fcall_op_array_extension != -1 && new_op_array != ZEND_FAKE_OP_ARRAY) { - void *observer_handlers = ZEND_OP_ARRAY_EXTENSION(new_op_array, zend_observer_fcall_op_array_extension); + void *observer_handlers = ZEND_OBSERVER_HANDLERS(new_op_array); + ZEND_ASSERT(observer_handlers); if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { zend_observe_fcall_begin(observer_handlers, execute_data); } @@ -8168,7 +8171,7 @@ ZEND_VM_HANDLER(158, ZEND_CALL_TRAMPOLINE, ANY, ANY) /* if (zend_observer_fcall_op_array_extension != -1) { - void *observer_handlers = ZEND_OP_ARRAY_EXTENSION(&fbc->op_array, zend_observer_fcall_op_array_extension); + void *observer_handlers = ZEND_OBSERVER_HANDLERS(&fbc->op_array); ZEND_ASSERT(observer_handlers); } */ diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 6ede6d8c3453d..ad6b2ce86fe38 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -1328,7 +1328,8 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_RETV i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); if (zend_observer_fcall_op_array_extension != -1 && !(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE))) { - void *observer_handlers = ZEND_OP_ARRAY_EXTENSION(&fbc->op_array, zend_observer_fcall_op_array_extension); + void *observer_handlers = ZEND_OBSERVER_HANDLERS(&fbc->op_array); + ZEND_ASSERT(observer_handlers); if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { zend_observe_fcall_begin(observer_handlers, call); } @@ -1359,7 +1360,8 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_RETV i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); if (zend_observer_fcall_op_array_extension != -1 && !(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE))) { - void *observer_handlers = ZEND_OP_ARRAY_EXTENSION(&fbc->op_array, zend_observer_fcall_op_array_extension); + void *observer_handlers = ZEND_OBSERVER_HANDLERS(&fbc->op_array); + ZEND_ASSERT(observer_handlers); if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { zend_observe_fcall_begin(observer_handlers, call); } @@ -1389,7 +1391,8 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_S i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); if (zend_observer_fcall_op_array_extension != -1 && !(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE))) { - void *observer_handlers = ZEND_OP_ARRAY_EXTENSION(&fbc->op_array, zend_observer_fcall_op_array_extension); + void *observer_handlers = ZEND_OBSERVER_HANDLERS(&fbc->op_array); + ZEND_ASSERT(observer_handlers); if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { zend_observe_fcall_begin(observer_handlers, call); } @@ -1478,7 +1481,8 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_S i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); if (zend_observer_fcall_op_array_extension != -1 && !(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE))) { - void *observer_handlers = ZEND_OP_ARRAY_EXTENSION(&fbc->op_array, zend_observer_fcall_op_array_extension); + void *observer_handlers = ZEND_OBSERVER_HANDLERS(&fbc->op_array); + ZEND_ASSERT(observer_handlers); if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { zend_observe_fcall_begin(observer_handlers, call); } @@ -1567,7 +1571,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETV i_init_func_execute_data(&fbc->op_array, ret, 1 EXECUTE_DATA_CC); if (zend_observer_fcall_op_array_extension != -1 && !(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE))) { - void *observer_handlers = ZEND_OP_ARRAY_EXTENSION(&fbc->op_array, zend_observer_fcall_op_array_extension); + void *observer_handlers = ZEND_OBSERVER_HANDLERS(&fbc->op_array); ZEND_ASSERT(observer_handlers); if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { zend_observe_fcall_begin(observer_handlers, call); @@ -1673,7 +1677,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETV i_init_func_execute_data(&fbc->op_array, ret, 1 EXECUTE_DATA_CC); if (zend_observer_fcall_op_array_extension != -1 && !(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE))) { - void *observer_handlers = ZEND_OP_ARRAY_EXTENSION(&fbc->op_array, zend_observer_fcall_op_array_extension); + void *observer_handlers = ZEND_OBSERVER_HANDLERS(&fbc->op_array); ZEND_ASSERT(observer_handlers); if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { zend_observe_fcall_begin(observer_handlers, call); @@ -2797,7 +2801,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CALL_TRAMPOLINE_SPEC_HANDLER(Z /* if (zend_observer_fcall_op_array_extension != -1) { - void *observer_handlers = ZEND_OP_ARRAY_EXTENSION(&fbc->op_array, zend_observer_fcall_op_array_extension); + void *observer_handlers = ZEND_OBSERVER_HANDLERS(&fbc->op_array); ZEND_ASSERT(observer_handlers); } */ @@ -4079,7 +4083,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HAN i_init_code_execute_data(call, new_op_array, return_value); if (zend_observer_fcall_op_array_extension != -1 && new_op_array != ZEND_FAKE_OP_ARRAY) { - void *observer_handlers = ZEND_OP_ARRAY_EXTENSION(new_op_array, zend_observer_fcall_op_array_extension); + void *observer_handlers = ZEND_OBSERVER_HANDLERS(new_op_array); + ZEND_ASSERT(observer_handlers); if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { zend_observe_fcall_begin(observer_handlers, execute_data); } @@ -13315,7 +13320,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HA i_init_code_execute_data(call, new_op_array, return_value); if (zend_observer_fcall_op_array_extension != -1 && new_op_array != ZEND_FAKE_OP_ARRAY) { - void *observer_handlers = ZEND_OP_ARRAY_EXTENSION(new_op_array, zend_observer_fcall_op_array_extension); + void *observer_handlers = ZEND_OBSERVER_HANDLERS(new_op_array); + ZEND_ASSERT(observer_handlers); if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { zend_observe_fcall_begin(observer_handlers, execute_data); } @@ -36551,7 +36557,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLE i_init_code_execute_data(call, new_op_array, return_value); if (zend_observer_fcall_op_array_extension != -1 && new_op_array != ZEND_FAKE_OP_ARRAY) { - void *observer_handlers = ZEND_OP_ARRAY_EXTENSION(new_op_array, zend_observer_fcall_op_array_extension); + void *observer_handlers = ZEND_OBSERVER_HANDLERS(new_op_array); + ZEND_ASSERT(observer_handlers); if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { zend_observe_fcall_begin(observer_handlers, execute_data); } From 3f617d11939c1986fd38a55e66c48b28cc27852f Mon Sep 17 00:00:00 2001 From: Sammy Powers Date: Fri, 7 Aug 2020 12:38:46 -0700 Subject: [PATCH 11/53] Refactor where function init/begin/end handlers are called --- Zend/zend_execute.c | 36 ++++++++++++++---- Zend/zend_observer.h | 3 ++ Zend/zend_vm_def.h | 39 ++----------------- Zend/zend_vm_execute.h | 85 ++++++------------------------------------ 4 files changed, 47 insertions(+), 116 deletions(-) diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c index ac435c9f51400..0812b9afde9e0 100644 --- a/Zend/zend_execute.c +++ b/Zend/zend_execute.c @@ -3541,6 +3541,14 @@ static zend_always_inline void i_init_func_execute_data(zend_op_array *op_array, EX(run_time_cache) = RUN_TIME_CACHE(op_array); EG(current_execute_data) = execute_data; + + if (ZEND_SHOULD_OBSERVE_FN(op_array->fn_flags)) { + void *observer_handlers = ZEND_OBSERVER_HANDLERS(&EX(func)->op_array); + ZEND_ASSERT(observer_handlers); + if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { + zend_observe_fcall_begin(observer_handlers, execute_data); + } + } } /* }}} */ @@ -3552,7 +3560,10 @@ static zend_always_inline void init_func_run_time_cache_i(zend_op_array *op_arra run_time_cache = zend_arena_alloc(&CG(arena), op_array->cache_size); memset(run_time_cache, 0, op_array->cache_size); ZEND_MAP_PTR_SET(op_array->run_time_cache, run_time_cache); - zend_observer_fcall_install((zend_function*) op_array); + + if (ZEND_SHOULD_OBSERVE_FN(op_array->fn_flags)) { + zend_observer_fcall_install((zend_function*) op_array); + } } /* }}} */ @@ -3599,8 +3610,12 @@ ZEND_API void ZEND_FASTCALL zend_init_func_run_time_cache(zend_op_array *op_arra } } /* }}} */ +#define ZEND_FAKE_OP_ARRAY ((zend_op_array*)(zend_intptr_t)-1) + static zend_always_inline void i_init_code_execute_data(zend_execute_data *execute_data, zend_op_array *op_array, zval *return_value) /* {{{ */ { + void *ptr = NULL; + ZEND_ASSERT(EX(func) == (zend_function*)op_array); EX(opline) = op_array->opcodes; @@ -3610,20 +3625,29 @@ static zend_always_inline void i_init_code_execute_data(zend_execute_data *execu zend_attach_symbol_table(execute_data); if (!ZEND_MAP_PTR(op_array->run_time_cache)) { - void *ptr; - ZEND_ASSERT(op_array->fn_flags & ZEND_ACC_HEAP_RT_CACHE); ptr = emalloc(op_array->cache_size + sizeof(void*)); ZEND_MAP_PTR_INIT(op_array->run_time_cache, ptr); ptr = (char*)ptr + sizeof(void*); ZEND_MAP_PTR_SET(op_array->run_time_cache, ptr); memset(ptr, 0, op_array->cache_size); - - zend_observer_fcall_install((zend_function*)op_array); } EX(run_time_cache) = RUN_TIME_CACHE(op_array); EG(current_execute_data) = execute_data; + + if (zend_observer_fcall_op_array_extension != -1 && op_array != ZEND_FAKE_OP_ARRAY) { + if (ptr != NULL) { + // TODO: Pass execute_data via zend_observer_execute_install() + zend_observer_fcall_install((zend_function*)op_array); + } + void *observer_handlers = ZEND_OBSERVER_HANDLERS(op_array); + ZEND_ASSERT(observer_handlers); + if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { + // TODO: Run zend_observe_execute_begin() handlers + zend_observe_fcall_begin(observer_handlers, execute_data); + } + } } /* }}} */ @@ -4149,8 +4173,6 @@ static zend_never_inline zend_execute_data *zend_init_dynamic_call_array(zend_ar } /* }}} */ -#define ZEND_FAKE_OP_ARRAY ((zend_op_array*)(zend_intptr_t)-1) - static zend_never_inline zend_op_array* ZEND_FASTCALL zend_include_or_eval(zval *inc_filename, int type) /* {{{ */ { zend_op_array *new_op_array = NULL; diff --git a/Zend/zend_observer.h b/Zend/zend_observer.h index 6aabebddb9dc1..36e30c1321a24 100644 --- a/Zend/zend_observer.h +++ b/Zend/zend_observer.h @@ -15,6 +15,9 @@ extern int zend_observer_fcall_op_array_extension; #define ZEND_OBSERVER_NOT_OBSERVED ((void *) 2) +#define ZEND_SHOULD_OBSERVE_FN(fn_flags) \ + zend_observer_fcall_op_array_extension != -1 && !(fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE)) + struct zend_observer_fcall { void (*begin)(zend_execute_data *execute_data); void (*end)(zend_execute_data *execute_data, zval *retval); diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index a06f62c5f9369..637ffe902a55e 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -2761,6 +2761,9 @@ ZEND_VM_HOT_HELPER(zend_leave_helper, ANY, ANY) uint32_t call_info = EX_CALL_INFO(); SAVE_OPLINE(); + // TODO Maybe not pass in return_value explicitly? + zend_observer_maybe_fcall_call_end(execute_data, EX(return_value)); + if (EXPECTED((call_info & (ZEND_CALL_CODE|ZEND_CALL_TOP|ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS|ZEND_CALL_ALLOCATED)) == 0)) { EG(current_execute_data) = EX(prev_execute_data); i_free_compiled_variables(execute_data); @@ -3932,14 +3935,6 @@ ZEND_VM_HOT_HANDLER(130, ZEND_DO_UCALL, ANY, ANY, SPEC(RETVAL)) execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); - if (zend_observer_fcall_op_array_extension != -1 && !(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE))) { - void *observer_handlers = ZEND_OBSERVER_HANDLERS(&fbc->op_array); - ZEND_ASSERT(observer_handlers); - if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { - zend_observe_fcall_begin(observer_handlers, call); - } - } - ZEND_VM_ENTER_EX(); } @@ -3963,14 +3958,6 @@ ZEND_VM_HOT_HANDLER(131, ZEND_DO_FCALL_BY_NAME, ANY, ANY, SPEC(RETVAL)) execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); - if (zend_observer_fcall_op_array_extension != -1 && !(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE))) { - void *observer_handlers = ZEND_OBSERVER_HANDLERS(&fbc->op_array); - ZEND_ASSERT(observer_handlers); - if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { - zend_observe_fcall_begin(observer_handlers, call); - } - } - LOAD_OPLINE_EX(); ZEND_VM_ENTER_EX(); @@ -4053,14 +4040,6 @@ ZEND_VM_HOT_HANDLER(60, ZEND_DO_FCALL, ANY, ANY, SPEC(RETVAL)) execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 1 EXECUTE_DATA_CC); - if (zend_observer_fcall_op_array_extension != -1 && !(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE))) { - void *observer_handlers = ZEND_OBSERVER_HANDLERS(&fbc->op_array); - ZEND_ASSERT(observer_handlers); - if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { - zend_observe_fcall_begin(observer_handlers, call); - } - } - if (EXPECTED(zend_execute_ex == execute_ex)) { LOAD_OPLINE_EX(); ZEND_VM_ENTER_EX(); @@ -4275,9 +4254,6 @@ ZEND_VM_INLINE_HANDLER(62, ZEND_RETURN, CONST|TMP|VAR|CV, ANY) } } - // todo: should this go in the leave helper? - zend_observer_maybe_fcall_call_end(execute_data, return_value); - ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper); } @@ -5906,14 +5882,6 @@ ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMPVAR|CV, ANY, EVAL) call->prev_execute_data = execute_data; i_init_code_execute_data(call, new_op_array, return_value); - if (zend_observer_fcall_op_array_extension != -1 && new_op_array != ZEND_FAKE_OP_ARRAY) { - void *observer_handlers = ZEND_OBSERVER_HANDLERS(new_op_array); - ZEND_ASSERT(observer_handlers); - if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { - zend_observe_fcall_begin(observer_handlers, execute_data); - } - } - if (EXPECTED(zend_execute_ex == execute_ex)) { ZEND_VM_ENTER(); } else { @@ -7374,7 +7342,6 @@ ZEND_VM_HELPER(zend_dispatch_try_catch_finally_helper, ANY, ANY, uint32_t try_ca } /* Uncaught exception */ - zend_observer_maybe_fcall_call_end(execute_data, &EG(uninitialized_zval)); cleanup_live_vars(execute_data, op_num, 0); if (UNEXPECTED((EX_CALL_INFO() & ZEND_CALL_GENERATOR) != 0)) { diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index ad6b2ce86fe38..a1fe934c4b1c4 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -1085,6 +1085,9 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_leave_helper uint32_t call_info = EX_CALL_INFO(); SAVE_OPLINE(); + // TODO Maybe not pass in return_value explicitly? + zend_observer_maybe_fcall_call_end(execute_data, EX(return_value)); + if (EXPECTED((call_info & (ZEND_CALL_CODE|ZEND_CALL_TOP|ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS|ZEND_CALL_ALLOCATED)) == 0)) { EG(current_execute_data) = EX(prev_execute_data); i_free_compiled_variables(execute_data); @@ -1327,14 +1330,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_RETV execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); - if (zend_observer_fcall_op_array_extension != -1 && !(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE))) { - void *observer_handlers = ZEND_OBSERVER_HANDLERS(&fbc->op_array); - ZEND_ASSERT(observer_handlers); - if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { - zend_observe_fcall_begin(observer_handlers, call); - } - } - ZEND_VM_ENTER_EX(); } @@ -1359,14 +1354,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_RETV execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); - if (zend_observer_fcall_op_array_extension != -1 && !(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE))) { - void *observer_handlers = ZEND_OBSERVER_HANDLERS(&fbc->op_array); - ZEND_ASSERT(observer_handlers); - if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { - zend_observe_fcall_begin(observer_handlers, call); - } - } - ZEND_VM_ENTER_EX(); } @@ -1390,14 +1377,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_S execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); - if (zend_observer_fcall_op_array_extension != -1 && !(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE))) { - void *observer_handlers = ZEND_OBSERVER_HANDLERS(&fbc->op_array); - ZEND_ASSERT(observer_handlers); - if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { - zend_observe_fcall_begin(observer_handlers, call); - } - } - LOAD_OPLINE_EX(); ZEND_VM_ENTER_EX(); @@ -1480,14 +1459,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_S execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); - if (zend_observer_fcall_op_array_extension != -1 && !(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE))) { - void *observer_handlers = ZEND_OBSERVER_HANDLERS(&fbc->op_array); - ZEND_ASSERT(observer_handlers); - if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { - zend_observe_fcall_begin(observer_handlers, call); - } - } - LOAD_OPLINE_EX(); ZEND_VM_ENTER_EX(); @@ -1570,14 +1541,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETV execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 1 EXECUTE_DATA_CC); - if (zend_observer_fcall_op_array_extension != -1 && !(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE))) { - void *observer_handlers = ZEND_OBSERVER_HANDLERS(&fbc->op_array); - ZEND_ASSERT(observer_handlers); - if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { - zend_observe_fcall_begin(observer_handlers, call); - } - } - if (EXPECTED(zend_execute_ex == execute_ex)) { LOAD_OPLINE_EX(); ZEND_VM_ENTER_EX(); @@ -1676,14 +1639,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETV execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 1 EXECUTE_DATA_CC); - if (zend_observer_fcall_op_array_extension != -1 && !(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE))) { - void *observer_handlers = ZEND_OBSERVER_HANDLERS(&fbc->op_array); - ZEND_ASSERT(observer_handlers); - if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { - zend_observe_fcall_begin(observer_handlers, call); - } - } - if (EXPECTED(zend_execute_ex == execute_ex)) { LOAD_OPLINE_EX(); ZEND_VM_ENTER_EX(); @@ -2568,7 +2523,6 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_dispatch_try } /* Uncaught exception */ - zend_observer_maybe_fcall_call_end(execute_data, &EG(uninitialized_zval)); cleanup_live_vars(execute_data, op_num, 0); if (UNEXPECTED((EX_CALL_INFO() & ZEND_CALL_GENERATOR) != 0)) { @@ -3580,9 +3534,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_CONST_ } } - // todo: should this go in the leave helper? - zend_observer_maybe_fcall_call_end(execute_data, return_value); - ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } @@ -4082,6 +4033,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HAN call->prev_execute_data = execute_data; i_init_code_execute_data(call, new_op_array, return_value); + /* TODO Move to i_init_code_execute_data if (zend_observer_fcall_op_array_extension != -1 && new_op_array != ZEND_FAKE_OP_ARRAY) { void *observer_handlers = ZEND_OBSERVER_HANDLERS(new_op_array); ZEND_ASSERT(observer_handlers); @@ -4089,6 +4041,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HAN zend_observe_fcall_begin(observer_handlers, execute_data); } } + */ if (EXPECTED(zend_execute_ex == execute_ex)) { ZEND_VM_ENTER(); @@ -13319,6 +13272,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HA call->prev_execute_data = execute_data; i_init_code_execute_data(call, new_op_array, return_value); + /* TODO Move to i_init_code_execute_data if (zend_observer_fcall_op_array_extension != -1 && new_op_array != ZEND_FAKE_OP_ARRAY) { void *observer_handlers = ZEND_OBSERVER_HANDLERS(new_op_array); ZEND_ASSERT(observer_handlers); @@ -13326,6 +13280,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HA zend_observe_fcall_begin(observer_handlers, execute_data); } } + */ if (EXPECTED(zend_execute_ex == execute_ex)) { ZEND_VM_ENTER(); @@ -17557,9 +17512,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_TMP_HA } } - // todo: should this go in the leave helper? - zend_observer_maybe_fcall_call_end(execute_data, return_value); - ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } @@ -20047,9 +19999,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_VAR_HA } } - // todo: should this go in the leave helper? - zend_observer_maybe_fcall_call_end(execute_data, return_value); - ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } @@ -36016,9 +35965,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_CV_HAN } } - // todo: should this go in the leave helper? - zend_observer_maybe_fcall_call_end(execute_data, return_value); - ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } @@ -36556,6 +36502,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLE call->prev_execute_data = execute_data; i_init_code_execute_data(call, new_op_array, return_value); + /* TODO Move to i_init_code_execute_data if (zend_observer_fcall_op_array_extension != -1 && new_op_array != ZEND_FAKE_OP_ARRAY) { void *observer_handlers = ZEND_OBSERVER_HANDLERS(new_op_array); ZEND_ASSERT(observer_handlers); @@ -36563,6 +36510,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLE zend_observe_fcall_begin(observer_handlers, execute_data); } } + */ if (EXPECTED(zend_execute_ex == execute_ex)) { ZEND_VM_ENTER(); @@ -52237,6 +52185,9 @@ ZEND_API void execute_ex(zend_execute_data *ex) uint32_t call_info = EX_CALL_INFO(); SAVE_OPLINE(); + // TODO Maybe not pass in return_value explicitly? + zend_observer_maybe_fcall_call_end(execute_data, EX(return_value)); + if (EXPECTED((call_info & (ZEND_CALL_CODE|ZEND_CALL_TOP|ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS|ZEND_CALL_ALLOCATED)) == 0)) { EG(current_execute_data) = EX(prev_execute_data); i_free_compiled_variables(execute_data); @@ -52622,9 +52573,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) } } - // todo: should this go in the leave helper? - zend_observer_maybe_fcall_call_end(execute_data, return_value); - goto zend_leave_helper_SPEC_LABEL; } @@ -54127,9 +54075,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) } } - // todo: should this go in the leave helper? - zend_observer_maybe_fcall_call_end(execute_data, return_value); - goto zend_leave_helper_SPEC_LABEL; } @@ -54424,9 +54369,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) } } - // todo: should this go in the leave helper? - zend_observer_maybe_fcall_call_end(execute_data, return_value); - goto zend_leave_helper_SPEC_LABEL; } @@ -55509,9 +55451,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) } } - // todo: should this go in the leave helper? - zend_observer_maybe_fcall_call_end(execute_data, return_value); - goto zend_leave_helper_SPEC_LABEL; } From a3e013965344e263ffa9775fe5336f912b23cc32 Mon Sep 17 00:00:00 2001 From: Sammy Powers Date: Fri, 7 Aug 2020 12:42:42 -0700 Subject: [PATCH 12/53] Remove fcall init handlers from zend_call_function() --- Zend/zend_execute_API.c | 8 -------- 1 file changed, 8 deletions(-) diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c index c4402dbe4230e..998eb495dc511 100644 --- a/Zend/zend_execute_API.c +++ b/Zend/zend_execute_API.c @@ -35,7 +35,6 @@ #include "zend_float.h" #include "zend_weakrefs.h" #include "zend_inheritance.h" -#include "zend_observer.h" #ifdef HAVE_SYS_TIME_H #include #endif @@ -783,13 +782,6 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache) / uint32_t orig_jit_trace_num = EG(jit_trace_num); zend_init_func_execute_data(call, &func->op_array, fci->retval); - if (zend_observer_fcall_op_array_extension != -1 && !(func->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE))) { - void *observer_handlers = ZEND_OBSERVER_HANDLERS(&func->op_array); - ZEND_ASSERT(observer_handlers); - if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { - zend_observe_fcall_begin(observer_handlers, call); - } - } zend_execute_ex(call); EG(jit_trace_num) = orig_jit_trace_num; EG(opline_before_exception) = current_opline_before_exception; From e5e7bced4cab2d632001a52f7b382cb8c5e23db0 Mon Sep 17 00:00:00 2001 From: Sammy Powers Date: Fri, 7 Aug 2020 12:51:01 -0700 Subject: [PATCH 13/53] Clean up --- Zend/zend_execute.c | 1 - Zend/zend_vm_def.h | 4 ---- Zend/zend_vm_execute.h | 46 ------------------------------------------ 3 files changed, 51 deletions(-) diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c index 0812b9afde9e0..4658c5ccb100f 100644 --- a/Zend/zend_execute.c +++ b/Zend/zend_execute.c @@ -35,7 +35,6 @@ #include "zend_interfaces.h" #include "zend_closures.h" #include "zend_generators.h" -#include "zend_observer.h" #include "zend_vm.h" #include "zend_dtrace.h" #include "zend_inheritance.h" diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 637ffe902a55e..a64bf0b869499 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -3957,7 +3957,6 @@ ZEND_VM_HOT_HANDLER(131, ZEND_DO_FCALL_BY_NAME, ANY, ANY, SPEC(RETVAL)) call->prev_execute_data = execute_data; execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); - LOAD_OPLINE_EX(); ZEND_VM_ENTER_EX(); @@ -4253,7 +4252,6 @@ ZEND_VM_INLINE_HANDLER(62, ZEND_RETURN, CONST|TMP|VAR|CV, ANY) } } } - ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper); } @@ -5845,7 +5843,6 @@ ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMPVAR|CV, ANY, EVAL) SAVE_OPLINE(); inc_filename = GET_OP1_ZVAL_PTR(BP_VAR_R); new_op_array = zend_include_or_eval(inc_filename, opline->extended_value); - if (UNEXPECTED(EG(exception) != NULL)) { FREE_OP1(); if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) { @@ -5881,7 +5878,6 @@ ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMPVAR|CV, ANY, EVAL) call->prev_execute_data = execute_data; i_init_code_execute_data(call, new_op_array, return_value); - if (EXPECTED(zend_execute_ex == execute_ex)) { ZEND_VM_ENTER(); } else { diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index a1fe934c4b1c4..7ef638cd58e09 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -1376,7 +1376,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_S call->prev_execute_data = execute_data; execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); - LOAD_OPLINE_EX(); ZEND_VM_ENTER_EX(); @@ -1458,7 +1457,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_S call->prev_execute_data = execute_data; execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); - LOAD_OPLINE_EX(); ZEND_VM_ENTER_EX(); @@ -3533,7 +3531,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_CONST_ } } } - ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } @@ -3996,7 +3993,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HAN SAVE_OPLINE(); inc_filename = RT_CONSTANT(opline, opline->op1); new_op_array = zend_include_or_eval(inc_filename, opline->extended_value); - if (UNEXPECTED(EG(exception) != NULL)) { if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) { @@ -4032,17 +4028,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HAN call->prev_execute_data = execute_data; i_init_code_execute_data(call, new_op_array, return_value); - - /* TODO Move to i_init_code_execute_data - if (zend_observer_fcall_op_array_extension != -1 && new_op_array != ZEND_FAKE_OP_ARRAY) { - void *observer_handlers = ZEND_OBSERVER_HANDLERS(new_op_array); - ZEND_ASSERT(observer_handlers); - if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { - zend_observe_fcall_begin(observer_handlers, execute_data); - } - } - */ - if (EXPECTED(zend_execute_ex == execute_ex)) { ZEND_VM_ENTER(); } else { @@ -13235,7 +13220,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HA SAVE_OPLINE(); inc_filename = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); new_op_array = zend_include_or_eval(inc_filename, opline->extended_value); - if (UNEXPECTED(EG(exception) != NULL)) { zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) { @@ -13271,17 +13255,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HA call->prev_execute_data = execute_data; i_init_code_execute_data(call, new_op_array, return_value); - - /* TODO Move to i_init_code_execute_data - if (zend_observer_fcall_op_array_extension != -1 && new_op_array != ZEND_FAKE_OP_ARRAY) { - void *observer_handlers = ZEND_OBSERVER_HANDLERS(new_op_array); - ZEND_ASSERT(observer_handlers); - if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { - zend_observe_fcall_begin(observer_handlers, execute_data); - } - } - */ - if (EXPECTED(zend_execute_ex == execute_ex)) { ZEND_VM_ENTER(); } else { @@ -17511,7 +17484,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_TMP_HA } } } - ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } @@ -19998,7 +19970,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_VAR_HA } } } - ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } @@ -35964,7 +35935,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_CV_HAN } } } - ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } @@ -36465,7 +36435,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLE SAVE_OPLINE(); inc_filename = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); new_op_array = zend_include_or_eval(inc_filename, opline->extended_value); - if (UNEXPECTED(EG(exception) != NULL)) { if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) { @@ -36501,17 +36470,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLE call->prev_execute_data = execute_data; i_init_code_execute_data(call, new_op_array, return_value); - - /* TODO Move to i_init_code_execute_data - if (zend_observer_fcall_op_array_extension != -1 && new_op_array != ZEND_FAKE_OP_ARRAY) { - void *observer_handlers = ZEND_OBSERVER_HANDLERS(new_op_array); - ZEND_ASSERT(observer_handlers); - if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { - zend_observe_fcall_begin(observer_handlers, execute_data); - } - } - */ - if (EXPECTED(zend_execute_ex == execute_ex)) { ZEND_VM_ENTER(); } else { @@ -52572,7 +52530,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) } } } - goto zend_leave_helper_SPEC_LABEL; } @@ -54074,7 +54031,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) } } } - goto zend_leave_helper_SPEC_LABEL; } @@ -54368,7 +54324,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) } } } - goto zend_leave_helper_SPEC_LABEL; } @@ -55450,7 +55405,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) } } } - goto zend_leave_helper_SPEC_LABEL; } From e7badd9c63a0946791077c217eafaed947fd3253 Mon Sep 17 00:00:00 2001 From: Sammy Powers Date: Fri, 7 Aug 2020 12:57:57 -0700 Subject: [PATCH 14/53] Clean up one more --- Zend/zend_vm_def.h | 9 --------- Zend/zend_vm_execute.h | 9 --------- 2 files changed, 18 deletions(-) diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index a64bf0b869499..161ea82a4c674 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -7338,7 +7338,6 @@ ZEND_VM_HELPER(zend_dispatch_try_catch_finally_helper, ANY, ANY, uint32_t try_ca } /* Uncaught exception */ - cleanup_live_vars(execute_data, op_num, 0); if (UNEXPECTED((EX_CALL_INFO() & ZEND_CALL_GENERATOR) != 0)) { zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C); @@ -8131,14 +8130,6 @@ ZEND_VM_HANDLER(158, ZEND_CALL_TRAMPOLINE, ANY, ANY) } execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); - -/* - if (zend_observer_fcall_op_array_extension != -1) { - void *observer_handlers = ZEND_OBSERVER_HANDLERS(&fbc->op_array); - ZEND_ASSERT(observer_handlers); - } -*/ - if (EXPECTED(zend_execute_ex == execute_ex)) { LOAD_OPLINE_EX(); ZEND_VM_ENTER_EX(); diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 7ef638cd58e09..122d64ec3a79b 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -2521,7 +2521,6 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_dispatch_try } /* Uncaught exception */ - cleanup_live_vars(execute_data, op_num, 0); if (UNEXPECTED((EX_CALL_INFO() & ZEND_CALL_GENERATOR) != 0)) { zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C); @@ -2750,14 +2749,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CALL_TRAMPOLINE_SPEC_HANDLER(Z } execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); - -/* - if (zend_observer_fcall_op_array_extension != -1) { - void *observer_handlers = ZEND_OBSERVER_HANDLERS(&fbc->op_array); - ZEND_ASSERT(observer_handlers); - } -*/ - if (EXPECTED(zend_execute_ex == execute_ex)) { LOAD_OPLINE_EX(); ZEND_VM_ENTER_EX(); From 71bbb1f8d911bb378d0a43bba6759a5b8cbd6f15 Mon Sep 17 00:00:00 2001 From: Sammy Powers Date: Fri, 7 Aug 2020 15:28:55 -0700 Subject: [PATCH 15/53] Add observer hooks to zend_test extension --- ext/zend_test/test.c | 97 +++++++++++++++++++++- ext/zend_test/tests/observer.inc | 8 ++ ext/zend_test/tests/observer_basic_01.phpt | 53 ++++++++++++ ext/zend_test/tests/observer_basic_02.phpt | 57 +++++++++++++ ext/zend_test/tests/observer_basic_03.phpt | 34 ++++++++ ext/zend_test/tests/observer_basic_04.phpt | 28 +++++++ ext/zend_test/tests/observer_basic_05.phpt | 30 +++++++ 7 files changed, 303 insertions(+), 4 deletions(-) create mode 100644 ext/zend_test/tests/observer.inc create mode 100644 ext/zend_test/tests/observer_basic_01.phpt create mode 100644 ext/zend_test/tests/observer_basic_02.phpt create mode 100644 ext/zend_test/tests/observer_basic_03.phpt create mode 100644 ext/zend_test/tests/observer_basic_04.phpt create mode 100644 ext/zend_test/tests/observer_basic_05.phpt diff --git a/ext/zend_test/test.c b/ext/zend_test/test.c index baff391f9e476..7cb95c2665f4e 100644 --- a/ext/zend_test/test.c +++ b/ext/zend_test/test.c @@ -24,6 +24,20 @@ #include "php_test.h" #include "test_arginfo.h" #include "zend_attributes.h" +#include "zend_observer.h" + +ZEND_BEGIN_MODULE_GLOBALS(zend_test) + int observer_enabled; + int observer_observe_all; + int observer_observe_includes; + int observer_observe_functions; + //HashTable observer_observe_functions_list; + int observer_nesting_depth; +ZEND_END_MODULE_GLOBALS(zend_test) + +ZEND_DECLARE_MODULE_GLOBALS(zend_test) + +#define ZT_G(v) ZEND_MODULE_GLOBALS_ACCESSOR(zend_test, v) static zend_class_entry *zend_test_interface; static zend_class_entry *zend_test_class; @@ -280,6 +294,13 @@ ZEND_METHOD(_ZendTestTrait, testMethod) /* {{{ */ { } /* }}} */ +PHP_INI_BEGIN() + STD_PHP_INI_BOOLEAN("zend_test.observer.enabled", "0", PHP_INI_SYSTEM, OnUpdateBool, observer_enabled, zend_zend_test_globals, zend_test_globals) + STD_PHP_INI_BOOLEAN("zend_test.observer.observe_all", "0", PHP_INI_SYSTEM, OnUpdateBool, observer_observe_all, zend_zend_test_globals, zend_test_globals) + STD_PHP_INI_BOOLEAN("zend_test.observer.observe_includes", "0", PHP_INI_SYSTEM, OnUpdateBool, observer_observe_includes, zend_zend_test_globals, zend_test_globals) + STD_PHP_INI_BOOLEAN("zend_test.observer.observe_functions", "0", PHP_INI_SYSTEM, OnUpdateBool, observer_observe_functions, zend_zend_test_globals, zend_test_globals) +PHP_INI_END() + PHP_MINIT_FUNCTION(zend_test) { zend_class_entry class_entry; @@ -365,19 +386,73 @@ PHP_MINIT_FUNCTION(zend_test) attr->validator = zend_attribute_validate_zendtestattribute; } + REGISTER_INI_ENTRIES(); + return SUCCESS; } PHP_MSHUTDOWN_FUNCTION(zend_test) { + UNREGISTER_INI_ENTRIES(); + return SUCCESS; } +static void observer_begin(zend_execute_data *execute_data) +{ + if (execute_data->func && execute_data->func->common.function_name) { + if (execute_data->func->common.scope) { + php_printf("%*s<%s::%s>\n", 2 * ZT_G(observer_nesting_depth), "", ZSTR_VAL(execute_data->func->common.scope->name), ZSTR_VAL(execute_data->func->common.function_name)); + } else { + php_printf("%*s<%s>\n", 2 * ZT_G(observer_nesting_depth), "", ZSTR_VAL(execute_data->func->common.function_name)); + } + } else { + php_printf("%*s\n", 2 * ZT_G(observer_nesting_depth), "", ZSTR_VAL(execute_data->func->op_array.filename)); + } + ZT_G(observer_nesting_depth)++; +} + +static void observer_end(zend_execute_data *execute_data, zval *retval) +{ + ZT_G(observer_nesting_depth)--; + if (execute_data->func && execute_data->func->common.function_name) { + if (execute_data->func->common.scope) { + php_printf("%*s\n", 2 * ZT_G(observer_nesting_depth), "", ZSTR_VAL(execute_data->func->common.scope->name), ZSTR_VAL(execute_data->func->common.function_name)); + } else { + php_printf("%*s\n", 2 * ZT_G(observer_nesting_depth), "", ZSTR_VAL(execute_data->func->common.function_name)); + } + } else { + php_printf("%*s\n", 2 * ZT_G(observer_nesting_depth), "", ZSTR_VAL(execute_data->func->op_array.filename)); + } +} + +static zend_observer_fcall observer_fcall_init(zend_function *fbc) +{ + if (fbc->common.function_name) { + if (fbc->common.scope) { + php_printf("[should observe %s::%s()?]\n", ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); + } else { + php_printf("[should observe %s()?]\n", ZSTR_VAL(fbc->common.function_name)); + } + } else { + php_printf("[should observe '%s'?]\n", ZSTR_VAL(fbc->op_array.filename)); + } + + if (ZT_G(observer_observe_all)) { + return (zend_observer_fcall){observer_begin, observer_end}; + } else if (ZT_G(observer_observe_includes) && !fbc->common.function_name) { + return (zend_observer_fcall){observer_begin, observer_end}; + } else if (ZT_G(observer_observe_functions) && fbc->common.function_name) { + return (zend_observer_fcall){observer_begin, observer_end}; + } + return (zend_observer_fcall){NULL, NULL}; +} + PHP_RINIT_FUNCTION(zend_test) { -#if defined(COMPILE_DL_ZEND_TEST) && defined(ZTS) - ZEND_TSRMLS_CACHE_UPDATE(); -#endif + if (ZT_G(observer_enabled)) { + zend_observer_fcall_register(observer_fcall_init); + } return SUCCESS; } @@ -386,11 +461,21 @@ PHP_RSHUTDOWN_FUNCTION(zend_test) return SUCCESS; } +static PHP_GINIT_FUNCTION(zend_test) +{ +#if defined(COMPILE_DL_ZEND_TEST) && defined(ZTS) + ZEND_TSRMLS_CACHE_UPDATE(); +#endif + memset(zend_test_globals, 0, sizeof(*zend_test_globals)); +} + PHP_MINFO_FUNCTION(zend_test) { php_info_print_table_start(); php_info_print_table_header(2, "zend-test extension", "enabled"); php_info_print_table_end(); + + DISPLAY_INI_ENTRIES(); } zend_module_entry zend_test_module_entry = { @@ -403,7 +488,11 @@ zend_module_entry zend_test_module_entry = { PHP_RSHUTDOWN(zend_test), PHP_MINFO(zend_test), PHP_ZEND_TEST_VERSION, - STANDARD_MODULE_PROPERTIES + PHP_MODULE_GLOBALS(zend_test), + PHP_GINIT(zend_test), + NULL, + NULL, + STANDARD_MODULE_PROPERTIES_EX }; #ifdef COMPILE_DL_ZEND_TEST diff --git a/ext/zend_test/tests/observer.inc b/ext/zend_test/tests/observer.inc new file mode 100644 index 0000000000000..611e9fa0e6c3d --- /dev/null +++ b/ext/zend_test/tests/observer.inc @@ -0,0 +1,8 @@ + +--EXPECTF-- +[should observe '%s/observer_basic_01.php'?] + +[should observe foo()?] + +Foo +[should observe bar()?] + +Bar +int(6) + + + +Foo + +Bar +int(6) + + + +Foo + +Bar +int(6) + + +DONE + diff --git a/ext/zend_test/tests/observer_basic_02.phpt b/ext/zend_test/tests/observer_basic_02.phpt new file mode 100644 index 0000000000000..06c47160b337d --- /dev/null +++ b/ext/zend_test/tests/observer_basic_02.phpt @@ -0,0 +1,57 @@ +--TEST-- +Observer: Basic observability of userland methods +--INI-- +zend_test.observer.enabled=1 +zend_test.observer.observe_all=1 +--FILE-- +bar(); + } +} + +$test = new TestClass(); +$test->foo(); +$test->foo(); +$test->foo(); + +echo 'DONE' . PHP_EOL; +?> +--EXPECTF-- +[should observe '%s/observer_basic_02.php'?] + +[should observe TestClass::foo()?] + +Foo +[should observe TestClass::bar()?] + +Bar +int(6) + + + +Foo + +Bar +int(6) + + + +Foo + +Bar +int(6) + + +DONE + diff --git a/ext/zend_test/tests/observer_basic_03.phpt b/ext/zend_test/tests/observer_basic_03.phpt new file mode 100644 index 0000000000000..600305decbb6b --- /dev/null +++ b/ext/zend_test/tests/observer_basic_03.phpt @@ -0,0 +1,34 @@ +--TEST-- +Observer: Basic observability of includes +--INI-- +zend_test.observer.enabled=1 +zend_test.observer.observe_all=1 +--FILE-- + +--EXPECTF-- +[should observe '%s/observer_basic_03.php'?] + +[should observe foo()?] + +Foo + +[should observe '%s/observer.inc'?] + +[should observe foo_observer_test()?] + +foo_observer_test + + + +Foo + + diff --git a/ext/zend_test/tests/observer_basic_04.phpt b/ext/zend_test/tests/observer_basic_04.phpt new file mode 100644 index 0000000000000..042cb685e2d5d --- /dev/null +++ b/ext/zend_test/tests/observer_basic_04.phpt @@ -0,0 +1,28 @@ +--TEST-- +Observer: Basic observability of includes only (no functions) +--INI-- +zend_test.observer.enabled=1 +zend_test.observer.observe_includes=1 +--FILE-- + +--EXPECTF-- +[should observe '%s/observer_basic_04.php'?] + +[should observe foo()?] +Foo +[should observe '%s/observer.inc'?] + +[should observe foo_observer_test()?] +foo_observer_test + +Foo + diff --git a/ext/zend_test/tests/observer_basic_05.phpt b/ext/zend_test/tests/observer_basic_05.phpt new file mode 100644 index 0000000000000..7583ec3f6d3b6 --- /dev/null +++ b/ext/zend_test/tests/observer_basic_05.phpt @@ -0,0 +1,30 @@ +--TEST-- +Observer: Basic observability of functions only (no includes) +--INI-- +zend_test.observer.enabled=1 +zend_test.observer.observe_functions=1 +--FILE-- + +--EXPECTF-- +[should observe '%s/observer_basic_05.php'?] +[should observe foo()?] + +Foo + +[should observe '%s/observer.inc'?] +[should observe foo_observer_test()?] + +foo_observer_test + + +Foo + From 9837e2bed3570c156a1caef28fecb91c653593e4 Mon Sep 17 00:00:00 2001 From: Sammy Powers Date: Mon, 10 Aug 2020 15:43:39 -0700 Subject: [PATCH 16/53] Add test for magic --- ext/zend_test/tests/observer_magic_01.phpt | 43 ++++++++++++++++++++++ 1 file changed, 43 insertions(+) create mode 100644 ext/zend_test/tests/observer_magic_01.phpt diff --git a/ext/zend_test/tests/observer_magic_01.phpt b/ext/zend_test/tests/observer_magic_01.phpt new file mode 100644 index 0000000000000..b2073ab06df57 --- /dev/null +++ b/ext/zend_test/tests/observer_magic_01.phpt @@ -0,0 +1,43 @@ +--TEST-- +Observer: Basic magic method observability +--INI-- +zend_test.observer.enabled=1 +zend_test.observer.observe_all=1 +--FILE-- +foo($name); + } + + public function foo($name) + { + echo $name . PHP_EOL; + } +} + +$test = new MagicTest(); +$test->foo('test'); +$test->bar(); + +echo 'DONE' . PHP_EOL; +?> +--EXPECTF-- +[should observe '%s/observer_magic_01.php'?] + +[should observe MagicTest::foo()?] + +test + +[should observe MagicTest::__call()?] + +__call() + +bar + + +DONE + From ef1bcdc3894a6c797226adb3d68a78c7ce539f20 Mon Sep 17 00:00:00 2001 From: Sammy Powers Date: Mon, 10 Aug 2020 15:44:11 -0700 Subject: [PATCH 17/53] Add basic generator support --- Zend/zend_execute.c | 2 +- Zend/zend_generators.c | 12 +++++ Zend/zend_observer.h | 3 +- Zend/zend_vm_def.h | 2 + Zend/zend_vm_execute.h | 8 ++++ .../tests/observer_generator_01.phpt | 44 +++++++++++++++++++ 6 files changed, 69 insertions(+), 2 deletions(-) create mode 100644 ext/zend_test/tests/observer_generator_01.phpt diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c index 364bf0b2f82b5..34e5b863e4c56 100644 --- a/Zend/zend_execute.c +++ b/Zend/zend_execute.c @@ -3542,7 +3542,7 @@ static zend_always_inline void i_init_func_execute_data(zend_op_array *op_array, EG(current_execute_data) = execute_data; - if (ZEND_SHOULD_OBSERVE_FN(op_array->fn_flags)) { + if (ZEND_SHOULD_OBSERVE_FN(op_array->fn_flags) && !(op_array->fn_flags & ZEND_ACC_GENERATOR)) { void *observer_handlers = ZEND_OBSERVER_HANDLERS(&EX(func)->op_array); ZEND_ASSERT(observer_handlers); if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { diff --git a/Zend/zend_generators.c b/Zend/zend_generators.c index 0d2d7e4a4d956..645bea4435386 100644 --- a/Zend/zend_generators.c +++ b/Zend/zend_generators.c @@ -24,6 +24,7 @@ #include "zend_generators.h" #include "zend_closures.h" #include "zend_generators_arginfo.h" +#include "zend_observer.h" ZEND_API zend_class_entry *zend_ce_generator; ZEND_API zend_class_entry *zend_ce_ClosedGeneratorException; @@ -771,7 +772,18 @@ ZEND_API void zend_generator_resume(zend_generator *orig_generator) /* {{{ */ /* Resume execution */ generator->flags |= ZEND_GENERATOR_CURRENTLY_RUNNING; + if (zend_observer_fcall_op_array_extension != -1) { + void *observer_handlers = ZEND_OBSERVER_HANDLERS(&generator->execute_data->func->op_array); + ZEND_ASSERT(observer_handlers); + if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { + zend_observe_fcall_begin(observer_handlers, generator->execute_data); + } + } zend_execute_ex(generator->execute_data); + if (generator->execute_data) { + /* On the final return, this will be called from ZEND_GENERATOR_RETURN */ + zend_observer_maybe_fcall_call_end(generator->execute_data, &generator->retval); + } generator->flags &= ~ZEND_GENERATOR_CURRENTLY_RUNNING; generator->frozen_call_stack = NULL; diff --git a/Zend/zend_observer.h b/Zend/zend_observer.h index 36e30c1321a24..7e14389b34cad 100644 --- a/Zend/zend_observer.h +++ b/Zend/zend_observer.h @@ -16,7 +16,8 @@ extern int zend_observer_fcall_op_array_extension; #define ZEND_OBSERVER_NOT_OBSERVED ((void *) 2) #define ZEND_SHOULD_OBSERVE_FN(fn_flags) \ - zend_observer_fcall_op_array_extension != -1 && !(fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE)) + zend_observer_fcall_op_array_extension != -1 && \ + !(fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE)) struct zend_observer_fcall { void (*begin)(zend_execute_data *execute_data); diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 6575747d0d95e..e824cb93c757c 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -4457,6 +4457,8 @@ ZEND_VM_HANDLER(161, ZEND_GENERATOR_RETURN, CONST|TMP|VAR|CV, ANY) } } + zend_observer_maybe_fcall_call_end(generator->execute_data, &generator->retval); + /* Close the generator to free up resources */ zend_generator_close(generator, 1); diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 28ca4ed5e8925..67c8607c11c0c 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -3781,6 +3781,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_CONST_HA } } + zend_observer_maybe_fcall_call_end(generator->execute_data, &generator->retval); + /* Close the generator to free up resources */ zend_generator_close(generator, 1); @@ -17934,6 +17936,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_TMP_HAND } } + zend_observer_maybe_fcall_call_end(generator->execute_data, &generator->retval); + /* Close the generator to free up resources */ zend_generator_close(generator, 1); @@ -20479,6 +20483,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_VAR_HAND } } + zend_observer_maybe_fcall_call_end(generator->execute_data, &generator->retval); + /* Close the generator to free up resources */ zend_generator_close(generator, 1); @@ -36944,6 +36950,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_CV_HANDL } } + zend_observer_maybe_fcall_call_end(generator->execute_data, &generator->retval); + /* Close the generator to free up resources */ zend_generator_close(generator, 1); diff --git a/ext/zend_test/tests/observer_generator_01.phpt b/ext/zend_test/tests/observer_generator_01.phpt new file mode 100644 index 0000000000000..4e1cf23755ebf --- /dev/null +++ b/ext/zend_test/tests/observer_generator_01.phpt @@ -0,0 +1,44 @@ +--TEST-- +Observer: Basic generator observability +--INI-- +zend_test.observer.enabled=1 +zend_test.observer.observe_all=1 +--FILE-- + +--EXPECTF-- +[should observe '%s/observer_generator_01.php'?] + +[should observe doSomething()?] + +[should observe getResults()?] + + +10 + + +11 + + +12 + + + +Done + From f6edb808e8315c89651f48e8f07860cf4dbe58fd Mon Sep 17 00:00:00 2001 From: Sammy Powers Date: Mon, 10 Aug 2020 15:59:38 -0700 Subject: [PATCH 18/53] Make cleaner test output --- ext/zend_test/test.c | 6 +++--- ext/zend_test/tests/observer_basic_01.phpt | 6 +++--- ext/zend_test/tests/observer_basic_02.phpt | 6 +++--- ext/zend_test/tests/observer_basic_03.phpt | 8 ++++---- ext/zend_test/tests/observer_basic_04.phpt | 8 ++++---- ext/zend_test/tests/observer_basic_05.phpt | 8 ++++---- ext/zend_test/tests/observer_generator_01.phpt | 6 +++--- ext/zend_test/tests/observer_magic_01.phpt | 6 +++--- 8 files changed, 27 insertions(+), 27 deletions(-) diff --git a/ext/zend_test/test.c b/ext/zend_test/test.c index 1cf3846171d43..7048deb984f8f 100644 --- a/ext/zend_test/test.c +++ b/ext/zend_test/test.c @@ -427,12 +427,12 @@ static zend_observer_fcall observer_fcall_init(zend_function *fbc) { if (fbc->common.function_name) { if (fbc->common.scope) { - php_printf("[should observe %s::%s()?]\n", ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); + php_printf("%*s\n", 2 * ZT_G(observer_nesting_depth), "", ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); } else { - php_printf("[should observe %s()?]\n", ZSTR_VAL(fbc->common.function_name)); + php_printf("%*s\n", 2 * ZT_G(observer_nesting_depth), "", ZSTR_VAL(fbc->common.function_name)); } } else { - php_printf("[should observe '%s'?]\n", ZSTR_VAL(fbc->op_array.filename)); + php_printf("%*s\n", 2 * ZT_G(observer_nesting_depth), "", ZSTR_VAL(fbc->op_array.filename)); } if (ZT_G(observer_observe_all)) { diff --git a/ext/zend_test/tests/observer_basic_01.phpt b/ext/zend_test/tests/observer_basic_01.phpt index 6c3faf58d21d9..4824885a4272f 100644 --- a/ext/zend_test/tests/observer_basic_01.phpt +++ b/ext/zend_test/tests/observer_basic_01.phpt @@ -24,12 +24,12 @@ foo(); echo 'DONE' . PHP_EOL; ?> --EXPECTF-- -[should observe '%s/observer_basic_01.php'?] + -[should observe foo()?] + Foo -[should observe bar()?] + Bar int(6) diff --git a/ext/zend_test/tests/observer_basic_02.phpt b/ext/zend_test/tests/observer_basic_02.phpt index 06c47160b337d..8ea02fe6a5c7d 100644 --- a/ext/zend_test/tests/observer_basic_02.phpt +++ b/ext/zend_test/tests/observer_basic_02.phpt @@ -28,12 +28,12 @@ $test->foo(); echo 'DONE' . PHP_EOL; ?> --EXPECTF-- -[should observe '%s/observer_basic_02.php'?] + -[should observe TestClass::foo()?] + Foo -[should observe TestClass::bar()?] + Bar int(6) diff --git a/ext/zend_test/tests/observer_basic_03.phpt b/ext/zend_test/tests/observer_basic_03.phpt index 600305decbb6b..393057f082436 100644 --- a/ext/zend_test/tests/observer_basic_03.phpt +++ b/ext/zend_test/tests/observer_basic_03.phpt @@ -15,15 +15,15 @@ include __DIR__ . '/observer.inc'; foo(); ?> --EXPECTF-- -[should observe '%s/observer_basic_03.php'?] + -[should observe foo()?] + Foo -[should observe '%s/observer.inc'?] + -[should observe foo_observer_test()?] + foo_observer_test diff --git a/ext/zend_test/tests/observer_basic_04.phpt b/ext/zend_test/tests/observer_basic_04.phpt index 042cb685e2d5d..5448da4912062 100644 --- a/ext/zend_test/tests/observer_basic_04.phpt +++ b/ext/zend_test/tests/observer_basic_04.phpt @@ -15,13 +15,13 @@ include __DIR__ . '/observer.inc'; foo(); ?> --EXPECTF-- -[should observe '%s/observer_basic_04.php'?] + -[should observe foo()?] + Foo -[should observe '%s/observer.inc'?] + -[should observe foo_observer_test()?] + foo_observer_test Foo diff --git a/ext/zend_test/tests/observer_basic_05.phpt b/ext/zend_test/tests/observer_basic_05.phpt index 7583ec3f6d3b6..31a889ef53a4a 100644 --- a/ext/zend_test/tests/observer_basic_05.phpt +++ b/ext/zend_test/tests/observer_basic_05.phpt @@ -15,13 +15,13 @@ include __DIR__ . '/observer.inc'; foo(); ?> --EXPECTF-- -[should observe '%s/observer_basic_05.php'?] -[should observe foo()?] + + Foo -[should observe '%s/observer.inc'?] -[should observe foo_observer_test()?] + + foo_observer_test diff --git a/ext/zend_test/tests/observer_generator_01.phpt b/ext/zend_test/tests/observer_generator_01.phpt index 4e1cf23755ebf..77a876638f15d 100644 --- a/ext/zend_test/tests/observer_generator_01.phpt +++ b/ext/zend_test/tests/observer_generator_01.phpt @@ -23,11 +23,11 @@ function doSomething() { echo doSomething() . PHP_EOL; ?> --EXPECTF-- -[should observe '%s/observer_generator_01.php'?] + -[should observe doSomething()?] + -[should observe getResults()?] + 10 diff --git a/ext/zend_test/tests/observer_magic_01.phpt b/ext/zend_test/tests/observer_magic_01.phpt index b2073ab06df57..2ecf3d8001df4 100644 --- a/ext/zend_test/tests/observer_magic_01.phpt +++ b/ext/zend_test/tests/observer_magic_01.phpt @@ -26,13 +26,13 @@ $test->bar(); echo 'DONE' . PHP_EOL; ?> --EXPECTF-- -[should observe '%s/observer_magic_01.php'?] + -[should observe MagicTest::foo()?] + test -[should observe MagicTest::__call()?] + __call() From c66d6598cc64d5fbeae4f8560fb2c822d13bea4f Mon Sep 17 00:00:00 2001 From: Sammy Powers Date: Tue, 11 Aug 2020 14:35:23 -0700 Subject: [PATCH 19/53] Pass proper return value for generators --- Zend/zend_generators.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Zend/zend_generators.c b/Zend/zend_generators.c index 645bea4435386..61e7fd60f7ea1 100644 --- a/Zend/zend_generators.c +++ b/Zend/zend_generators.c @@ -782,7 +782,7 @@ ZEND_API void zend_generator_resume(zend_generator *orig_generator) /* {{{ */ zend_execute_ex(generator->execute_data); if (generator->execute_data) { /* On the final return, this will be called from ZEND_GENERATOR_RETURN */ - zend_observer_maybe_fcall_call_end(generator->execute_data, &generator->retval); + zend_observer_maybe_fcall_call_end(generator->execute_data, &generator->value); } generator->flags &= ~ZEND_GENERATOR_CURRENTLY_RUNNING; From a6faa3bac442ac575f6afaaf0b207c970df290b5 Mon Sep 17 00:00:00 2001 From: Sammy Powers Date: Tue, 11 Aug 2020 14:36:17 -0700 Subject: [PATCH 20/53] Expose return values in tests --- ext/zend_test/test.c | 30 +++++++++++++++++-- .../tests/observer_generator_01.phpt | 11 +++---- 2 files changed, 34 insertions(+), 7 deletions(-) diff --git a/ext/zend_test/test.c b/ext/zend_test/test.c index 7048deb984f8f..642b7a666b3d1 100644 --- a/ext/zend_test/test.c +++ b/ext/zend_test/test.c @@ -21,16 +21,20 @@ #include "php.h" #include "php_ini.h" #include "ext/standard/info.h" +#include "ext/standard/php_var.h" #include "php_test.h" #include "test_arginfo.h" #include "zend_attributes.h" #include "zend_observer.h" +#include "zend_smart_str.h" ZEND_BEGIN_MODULE_GLOBALS(zend_test) int observer_enabled; int observer_observe_all; int observer_observe_includes; int observer_observe_functions; + int observer_show_return_type; + int observer_show_return_value; //HashTable observer_observe_functions_list; int observer_nesting_depth; ZEND_END_MODULE_GLOBALS(zend_test) @@ -296,6 +300,8 @@ PHP_INI_BEGIN() STD_PHP_INI_BOOLEAN("zend_test.observer.observe_all", "0", PHP_INI_SYSTEM, OnUpdateBool, observer_observe_all, zend_zend_test_globals, zend_test_globals) STD_PHP_INI_BOOLEAN("zend_test.observer.observe_includes", "0", PHP_INI_SYSTEM, OnUpdateBool, observer_observe_includes, zend_zend_test_globals, zend_test_globals) STD_PHP_INI_BOOLEAN("zend_test.observer.observe_functions", "0", PHP_INI_SYSTEM, OnUpdateBool, observer_observe_functions, zend_zend_test_globals, zend_test_globals) + STD_PHP_INI_BOOLEAN("zend_test.observer.show_return_type", "0", PHP_INI_SYSTEM, OnUpdateBool, observer_show_return_type, zend_zend_test_globals, zend_test_globals) + STD_PHP_INI_BOOLEAN("zend_test.observer.show_return_value", "0", PHP_INI_SYSTEM, OnUpdateBool, observer_show_return_value, zend_zend_test_globals, zend_test_globals) PHP_INI_END() PHP_MINIT_FUNCTION(zend_test) @@ -409,15 +415,35 @@ static void observer_begin(zend_execute_data *execute_data) ZT_G(observer_nesting_depth)++; } +static void get_retval_info(zval *retval, smart_str *buf) +{ + if (!ZT_G(observer_show_return_type) && !ZT_G(observer_show_return_value)) { + return; + } + + smart_str_appendc(buf, ':'); + if (retval == NULL) { + smart_str_appendl(buf, "NULL", 4); + } else if (ZT_G(observer_show_return_value)) { + php_var_export_ex(retval, 2 * ZT_G(observer_nesting_depth) + 3, buf); + } else if (ZT_G(observer_show_return_type)) { + smart_str_appends(buf, zend_zval_type_name(retval)); + } + smart_str_0(buf); +} + static void observer_end(zend_execute_data *execute_data, zval *retval) { ZT_G(observer_nesting_depth)--; if (execute_data->func && execute_data->func->common.function_name) { + smart_str retval_info = {0}; + get_retval_info(retval, &retval_info); if (execute_data->func->common.scope) { - php_printf("%*s\n", 2 * ZT_G(observer_nesting_depth), "", ZSTR_VAL(execute_data->func->common.scope->name), ZSTR_VAL(execute_data->func->common.function_name)); + php_printf("%*s\n", 2 * ZT_G(observer_nesting_depth), "", ZSTR_VAL(execute_data->func->common.scope->name), ZSTR_VAL(execute_data->func->common.function_name), retval_info.s ? ZSTR_VAL(retval_info.s) : ""); } else { - php_printf("%*s\n", 2 * ZT_G(observer_nesting_depth), "", ZSTR_VAL(execute_data->func->common.function_name)); + php_printf("%*s\n", 2 * ZT_G(observer_nesting_depth), "", ZSTR_VAL(execute_data->func->common.function_name), retval_info.s ? ZSTR_VAL(retval_info.s) : ""); } + smart_str_free(&retval_info); } else { php_printf("%*s\n", 2 * ZT_G(observer_nesting_depth), "", ZSTR_VAL(execute_data->func->op_array.filename)); } diff --git a/ext/zend_test/tests/observer_generator_01.phpt b/ext/zend_test/tests/observer_generator_01.phpt index 77a876638f15d..71fb9349da829 100644 --- a/ext/zend_test/tests/observer_generator_01.phpt +++ b/ext/zend_test/tests/observer_generator_01.phpt @@ -3,6 +3,7 @@ Observer: Basic generator observability --INI-- zend_test.observer.enabled=1 zend_test.observer.observe_all=1 +zend_test.observer.show_return_value=1 --FILE-- - + 10 - + 11 - + 12 - - + + Done From 5f24f65a3f99208b195715a41c030fc82a1b92df Mon Sep 17 00:00:00 2001 From: Sammy Powers Date: Tue, 11 Aug 2020 15:17:56 -0700 Subject: [PATCH 21/53] Add more generator tests --- .../tests/observer_generator_01.phpt | 6 +- .../tests/observer_generator_02.phpt | 48 ++++++++++++++ .../tests/observer_generator_03.phpt | 66 +++++++++++++++++++ .../tests/observer_generator_04.phpt | 62 +++++++++++++++++ 4 files changed, 179 insertions(+), 3 deletions(-) create mode 100644 ext/zend_test/tests/observer_generator_02.phpt create mode 100644 ext/zend_test/tests/observer_generator_03.phpt create mode 100644 ext/zend_test/tests/observer_generator_04.phpt diff --git a/ext/zend_test/tests/observer_generator_01.phpt b/ext/zend_test/tests/observer_generator_01.phpt index 71fb9349da829..f6dabf5b7a34f 100644 --- a/ext/zend_test/tests/observer_generator_01.phpt +++ b/ext/zend_test/tests/observer_generator_01.phpt @@ -24,8 +24,8 @@ function doSomething() { echo doSomething() . PHP_EOL; ?> --EXPECTF-- - - + + @@ -42,4 +42,4 @@ echo doSomething() . PHP_EOL; Done - + diff --git a/ext/zend_test/tests/observer_generator_02.phpt b/ext/zend_test/tests/observer_generator_02.phpt new file mode 100644 index 0000000000000..7c1c10fa71643 --- /dev/null +++ b/ext/zend_test/tests/observer_generator_02.phpt @@ -0,0 +1,48 @@ +--TEST-- +Observer: Generator with explicit return +--INI-- +zend_test.observer.enabled=1 +zend_test.observer.observe_all=1 +zend_test.observer.show_return_value=1 +--FILE-- +getReturn() . PHP_EOL; + + return 'Done'; +} + +echo doSomething() . PHP_EOL; +?> +--EXPECTF-- + + + + + + + +10 + + +11 + + +12 + + +1337 + +Done + diff --git a/ext/zend_test/tests/observer_generator_03.phpt b/ext/zend_test/tests/observer_generator_03.phpt new file mode 100644 index 0000000000000..34e9381a18546 --- /dev/null +++ b/ext/zend_test/tests/observer_generator_03.phpt @@ -0,0 +1,66 @@ +--TEST-- +Observer: Generator with 'yield from' +--INI-- +zend_test.observer.enabled=1 +zend_test.observer.observe_all=1 +zend_test.observer.show_return_value=1 +--FILE-- + +--EXPECTF-- + + + + + + + +0 + + +1 + + + + + +10 + + +11 + + +12 + + + + +42 + + + +Done + diff --git a/ext/zend_test/tests/observer_generator_04.phpt b/ext/zend_test/tests/observer_generator_04.phpt new file mode 100644 index 0000000000000..bbb689e7ba8a5 --- /dev/null +++ b/ext/zend_test/tests/observer_generator_04.phpt @@ -0,0 +1,62 @@ +--TEST-- +Observer: Generator with manual traversal +--INI-- +zend_test.observer.enabled=1 +zend_test.observer.observe_all=1 +zend_test.observer.show_return_value=1 +--FILE-- +current() !== NULL) { + echo $generator->current() . PHP_EOL; + if ($generator->current() === 5) { + $generator->send('Boop'); + } + $generator->next(); + } + + return 'Done'; +} + +echo doSomething() . PHP_EOL; +?> +--EXPECTF-- + + + + + + +Starting generator + +0 + + +1 + + +2 + + +3 + + +4 + + +5 + + + +Done + From 9e9bfc9367c5783a4a79ee553d07ebf8a23770b4 Mon Sep 17 00:00:00 2001 From: Sammy Powers Date: Wed, 12 Aug 2020 09:46:39 -0700 Subject: [PATCH 22/53] Remove temporary observer extension --- ext/observer/config.m4 | 94 ------------------ ext/observer/config.w32 | 7 -- ext/observer/observer.c | 166 -------------------------------- ext/observer/observer.stub.php | 6 -- ext/observer/observer_arginfo.h | 14 --- ext/observer/php_observer.h | 15 --- 6 files changed, 302 deletions(-) delete mode 100644 ext/observer/config.m4 delete mode 100644 ext/observer/config.w32 delete mode 100644 ext/observer/observer.c delete mode 100644 ext/observer/observer.stub.php delete mode 100644 ext/observer/observer_arginfo.h delete mode 100644 ext/observer/php_observer.h diff --git a/ext/observer/config.m4 b/ext/observer/config.m4 deleted file mode 100644 index 0c2a99c957458..0000000000000 --- a/ext/observer/config.m4 +++ /dev/null @@ -1,94 +0,0 @@ -dnl config.m4 for extension observer - -dnl Comments in this file start with the string 'dnl'. -dnl Remove where necessary. - -dnl If your extension references something external, use 'with': - -dnl PHP_ARG_WITH([observer], -dnl [for observer support], -dnl [AS_HELP_STRING([--with-observer], -dnl [Include observer support])]) - -dnl Otherwise use 'enable': - -PHP_ARG_ENABLE([observer], - [whether to enable observer support], - [AS_HELP_STRING([--enable-observer], - [Enable observer support])], - [no]) - -if test "$PHP_OBSERVER" != "no"; then - dnl Write more examples of tests here... - - dnl Remove this code block if the library does not support pkg-config. - dnl PKG_CHECK_MODULES([LIBFOO], [foo]) - dnl PHP_EVAL_INCLINE($LIBFOO_CFLAGS) - dnl PHP_EVAL_LIBLINE($LIBFOO_LIBS, OBSERVER_SHARED_LIBADD) - - dnl If you need to check for a particular library version using PKG_CHECK_MODULES, - dnl you can use comparison operators. For example: - dnl PKG_CHECK_MODULES([LIBFOO], [foo >= 1.2.3]) - dnl PKG_CHECK_MODULES([LIBFOO], [foo < 3.4]) - dnl PKG_CHECK_MODULES([LIBFOO], [foo = 1.2.3]) - - dnl Remove this code block if the library supports pkg-config. - dnl --with-observer -> check with-path - dnl SEARCH_PATH="/usr/local /usr" # you might want to change this - dnl SEARCH_FOR="/include/observer.h" # you most likely want to change this - dnl if test -r $PHP_OBSERVER/$SEARCH_FOR; then # path given as parameter - dnl OBSERVER_DIR=$PHP_OBSERVER - dnl else # search default path list - dnl AC_MSG_CHECKING([for observer files in default path]) - dnl for i in $SEARCH_PATH ; do - dnl if test -r $i/$SEARCH_FOR; then - dnl OBSERVER_DIR=$i - dnl AC_MSG_RESULT(found in $i) - dnl fi - dnl done - dnl fi - dnl - dnl if test -z "$OBSERVER_DIR"; then - dnl AC_MSG_RESULT([not found]) - dnl AC_MSG_ERROR([Please reinstall the observer distribution]) - dnl fi - - dnl Remove this code block if the library supports pkg-config. - dnl --with-observer -> add include path - dnl PHP_ADD_INCLUDE($OBSERVER_DIR/include) - - dnl Remove this code block if the library supports pkg-config. - dnl --with-observer -> check for lib and symbol presence - dnl LIBNAME=OBSERVER # you may want to change this - dnl LIBSYMBOL=OBSERVER # you most likely want to change this - - dnl If you need to check for a particular library function (e.g. a conditional - dnl or version-dependent feature) and you are using pkg-config: - dnl PHP_CHECK_LIBRARY($LIBNAME, $LIBSYMBOL, - dnl [ - dnl AC_DEFINE(HAVE_OBSERVER_FEATURE, 1, [ ]) - dnl ],[ - dnl AC_MSG_ERROR([FEATURE not supported by your observer library.]) - dnl ], [ - dnl $LIBFOO_LIBS - dnl ]) - - dnl If you need to check for a particular library function (e.g. a conditional - dnl or version-dependent feature) and you are not using pkg-config: - dnl PHP_CHECK_LIBRARY($LIBNAME, $LIBSYMBOL, - dnl [ - dnl PHP_ADD_LIBRARY_WITH_PATH($LIBNAME, $OBSERVER_DIR/$PHP_LIBDIR, OBSERVER_SHARED_LIBADD) - dnl AC_DEFINE(HAVE_OBSERVER_FEATURE, 1, [ ]) - dnl ],[ - dnl AC_MSG_ERROR([FEATURE not supported by your observer library.]) - dnl ],[ - dnl -L$OBSERVER_DIR/$PHP_LIBDIR -lm - dnl ]) - dnl - dnl PHP_SUBST(OBSERVER_SHARED_LIBADD) - - dnl In case of no dependencies - AC_DEFINE(HAVE_OBSERVER, 1, [ Have observer support ]) - - PHP_NEW_EXTENSION(observer, observer.c, $ext_shared) -fi diff --git a/ext/observer/config.w32 b/ext/observer/config.w32 deleted file mode 100644 index 70165a4bb80dc..0000000000000 --- a/ext/observer/config.w32 +++ /dev/null @@ -1,7 +0,0 @@ -ARG_ENABLE('observer', 'observer support', 'no'); - -if (PHP_OBSERVER != 'no') { - AC_DEFINE('HAVE_OBSERVER', 1, 'observer support enabled'); - - EXTENSION('observer', 'observer.c', null, '/DZEND_ENABLE_STATIC_TSRMLS_CACHE=1'); -} diff --git a/ext/observer/observer.c b/ext/observer/observer.c deleted file mode 100644 index a9b5147069613..0000000000000 --- a/ext/observer/observer.c +++ /dev/null @@ -1,166 +0,0 @@ -/* observer extension for PHP */ - -#ifdef HAVE_CONFIG_H -# include "config.h" -#endif - -#include "php.h" -#include "ext/standard/info.h" -#include "php_observer.h" -#include "observer_arginfo.h" - -#include "zend_observer.h" - -/* For compatibility with older PHP versions */ -#ifndef ZEND_PARSE_PARAMETERS_NONE -#define ZEND_PARSE_PARAMETERS_NONE() \ - ZEND_PARSE_PARAMETERS_START(0, 0) \ - ZEND_PARSE_PARAMETERS_END() -#endif - -int zend_observer_fcall_op_array_extension; -ZEND_TLS int nesting_depth = 0; - -PHP_FUNCTION(observer_op_array_extension_handle) -{ - ZEND_PARSE_PARAMETERS_NONE(); - - RETVAL_LONG(zend_observer_fcall_op_array_extension); -} - -static char *observer_get_filename(zend_execute_data *execute_data) { - const zend_op *opline = execute_data->opline; - uint32_t extended_value = opline->extended_value; - ZEND_ASSERT(opline->opcode == ZEND_INCLUDE_OR_EVAL); - ZEND_ASSERT( - extended_value == ZEND_INCLUDE - || extended_value == ZEND_INCLUDE_ONCE - || extended_value == ZEND_REQUIRE - || extended_value == ZEND_REQUIRE_ONCE - ); - - zval *op = zend_get_zval_ptr(opline, opline->op1_type, &opline->op1, execute_data); - return (op && Z_TYPE_P(op) == IS_STRING) ? Z_STRVAL_P(op) : NULL; -} - -static char *include_pretty_name[] = { - [ZEND_EVAL] = "eval", - [ZEND_INCLUDE] = "include", - [ZEND_INCLUDE_ONCE] = "include_once", - [ZEND_REQUIRE] = "require", - [ZEND_REQUIRE_ONCE] = "require_once", -}; - -static void observer_begin(zend_execute_data *execute_data) -{ - - if (getenv("OBSERVER_DEBUG")) { - if (execute_data->func && execute_data->func->common.function_name) { - printf("%*s<%s>\n", 2 * nesting_depth, "", ZSTR_VAL(execute_data->func->common.function_name)); - } else if (execute_data->opline->opcode == ZEND_INCLUDE_OR_EVAL) { - uint32_t extended_value = execute_data->opline->extended_value; - switch (extended_value) { - case ZEND_INCLUDE: - case ZEND_INCLUDE_ONCE: - case ZEND_REQUIRE: - case ZEND_REQUIRE_ONCE: { - char *filename = observer_get_filename(execute_data); - printf("%*s<%s filename=\"%s\">\n", 2 * nesting_depth, "", include_pretty_name[extended_value], filename ? filename : "(unknown)"); - } - break; - - case ZEND_EVAL: - printf("%*s\n", 2 * nesting_depth, ""); - } - } - - ++nesting_depth; - } -} - -static void observer_end(zend_execute_data *execute_data, zval *retval) { - if (getenv("OBSERVER_DEBUG")) { - --nesting_depth; - - if (execute_data->func && execute_data->func->common.function_name) { - printf("%*s\n", 2 * nesting_depth, "", ZSTR_VAL(execute_data->func->common.function_name)); - return; - } - zend_execute_data *prev_execute_data = execute_data->prev_execute_data; - if (prev_execute_data && prev_execute_data->opline->opcode == ZEND_INCLUDE_OR_EVAL) { - uint32_t extended_value = prev_execute_data->opline->extended_value; - switch (extended_value) { - case ZEND_INCLUDE: - case ZEND_INCLUDE_ONCE: - case ZEND_REQUIRE: - case ZEND_REQUIRE_ONCE: - printf("%*s\n", 2 * nesting_depth, "", include_pretty_name[extended_value]); - break; - - case ZEND_EVAL: - printf("%*s\n", 2 * nesting_depth, ""); - break; - default: - ZEND_ASSERT(0); - } - } - } -} - -static zend_observer_fcall observer_fcall_init(zend_function *fbc) -{ - return (zend_observer_fcall){observer_begin, observer_end}; -} - -PHP_MINIT_FUNCTION(observer) -{ - zend_observer_fcall_register(observer_fcall_init); - return SUCCESS; -} - -PHP_MSHUTDOWN_FUNCTION(observer) { return SUCCESS; } - -/* {{{ PHP_RINIT_FUNCTION - */ -PHP_RINIT_FUNCTION(observer) -{ -#if defined(ZTS) && defined(COMPILE_DL_OBSERVER) - ZEND_TSRMLS_CACHE_UPDATE(); -#endif - - return SUCCESS; -} -/* }}} */ - -/* {{{ PHP_MINFO_FUNCTION - */ -PHP_MINFO_FUNCTION(observer) -{ - php_info_print_table_start(); - php_info_print_table_header(2, "observer support", "enabled"); - php_info_print_table_end(); -} -/* }}} */ - -/* {{{ observer_module_entry - */ -zend_module_entry observer_module_entry = { - STANDARD_MODULE_HEADER, - "observer", /* Extension name */ - ext_functions, /* zend_function_entry */ - PHP_MINIT(observer), /* PHP_MINIT - Module initialization */ - PHP_MSHUTDOWN(observer), /* PHP_MSHUTDOWN - Module shutdown */ - PHP_RINIT(observer), /* PHP_RINIT - Request initialization */ - NULL, /* PHP_RSHUTDOWN - Request shutdown */ - PHP_MINFO(observer), /* PHP_MINFO - Module info */ - PHP_OBSERVER_VERSION, /* Version */ - STANDARD_MODULE_PROPERTIES -}; -/* }}} */ - -#ifdef COMPILE_DL_OBSERVER -# ifdef ZTS -ZEND_TSRMLS_CACHE_DEFINE() -# endif -ZEND_GET_MODULE(observer) -#endif diff --git a/ext/observer/observer.stub.php b/ext/observer/observer.stub.php deleted file mode 100644 index a28fcefe1b99a..0000000000000 --- a/ext/observer/observer.stub.php +++ /dev/null @@ -1,6 +0,0 @@ - Date: Wed, 12 Aug 2020 11:12:25 -0700 Subject: [PATCH 23/53] Fix memleak on TMPVAR with eval() --- Zend/zend_vm_def.h | 1 + Zend/zend_vm_execute.h | 3 +++ 2 files changed, 4 insertions(+) diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 5b211ed317a3f..56110c7b7460e 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -6155,6 +6155,7 @@ ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMPVAR|CV, ANY, EVAL) call->prev_execute_data = execute_data; i_init_code_execute_data(call, new_op_array, return_value); if (EXPECTED(zend_execute_ex == execute_ex)) { + FREE_OP1(); ZEND_VM_ENTER(); } else { ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP); diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index fe655b2751758..ced2ceae4f5cd 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -4117,6 +4117,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HAN call->prev_execute_data = execute_data; i_init_code_execute_data(call, new_op_array, return_value); if (EXPECTED(zend_execute_ex == execute_ex)) { + ZEND_VM_ENTER(); } else { ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP); @@ -13562,6 +13563,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HA call->prev_execute_data = execute_data; i_init_code_execute_data(call, new_op_array, return_value); if (EXPECTED(zend_execute_ex == execute_ex)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); ZEND_VM_ENTER(); } else { ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP); @@ -37241,6 +37243,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLE call->prev_execute_data = execute_data; i_init_code_execute_data(call, new_op_array, return_value); if (EXPECTED(zend_execute_ex == execute_ex)) { + ZEND_VM_ENTER(); } else { ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP); From 95bcf05142257c015fefeb34fa4cab4f85ec17f7 Mon Sep 17 00:00:00 2001 From: Sammy Powers Date: Wed, 12 Aug 2020 15:45:56 -0700 Subject: [PATCH 24/53] Fix arena allocation again :facepalm: --- Zend/zend.c | 1 + Zend/zend_observer.c | 9 +++++++-- Zend/zend_observer.h | 1 + ext/zend_test/test.c | 11 ++++++++--- 4 files changed, 17 insertions(+), 5 deletions(-) diff --git a/Zend/zend.c b/Zend/zend.c index df19c57944acd..8df23839e2ce3 100644 --- a/Zend/zend.c +++ b/Zend/zend.c @@ -1209,6 +1209,7 @@ ZEND_API void zend_activate(void) /* {{{ */ if (CG(map_ptr_last)) { memset(ZEND_MAP_PTR_REAL_BASE(CG(map_ptr_base)), 0, CG(map_ptr_last) * sizeof(void*)); } + zend_observer_activate(); } /* }}} */ diff --git a/Zend/zend_observer.c b/Zend/zend_observer.c index 21193bcb8d442..d8d6335217a9e 100644 --- a/Zend/zend_observer.c +++ b/Zend/zend_observer.c @@ -17,8 +17,6 @@ ZEND_API void zend_observer_fcall_register(zend_observer_fcall_init init) { /* We don't want to get an extension handle unless an ext installs an observer */ if (zend_observer_fcall_op_array_extension == -1) { zend_observer_fcall_op_array_extension = zend_get_op_array_extension_handle(); - /* todo: how to size the arena? */ - fcall_handlers_arena = zend_arena_create(1024); } zend_llist_add_element(&zend_observers_fcall_list, &init); } @@ -28,6 +26,13 @@ ZEND_API void zend_observer_startup(void) { zend_llist_init(&zend_observers_fcall_list, sizeof(zend_observer_fcall_init), NULL, 1); } +ZEND_API void zend_observer_activate(void) { + /* todo: how to size the arena? */ + if (zend_observer_fcall_op_array_extension != -1) { + fcall_handlers_arena = zend_arena_create(1024); + } +} + ZEND_API void zend_observer_deactivate(void) { if (fcall_handlers_arena) { zend_arena_destroy(fcall_handlers_arena); diff --git a/Zend/zend_observer.h b/Zend/zend_observer.h index 7e14389b34cad..e59693f270ac3 100644 --- a/Zend/zend_observer.h +++ b/Zend/zend_observer.h @@ -40,6 +40,7 @@ typedef zend_observer_fcall(*zend_observer_fcall_init)(zend_function *func); ZEND_API void zend_observer_fcall_register(zend_observer_fcall_init init); ZEND_API void zend_observer_startup(void); // Called by engine before MINITs +ZEND_API void zend_observer_activate(void); ZEND_API void zend_observer_deactivate(void); ZEND_API void zend_observer_shutdown(void); diff --git a/ext/zend_test/test.c b/ext/zend_test/test.c index 642b7a666b3d1..a260e33b551f5 100644 --- a/ext/zend_test/test.c +++ b/ext/zend_test/test.c @@ -304,6 +304,8 @@ PHP_INI_BEGIN() STD_PHP_INI_BOOLEAN("zend_test.observer.show_return_value", "0", PHP_INI_SYSTEM, OnUpdateBool, observer_show_return_value, zend_zend_test_globals, zend_test_globals) PHP_INI_END() +static zend_observer_fcall observer_fcall_init(zend_function *fbc); + PHP_MINIT_FUNCTION(zend_test) { zend_class_entry class_entry; @@ -391,6 +393,8 @@ PHP_MINIT_FUNCTION(zend_test) REGISTER_INI_ENTRIES(); + zend_observer_fcall_register(observer_fcall_init); + return SUCCESS; } @@ -451,6 +455,10 @@ static void observer_end(zend_execute_data *execute_data, zval *retval) static zend_observer_fcall observer_fcall_init(zend_function *fbc) { + if (!ZT_G(observer_enabled)) { + return (zend_observer_fcall){NULL, NULL}; + } + if (fbc->common.function_name) { if (fbc->common.scope) { php_printf("%*s\n", 2 * ZT_G(observer_nesting_depth), "", ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); @@ -473,9 +481,6 @@ static zend_observer_fcall observer_fcall_init(zend_function *fbc) PHP_RINIT_FUNCTION(zend_test) { - if (ZT_G(observer_enabled)) { - zend_observer_fcall_register(observer_fcall_init); - } return SUCCESS; } From 1e3b6be0407c5d0215561ed6f1f285e44da7d038 Mon Sep 17 00:00:00 2001 From: Sammy Powers Date: Fri, 21 Aug 2020 07:54:01 -0700 Subject: [PATCH 25/53] Whitespace --- Zend/zend_observer.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Zend/zend_observer.c b/Zend/zend_observer.c index d8d6335217a9e..a0d6f4b125872 100644 --- a/Zend/zend_observer.c +++ b/Zend/zend_observer.c @@ -92,7 +92,7 @@ void zend_observe_fcall_begin( for (handler = cache->handlers; handler != end; ++handler) { if (handler->begin) { handler->begin(execute_data); - } + } } } From 1445b3b49d2630f843a55cd376ee05f0db950cd9 Mon Sep 17 00:00:00 2001 From: Sammy Powers Date: Fri, 21 Aug 2020 07:54:53 -0700 Subject: [PATCH 26/53] Disable observer API when loaded via dl() --- ext/zend_test/test.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/ext/zend_test/test.c b/ext/zend_test/test.c index a260e33b551f5..f71c2b38018e3 100644 --- a/ext/zend_test/test.c +++ b/ext/zend_test/test.c @@ -393,7 +393,10 @@ PHP_MINIT_FUNCTION(zend_test) REGISTER_INI_ENTRIES(); - zend_observer_fcall_register(observer_fcall_init); + // Loading via dl() not supported with the observer API + if (type != MODULE_TEMPORARY) { + zend_observer_fcall_register(observer_fcall_init); + } return SUCCESS; } From 228807a6f12ed6f6524907c44b51ad47917839be Mon Sep 17 00:00:00 2001 From: Sammy Powers Date: Fri, 21 Aug 2020 14:03:40 -0700 Subject: [PATCH 27/53] Wrap up some TODOs and cleanup --- Zend/zend_compile.c | 5 +---- Zend/zend_execute.c | 2 -- Zend/zend_observer.c | 19 +++++++++++++++++++ Zend/zend_observer.h | 19 ++++++++++++++++++- Zend/zend_vm_def.h | 1 - Zend/zend_vm_execute.h | 2 -- ext/zend_test/test.c | 1 - main/main.c | 2 +- 8 files changed, 39 insertions(+), 12 deletions(-) diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index d61fe11df15c0..a03a440214f1a 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -32,10 +32,7 @@ #include "zend_language_scanner.h" #include "zend_inheritance.h" #include "zend_vm.h" -//#include "zend_observer.h" - -// TODO -ZEND_API void zend_observer_fcall_install(zend_function *function); +#include "zend_observer.h" #define SET_NODE(target, src) do { \ target ## _type = (src)->op_type; \ diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c index 34e5b863e4c56..2b890e7d62a90 100644 --- a/Zend/zend_execute.c +++ b/Zend/zend_execute.c @@ -3638,13 +3638,11 @@ static zend_always_inline void i_init_code_execute_data(zend_execute_data *execu if (zend_observer_fcall_op_array_extension != -1 && op_array != ZEND_FAKE_OP_ARRAY) { if (ptr != NULL) { - // TODO: Pass execute_data via zend_observer_execute_install() zend_observer_fcall_install((zend_function*)op_array); } void *observer_handlers = ZEND_OBSERVER_HANDLERS(op_array); ZEND_ASSERT(observer_handlers); if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { - // TODO: Run zend_observe_execute_begin() handlers zend_observe_fcall_begin(observer_handlers, execute_data); } } diff --git a/Zend/zend_observer.c b/Zend/zend_observer.c index a0d6f4b125872..bab547427568e 100644 --- a/Zend/zend_observer.c +++ b/Zend/zend_observer.c @@ -1,3 +1,22 @@ +/* + +----------------------------------------------------------------------+ + | Zend Engine | + +----------------------------------------------------------------------+ + | Copyright (c) Zend Technologies Ltd. (http://www.zend.com) | + +----------------------------------------------------------------------+ + | This source file is subject to version 2.00 of the Zend license, | + | that is bundled with this package in the file LICENSE, and is | + | available through the world-wide-web at the following url: | + | http://www.zend.com/license/2_00.txt. | + | If you did not receive a copy of the Zend license and are unable to | + | obtain it through the world-wide-web, please send a note to | + | license@zend.com so we can mail you a copy immediately. | + +----------------------------------------------------------------------+ + | Authors: Levi Morrison | + | Sammy Kaye Powers | + +----------------------------------------------------------------------+ +*/ + #include "zend_observer.h" #include "zend_extensions.h" diff --git a/Zend/zend_observer.h b/Zend/zend_observer.h index e59693f270ac3..408edc4790d50 100644 --- a/Zend/zend_observer.h +++ b/Zend/zend_observer.h @@ -1,4 +1,21 @@ -// todo: license garbage +/* + +----------------------------------------------------------------------+ + | Zend Engine | + +----------------------------------------------------------------------+ + | Copyright (c) Zend Technologies Ltd. (http://www.zend.com) | + +----------------------------------------------------------------------+ + | This source file is subject to version 2.00 of the Zend license, | + | that is bundled with this package in the file LICENSE, and is | + | available through the world-wide-web at the following url: | + | http://www.zend.com/license/2_00.txt. | + | If you did not receive a copy of the Zend license and are unable to | + | obtain it through the world-wide-web, please send a note to | + | license@zend.com so we can mail you a copy immediately. | + +----------------------------------------------------------------------+ + | Authors: Levi Morrison | + | Sammy Kaye Powers | + +----------------------------------------------------------------------+ +*/ #ifndef ZEND_OBSERVER_H #define ZEND_OBSERVER_H diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 56110c7b7460e..4e306010702cf 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -2762,7 +2762,6 @@ ZEND_VM_HOT_HELPER(zend_leave_helper, ANY, ANY) uint32_t call_info = EX_CALL_INFO(); SAVE_OPLINE(); - // TODO Maybe not pass in return_value explicitly? zend_observer_maybe_fcall_call_end(execute_data, EX(return_value)); if (EXPECTED((call_info & (ZEND_CALL_CODE|ZEND_CALL_TOP|ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS|ZEND_CALL_ALLOCATED|ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) == 0)) { diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index ced2ceae4f5cd..86d318ec8a12f 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -1085,7 +1085,6 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_leave_helper uint32_t call_info = EX_CALL_INFO(); SAVE_OPLINE(); - // TODO Maybe not pass in return_value explicitly? zend_observer_maybe_fcall_call_end(execute_data, EX(return_value)); if (EXPECTED((call_info & (ZEND_CALL_CODE|ZEND_CALL_TOP|ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS|ZEND_CALL_ALLOCATED|ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) == 0)) { @@ -53434,7 +53433,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) uint32_t call_info = EX_CALL_INFO(); SAVE_OPLINE(); - // TODO Maybe not pass in return_value explicitly? zend_observer_maybe_fcall_call_end(execute_data, EX(return_value)); if (EXPECTED((call_info & (ZEND_CALL_CODE|ZEND_CALL_TOP|ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS|ZEND_CALL_ALLOCATED|ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) == 0)) { diff --git a/ext/zend_test/test.c b/ext/zend_test/test.c index f71c2b38018e3..987dd76c57d68 100644 --- a/ext/zend_test/test.c +++ b/ext/zend_test/test.c @@ -35,7 +35,6 @@ ZEND_BEGIN_MODULE_GLOBALS(zend_test) int observer_observe_functions; int observer_show_return_type; int observer_show_return_value; - //HashTable observer_observe_functions_list; int observer_nesting_depth; ZEND_END_MODULE_GLOBALS(zend_test) diff --git a/main/main.c b/main/main.c index 1e9addf70eb4a..00af0bb4c2d6d 100644 --- a/main/main.c +++ b/main/main.c @@ -2239,6 +2239,7 @@ int php_module_startup(sapi_module_struct *sf, zend_module_entry *additional_mod php_startup_auto_globals(); zend_set_utility_values(&zuv); php_startup_sapi_content_types(); + zend_observer_startup(); /* startup extensions statically compiled in */ if (php_register_internal_extensions_func() == FAILURE) { @@ -2257,7 +2258,6 @@ int php_module_startup(sapi_module_struct *sf, zend_module_entry *additional_mod ahead of all other internals */ php_ini_register_extensions(); - zend_observer_startup(); zend_startup_modules(); /* start Zend extensions */ From fc739426b9d881fed87b07681f1410e3322c6635 Mon Sep 17 00:00:00 2001 From: Sammy Powers Date: Mon, 24 Aug 2020 13:20:57 -0700 Subject: [PATCH 28/53] Implement ZEND_OBSERVE_RETURN --- Zend/zend_compile.c | 15 +- Zend/zend_opcode.c | 6 + Zend/zend_vm_def.h | 78 +++- Zend/zend_vm_execute.h | 713 ++++++++++++++++++++++++++++--- Zend/zend_vm_handlers.h | 914 ++++++++++++++++++++-------------------- Zend/zend_vm_opcodes.c | 6 +- Zend/zend_vm_opcodes.h | 3 +- 7 files changed, 1225 insertions(+), 510 deletions(-) diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index a03a440214f1a..eda0c0707e1fd 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -2439,7 +2439,12 @@ void zend_emit_final_return(int return_one) /* {{{ */ ZVAL_NULL(&zn.u.constant); } - ret = zend_emit_op(NULL, returns_reference ? ZEND_RETURN_BY_REF : ZEND_RETURN, &zn, NULL); + if (ZEND_SHOULD_OBSERVE_FN(CG(active_op_array)->fn_flags)) { + // TODO Emit ZEND_OBSERVE_RETURN_BY_REF + ret = zend_emit_op(NULL, returns_reference ? ZEND_RETURN_BY_REF : ZEND_OBSERVE_RETURN, &zn, NULL); + } else { + ret = zend_emit_op(NULL, returns_reference ? ZEND_RETURN_BY_REF : ZEND_RETURN, &zn, NULL); + } ret->extended_value = -1; } /* }}} */ @@ -4776,8 +4781,12 @@ void zend_compile_return(zend_ast *ast) /* {{{ */ zend_handle_loops_and_finally((expr_node.op_type & (IS_TMP_VAR | IS_VAR)) ? &expr_node : NULL); - opline = zend_emit_op(NULL, by_ref ? ZEND_RETURN_BY_REF : ZEND_RETURN, - &expr_node, NULL); + if (ZEND_SHOULD_OBSERVE_FN(CG(active_op_array)->fn_flags)) { + // TODO Emit ZEND_OBSERVE_RETURN_BY_REF + opline = zend_emit_op(NULL, by_ref ? ZEND_RETURN_BY_REF : ZEND_OBSERVE_RETURN, &expr_node, NULL); + } else { + opline = zend_emit_op(NULL, by_ref ? ZEND_RETURN_BY_REF : ZEND_RETURN, &expr_node, NULL); + } if (by_ref && expr_ast) { if (zend_is_call(expr_ast)) { diff --git a/Zend/zend_opcode.c b/Zend/zend_opcode.c index 14dd6e46db27d..07fd130fdf1a3 100644 --- a/Zend/zend_opcode.c +++ b/Zend/zend_opcode.c @@ -1040,6 +1040,12 @@ ZEND_API int pass_two(zend_op_array *op_array) opline->opcode = ZEND_GENERATOR_RETURN; } break; + case ZEND_OBSERVE_RETURN: + // TODO case ZEND_OBSERVE_RETURN_BY_REF: + if (op_array->fn_flags & ZEND_ACC_GENERATOR) { + opline->opcode = ZEND_GENERATOR_RETURN; // TODO ZEND_OBSERVE_GENERATOR_RETURN + } + break; case ZEND_SWITCH_LONG: case ZEND_SWITCH_STRING: case ZEND_MATCH: diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 4e306010702cf..62fd4bf0e92f9 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -2762,8 +2762,6 @@ ZEND_VM_HOT_HELPER(zend_leave_helper, ANY, ANY) uint32_t call_info = EX_CALL_INFO(); SAVE_OPLINE(); - zend_observer_maybe_fcall_call_end(execute_data, EX(return_value)); - if (EXPECTED((call_info & (ZEND_CALL_CODE|ZEND_CALL_TOP|ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS|ZEND_CALL_ALLOCATED|ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) == 0)) { EG(current_execute_data) = EX(prev_execute_data); i_free_compiled_variables(execute_data); @@ -4284,6 +4282,82 @@ ZEND_VM_INLINE_HANDLER(62, ZEND_RETURN, CONST|TMP|VAR|CV, ANY) ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper); } +// TODO Make a helper for the shared return code +ZEND_VM_INLINE_HANDLER(200, ZEND_OBSERVE_RETURN, CONST|TMP|VAR|CV, ANY) +{ + USE_OPLINE + zval *retval_ptr; + zval *return_value; + + retval_ptr = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R); + return_value = EX(return_value); + if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) { + SAVE_OPLINE(); + retval_ptr = ZVAL_UNDEFINED_OP1(); + if (return_value) { + ZVAL_NULL(return_value); + } + } else if (!return_value) { + if (OP1_TYPE & (IS_VAR|IS_TMP_VAR)) { + if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) { + SAVE_OPLINE(); + rc_dtor_func(Z_COUNTED_P(retval_ptr)); + } + } + } else { + if ((OP1_TYPE & (IS_CONST|IS_TMP_VAR))) { + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (OP1_TYPE == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) { + Z_ADDREF_P(return_value); + } + } + } else if (OP1_TYPE == IS_CV) { + do { + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) { + if (EXPECTED(!(EX_CALL_INFO() & ZEND_CALL_CODE))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (GC_MAY_LEAK(ref)) { + gc_possible_root(ref); + } + ZVAL_NULL(retval_ptr); + break; + } else { + Z_ADDREF_P(retval_ptr); + } + } else { + retval_ptr = Z_REFVAL_P(retval_ptr); + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } + } + ZVAL_COPY_VALUE(return_value, retval_ptr); + } while (0); + } else /* if (OP1_TYPE == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(retval_ptr))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + + retval_ptr = Z_REFVAL_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } else { + ZVAL_COPY_VALUE(return_value, retval_ptr); + } + } + } + + zend_observer_maybe_fcall_call_end(execute_data, return_value); + + ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper); +} + ZEND_VM_COLD_CONST_HANDLER(111, ZEND_RETURN_BY_REF, CONST|TMP|VAR|CV, ANY, SRC) { USE_OPLINE diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 86d318ec8a12f..d5c26c3fed406 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -1085,8 +1085,6 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_leave_helper uint32_t call_info = EX_CALL_INFO(); SAVE_OPLINE(); - zend_observer_maybe_fcall_call_end(execute_data, EX(return_value)); - if (EXPECTED((call_info & (ZEND_CALL_CODE|ZEND_CALL_TOP|ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS|ZEND_CALL_ALLOCATED|ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) == 0)) { EG(current_execute_data) = EX(prev_execute_data); i_free_compiled_variables(execute_data); @@ -3685,6 +3683,82 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_CONST_ ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } +// TODO Make a helper for the shared return code +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_OBSERVE_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *retval_ptr; + zval *return_value; + + retval_ptr = RT_CONSTANT(opline, opline->op1); + return_value = EX(return_value); + if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) { + SAVE_OPLINE(); + retval_ptr = ZVAL_UNDEFINED_OP1(); + if (return_value) { + ZVAL_NULL(return_value); + } + } else if (!return_value) { + if (IS_CONST & (IS_VAR|IS_TMP_VAR)) { + if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) { + SAVE_OPLINE(); + rc_dtor_func(Z_COUNTED_P(retval_ptr)); + } + } + } else { + if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) { + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (IS_CONST == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) { + Z_ADDREF_P(return_value); + } + } + } else if (IS_CONST == IS_CV) { + do { + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) { + if (EXPECTED(!(EX_CALL_INFO() & ZEND_CALL_CODE))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (GC_MAY_LEAK(ref)) { + gc_possible_root(ref); + } + ZVAL_NULL(retval_ptr); + break; + } else { + Z_ADDREF_P(retval_ptr); + } + } else { + retval_ptr = Z_REFVAL_P(retval_ptr); + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } + } + ZVAL_COPY_VALUE(return_value, retval_ptr); + } while (0); + } else /* if (IS_CONST == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(retval_ptr))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + + retval_ptr = Z_REFVAL_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } else { + ZVAL_COPY_VALUE(return_value, retval_ptr); + } + } + } + + zend_observer_maybe_fcall_call_end(execute_data, return_value); + + ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); +} + static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -17848,6 +17922,82 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_TMP_HA ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } +// TODO Make a helper for the shared return code +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_OBSERVE_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *retval_ptr; + zval *return_value; + + retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + return_value = EX(return_value); + if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) { + SAVE_OPLINE(); + retval_ptr = ZVAL_UNDEFINED_OP1(); + if (return_value) { + ZVAL_NULL(return_value); + } + } else if (!return_value) { + if (IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) { + if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) { + SAVE_OPLINE(); + rc_dtor_func(Z_COUNTED_P(retval_ptr)); + } + } + } else { + if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) { + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (IS_TMP_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) { + Z_ADDREF_P(return_value); + } + } + } else if (IS_TMP_VAR == IS_CV) { + do { + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) { + if (EXPECTED(!(EX_CALL_INFO() & ZEND_CALL_CODE))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (GC_MAY_LEAK(ref)) { + gc_possible_root(ref); + } + ZVAL_NULL(retval_ptr); + break; + } else { + Z_ADDREF_P(retval_ptr); + } + } else { + retval_ptr = Z_REFVAL_P(retval_ptr); + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } + } + ZVAL_COPY_VALUE(return_value, retval_ptr); + } while (0); + } else /* if (IS_TMP_VAR == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(retval_ptr))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + + retval_ptr = Z_REFVAL_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } else { + ZVAL_COPY_VALUE(return_value, retval_ptr); + } + } + } + + zend_observer_maybe_fcall_call_end(execute_data, return_value); + + ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -20394,6 +20544,82 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_VAR_HA ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } +// TODO Make a helper for the shared return code +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_OBSERVE_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *retval_ptr; + zval *return_value; + + retval_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + return_value = EX(return_value); + if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) { + SAVE_OPLINE(); + retval_ptr = ZVAL_UNDEFINED_OP1(); + if (return_value) { + ZVAL_NULL(return_value); + } + } else if (!return_value) { + if (IS_VAR & (IS_VAR|IS_TMP_VAR)) { + if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) { + SAVE_OPLINE(); + rc_dtor_func(Z_COUNTED_P(retval_ptr)); + } + } + } else { + if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) { + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) { + Z_ADDREF_P(return_value); + } + } + } else if (IS_VAR == IS_CV) { + do { + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) { + if (EXPECTED(!(EX_CALL_INFO() & ZEND_CALL_CODE))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (GC_MAY_LEAK(ref)) { + gc_possible_root(ref); + } + ZVAL_NULL(retval_ptr); + break; + } else { + Z_ADDREF_P(retval_ptr); + } + } else { + retval_ptr = Z_REFVAL_P(retval_ptr); + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } + } + ZVAL_COPY_VALUE(return_value, retval_ptr); + } while (0); + } else /* if (IS_VAR == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(retval_ptr))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + + retval_ptr = Z_REFVAL_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } else { + ZVAL_COPY_VALUE(return_value, retval_ptr); + } + } + } + + zend_observer_maybe_fcall_call_end(execute_data, return_value); + + ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -36862,6 +37088,82 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_CV_HAN ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } +// TODO Make a helper for the shared return code +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_OBSERVE_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *retval_ptr; + zval *return_value; + + retval_ptr = EX_VAR(opline->op1.var); + return_value = EX(return_value); + if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) { + SAVE_OPLINE(); + retval_ptr = ZVAL_UNDEFINED_OP1(); + if (return_value) { + ZVAL_NULL(return_value); + } + } else if (!return_value) { + if (IS_CV & (IS_VAR|IS_TMP_VAR)) { + if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) { + SAVE_OPLINE(); + rc_dtor_func(Z_COUNTED_P(retval_ptr)); + } + } + } else { + if ((IS_CV & (IS_CONST|IS_TMP_VAR))) { + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (IS_CV == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) { + Z_ADDREF_P(return_value); + } + } + } else if (IS_CV == IS_CV) { + do { + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) { + if (EXPECTED(!(EX_CALL_INFO() & ZEND_CALL_CODE))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (GC_MAY_LEAK(ref)) { + gc_possible_root(ref); + } + ZVAL_NULL(retval_ptr); + break; + } else { + Z_ADDREF_P(retval_ptr); + } + } else { + retval_ptr = Z_REFVAL_P(retval_ptr); + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } + } + ZVAL_COPY_VALUE(return_value, retval_ptr); + } while (0); + } else /* if (IS_CV == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(retval_ptr))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + + retval_ptr = Z_REFVAL_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } else { + ZVAL_COPY_VALUE(return_value, retval_ptr); + } + } + } + + zend_observer_maybe_fcall_call_end(execute_data, return_value); + + ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -52440,6 +52742,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_JMP_NULL_SPEC_TMPVARCV_LABEL, (void*)&&ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED_LABEL, + (void*)&&ZEND_OBSERVE_RETURN_SPEC_CONST_LABEL, + (void*)&&ZEND_OBSERVE_RETURN_SPEC_TMP_LABEL, + (void*)&&ZEND_OBSERVE_RETURN_SPEC_VAR_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_OBSERVE_RETURN_SPEC_CV_LABEL, (void*)&&ZEND_RECV_NOTYPE_SPEC_LABEL, (void*)&&ZEND_JMP_FORWARD_SPEC_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -53433,8 +53740,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) uint32_t call_info = EX_CALL_INFO(); SAVE_OPLINE(); - zend_observer_maybe_fcall_call_end(execute_data, EX(return_value)); - if (EXPECTED((call_info & (ZEND_CALL_CODE|ZEND_CALL_TOP|ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS|ZEND_CALL_ALLOCATED|ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) == 0)) { EG(current_execute_data) = EX(prev_execute_data); i_free_compiled_variables(execute_data); @@ -53826,6 +54131,83 @@ ZEND_API void execute_ex(zend_execute_data *ex) } } } + goto zend_leave_helper_SPEC_LABEL; +} + +// TODO Make a helper for the shared return code + HYBRID_CASE(ZEND_OBSERVE_RETURN_SPEC_CONST): + VM_TRACE(ZEND_OBSERVE_RETURN_SPEC_CONST) +{ + USE_OPLINE + zval *retval_ptr; + zval *return_value; + + retval_ptr = RT_CONSTANT(opline, opline->op1); + return_value = EX(return_value); + if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) { + SAVE_OPLINE(); + retval_ptr = ZVAL_UNDEFINED_OP1(); + if (return_value) { + ZVAL_NULL(return_value); + } + } else if (!return_value) { + if (IS_CONST & (IS_VAR|IS_TMP_VAR)) { + if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) { + SAVE_OPLINE(); + rc_dtor_func(Z_COUNTED_P(retval_ptr)); + } + } + } else { + if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) { + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (IS_CONST == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) { + Z_ADDREF_P(return_value); + } + } + } else if (IS_CONST == IS_CV) { + do { + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) { + if (EXPECTED(!(EX_CALL_INFO() & ZEND_CALL_CODE))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (GC_MAY_LEAK(ref)) { + gc_possible_root(ref); + } + ZVAL_NULL(retval_ptr); + break; + } else { + Z_ADDREF_P(retval_ptr); + } + } else { + retval_ptr = Z_REFVAL_P(retval_ptr); + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } + } + ZVAL_COPY_VALUE(return_value, retval_ptr); + } while (0); + } else /* if (IS_CONST == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(retval_ptr))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + + retval_ptr = Z_REFVAL_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } else { + ZVAL_COPY_VALUE(return_value, retval_ptr); + } + } + } + + zend_observer_maybe_fcall_call_end(execute_data, return_value); + goto zend_leave_helper_SPEC_LABEL; } @@ -55347,6 +55729,83 @@ ZEND_API void execute_ex(zend_execute_data *ex) } } } + goto zend_leave_helper_SPEC_LABEL; +} + +// TODO Make a helper for the shared return code + HYBRID_CASE(ZEND_OBSERVE_RETURN_SPEC_TMP): + VM_TRACE(ZEND_OBSERVE_RETURN_SPEC_TMP) +{ + USE_OPLINE + zval *retval_ptr; + zval *return_value; + + retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + return_value = EX(return_value); + if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) { + SAVE_OPLINE(); + retval_ptr = ZVAL_UNDEFINED_OP1(); + if (return_value) { + ZVAL_NULL(return_value); + } + } else if (!return_value) { + if (IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) { + if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) { + SAVE_OPLINE(); + rc_dtor_func(Z_COUNTED_P(retval_ptr)); + } + } + } else { + if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) { + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (IS_TMP_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) { + Z_ADDREF_P(return_value); + } + } + } else if (IS_TMP_VAR == IS_CV) { + do { + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) { + if (EXPECTED(!(EX_CALL_INFO() & ZEND_CALL_CODE))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (GC_MAY_LEAK(ref)) { + gc_possible_root(ref); + } + ZVAL_NULL(retval_ptr); + break; + } else { + Z_ADDREF_P(retval_ptr); + } + } else { + retval_ptr = Z_REFVAL_P(retval_ptr); + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } + } + ZVAL_COPY_VALUE(return_value, retval_ptr); + } while (0); + } else /* if (IS_TMP_VAR == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(retval_ptr))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + + retval_ptr = Z_REFVAL_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } else { + ZVAL_COPY_VALUE(return_value, retval_ptr); + } + } + } + + zend_observer_maybe_fcall_call_end(execute_data, return_value); + goto zend_leave_helper_SPEC_LABEL; } @@ -55644,6 +56103,83 @@ ZEND_API void execute_ex(zend_execute_data *ex) } } } + goto zend_leave_helper_SPEC_LABEL; +} + +// TODO Make a helper for the shared return code + HYBRID_CASE(ZEND_OBSERVE_RETURN_SPEC_VAR): + VM_TRACE(ZEND_OBSERVE_RETURN_SPEC_VAR) +{ + USE_OPLINE + zval *retval_ptr; + zval *return_value; + + retval_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + return_value = EX(return_value); + if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) { + SAVE_OPLINE(); + retval_ptr = ZVAL_UNDEFINED_OP1(); + if (return_value) { + ZVAL_NULL(return_value); + } + } else if (!return_value) { + if (IS_VAR & (IS_VAR|IS_TMP_VAR)) { + if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) { + SAVE_OPLINE(); + rc_dtor_func(Z_COUNTED_P(retval_ptr)); + } + } + } else { + if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) { + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) { + Z_ADDREF_P(return_value); + } + } + } else if (IS_VAR == IS_CV) { + do { + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) { + if (EXPECTED(!(EX_CALL_INFO() & ZEND_CALL_CODE))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (GC_MAY_LEAK(ref)) { + gc_possible_root(ref); + } + ZVAL_NULL(retval_ptr); + break; + } else { + Z_ADDREF_P(retval_ptr); + } + } else { + retval_ptr = Z_REFVAL_P(retval_ptr); + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } + } + ZVAL_COPY_VALUE(return_value, retval_ptr); + } while (0); + } else /* if (IS_VAR == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(retval_ptr))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + + retval_ptr = Z_REFVAL_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } else { + ZVAL_COPY_VALUE(return_value, retval_ptr); + } + } + } + + zend_observer_maybe_fcall_call_end(execute_data, return_value); + goto zend_leave_helper_SPEC_LABEL; } @@ -56757,6 +57293,83 @@ ZEND_API void execute_ex(zend_execute_data *ex) } } } + goto zend_leave_helper_SPEC_LABEL; +} + +// TODO Make a helper for the shared return code + HYBRID_CASE(ZEND_OBSERVE_RETURN_SPEC_CV): + VM_TRACE(ZEND_OBSERVE_RETURN_SPEC_CV) +{ + USE_OPLINE + zval *retval_ptr; + zval *return_value; + + retval_ptr = EX_VAR(opline->op1.var); + return_value = EX(return_value); + if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) { + SAVE_OPLINE(); + retval_ptr = ZVAL_UNDEFINED_OP1(); + if (return_value) { + ZVAL_NULL(return_value); + } + } else if (!return_value) { + if (IS_CV & (IS_VAR|IS_TMP_VAR)) { + if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) { + SAVE_OPLINE(); + rc_dtor_func(Z_COUNTED_P(retval_ptr)); + } + } + } else { + if ((IS_CV & (IS_CONST|IS_TMP_VAR))) { + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (IS_CV == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) { + Z_ADDREF_P(return_value); + } + } + } else if (IS_CV == IS_CV) { + do { + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) { + if (EXPECTED(!(EX_CALL_INFO() & ZEND_CALL_CODE))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (GC_MAY_LEAK(ref)) { + gc_possible_root(ref); + } + ZVAL_NULL(retval_ptr); + break; + } else { + Z_ADDREF_P(retval_ptr); + } + } else { + retval_ptr = Z_REFVAL_P(retval_ptr); + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } + } + ZVAL_COPY_VALUE(return_value, retval_ptr); + } while (0); + } else /* if (IS_CV == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(retval_ptr))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + + retval_ptr = Z_REFVAL_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } else { + ZVAL_COPY_VALUE(return_value, retval_ptr); + } + } + } + + zend_observer_maybe_fcall_call_end(execute_data, return_value); + goto zend_leave_helper_SPEC_LABEL; } @@ -60314,6 +60927,11 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_JMP_NULL_SPEC_TMPVARCV_HANDLER, ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED_HANDLER, + ZEND_OBSERVE_RETURN_SPEC_CONST_HANDLER, + ZEND_OBSERVE_RETURN_SPEC_TMP_HANDLER, + ZEND_OBSERVE_RETURN_SPEC_VAR_HANDLER, + ZEND_NULL_HANDLER, + ZEND_OBSERVE_RETURN_SPEC_CV_HANDLER, ZEND_RECV_NOTYPE_SPEC_HANDLER, ZEND_JMP_FORWARD_SPEC_HANDLER, ZEND_NULL_HANDLER, @@ -61420,7 +62038,8 @@ void zend_vm_init(void) 2509 | SPEC_RULE_OP1, 2514 | SPEC_RULE_OP1, 2519, - 3423 + 2520 | SPEC_RULE_OP1, + 3428 }; #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID) zend_opcode_handler_funcs = labels; @@ -61585,7 +62204,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 = 2522 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2527 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -61593,7 +62212,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 = 2547 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2552 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -61601,7 +62220,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 = 2572 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2577 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -61612,17 +62231,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 = 2597 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2602 | 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 = 2622 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2627 | 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 = 2647 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2652 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_MUL: @@ -61633,17 +62252,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 = 2672 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2677 | 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 = 2697 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2702 | 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 = 2722 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2727 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_IDENTICAL: @@ -61654,14 +62273,14 @@ 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 = 2747 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2752 | 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 = 2822 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2827 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF))) { - spec = 3047 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3052 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_IDENTICAL: @@ -61672,14 +62291,14 @@ 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 = 2897 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2902 | 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 = 2972 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2977 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF))) { - spec = 3052 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3057 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_EQUAL: @@ -61690,12 +62309,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 = 2747 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2752 | 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 = 2822 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2827 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_EQUAL: @@ -61706,12 +62325,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 = 2897 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2902 | 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 = 2972 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2977 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_SMALLER: @@ -61719,12 +62338,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 = 3057 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3062 | 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 = 3132 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3137 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_IS_SMALLER_OR_EQUAL: @@ -61732,74 +62351,74 @@ 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 = 3207 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3212 | 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 = 3282 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3287 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_QM_ASSIGN: if (op1_info == MAY_BE_LONG) { - spec = 3369 | SPEC_RULE_OP1; - } else if (op1_info == MAY_BE_DOUBLE) { spec = 3374 | 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))))) { + } else if (op1_info == MAY_BE_DOUBLE) { spec = 3379 | 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 = 3384 | SPEC_RULE_OP1; } break; case ZEND_PRE_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3357 | SPEC_RULE_RETVAL; + spec = 3362 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3359 | SPEC_RULE_RETVAL; + spec = 3364 | SPEC_RULE_RETVAL; } break; case ZEND_PRE_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3361 | SPEC_RULE_RETVAL; + spec = 3366 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3363 | SPEC_RULE_RETVAL; + spec = 3368 | SPEC_RULE_RETVAL; } break; case ZEND_POST_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3365; + spec = 3370; } else if (op1_info == MAY_BE_LONG) { - spec = 3366; + spec = 3371; } break; case ZEND_POST_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3367; + spec = 3372; } else if (op1_info == MAY_BE_LONG) { - spec = 3368; + spec = 3373; } break; case ZEND_JMP: if (OP_JMP_ADDR(op, op->op1) > op) { - spec = 2521; + spec = 2526; } break; case ZEND_RECV: if (op->op2.num == MAY_BE_ANY) { - spec = 2520; + spec = 2525; } break; case ZEND_SEND_VAL: if (op->op1_type == IS_CONST && op->op2_type == IS_UNUSED && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3419; + spec = 3424; } break; case ZEND_SEND_VAR_EX: if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3414 | SPEC_RULE_OP1; + spec = 3419 | 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 = 3421 | SPEC_RULE_RETVAL; + spec = 3426 | SPEC_RULE_RETVAL; } break; case ZEND_FETCH_DIM_R: @@ -61807,17 +62426,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 = 3384 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 3389 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_SEND_VAL_EX: if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3420; + spec = 3425; } break; case ZEND_SEND_VAR: if (op->op2_type == IS_UNUSED && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3409 | SPEC_RULE_OP1; + spec = 3414 | SPEC_RULE_OP1; } break; case ZEND_BW_OR: diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h index afcc07a8fdc35..359fb2b348ab1 100644 --- a/Zend/zend_vm_handlers.h +++ b/Zend/zend_vm_handlers.h @@ -1329,498 +1329,502 @@ _(2516, ZEND_JMP_NULL_SPEC_TMPVARCV) \ _(2518, ZEND_JMP_NULL_SPEC_TMPVARCV) \ _(2519, ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED) \ - _(2520, ZEND_RECV_NOTYPE_SPEC) \ - _(2521, ZEND_JMP_FORWARD_SPEC) \ - _(2527, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2528, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2529, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2531, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2520, ZEND_OBSERVE_RETURN_SPEC_CONST) \ + _(2521, ZEND_OBSERVE_RETURN_SPEC_TMP) \ + _(2522, ZEND_OBSERVE_RETURN_SPEC_VAR) \ + _(2524, ZEND_OBSERVE_RETURN_SPEC_CV) \ + _(2525, ZEND_RECV_NOTYPE_SPEC) \ + _(2526, ZEND_JMP_FORWARD_SPEC) \ _(2532, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2533, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2534, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2536, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2542, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2543, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2544, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2546, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2552, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2553, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2554, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2556, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2537, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2538, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2539, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2541, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2547, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2548, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2549, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2551, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2557, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ _(2558, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2559, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2561, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2567, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2568, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2569, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2571, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2577, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2578, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2579, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2581, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2562, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2563, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2564, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2566, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2572, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2573, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2574, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2576, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2582, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2583, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2584, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2586, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2592, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2593, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2594, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2596, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2598, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2599, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2601, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2602, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2603, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2604, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2606, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2587, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2588, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2589, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2591, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2597, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2598, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2599, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2601, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2603, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2604, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2606, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ _(2607, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2608, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2609, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2611, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2617, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2618, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2619, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2621, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2623, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2624, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2626, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2627, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2628, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2629, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2631, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2612, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2613, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2614, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2616, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2622, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2623, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2624, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2626, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2628, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2629, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2631, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ _(2632, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ _(2633, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2634, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2636, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2642, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2643, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2644, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2646, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2648, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2649, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2651, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2652, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2653, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2654, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2656, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2637, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2638, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2639, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2641, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2647, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2648, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2649, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2651, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2653, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2654, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2656, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ _(2657, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2658, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2659, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2661, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2667, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2668, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2669, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2671, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2677, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2678, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2679, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2681, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2662, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2663, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2664, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2666, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2672, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2673, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2674, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2676, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2682, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2683, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2684, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2686, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2692, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2693, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2694, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2696, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2702, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2703, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2704, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2706, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2687, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2688, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2689, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2691, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2697, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2698, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2699, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2701, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2707, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ _(2708, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2709, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2711, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2717, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2718, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2719, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2721, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2727, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2728, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2729, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2731, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2712, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2713, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2714, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2716, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2722, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2723, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2724, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2726, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2732, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2733, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2734, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2736, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2742, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2743, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2744, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2746, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2762, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2763, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2764, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2765, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2766, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2767, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2768, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2769, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2770, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2774, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2775, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2776, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2777, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2778, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2779, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2780, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2781, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2782, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2783, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2784, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2785, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2789, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2790, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2791, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2807, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2808, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2809, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2810, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2811, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2812, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2813, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2814, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2815, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2819, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2820, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2821, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2837, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2838, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2839, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2840, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2841, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2842, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2843, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2844, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2845, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2849, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2850, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2851, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2852, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2853, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2854, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2855, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2856, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2857, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2858, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2859, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2860, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2864, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2865, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2866, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2882, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2883, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2884, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2885, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2886, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2887, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2888, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2889, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2890, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2894, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2895, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2896, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2912, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2913, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2914, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2915, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2916, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2917, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2918, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2919, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2920, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2924, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2925, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2926, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2927, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2928, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2929, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2930, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2931, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2932, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2933, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2934, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2935, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2939, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2940, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2941, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2957, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2958, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2959, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2960, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2961, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2962, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2963, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2964, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2965, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2969, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2970, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2971, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2987, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2988, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2989, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2990, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2991, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2992, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2993, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2994, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2995, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2999, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3000, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3001, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3002, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3003, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3004, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3005, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3006, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3007, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3008, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3009, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3010, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3014, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3015, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3016, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3032, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3033, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3034, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3035, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3036, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3037, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3038, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3039, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3040, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3044, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3045, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3046, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3047, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(3051, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(3052, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(3056, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(3060, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3061, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3062, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3063, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3064, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3065, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3069, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3070, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3071, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3072, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3073, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3074, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3075, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3076, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3077, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3078, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3079, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3080, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3084, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3085, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3086, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3087, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3088, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3089, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3090, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3091, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3092, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3093, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3094, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3095, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3099, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3100, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3101, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3117, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3118, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3119, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3120, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3121, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3122, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3123, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3124, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3125, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3129, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3130, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3131, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3135, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3136, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3137, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3138, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3139, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3140, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3144, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3145, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3146, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3147, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3148, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3149, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3150, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3151, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3152, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3153, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3154, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3155, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3159, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3160, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3161, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3162, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3163, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3164, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3165, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3166, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3167, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3168, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3169, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3170, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3174, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3175, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3176, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3192, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3193, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3194, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3195, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3196, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3197, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3198, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3199, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3200, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3204, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3205, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3206, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3210, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3211, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3212, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3213, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3214, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3215, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3219, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3220, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3221, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3222, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3223, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3224, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3225, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3226, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3227, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3228, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3229, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3230, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3234, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3235, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3236, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3237, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3238, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3239, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3240, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3241, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3242, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3243, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3244, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3245, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3249, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3250, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3251, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3267, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3268, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3269, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3270, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3271, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3272, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3273, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3274, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3275, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3279, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3280, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3281, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3285, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3286, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3287, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3288, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3289, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3290, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3294, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3295, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3296, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3297, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3298, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3299, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3300, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3301, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3302, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3303, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3304, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3305, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3309, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3310, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3311, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3312, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3313, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3314, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3315, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3316, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3317, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3318, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3319, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3320, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3324, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3325, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3326, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3342, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3343, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3344, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3345, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3346, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3347, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3348, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3349, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3350, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3354, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3355, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3356, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3357, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3358, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3359, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3360, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ - _(3361, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3362, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3363, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3364, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ - _(3365, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3366, ZEND_POST_INC_LONG_SPEC_CV) \ - _(3367, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3368, ZEND_POST_DEC_LONG_SPEC_CV) \ - _(3369, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ - _(3370, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3371, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3373, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3374, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ - _(3375, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3376, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3378, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3379, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ - _(3380, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3381, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3383, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3385, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3386, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3388, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3389, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(3390, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3391, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3393, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(2737, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2738, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2739, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2741, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2747, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2748, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2749, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2751, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2767, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2768, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2769, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2770, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2771, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2772, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2773, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2774, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2775, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2779, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2780, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2781, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2782, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2783, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2784, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2785, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2786, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2787, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2788, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2789, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2790, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2794, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2795, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2796, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2812, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2813, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2814, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2815, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2816, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2817, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2818, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2819, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2820, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2824, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2825, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2826, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2842, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2843, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2844, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2845, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2846, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2847, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2848, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2849, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2850, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2854, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2855, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2856, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2857, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2858, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2859, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2860, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2861, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2862, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2863, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2864, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2865, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2869, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2870, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2871, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2887, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2888, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2889, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2890, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2891, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2892, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2893, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2894, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2895, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2899, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2900, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2901, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2917, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2918, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2919, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2920, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2921, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2922, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2923, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2924, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2925, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2929, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2930, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2931, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2932, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2933, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2934, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2935, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2936, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2937, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2938, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2939, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2940, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2944, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2945, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2946, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2962, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2963, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2964, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2965, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2966, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2967, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2968, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2969, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2970, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2974, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2975, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2976, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2992, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2993, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2994, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2995, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2996, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2997, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2998, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2999, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3000, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3004, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3005, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3006, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3007, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3008, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3009, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3010, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3011, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3012, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3013, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3014, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3015, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3019, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3020, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3021, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3037, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3038, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3039, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3040, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3041, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3042, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3043, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3044, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3045, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3049, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3050, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3051, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3052, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3056, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3057, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3061, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3065, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3066, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3067, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3068, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3069, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3070, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3074, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3075, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3076, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3077, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3078, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3079, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3080, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3081, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3082, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3083, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3084, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3085, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3089, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3090, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3091, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3092, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3093, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3094, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3095, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3096, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3097, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3098, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3099, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3100, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3104, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3105, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3106, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3122, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3123, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3124, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3125, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3126, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3127, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3128, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3129, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3130, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3134, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3135, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3136, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3140, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3141, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3142, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3143, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3144, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3145, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3149, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3150, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3151, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3152, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3153, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3154, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3155, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3156, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3157, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3158, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3159, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3160, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3164, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3165, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3166, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3167, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3168, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3169, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3170, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3171, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3172, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3173, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3174, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3175, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3179, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3180, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3181, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3197, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3198, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3199, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3200, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3201, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3202, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3203, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3204, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3205, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3209, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3210, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3211, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3215, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3216, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3217, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3218, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3219, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3220, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3224, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3225, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3226, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3227, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3228, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3229, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3230, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3231, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3232, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3233, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3234, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3235, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3239, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3240, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3241, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3242, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3243, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3244, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3245, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3246, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3247, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3248, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3249, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3250, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3254, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3255, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3256, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3272, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3273, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3274, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3275, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3276, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3277, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3278, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3279, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3280, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3284, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3285, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3286, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3290, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3291, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3292, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3293, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3294, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3295, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3299, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3300, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3301, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3302, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3303, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3304, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3305, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3306, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3307, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3308, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3309, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3310, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3314, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3315, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3316, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3317, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3318, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3319, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3320, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3321, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3322, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3323, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3324, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3325, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3329, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3330, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3331, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3347, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3348, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3349, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3350, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3351, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3352, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3353, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3354, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3355, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3359, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3360, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3361, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3362, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3363, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3364, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3365, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ + _(3366, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3367, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3368, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3369, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ + _(3370, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3371, ZEND_POST_INC_LONG_SPEC_CV) \ + _(3372, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3373, ZEND_POST_DEC_LONG_SPEC_CV) \ + _(3374, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ + _(3375, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3376, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3378, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3379, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ + _(3380, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3381, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3383, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3384, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ + _(3385, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3386, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3388, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3390, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3391, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3393, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ _(3394, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ _(3395, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ _(3396, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ _(3398, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3404, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ - _(3405, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3406, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3408, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3411, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ - _(3413, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ - _(3416, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ - _(3418, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ - _(3419, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ - _(3420, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ - _(3421, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ - _(3422, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ - _(3422+1, ZEND_NULL) + _(3399, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3400, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3401, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3403, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3409, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ + _(3410, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3411, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3413, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3416, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ + _(3418, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ + _(3421, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ + _(3423, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ + _(3424, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ + _(3425, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ + _(3426, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ + _(3427, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ + _(3427+1, ZEND_NULL) diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c index 56a31aa19a095..3ea2b4da4516f 100644 --- a/Zend/zend_vm_opcodes.c +++ b/Zend/zend_vm_opcodes.c @@ -22,7 +22,7 @@ #include #include -static const char *zend_vm_opcodes_names[200] = { +static const char *zend_vm_opcodes_names[201] = { "ZEND_NOP", "ZEND_ADD", "ZEND_SUB", @@ -223,9 +223,10 @@ static const char *zend_vm_opcodes_names[200] = { "ZEND_MATCH_ERROR", "ZEND_JMP_NULL", "ZEND_CHECK_UNDEF_ARGS", + "ZEND_OBSERVE_RETURN", }; -static uint32_t zend_vm_opcodes_flags[200] = { +static uint32_t zend_vm_opcodes_flags[201] = { 0x00000000, 0x00000b0b, 0x00000b0b, @@ -426,6 +427,7 @@ static uint32_t zend_vm_opcodes_flags[200] = { 0x0000010b, 0x0000200b, 0x00000101, + 0x00000003, }; ZEND_API const char* ZEND_FASTCALL zend_get_opcode_name(zend_uchar opcode) { diff --git a/Zend/zend_vm_opcodes.h b/Zend/zend_vm_opcodes.h index df5a14799953a..cbf862ccf9a2e 100644 --- a/Zend/zend_vm_opcodes.h +++ b/Zend/zend_vm_opcodes.h @@ -276,7 +276,8 @@ END_EXTERN_C() #define ZEND_MATCH_ERROR 197 #define ZEND_JMP_NULL 198 #define ZEND_CHECK_UNDEF_ARGS 199 +#define ZEND_OBSERVE_RETURN 200 -#define ZEND_VM_LAST_OPCODE 199 +#define ZEND_VM_LAST_OPCODE 200 #endif From b4731c5a30a82d480327385702f24c28da249056 Mon Sep 17 00:00:00 2001 From: Levi Morrison Date: Mon, 24 Aug 2020 17:47:14 -0600 Subject: [PATCH 29/53] Clean up fcall observer This also adjusts zend_observer_maybe_fcall_call_end to be always inlined and shortens its body. --- Zend/zend_execute.c | 2 +- Zend/zend_generators.c | 2 +- Zend/zend_observer.c | 23 +++++++++++++++++++---- Zend/zend_observer.h | 29 +++++++++++++---------------- 4 files changed, 34 insertions(+), 22 deletions(-) diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c index 2b890e7d62a90..82560bbb33809 100644 --- a/Zend/zend_execute.c +++ b/Zend/zend_execute.c @@ -3636,7 +3636,7 @@ static zend_always_inline void i_init_code_execute_data(zend_execute_data *execu EG(current_execute_data) = execute_data; - if (zend_observer_fcall_op_array_extension != -1 && op_array != ZEND_FAKE_OP_ARRAY) { + if (ZEND_OBSERVER_ENABLED && op_array != ZEND_FAKE_OP_ARRAY) { if (ptr != NULL) { zend_observer_fcall_install((zend_function*)op_array); } diff --git a/Zend/zend_generators.c b/Zend/zend_generators.c index 3bb79bab16f99..877ca071adcd9 100644 --- a/Zend/zend_generators.c +++ b/Zend/zend_generators.c @@ -772,7 +772,7 @@ ZEND_API void zend_generator_resume(zend_generator *orig_generator) /* {{{ */ /* Resume execution */ generator->flags |= ZEND_GENERATOR_CURRENTLY_RUNNING; - if (zend_observer_fcall_op_array_extension != -1) { + if (ZEND_OBSERVER_ENABLED) { void *observer_handlers = ZEND_OBSERVER_HANDLERS(&generator->execute_data->func->op_array); ZEND_ASSERT(observer_handlers); if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { diff --git a/Zend/zend_observer.c b/Zend/zend_observer.c index bab547427568e..dcc9ed546fc8f 100644 --- a/Zend/zend_observer.c +++ b/Zend/zend_observer.c @@ -34,8 +34,9 @@ ZEND_API extern inline void zend_observer_maybe_fcall_call_end( // Call during minit/startup ONLY ZEND_API void zend_observer_fcall_register(zend_observer_fcall_init init) { /* We don't want to get an extension handle unless an ext installs an observer */ - if (zend_observer_fcall_op_array_extension == -1) { - zend_observer_fcall_op_array_extension = zend_get_op_array_extension_handle(); + if (!ZEND_OBSERVER_ENABLED) { + zend_observer_fcall_op_array_extension = + zend_get_op_array_extension_handle(); } zend_llist_add_element(&zend_observers_fcall_list, &init); } @@ -47,7 +48,7 @@ ZEND_API void zend_observer_startup(void) { ZEND_API void zend_observer_activate(void) { /* todo: how to size the arena? */ - if (zend_observer_fcall_op_array_extension != -1) { + if (ZEND_OBSERVER_ENABLED) { fcall_handlers_arena = zend_arena_create(1024); } } @@ -99,7 +100,7 @@ ZEND_API void zend_observer_fcall_install(zend_function *function) { ext = ZEND_OBSERVER_NOT_OBSERVED; } - ZEND_OP_ARRAY_EXTENSION(op_array, zend_observer_fcall_op_array_extension) = ext; + ZEND_OBSERVER_HANDLERS(op_array) = ext; zend_llist_destroy(&handlers_list); } @@ -115,6 +116,20 @@ void zend_observe_fcall_begin( } } +void zend_observer_fcall_call_end_helper( + zend_execute_data *execute_data, + zval *return_value) +{ + zend_function *func = execute_data->func; + ZEND_ASSUME(ZEND_SHOULD_OBSERVE_FN(func->common.fn_flags)); + void *observer_handlers = ZEND_OBSERVER_HANDLERS(&func->op_array); + ZEND_ASSERT(observer_handlers); + if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { + zend_observer_fcall_cache *cache = observer_handlers; + zend_observe_fcall_end(cache, execute_data, return_value); + } +} + void zend_observe_fcall_end( zend_observer_fcall_cache *cache, zend_execute_data *execute_data, diff --git a/Zend/zend_observer.h b/Zend/zend_observer.h index 408edc4790d50..e344caef3a737 100644 --- a/Zend/zend_observer.h +++ b/Zend/zend_observer.h @@ -27,14 +27,16 @@ BEGIN_EXTERN_C() extern int zend_observer_fcall_op_array_extension; +#define ZEND_OBSERVER_ENABLED (zend_observer_fcall_op_array_extension != -1) + #define ZEND_OBSERVER_HANDLERS(op_array) \ ZEND_OP_ARRAY_EXTENSION(op_array, zend_observer_fcall_op_array_extension) #define ZEND_OBSERVER_NOT_OBSERVED ((void *) 2) #define ZEND_SHOULD_OBSERVE_FN(fn_flags) \ - zend_observer_fcall_op_array_extension != -1 && \ - !(fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE)) + (ZEND_OBSERVER_ENABLED && \ + !(fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE))) struct zend_observer_fcall { void (*begin)(zend_execute_data *execute_data); @@ -63,31 +65,26 @@ ZEND_API void zend_observer_shutdown(void); ZEND_API void zend_observer_fcall_install(zend_function *function); -void zend_observe_fcall_begin( +ZEND_API void zend_observe_fcall_begin( zend_observer_fcall_cache *cache, zend_execute_data *execute_data); -void zend_observe_fcall_end( +ZEND_API void zend_observe_fcall_end( zend_observer_fcall_cache *cache, zend_execute_data *execute_data, zval *return_value); -ZEND_API inline void zend_observer_maybe_fcall_call_end( +ZEND_API void zend_observer_fcall_call_end_helper( + zend_execute_data *execute_data, + zval *return_value); + +ZEND_API zend_always_inline void zend_observer_maybe_fcall_call_end( zend_execute_data *execute_data, zval *return_value) { - if (zend_observer_fcall_op_array_extension == -1) { - return; - } - zend_function *func = execute_data->func; - if (!(func->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE))) { - void *observer_handlers = ZEND_OBSERVER_HANDLERS(&func->op_array); - ZEND_ASSERT(observer_handlers); - if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { - zend_observer_fcall_cache *cache = observer_handlers; - zend_observe_fcall_end(cache, execute_data, return_value); - } + if (ZEND_SHOULD_OBSERVE_FN(func->common.fn_flags)) { + zend_observer_fcall_call_end_helper(execute_data, return_value); } } From c76e8f5fc9fa9827265ef1bad6fac123a04cc793 Mon Sep 17 00:00:00 2001 From: Sammy Powers Date: Tue, 25 Aug 2020 14:04:09 -0700 Subject: [PATCH 30/53] Revert "Implement ZEND_OBSERVE_RETURN" This reverts commit fc739426b9d881fed87b07681f1410e3322c6635. --- Zend/zend_compile.c | 15 +- Zend/zend_opcode.c | 6 - Zend/zend_vm_def.h | 78 +--- Zend/zend_vm_execute.h | 713 +++---------------------------- Zend/zend_vm_handlers.h | 914 ++++++++++++++++++++-------------------- Zend/zend_vm_opcodes.c | 6 +- Zend/zend_vm_opcodes.h | 3 +- 7 files changed, 510 insertions(+), 1225 deletions(-) diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index eda0c0707e1fd..a03a440214f1a 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -2439,12 +2439,7 @@ void zend_emit_final_return(int return_one) /* {{{ */ ZVAL_NULL(&zn.u.constant); } - if (ZEND_SHOULD_OBSERVE_FN(CG(active_op_array)->fn_flags)) { - // TODO Emit ZEND_OBSERVE_RETURN_BY_REF - ret = zend_emit_op(NULL, returns_reference ? ZEND_RETURN_BY_REF : ZEND_OBSERVE_RETURN, &zn, NULL); - } else { - ret = zend_emit_op(NULL, returns_reference ? ZEND_RETURN_BY_REF : ZEND_RETURN, &zn, NULL); - } + ret = zend_emit_op(NULL, returns_reference ? ZEND_RETURN_BY_REF : ZEND_RETURN, &zn, NULL); ret->extended_value = -1; } /* }}} */ @@ -4781,12 +4776,8 @@ void zend_compile_return(zend_ast *ast) /* {{{ */ zend_handle_loops_and_finally((expr_node.op_type & (IS_TMP_VAR | IS_VAR)) ? &expr_node : NULL); - if (ZEND_SHOULD_OBSERVE_FN(CG(active_op_array)->fn_flags)) { - // TODO Emit ZEND_OBSERVE_RETURN_BY_REF - opline = zend_emit_op(NULL, by_ref ? ZEND_RETURN_BY_REF : ZEND_OBSERVE_RETURN, &expr_node, NULL); - } else { - opline = zend_emit_op(NULL, by_ref ? ZEND_RETURN_BY_REF : ZEND_RETURN, &expr_node, NULL); - } + opline = zend_emit_op(NULL, by_ref ? ZEND_RETURN_BY_REF : ZEND_RETURN, + &expr_node, NULL); if (by_ref && expr_ast) { if (zend_is_call(expr_ast)) { diff --git a/Zend/zend_opcode.c b/Zend/zend_opcode.c index 07fd130fdf1a3..14dd6e46db27d 100644 --- a/Zend/zend_opcode.c +++ b/Zend/zend_opcode.c @@ -1040,12 +1040,6 @@ ZEND_API int pass_two(zend_op_array *op_array) opline->opcode = ZEND_GENERATOR_RETURN; } break; - case ZEND_OBSERVE_RETURN: - // TODO case ZEND_OBSERVE_RETURN_BY_REF: - if (op_array->fn_flags & ZEND_ACC_GENERATOR) { - opline->opcode = ZEND_GENERATOR_RETURN; // TODO ZEND_OBSERVE_GENERATOR_RETURN - } - break; case ZEND_SWITCH_LONG: case ZEND_SWITCH_STRING: case ZEND_MATCH: diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 62fd4bf0e92f9..4e306010702cf 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -2762,6 +2762,8 @@ ZEND_VM_HOT_HELPER(zend_leave_helper, ANY, ANY) uint32_t call_info = EX_CALL_INFO(); SAVE_OPLINE(); + zend_observer_maybe_fcall_call_end(execute_data, EX(return_value)); + if (EXPECTED((call_info & (ZEND_CALL_CODE|ZEND_CALL_TOP|ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS|ZEND_CALL_ALLOCATED|ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) == 0)) { EG(current_execute_data) = EX(prev_execute_data); i_free_compiled_variables(execute_data); @@ -4282,82 +4284,6 @@ ZEND_VM_INLINE_HANDLER(62, ZEND_RETURN, CONST|TMP|VAR|CV, ANY) ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper); } -// TODO Make a helper for the shared return code -ZEND_VM_INLINE_HANDLER(200, ZEND_OBSERVE_RETURN, CONST|TMP|VAR|CV, ANY) -{ - USE_OPLINE - zval *retval_ptr; - zval *return_value; - - retval_ptr = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R); - return_value = EX(return_value); - if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) { - SAVE_OPLINE(); - retval_ptr = ZVAL_UNDEFINED_OP1(); - if (return_value) { - ZVAL_NULL(return_value); - } - } else if (!return_value) { - if (OP1_TYPE & (IS_VAR|IS_TMP_VAR)) { - if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) { - SAVE_OPLINE(); - rc_dtor_func(Z_COUNTED_P(retval_ptr)); - } - } - } else { - if ((OP1_TYPE & (IS_CONST|IS_TMP_VAR))) { - ZVAL_COPY_VALUE(return_value, retval_ptr); - if (OP1_TYPE == IS_CONST) { - if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) { - Z_ADDREF_P(return_value); - } - } - } else if (OP1_TYPE == IS_CV) { - do { - if (Z_OPT_REFCOUNTED_P(retval_ptr)) { - if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) { - if (EXPECTED(!(EX_CALL_INFO() & ZEND_CALL_CODE))) { - zend_refcounted *ref = Z_COUNTED_P(retval_ptr); - ZVAL_COPY_VALUE(return_value, retval_ptr); - if (GC_MAY_LEAK(ref)) { - gc_possible_root(ref); - } - ZVAL_NULL(retval_ptr); - break; - } else { - Z_ADDREF_P(retval_ptr); - } - } else { - retval_ptr = Z_REFVAL_P(retval_ptr); - if (Z_OPT_REFCOUNTED_P(retval_ptr)) { - Z_ADDREF_P(retval_ptr); - } - } - } - ZVAL_COPY_VALUE(return_value, retval_ptr); - } while (0); - } else /* if (OP1_TYPE == IS_VAR) */ { - if (UNEXPECTED(Z_ISREF_P(retval_ptr))) { - zend_refcounted *ref = Z_COUNTED_P(retval_ptr); - - retval_ptr = Z_REFVAL_P(retval_ptr); - ZVAL_COPY_VALUE(return_value, retval_ptr); - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) { - Z_ADDREF_P(retval_ptr); - } - } else { - ZVAL_COPY_VALUE(return_value, retval_ptr); - } - } - } - - zend_observer_maybe_fcall_call_end(execute_data, return_value); - - ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper); -} - ZEND_VM_COLD_CONST_HANDLER(111, ZEND_RETURN_BY_REF, CONST|TMP|VAR|CV, ANY, SRC) { USE_OPLINE diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index d5c26c3fed406..86d318ec8a12f 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -1085,6 +1085,8 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_leave_helper uint32_t call_info = EX_CALL_INFO(); SAVE_OPLINE(); + zend_observer_maybe_fcall_call_end(execute_data, EX(return_value)); + if (EXPECTED((call_info & (ZEND_CALL_CODE|ZEND_CALL_TOP|ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS|ZEND_CALL_ALLOCATED|ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) == 0)) { EG(current_execute_data) = EX(prev_execute_data); i_free_compiled_variables(execute_data); @@ -3683,82 +3685,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_CONST_ ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } -// TODO Make a helper for the shared return code -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_OBSERVE_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *retval_ptr; - zval *return_value; - - retval_ptr = RT_CONSTANT(opline, opline->op1); - return_value = EX(return_value); - if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) { - SAVE_OPLINE(); - retval_ptr = ZVAL_UNDEFINED_OP1(); - if (return_value) { - ZVAL_NULL(return_value); - } - } else if (!return_value) { - if (IS_CONST & (IS_VAR|IS_TMP_VAR)) { - if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) { - SAVE_OPLINE(); - rc_dtor_func(Z_COUNTED_P(retval_ptr)); - } - } - } else { - if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) { - ZVAL_COPY_VALUE(return_value, retval_ptr); - if (IS_CONST == IS_CONST) { - if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) { - Z_ADDREF_P(return_value); - } - } - } else if (IS_CONST == IS_CV) { - do { - if (Z_OPT_REFCOUNTED_P(retval_ptr)) { - if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) { - if (EXPECTED(!(EX_CALL_INFO() & ZEND_CALL_CODE))) { - zend_refcounted *ref = Z_COUNTED_P(retval_ptr); - ZVAL_COPY_VALUE(return_value, retval_ptr); - if (GC_MAY_LEAK(ref)) { - gc_possible_root(ref); - } - ZVAL_NULL(retval_ptr); - break; - } else { - Z_ADDREF_P(retval_ptr); - } - } else { - retval_ptr = Z_REFVAL_P(retval_ptr); - if (Z_OPT_REFCOUNTED_P(retval_ptr)) { - Z_ADDREF_P(retval_ptr); - } - } - } - ZVAL_COPY_VALUE(return_value, retval_ptr); - } while (0); - } else /* if (IS_CONST == IS_VAR) */ { - if (UNEXPECTED(Z_ISREF_P(retval_ptr))) { - zend_refcounted *ref = Z_COUNTED_P(retval_ptr); - - retval_ptr = Z_REFVAL_P(retval_ptr); - ZVAL_COPY_VALUE(return_value, retval_ptr); - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) { - Z_ADDREF_P(retval_ptr); - } - } else { - ZVAL_COPY_VALUE(return_value, retval_ptr); - } - } - } - - zend_observer_maybe_fcall_call_end(execute_data, return_value); - - ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); -} - static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -17922,82 +17848,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_TMP_HA ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } -// TODO Make a helper for the shared return code -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_OBSERVE_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *retval_ptr; - zval *return_value; - - retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - return_value = EX(return_value); - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) { - SAVE_OPLINE(); - retval_ptr = ZVAL_UNDEFINED_OP1(); - if (return_value) { - ZVAL_NULL(return_value); - } - } else if (!return_value) { - if (IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) { - if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) { - SAVE_OPLINE(); - rc_dtor_func(Z_COUNTED_P(retval_ptr)); - } - } - } else { - if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) { - ZVAL_COPY_VALUE(return_value, retval_ptr); - if (IS_TMP_VAR == IS_CONST) { - if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) { - Z_ADDREF_P(return_value); - } - } - } else if (IS_TMP_VAR == IS_CV) { - do { - if (Z_OPT_REFCOUNTED_P(retval_ptr)) { - if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) { - if (EXPECTED(!(EX_CALL_INFO() & ZEND_CALL_CODE))) { - zend_refcounted *ref = Z_COUNTED_P(retval_ptr); - ZVAL_COPY_VALUE(return_value, retval_ptr); - if (GC_MAY_LEAK(ref)) { - gc_possible_root(ref); - } - ZVAL_NULL(retval_ptr); - break; - } else { - Z_ADDREF_P(retval_ptr); - } - } else { - retval_ptr = Z_REFVAL_P(retval_ptr); - if (Z_OPT_REFCOUNTED_P(retval_ptr)) { - Z_ADDREF_P(retval_ptr); - } - } - } - ZVAL_COPY_VALUE(return_value, retval_ptr); - } while (0); - } else /* if (IS_TMP_VAR == IS_VAR) */ { - if (UNEXPECTED(Z_ISREF_P(retval_ptr))) { - zend_refcounted *ref = Z_COUNTED_P(retval_ptr); - - retval_ptr = Z_REFVAL_P(retval_ptr); - ZVAL_COPY_VALUE(return_value, retval_ptr); - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) { - Z_ADDREF_P(retval_ptr); - } - } else { - ZVAL_COPY_VALUE(return_value, retval_ptr); - } - } - } - - zend_observer_maybe_fcall_call_end(execute_data, return_value); - - ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); -} - static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -20544,82 +20394,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_VAR_HA ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } -// TODO Make a helper for the shared return code -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_OBSERVE_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *retval_ptr; - zval *return_value; - - retval_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - return_value = EX(return_value); - if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) { - SAVE_OPLINE(); - retval_ptr = ZVAL_UNDEFINED_OP1(); - if (return_value) { - ZVAL_NULL(return_value); - } - } else if (!return_value) { - if (IS_VAR & (IS_VAR|IS_TMP_VAR)) { - if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) { - SAVE_OPLINE(); - rc_dtor_func(Z_COUNTED_P(retval_ptr)); - } - } - } else { - if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) { - ZVAL_COPY_VALUE(return_value, retval_ptr); - if (IS_VAR == IS_CONST) { - if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) { - Z_ADDREF_P(return_value); - } - } - } else if (IS_VAR == IS_CV) { - do { - if (Z_OPT_REFCOUNTED_P(retval_ptr)) { - if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) { - if (EXPECTED(!(EX_CALL_INFO() & ZEND_CALL_CODE))) { - zend_refcounted *ref = Z_COUNTED_P(retval_ptr); - ZVAL_COPY_VALUE(return_value, retval_ptr); - if (GC_MAY_LEAK(ref)) { - gc_possible_root(ref); - } - ZVAL_NULL(retval_ptr); - break; - } else { - Z_ADDREF_P(retval_ptr); - } - } else { - retval_ptr = Z_REFVAL_P(retval_ptr); - if (Z_OPT_REFCOUNTED_P(retval_ptr)) { - Z_ADDREF_P(retval_ptr); - } - } - } - ZVAL_COPY_VALUE(return_value, retval_ptr); - } while (0); - } else /* if (IS_VAR == IS_VAR) */ { - if (UNEXPECTED(Z_ISREF_P(retval_ptr))) { - zend_refcounted *ref = Z_COUNTED_P(retval_ptr); - - retval_ptr = Z_REFVAL_P(retval_ptr); - ZVAL_COPY_VALUE(return_value, retval_ptr); - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) { - Z_ADDREF_P(retval_ptr); - } - } else { - ZVAL_COPY_VALUE(return_value, retval_ptr); - } - } - } - - zend_observer_maybe_fcall_call_end(execute_data, return_value); - - ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); -} - static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -37088,82 +36862,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_CV_HAN ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } -// TODO Make a helper for the shared return code -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_OBSERVE_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *retval_ptr; - zval *return_value; - - retval_ptr = EX_VAR(opline->op1.var); - return_value = EX(return_value); - if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) { - SAVE_OPLINE(); - retval_ptr = ZVAL_UNDEFINED_OP1(); - if (return_value) { - ZVAL_NULL(return_value); - } - } else if (!return_value) { - if (IS_CV & (IS_VAR|IS_TMP_VAR)) { - if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) { - SAVE_OPLINE(); - rc_dtor_func(Z_COUNTED_P(retval_ptr)); - } - } - } else { - if ((IS_CV & (IS_CONST|IS_TMP_VAR))) { - ZVAL_COPY_VALUE(return_value, retval_ptr); - if (IS_CV == IS_CONST) { - if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) { - Z_ADDREF_P(return_value); - } - } - } else if (IS_CV == IS_CV) { - do { - if (Z_OPT_REFCOUNTED_P(retval_ptr)) { - if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) { - if (EXPECTED(!(EX_CALL_INFO() & ZEND_CALL_CODE))) { - zend_refcounted *ref = Z_COUNTED_P(retval_ptr); - ZVAL_COPY_VALUE(return_value, retval_ptr); - if (GC_MAY_LEAK(ref)) { - gc_possible_root(ref); - } - ZVAL_NULL(retval_ptr); - break; - } else { - Z_ADDREF_P(retval_ptr); - } - } else { - retval_ptr = Z_REFVAL_P(retval_ptr); - if (Z_OPT_REFCOUNTED_P(retval_ptr)) { - Z_ADDREF_P(retval_ptr); - } - } - } - ZVAL_COPY_VALUE(return_value, retval_ptr); - } while (0); - } else /* if (IS_CV == IS_VAR) */ { - if (UNEXPECTED(Z_ISREF_P(retval_ptr))) { - zend_refcounted *ref = Z_COUNTED_P(retval_ptr); - - retval_ptr = Z_REFVAL_P(retval_ptr); - ZVAL_COPY_VALUE(return_value, retval_ptr); - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) { - Z_ADDREF_P(retval_ptr); - } - } else { - ZVAL_COPY_VALUE(return_value, retval_ptr); - } - } - } - - zend_observer_maybe_fcall_call_end(execute_data, return_value); - - ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); -} - static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -52742,11 +52440,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_JMP_NULL_SPEC_TMPVARCV_LABEL, (void*)&&ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED_LABEL, - (void*)&&ZEND_OBSERVE_RETURN_SPEC_CONST_LABEL, - (void*)&&ZEND_OBSERVE_RETURN_SPEC_TMP_LABEL, - (void*)&&ZEND_OBSERVE_RETURN_SPEC_VAR_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_OBSERVE_RETURN_SPEC_CV_LABEL, (void*)&&ZEND_RECV_NOTYPE_SPEC_LABEL, (void*)&&ZEND_JMP_FORWARD_SPEC_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -53740,6 +53433,8 @@ ZEND_API void execute_ex(zend_execute_data *ex) uint32_t call_info = EX_CALL_INFO(); SAVE_OPLINE(); + zend_observer_maybe_fcall_call_end(execute_data, EX(return_value)); + if (EXPECTED((call_info & (ZEND_CALL_CODE|ZEND_CALL_TOP|ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS|ZEND_CALL_ALLOCATED|ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) == 0)) { EG(current_execute_data) = EX(prev_execute_data); i_free_compiled_variables(execute_data); @@ -54131,83 +53826,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) } } } - goto zend_leave_helper_SPEC_LABEL; -} - -// TODO Make a helper for the shared return code - HYBRID_CASE(ZEND_OBSERVE_RETURN_SPEC_CONST): - VM_TRACE(ZEND_OBSERVE_RETURN_SPEC_CONST) -{ - USE_OPLINE - zval *retval_ptr; - zval *return_value; - - retval_ptr = RT_CONSTANT(opline, opline->op1); - return_value = EX(return_value); - if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) { - SAVE_OPLINE(); - retval_ptr = ZVAL_UNDEFINED_OP1(); - if (return_value) { - ZVAL_NULL(return_value); - } - } else if (!return_value) { - if (IS_CONST & (IS_VAR|IS_TMP_VAR)) { - if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) { - SAVE_OPLINE(); - rc_dtor_func(Z_COUNTED_P(retval_ptr)); - } - } - } else { - if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) { - ZVAL_COPY_VALUE(return_value, retval_ptr); - if (IS_CONST == IS_CONST) { - if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) { - Z_ADDREF_P(return_value); - } - } - } else if (IS_CONST == IS_CV) { - do { - if (Z_OPT_REFCOUNTED_P(retval_ptr)) { - if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) { - if (EXPECTED(!(EX_CALL_INFO() & ZEND_CALL_CODE))) { - zend_refcounted *ref = Z_COUNTED_P(retval_ptr); - ZVAL_COPY_VALUE(return_value, retval_ptr); - if (GC_MAY_LEAK(ref)) { - gc_possible_root(ref); - } - ZVAL_NULL(retval_ptr); - break; - } else { - Z_ADDREF_P(retval_ptr); - } - } else { - retval_ptr = Z_REFVAL_P(retval_ptr); - if (Z_OPT_REFCOUNTED_P(retval_ptr)) { - Z_ADDREF_P(retval_ptr); - } - } - } - ZVAL_COPY_VALUE(return_value, retval_ptr); - } while (0); - } else /* if (IS_CONST == IS_VAR) */ { - if (UNEXPECTED(Z_ISREF_P(retval_ptr))) { - zend_refcounted *ref = Z_COUNTED_P(retval_ptr); - - retval_ptr = Z_REFVAL_P(retval_ptr); - ZVAL_COPY_VALUE(return_value, retval_ptr); - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) { - Z_ADDREF_P(retval_ptr); - } - } else { - ZVAL_COPY_VALUE(return_value, retval_ptr); - } - } - } - - zend_observer_maybe_fcall_call_end(execute_data, return_value); - goto zend_leave_helper_SPEC_LABEL; } @@ -55729,83 +55347,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) } } } - goto zend_leave_helper_SPEC_LABEL; -} - -// TODO Make a helper for the shared return code - HYBRID_CASE(ZEND_OBSERVE_RETURN_SPEC_TMP): - VM_TRACE(ZEND_OBSERVE_RETURN_SPEC_TMP) -{ - USE_OPLINE - zval *retval_ptr; - zval *return_value; - - retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - return_value = EX(return_value); - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) { - SAVE_OPLINE(); - retval_ptr = ZVAL_UNDEFINED_OP1(); - if (return_value) { - ZVAL_NULL(return_value); - } - } else if (!return_value) { - if (IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) { - if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) { - SAVE_OPLINE(); - rc_dtor_func(Z_COUNTED_P(retval_ptr)); - } - } - } else { - if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) { - ZVAL_COPY_VALUE(return_value, retval_ptr); - if (IS_TMP_VAR == IS_CONST) { - if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) { - Z_ADDREF_P(return_value); - } - } - } else if (IS_TMP_VAR == IS_CV) { - do { - if (Z_OPT_REFCOUNTED_P(retval_ptr)) { - if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) { - if (EXPECTED(!(EX_CALL_INFO() & ZEND_CALL_CODE))) { - zend_refcounted *ref = Z_COUNTED_P(retval_ptr); - ZVAL_COPY_VALUE(return_value, retval_ptr); - if (GC_MAY_LEAK(ref)) { - gc_possible_root(ref); - } - ZVAL_NULL(retval_ptr); - break; - } else { - Z_ADDREF_P(retval_ptr); - } - } else { - retval_ptr = Z_REFVAL_P(retval_ptr); - if (Z_OPT_REFCOUNTED_P(retval_ptr)) { - Z_ADDREF_P(retval_ptr); - } - } - } - ZVAL_COPY_VALUE(return_value, retval_ptr); - } while (0); - } else /* if (IS_TMP_VAR == IS_VAR) */ { - if (UNEXPECTED(Z_ISREF_P(retval_ptr))) { - zend_refcounted *ref = Z_COUNTED_P(retval_ptr); - - retval_ptr = Z_REFVAL_P(retval_ptr); - ZVAL_COPY_VALUE(return_value, retval_ptr); - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) { - Z_ADDREF_P(retval_ptr); - } - } else { - ZVAL_COPY_VALUE(return_value, retval_ptr); - } - } - } - - zend_observer_maybe_fcall_call_end(execute_data, return_value); - goto zend_leave_helper_SPEC_LABEL; } @@ -56103,83 +55644,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) } } } - goto zend_leave_helper_SPEC_LABEL; -} - -// TODO Make a helper for the shared return code - HYBRID_CASE(ZEND_OBSERVE_RETURN_SPEC_VAR): - VM_TRACE(ZEND_OBSERVE_RETURN_SPEC_VAR) -{ - USE_OPLINE - zval *retval_ptr; - zval *return_value; - - retval_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - return_value = EX(return_value); - if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) { - SAVE_OPLINE(); - retval_ptr = ZVAL_UNDEFINED_OP1(); - if (return_value) { - ZVAL_NULL(return_value); - } - } else if (!return_value) { - if (IS_VAR & (IS_VAR|IS_TMP_VAR)) { - if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) { - SAVE_OPLINE(); - rc_dtor_func(Z_COUNTED_P(retval_ptr)); - } - } - } else { - if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) { - ZVAL_COPY_VALUE(return_value, retval_ptr); - if (IS_VAR == IS_CONST) { - if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) { - Z_ADDREF_P(return_value); - } - } - } else if (IS_VAR == IS_CV) { - do { - if (Z_OPT_REFCOUNTED_P(retval_ptr)) { - if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) { - if (EXPECTED(!(EX_CALL_INFO() & ZEND_CALL_CODE))) { - zend_refcounted *ref = Z_COUNTED_P(retval_ptr); - ZVAL_COPY_VALUE(return_value, retval_ptr); - if (GC_MAY_LEAK(ref)) { - gc_possible_root(ref); - } - ZVAL_NULL(retval_ptr); - break; - } else { - Z_ADDREF_P(retval_ptr); - } - } else { - retval_ptr = Z_REFVAL_P(retval_ptr); - if (Z_OPT_REFCOUNTED_P(retval_ptr)) { - Z_ADDREF_P(retval_ptr); - } - } - } - ZVAL_COPY_VALUE(return_value, retval_ptr); - } while (0); - } else /* if (IS_VAR == IS_VAR) */ { - if (UNEXPECTED(Z_ISREF_P(retval_ptr))) { - zend_refcounted *ref = Z_COUNTED_P(retval_ptr); - - retval_ptr = Z_REFVAL_P(retval_ptr); - ZVAL_COPY_VALUE(return_value, retval_ptr); - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) { - Z_ADDREF_P(retval_ptr); - } - } else { - ZVAL_COPY_VALUE(return_value, retval_ptr); - } - } - } - - zend_observer_maybe_fcall_call_end(execute_data, return_value); - goto zend_leave_helper_SPEC_LABEL; } @@ -57293,83 +56757,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) } } } - goto zend_leave_helper_SPEC_LABEL; -} - -// TODO Make a helper for the shared return code - HYBRID_CASE(ZEND_OBSERVE_RETURN_SPEC_CV): - VM_TRACE(ZEND_OBSERVE_RETURN_SPEC_CV) -{ - USE_OPLINE - zval *retval_ptr; - zval *return_value; - - retval_ptr = EX_VAR(opline->op1.var); - return_value = EX(return_value); - if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) { - SAVE_OPLINE(); - retval_ptr = ZVAL_UNDEFINED_OP1(); - if (return_value) { - ZVAL_NULL(return_value); - } - } else if (!return_value) { - if (IS_CV & (IS_VAR|IS_TMP_VAR)) { - if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) { - SAVE_OPLINE(); - rc_dtor_func(Z_COUNTED_P(retval_ptr)); - } - } - } else { - if ((IS_CV & (IS_CONST|IS_TMP_VAR))) { - ZVAL_COPY_VALUE(return_value, retval_ptr); - if (IS_CV == IS_CONST) { - if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) { - Z_ADDREF_P(return_value); - } - } - } else if (IS_CV == IS_CV) { - do { - if (Z_OPT_REFCOUNTED_P(retval_ptr)) { - if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) { - if (EXPECTED(!(EX_CALL_INFO() & ZEND_CALL_CODE))) { - zend_refcounted *ref = Z_COUNTED_P(retval_ptr); - ZVAL_COPY_VALUE(return_value, retval_ptr); - if (GC_MAY_LEAK(ref)) { - gc_possible_root(ref); - } - ZVAL_NULL(retval_ptr); - break; - } else { - Z_ADDREF_P(retval_ptr); - } - } else { - retval_ptr = Z_REFVAL_P(retval_ptr); - if (Z_OPT_REFCOUNTED_P(retval_ptr)) { - Z_ADDREF_P(retval_ptr); - } - } - } - ZVAL_COPY_VALUE(return_value, retval_ptr); - } while (0); - } else /* if (IS_CV == IS_VAR) */ { - if (UNEXPECTED(Z_ISREF_P(retval_ptr))) { - zend_refcounted *ref = Z_COUNTED_P(retval_ptr); - - retval_ptr = Z_REFVAL_P(retval_ptr); - ZVAL_COPY_VALUE(return_value, retval_ptr); - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) { - Z_ADDREF_P(retval_ptr); - } - } else { - ZVAL_COPY_VALUE(return_value, retval_ptr); - } - } - } - - zend_observer_maybe_fcall_call_end(execute_data, return_value); - goto zend_leave_helper_SPEC_LABEL; } @@ -60927,11 +60314,6 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_JMP_NULL_SPEC_TMPVARCV_HANDLER, ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED_HANDLER, - ZEND_OBSERVE_RETURN_SPEC_CONST_HANDLER, - ZEND_OBSERVE_RETURN_SPEC_TMP_HANDLER, - ZEND_OBSERVE_RETURN_SPEC_VAR_HANDLER, - ZEND_NULL_HANDLER, - ZEND_OBSERVE_RETURN_SPEC_CV_HANDLER, ZEND_RECV_NOTYPE_SPEC_HANDLER, ZEND_JMP_FORWARD_SPEC_HANDLER, ZEND_NULL_HANDLER, @@ -62038,8 +61420,7 @@ void zend_vm_init(void) 2509 | SPEC_RULE_OP1, 2514 | SPEC_RULE_OP1, 2519, - 2520 | SPEC_RULE_OP1, - 3428 + 3423 }; #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID) zend_opcode_handler_funcs = labels; @@ -62204,7 +61585,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 = 2527 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2522 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -62212,7 +61593,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 = 2552 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2547 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -62220,7 +61601,7 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2577 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2572 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -62231,17 +61612,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 = 2602 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2597 | 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 = 2627 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2622 | 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 = 2652 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2647 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_MUL: @@ -62252,17 +61633,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 = 2677 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2672 | 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 = 2702 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2697 | 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 = 2727 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2722 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_IDENTICAL: @@ -62273,14 +61654,14 @@ 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 = 2752 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2747 | 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 = 2827 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2822 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF))) { - spec = 3052 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3047 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_IDENTICAL: @@ -62291,14 +61672,14 @@ 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 = 2902 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2897 | 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 = 2977 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2972 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF))) { - spec = 3057 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3052 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_EQUAL: @@ -62309,12 +61690,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 = 2752 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2747 | 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 = 2827 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2822 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_EQUAL: @@ -62325,12 +61706,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 = 2902 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2897 | 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 = 2977 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2972 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_SMALLER: @@ -62338,12 +61719,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 = 3062 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3057 | 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 = 3137 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3132 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_IS_SMALLER_OR_EQUAL: @@ -62351,74 +61732,74 @@ 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 = 3212 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3207 | 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 = 3287 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3282 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_QM_ASSIGN: if (op1_info == MAY_BE_LONG) { - spec = 3374 | SPEC_RULE_OP1; + spec = 3369 | SPEC_RULE_OP1; } else if (op1_info == MAY_BE_DOUBLE) { - spec = 3379 | SPEC_RULE_OP1; + spec = 3374 | 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 = 3384 | SPEC_RULE_OP1; + spec = 3379 | SPEC_RULE_OP1; } break; case ZEND_PRE_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3362 | SPEC_RULE_RETVAL; + spec = 3357 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3364 | SPEC_RULE_RETVAL; + spec = 3359 | SPEC_RULE_RETVAL; } break; case ZEND_PRE_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3366 | SPEC_RULE_RETVAL; + spec = 3361 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3368 | SPEC_RULE_RETVAL; + spec = 3363 | SPEC_RULE_RETVAL; } break; case ZEND_POST_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3370; + spec = 3365; } else if (op1_info == MAY_BE_LONG) { - spec = 3371; + spec = 3366; } break; case ZEND_POST_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3372; + spec = 3367; } else if (op1_info == MAY_BE_LONG) { - spec = 3373; + spec = 3368; } break; case ZEND_JMP: if (OP_JMP_ADDR(op, op->op1) > op) { - spec = 2526; + spec = 2521; } break; case ZEND_RECV: if (op->op2.num == MAY_BE_ANY) { - spec = 2525; + spec = 2520; } break; case ZEND_SEND_VAL: if (op->op1_type == IS_CONST && op->op2_type == IS_UNUSED && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3424; + spec = 3419; } break; case ZEND_SEND_VAR_EX: if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3419 | SPEC_RULE_OP1; + spec = 3414 | 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 = 3426 | SPEC_RULE_RETVAL; + spec = 3421 | SPEC_RULE_RETVAL; } break; case ZEND_FETCH_DIM_R: @@ -62426,17 +61807,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 = 3389 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 3384 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_SEND_VAL_EX: if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3425; + spec = 3420; } break; case ZEND_SEND_VAR: if (op->op2_type == IS_UNUSED && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3414 | SPEC_RULE_OP1; + spec = 3409 | SPEC_RULE_OP1; } break; case ZEND_BW_OR: diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h index 359fb2b348ab1..afcc07a8fdc35 100644 --- a/Zend/zend_vm_handlers.h +++ b/Zend/zend_vm_handlers.h @@ -1329,502 +1329,498 @@ _(2516, ZEND_JMP_NULL_SPEC_TMPVARCV) \ _(2518, ZEND_JMP_NULL_SPEC_TMPVARCV) \ _(2519, ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED) \ - _(2520, ZEND_OBSERVE_RETURN_SPEC_CONST) \ - _(2521, ZEND_OBSERVE_RETURN_SPEC_TMP) \ - _(2522, ZEND_OBSERVE_RETURN_SPEC_VAR) \ - _(2524, ZEND_OBSERVE_RETURN_SPEC_CV) \ - _(2525, ZEND_RECV_NOTYPE_SPEC) \ - _(2526, ZEND_JMP_FORWARD_SPEC) \ + _(2520, ZEND_RECV_NOTYPE_SPEC) \ + _(2521, ZEND_JMP_FORWARD_SPEC) \ + _(2527, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2528, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2529, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2531, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2532, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2533, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2534, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2536, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2537, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2538, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2539, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2541, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2547, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2548, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2549, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2551, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2542, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2543, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2544, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2546, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2552, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2553, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2554, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2556, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2557, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ _(2558, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2559, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2561, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2562, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2563, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2564, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2566, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2572, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2573, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2574, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2576, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2567, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2568, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2569, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2571, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2577, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2578, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2579, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2581, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2582, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2583, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2584, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2586, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2587, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2588, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2589, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2591, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2597, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2598, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2599, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2601, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2603, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2604, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2606, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2592, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2593, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2594, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2596, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2598, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2599, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2601, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2602, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2603, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2604, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2606, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2607, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2608, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2609, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2611, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2612, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2613, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2614, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2616, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2622, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2623, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2624, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2626, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2628, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2629, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2631, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2617, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2618, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2619, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2621, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2623, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2624, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2626, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2627, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2628, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2629, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2631, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2632, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ _(2633, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2634, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2636, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2637, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2638, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2639, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2641, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2647, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2648, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2649, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2651, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2653, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2654, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2656, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2642, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2643, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2644, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2646, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2648, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2649, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2651, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2652, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2653, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2654, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2656, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2657, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2658, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2659, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2661, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2662, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2663, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2664, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2666, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2672, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2673, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2674, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2676, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2667, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2668, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2669, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2671, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2677, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2678, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2679, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2681, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2682, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2683, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2684, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2686, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2687, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2688, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2689, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2691, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2697, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2698, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2699, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2701, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2692, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2693, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2694, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2696, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2702, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2703, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2704, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2706, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2707, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ _(2708, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2709, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2711, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2712, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2713, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2714, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2716, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2722, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2723, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2724, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2726, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2717, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2718, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2719, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2721, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2727, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2728, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2729, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2731, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2732, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2733, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2734, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2736, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2737, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2738, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2739, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2741, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2747, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2748, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2749, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2751, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2767, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2768, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2769, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2770, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2771, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2772, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2773, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2774, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2775, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2779, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2780, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2781, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2782, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2783, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2784, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2785, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2786, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2787, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2788, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2789, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2790, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2794, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2795, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2796, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2812, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2813, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2814, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2815, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2816, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2817, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2818, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2819, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2820, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2824, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2825, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2826, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2842, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2843, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2844, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2845, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2846, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2847, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2848, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2849, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2850, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2854, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2855, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2856, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2857, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2858, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2859, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2860, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2861, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2862, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2863, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2864, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2865, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2869, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2870, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2871, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2887, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2888, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2889, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2890, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2891, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2892, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2893, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2894, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2895, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2899, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2900, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2901, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2917, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2918, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2919, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2920, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2921, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2922, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2923, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2924, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2925, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2929, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2930, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2931, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2932, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2933, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2934, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2935, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2936, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2937, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2938, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2939, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2940, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2944, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2945, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2946, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2962, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2963, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2964, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2965, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2966, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2967, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2968, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2969, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2970, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2974, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2975, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2976, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2992, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2993, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2994, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2995, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2996, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2997, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2998, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2999, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3000, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3004, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3005, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3006, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3007, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3008, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3009, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3010, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3011, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3012, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3013, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3014, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3015, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3019, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3020, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3021, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3037, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3038, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3039, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3040, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3041, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3042, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3043, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3044, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3045, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3049, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3050, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3051, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3052, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(3056, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(3057, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(3061, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(3065, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3066, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3067, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3068, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3069, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3070, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3074, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3075, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3076, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3077, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3078, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3079, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3080, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3081, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3082, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3083, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3084, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3085, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3089, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3090, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3091, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3092, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3093, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3094, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3095, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3096, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3097, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3098, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3099, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3100, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3104, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3105, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3106, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3122, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3123, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3124, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3125, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3126, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3127, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3128, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3129, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3130, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3134, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3135, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3136, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3140, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3141, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3142, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3143, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3144, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3145, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3149, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3150, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3151, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3152, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3153, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3154, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3155, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3156, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3157, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3158, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3159, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3160, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3164, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3165, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3166, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3167, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3168, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3169, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3170, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3171, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3172, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3173, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3174, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3175, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3179, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3180, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3181, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3197, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3198, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3199, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3200, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3201, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3202, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3203, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3204, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3205, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3209, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3210, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3211, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3215, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3216, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3217, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3218, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3219, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3220, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3224, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3225, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3226, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3227, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3228, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3229, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3230, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3231, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3232, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3233, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3234, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3235, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3239, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3240, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3241, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3242, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3243, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3244, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3245, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3246, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3247, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3248, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3249, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3250, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3254, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3255, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3256, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3272, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3273, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3274, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3275, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3276, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3277, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3278, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3279, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3280, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3284, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3285, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3286, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3290, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3291, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3292, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3293, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3294, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3295, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3299, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3300, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3301, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3302, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3303, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3304, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3305, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3306, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3307, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3308, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3309, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3310, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3314, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3315, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3316, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3317, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3318, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3319, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3320, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3321, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3322, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3323, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3324, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3325, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3329, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3330, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3331, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3347, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3348, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3349, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3350, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3351, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3352, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3353, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3354, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3355, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3359, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3360, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3361, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3362, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3363, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3364, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3365, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ - _(3366, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3367, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3368, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3369, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ - _(3370, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3371, ZEND_POST_INC_LONG_SPEC_CV) \ - _(3372, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3373, ZEND_POST_DEC_LONG_SPEC_CV) \ - _(3374, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ - _(3375, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3376, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3378, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3379, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ - _(3380, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3381, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3383, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3384, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ - _(3385, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3386, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3388, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3390, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3391, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3393, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(2742, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2743, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2744, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2746, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2762, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2763, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2764, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2765, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2766, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2767, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2768, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2769, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2770, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2774, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2775, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2776, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2777, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2778, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2779, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2780, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2781, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2782, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2783, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2784, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2785, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2789, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2790, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2791, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2807, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2808, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2809, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2810, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2811, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2812, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2813, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2814, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2815, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2819, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2820, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2821, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2837, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2838, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2839, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2840, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2841, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2842, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2843, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2844, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2845, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2849, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2850, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2851, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2852, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2853, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2854, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2855, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2856, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2857, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2858, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2859, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2860, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2864, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2865, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2866, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2882, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2883, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2884, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2885, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2886, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2887, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2888, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2889, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2890, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2894, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2895, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2896, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2912, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2913, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2914, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2915, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2916, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2917, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2918, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2919, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2920, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2924, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2925, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2926, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2927, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2928, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2929, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2930, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2931, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2932, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2933, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2934, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2935, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2939, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2940, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2941, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2957, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2958, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2959, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2960, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2961, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2962, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2963, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2964, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2965, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2969, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2970, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2971, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2987, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2988, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2989, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2990, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2991, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2992, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2993, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2994, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2995, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2999, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3000, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3001, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3002, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3003, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3004, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3005, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3006, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3007, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3008, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3009, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3010, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3014, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3015, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3016, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3032, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3033, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3034, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3035, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3036, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3037, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3038, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3039, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3040, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3044, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3045, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3046, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3047, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3051, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3052, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3056, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3060, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3061, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3062, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3063, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3064, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3065, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3069, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3070, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3071, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3072, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3073, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3074, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3075, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3076, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3077, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3078, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3079, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3080, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3084, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3085, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3086, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3087, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3088, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3089, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3090, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3091, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3092, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3093, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3094, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3095, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3099, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3100, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3101, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3117, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3118, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3119, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3120, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3121, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3122, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3123, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3124, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3125, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3129, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3130, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3131, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3135, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3136, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3137, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3138, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3139, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3140, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3144, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3145, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3146, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3147, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3148, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3149, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3150, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3151, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3152, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3153, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3154, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3155, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3159, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3160, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3161, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3162, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3163, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3164, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3165, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3166, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3167, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3168, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3169, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3170, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3174, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3175, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3176, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3192, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3193, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3194, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3195, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3196, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3197, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3198, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3199, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3200, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3204, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3205, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3206, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3210, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3211, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3212, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3213, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3214, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3215, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3219, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3220, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3221, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3222, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3223, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3224, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3225, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3226, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3227, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3228, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3229, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3230, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3234, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3235, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3236, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3237, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3238, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3239, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3240, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3241, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3242, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3243, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3244, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3245, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3249, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3250, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3251, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3267, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3268, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3269, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3270, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3271, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3272, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3273, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3274, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3275, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3279, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3280, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3281, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3285, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3286, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3287, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3288, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3289, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3290, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3294, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3295, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3296, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3297, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3298, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3299, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3300, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3301, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3302, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3303, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3304, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3305, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3309, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3310, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3311, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3312, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3313, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3314, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3315, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3316, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3317, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3318, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3319, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3320, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3324, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3325, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3326, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3342, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3343, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3344, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3345, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3346, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3347, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3348, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3349, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3350, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3354, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3355, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3356, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3357, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3358, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3359, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3360, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ + _(3361, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3362, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3363, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3364, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ + _(3365, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3366, ZEND_POST_INC_LONG_SPEC_CV) \ + _(3367, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3368, ZEND_POST_DEC_LONG_SPEC_CV) \ + _(3369, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ + _(3370, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3371, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3373, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3374, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ + _(3375, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3376, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3378, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3379, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ + _(3380, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3381, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3383, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3385, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3386, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3388, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3389, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3390, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3391, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3393, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ _(3394, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ _(3395, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ _(3396, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ _(3398, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3399, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(3400, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3401, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3403, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3409, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ - _(3410, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3411, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3413, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3416, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ - _(3418, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ - _(3421, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ - _(3423, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ - _(3424, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ - _(3425, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ - _(3426, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ - _(3427, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ - _(3427+1, ZEND_NULL) + _(3404, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ + _(3405, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3406, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3408, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3411, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ + _(3413, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ + _(3416, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ + _(3418, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ + _(3419, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ + _(3420, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ + _(3421, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ + _(3422, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ + _(3422+1, ZEND_NULL) diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c index 3ea2b4da4516f..56a31aa19a095 100644 --- a/Zend/zend_vm_opcodes.c +++ b/Zend/zend_vm_opcodes.c @@ -22,7 +22,7 @@ #include #include -static const char *zend_vm_opcodes_names[201] = { +static const char *zend_vm_opcodes_names[200] = { "ZEND_NOP", "ZEND_ADD", "ZEND_SUB", @@ -223,10 +223,9 @@ static const char *zend_vm_opcodes_names[201] = { "ZEND_MATCH_ERROR", "ZEND_JMP_NULL", "ZEND_CHECK_UNDEF_ARGS", - "ZEND_OBSERVE_RETURN", }; -static uint32_t zend_vm_opcodes_flags[201] = { +static uint32_t zend_vm_opcodes_flags[200] = { 0x00000000, 0x00000b0b, 0x00000b0b, @@ -427,7 +426,6 @@ static uint32_t zend_vm_opcodes_flags[201] = { 0x0000010b, 0x0000200b, 0x00000101, - 0x00000003, }; ZEND_API const char* ZEND_FASTCALL zend_get_opcode_name(zend_uchar opcode) { diff --git a/Zend/zend_vm_opcodes.h b/Zend/zend_vm_opcodes.h index cbf862ccf9a2e..df5a14799953a 100644 --- a/Zend/zend_vm_opcodes.h +++ b/Zend/zend_vm_opcodes.h @@ -276,8 +276,7 @@ END_EXTERN_C() #define ZEND_MATCH_ERROR 197 #define ZEND_JMP_NULL 198 #define ZEND_CHECK_UNDEF_ARGS 199 -#define ZEND_OBSERVE_RETURN 200 -#define ZEND_VM_LAST_OPCODE 200 +#define ZEND_VM_LAST_OPCODE 199 #endif From bb429b052df0f893fa291429a0116c5a7ac5a0c4 Mon Sep 17 00:00:00 2001 From: Sammy Powers Date: Tue, 25 Aug 2020 16:31:44 -0700 Subject: [PATCH 31/53] Implement SPEC(OBSERVER) for return handlers --- Zend/zend_vm_def.h | 12 +- Zend/zend_vm_execute.h | 1427 +++++++++++++++++++++++---- Zend/zend_vm_gen.php | 26 +- Zend/zend_vm_handlers.h | 2074 ++++++++++++++++++++------------------- 4 files changed, 2324 insertions(+), 1215 deletions(-) diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 4e306010702cf..05d264d009ce1 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -2762,8 +2762,6 @@ ZEND_VM_HOT_HELPER(zend_leave_helper, ANY, ANY) uint32_t call_info = EX_CALL_INFO(); SAVE_OPLINE(); - zend_observer_maybe_fcall_call_end(execute_data, EX(return_value)); - if (EXPECTED((call_info & (ZEND_CALL_CODE|ZEND_CALL_TOP|ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS|ZEND_CALL_ALLOCATED|ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) == 0)) { EG(current_execute_data) = EX(prev_execute_data); i_free_compiled_variables(execute_data); @@ -4212,7 +4210,7 @@ ZEND_VM_COLD_CONST_HANDLER(124, ZEND_VERIFY_RETURN_TYPE, CONST|TMP|VAR|UNUSED|CV } } -ZEND_VM_INLINE_HANDLER(62, ZEND_RETURN, CONST|TMP|VAR|CV, ANY) +ZEND_VM_INLINE_HANDLER(62, ZEND_RETURN, CONST|TMP|VAR|CV, ANY, SPEC(OBSERVER)) { USE_OPLINE zval *retval_ptr; @@ -4281,10 +4279,11 @@ ZEND_VM_INLINE_HANDLER(62, ZEND_RETURN, CONST|TMP|VAR|CV, ANY) } } } + OBSERVER_END_HANDLERS(execute_data, return_value); ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper); } -ZEND_VM_COLD_CONST_HANDLER(111, ZEND_RETURN_BY_REF, CONST|TMP|VAR|CV, ANY, SRC) +ZEND_VM_COLD_CONST_HANDLER(111, ZEND_RETURN_BY_REF, CONST|TMP|VAR|CV, ANY, SRC, SPEC(OBSERVER)) { USE_OPLINE zval *retval_ptr; @@ -4341,6 +4340,7 @@ ZEND_VM_COLD_CONST_HANDLER(111, ZEND_RETURN_BY_REF, CONST|TMP|VAR|CV, ANY, SRC) FREE_OP1_VAR_PTR(); } while (0); + OBSERVER_END_HANDLERS(execute_data, EX(return_value)); ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper); } @@ -4420,7 +4420,7 @@ ZEND_VM_HANDLER(139, ZEND_GENERATOR_CREATE, ANY, ANY) } } -ZEND_VM_HANDLER(161, ZEND_GENERATOR_RETURN, CONST|TMP|VAR|CV, ANY) +ZEND_VM_HANDLER(161, ZEND_GENERATOR_RETURN, CONST|TMP|VAR|CV, ANY, SPEC(OBSERVER)) { USE_OPLINE zval *retval; @@ -4456,7 +4456,7 @@ ZEND_VM_HANDLER(161, ZEND_GENERATOR_RETURN, CONST|TMP|VAR|CV, ANY) } } - zend_observer_maybe_fcall_call_end(generator->execute_data, &generator->retval); + OBSERVER_END_HANDLERS(generator->execute_data, &generator->retval); /* Close the generator to free up resources */ zend_generator_close(generator, 1); diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 86d318ec8a12f..f59bd911b46da 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -316,6 +316,7 @@ static zend_uchar zend_user_opcodes[256] = {0, #define SPEC_RULE_SMART_BRANCH 0x00200000 #define SPEC_RULE_COMMUTATIVE 0x00800000 #define SPEC_RULE_ISSET 0x01000000 +#define SPEC_RULE_OBSERVER 0x02000000 static const uint32_t *zend_spec_handlers; static const void * const *zend_opcode_handlers; @@ -1085,8 +1086,6 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_leave_helper uint32_t call_info = EX_CALL_INFO(); SAVE_OPLINE(); - zend_observer_maybe_fcall_call_end(execute_data, EX(return_value)); - if (EXPECTED((call_info & (ZEND_CALL_CODE|ZEND_CALL_TOP|ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS|ZEND_CALL_ALLOCATED|ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) == 0)) { EG(current_execute_data) = EX(prev_execute_data); i_free_compiled_variables(execute_data); @@ -3682,6 +3681,80 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_CONST_ } } } + + ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); +} + +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *retval_ptr; + zval *return_value; + + retval_ptr = RT_CONSTANT(opline, opline->op1); + return_value = EX(return_value); + if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) { + SAVE_OPLINE(); + retval_ptr = ZVAL_UNDEFINED_OP1(); + if (return_value) { + ZVAL_NULL(return_value); + } + } else if (!return_value) { + if (IS_CONST & (IS_VAR|IS_TMP_VAR)) { + if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) { + SAVE_OPLINE(); + rc_dtor_func(Z_COUNTED_P(retval_ptr)); + } + } + } else { + if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) { + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (IS_CONST == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) { + Z_ADDREF_P(return_value); + } + } + } else if (IS_CONST == IS_CV) { + do { + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) { + if (EXPECTED(!(EX_CALL_INFO() & ZEND_CALL_CODE))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (GC_MAY_LEAK(ref)) { + gc_possible_root(ref); + } + ZVAL_NULL(retval_ptr); + break; + } else { + Z_ADDREF_P(retval_ptr); + } + } else { + retval_ptr = Z_REFVAL_P(retval_ptr); + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } + } + ZVAL_COPY_VALUE(return_value, retval_ptr); + } while (0); + } else /* if (IS_CONST == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(retval_ptr))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + + retval_ptr = Z_REFVAL_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } else { + ZVAL_COPY_VALUE(return_value, retval_ptr); + } + } + } + zend_observer_maybe_fcall_call_end(execute_data, return_value); ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } @@ -3744,6 +3817,66 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPE ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } +static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *retval_ptr; + + SAVE_OPLINE(); + + do { + if ((IS_CONST & (IS_CONST|IS_TMP_VAR)) || + (IS_CONST == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) { + /* Not supposed to happen, but we'll allow it */ + zend_error(E_NOTICE, "Only variable references should be returned by reference"); + + retval_ptr = RT_CONSTANT(opline, opline->op1); + if (!EX(return_value)) { + + } else { + if (IS_CONST == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) { + ZVAL_COPY_VALUE(EX(return_value), retval_ptr); + break; + } + + ZVAL_NEW_REF(EX(return_value), retval_ptr); + if (IS_CONST == IS_CONST) { + Z_TRY_ADDREF_P(retval_ptr); + } + } + break; + } + + retval_ptr = NULL; + + if (IS_CONST == IS_VAR) { + ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval)); + if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) { + zend_error(E_NOTICE, "Only variable references should be returned by reference"); + if (EX(return_value)) { + ZVAL_NEW_REF(EX(return_value), retval_ptr); + } else { + + } + break; + } + } + + if (EX(return_value)) { + if (Z_ISREF_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } else { + ZVAL_MAKE_REF_EX(retval_ptr, 2); + } + ZVAL_REF(EX(return_value), Z_REF_P(retval_ptr)); + } + + } while (0); + + zend_observer_maybe_fcall_call_end(execute_data, EX(return_value)); + ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -3780,6 +3913,49 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_CONST_HA } } + /* Close the generator to free up resources */ + zend_generator_close(generator, 1); + + /* Pass execution back to handling code */ + ZEND_VM_RETURN(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *retval; + + zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C); + + SAVE_OPLINE(); + retval = RT_CONSTANT(opline, opline->op1); + + /* Copy return value into generator->retval */ + if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) { + ZVAL_COPY_VALUE(&generator->retval, retval); + if (IS_CONST == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) { + Z_ADDREF(generator->retval); + } + } + } else if (IS_CONST == IS_CV) { + ZVAL_COPY_DEREF(&generator->retval, retval); + } else /* if (IS_CONST == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(retval))) { + zend_refcounted *ref = Z_COUNTED_P(retval); + + retval = Z_REFVAL_P(retval); + ZVAL_COPY_VALUE(&generator->retval, retval); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(retval)) { + Z_ADDREF_P(retval); + } + } else { + ZVAL_COPY_VALUE(&generator->retval, retval); + } + } + zend_observer_maybe_fcall_call_end(generator->execute_data, &generator->retval); /* Close the generator to free up resources */ @@ -17845,6 +18021,80 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_TMP_HA } } } + + ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); +} + +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_TMP_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *retval_ptr; + zval *return_value; + + retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + return_value = EX(return_value); + if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) { + SAVE_OPLINE(); + retval_ptr = ZVAL_UNDEFINED_OP1(); + if (return_value) { + ZVAL_NULL(return_value); + } + } else if (!return_value) { + if (IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) { + if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) { + SAVE_OPLINE(); + rc_dtor_func(Z_COUNTED_P(retval_ptr)); + } + } + } else { + if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) { + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (IS_TMP_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) { + Z_ADDREF_P(return_value); + } + } + } else if (IS_TMP_VAR == IS_CV) { + do { + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) { + if (EXPECTED(!(EX_CALL_INFO() & ZEND_CALL_CODE))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (GC_MAY_LEAK(ref)) { + gc_possible_root(ref); + } + ZVAL_NULL(retval_ptr); + break; + } else { + Z_ADDREF_P(retval_ptr); + } + } else { + retval_ptr = Z_REFVAL_P(retval_ptr); + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } + } + ZVAL_COPY_VALUE(return_value, retval_ptr); + } while (0); + } else /* if (IS_TMP_VAR == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(retval_ptr))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + + retval_ptr = Z_REFVAL_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } else { + ZVAL_COPY_VALUE(return_value, retval_ptr); + } + } + } + zend_observer_maybe_fcall_call_end(execute_data, return_value); ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } @@ -17907,6 +18157,66 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_TMP_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *retval_ptr; + + SAVE_OPLINE(); + + do { + if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR)) || + (IS_TMP_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) { + /* Not supposed to happen, but we'll allow it */ + zend_error(E_NOTICE, "Only variable references should be returned by reference"); + + retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + if (!EX(return_value)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + } else { + if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) { + ZVAL_COPY_VALUE(EX(return_value), retval_ptr); + break; + } + + ZVAL_NEW_REF(EX(return_value), retval_ptr); + if (IS_TMP_VAR == IS_CONST) { + Z_TRY_ADDREF_P(retval_ptr); + } + } + break; + } + + retval_ptr = NULL; + + if (IS_TMP_VAR == IS_VAR) { + ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval)); + if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) { + zend_error(E_NOTICE, "Only variable references should be returned by reference"); + if (EX(return_value)) { + ZVAL_NEW_REF(EX(return_value), retval_ptr); + } else { + + } + break; + } + } + + if (EX(return_value)) { + if (Z_ISREF_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } else { + ZVAL_MAKE_REF_EX(retval_ptr, 2); + } + ZVAL_REF(EX(return_value), Z_REF_P(retval_ptr)); + } + + } while (0); + + zend_observer_maybe_fcall_call_end(execute_data, EX(return_value)); + ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -17943,6 +18253,49 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_TMP_HAND } } + /* Close the generator to free up resources */ + zend_generator_close(generator, 1); + + /* Pass execution back to handling code */ + ZEND_VM_RETURN(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_TMP_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *retval; + + zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C); + + SAVE_OPLINE(); + retval = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + + /* Copy return value into generator->retval */ + if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) { + ZVAL_COPY_VALUE(&generator->retval, retval); + if (IS_TMP_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) { + Z_ADDREF(generator->retval); + } + } + } else if (IS_TMP_VAR == IS_CV) { + ZVAL_COPY_DEREF(&generator->retval, retval); + } else /* if (IS_TMP_VAR == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(retval))) { + zend_refcounted *ref = Z_COUNTED_P(retval); + + retval = Z_REFVAL_P(retval); + ZVAL_COPY_VALUE(&generator->retval, retval); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(retval)) { + Z_ADDREF_P(retval); + } + } else { + ZVAL_COPY_VALUE(&generator->retval, retval); + } + } + zend_observer_maybe_fcall_call_end(generator->execute_data, &generator->retval); /* Close the generator to free up resources */ @@ -20391,6 +20744,80 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_VAR_HA } } } + + ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); +} + +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_VAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *retval_ptr; + zval *return_value; + + retval_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + return_value = EX(return_value); + if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) { + SAVE_OPLINE(); + retval_ptr = ZVAL_UNDEFINED_OP1(); + if (return_value) { + ZVAL_NULL(return_value); + } + } else if (!return_value) { + if (IS_VAR & (IS_VAR|IS_TMP_VAR)) { + if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) { + SAVE_OPLINE(); + rc_dtor_func(Z_COUNTED_P(retval_ptr)); + } + } + } else { + if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) { + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) { + Z_ADDREF_P(return_value); + } + } + } else if (IS_VAR == IS_CV) { + do { + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) { + if (EXPECTED(!(EX_CALL_INFO() & ZEND_CALL_CODE))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (GC_MAY_LEAK(ref)) { + gc_possible_root(ref); + } + ZVAL_NULL(retval_ptr); + break; + } else { + Z_ADDREF_P(retval_ptr); + } + } else { + retval_ptr = Z_REFVAL_P(retval_ptr); + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } + } + ZVAL_COPY_VALUE(return_value, retval_ptr); + } while (0); + } else /* if (IS_VAR == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(retval_ptr))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + + retval_ptr = Z_REFVAL_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } else { + ZVAL_COPY_VALUE(return_value, retval_ptr); + } + } + } + zend_observer_maybe_fcall_call_end(execute_data, return_value); ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } @@ -20454,6 +20881,67 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_VAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *retval_ptr; + + SAVE_OPLINE(); + + do { + if ((IS_VAR & (IS_CONST|IS_TMP_VAR)) || + (IS_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) { + /* Not supposed to happen, but we'll allow it */ + zend_error(E_NOTICE, "Only variable references should be returned by reference"); + + retval_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + if (!EX(return_value)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + } else { + if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) { + ZVAL_COPY_VALUE(EX(return_value), retval_ptr); + break; + } + + ZVAL_NEW_REF(EX(return_value), retval_ptr); + if (IS_VAR == IS_CONST) { + Z_TRY_ADDREF_P(retval_ptr); + } + } + break; + } + + retval_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if (IS_VAR == IS_VAR) { + ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval)); + if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) { + zend_error(E_NOTICE, "Only variable references should be returned by reference"); + if (EX(return_value)) { + ZVAL_NEW_REF(EX(return_value), retval_ptr); + } else { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + } + break; + } + } + + if (EX(return_value)) { + if (Z_ISREF_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } else { + ZVAL_MAKE_REF_EX(retval_ptr, 2); + } + ZVAL_REF(EX(return_value), Z_REF_P(retval_ptr)); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + } while (0); + + zend_observer_maybe_fcall_call_end(execute_data, EX(return_value)); + ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -20490,6 +20978,49 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_VAR_HAND } } + /* Close the generator to free up resources */ + zend_generator_close(generator, 1); + + /* Pass execution back to handling code */ + ZEND_VM_RETURN(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_VAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *retval; + + zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C); + + SAVE_OPLINE(); + retval = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + /* Copy return value into generator->retval */ + if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) { + ZVAL_COPY_VALUE(&generator->retval, retval); + if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) { + Z_ADDREF(generator->retval); + } + } + } else if (IS_VAR == IS_CV) { + ZVAL_COPY_DEREF(&generator->retval, retval); + } else /* if (IS_VAR == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(retval))) { + zend_refcounted *ref = Z_COUNTED_P(retval); + + retval = Z_REFVAL_P(retval); + ZVAL_COPY_VALUE(&generator->retval, retval); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(retval)) { + Z_ADDREF_P(retval); + } + } else { + ZVAL_COPY_VALUE(&generator->retval, retval); + } + } + zend_observer_maybe_fcall_call_end(generator->execute_data, &generator->retval); /* Close the generator to free up resources */ @@ -36859,6 +37390,80 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_CV_HAN } } } + + ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); +} + +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *retval_ptr; + zval *return_value; + + retval_ptr = EX_VAR(opline->op1.var); + return_value = EX(return_value); + if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) { + SAVE_OPLINE(); + retval_ptr = ZVAL_UNDEFINED_OP1(); + if (return_value) { + ZVAL_NULL(return_value); + } + } else if (!return_value) { + if (IS_CV & (IS_VAR|IS_TMP_VAR)) { + if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) { + SAVE_OPLINE(); + rc_dtor_func(Z_COUNTED_P(retval_ptr)); + } + } + } else { + if ((IS_CV & (IS_CONST|IS_TMP_VAR))) { + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (IS_CV == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) { + Z_ADDREF_P(return_value); + } + } + } else if (IS_CV == IS_CV) { + do { + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) { + if (EXPECTED(!(EX_CALL_INFO() & ZEND_CALL_CODE))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (GC_MAY_LEAK(ref)) { + gc_possible_root(ref); + } + ZVAL_NULL(retval_ptr); + break; + } else { + Z_ADDREF_P(retval_ptr); + } + } else { + retval_ptr = Z_REFVAL_P(retval_ptr); + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } + } + ZVAL_COPY_VALUE(return_value, retval_ptr); + } while (0); + } else /* if (IS_CV == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(retval_ptr))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + + retval_ptr = Z_REFVAL_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } else { + ZVAL_COPY_VALUE(return_value, retval_ptr); + } + } + } + zend_observer_maybe_fcall_call_end(execute_data, return_value); ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } @@ -36921,6 +37526,66 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CV_HANDLER( ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *retval_ptr; + + SAVE_OPLINE(); + + do { + if ((IS_CV & (IS_CONST|IS_TMP_VAR)) || + (IS_CV == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) { + /* Not supposed to happen, but we'll allow it */ + zend_error(E_NOTICE, "Only variable references should be returned by reference"); + + retval_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); + if (!EX(return_value)) { + + } else { + if (IS_CV == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) { + ZVAL_COPY_VALUE(EX(return_value), retval_ptr); + break; + } + + ZVAL_NEW_REF(EX(return_value), retval_ptr); + if (IS_CV == IS_CONST) { + Z_TRY_ADDREF_P(retval_ptr); + } + } + break; + } + + retval_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC); + + if (IS_CV == IS_VAR) { + ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval)); + if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) { + zend_error(E_NOTICE, "Only variable references should be returned by reference"); + if (EX(return_value)) { + ZVAL_NEW_REF(EX(return_value), retval_ptr); + } else { + + } + break; + } + } + + if (EX(return_value)) { + if (Z_ISREF_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } else { + ZVAL_MAKE_REF_EX(retval_ptr, 2); + } + ZVAL_REF(EX(return_value), Z_REF_P(retval_ptr)); + } + + } while (0); + + zend_observer_maybe_fcall_call_end(execute_data, EX(return_value)); + ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -36957,6 +37622,49 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_CV_HANDL } } + /* Close the generator to free up resources */ + zend_generator_close(generator, 1); + + /* Pass execution back to handling code */ + ZEND_VM_RETURN(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *retval; + + zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C); + + SAVE_OPLINE(); + retval = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); + + /* Copy return value into generator->retval */ + if ((IS_CV & (IS_CONST|IS_TMP_VAR))) { + ZVAL_COPY_VALUE(&generator->retval, retval); + if (IS_CV == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) { + Z_ADDREF(generator->retval); + } + } + } else if (IS_CV == IS_CV) { + ZVAL_COPY_DEREF(&generator->retval, retval); + } else /* if (IS_CV == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(retval))) { + zend_refcounted *ref = Z_COUNTED_P(retval); + + retval = Z_REFVAL_P(retval); + ZVAL_COPY_VALUE(&generator->retval, retval); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(retval)) { + Z_ADDREF_P(retval); + } + } else { + ZVAL_COPY_VALUE(&generator->retval, retval); + } + } + zend_observer_maybe_fcall_call_end(generator->execute_data, &generator->retval); /* Close the generator to free up resources */ @@ -51274,10 +51982,15 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_DO_FCALL_SPEC_RETVAL_USED_LABEL, (void*)&&ZEND_INIT_FCALL_SPEC_CONST_LABEL, (void*)&&ZEND_RETURN_SPEC_CONST_LABEL, + (void*)&&ZEND_RETURN_SPEC_CONST_OBSERVER_LABEL, (void*)&&ZEND_RETURN_SPEC_TMP_LABEL, + (void*)&&ZEND_RETURN_SPEC_TMP_OBSERVER_LABEL, (void*)&&ZEND_RETURN_SPEC_VAR_LABEL, + (void*)&&ZEND_RETURN_SPEC_VAR_OBSERVER_LABEL, + (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_RETURN_SPEC_CV_LABEL, + (void*)&&ZEND_RETURN_SPEC_CV_OBSERVER_LABEL, (void*)&&ZEND_RECV_SPEC_UNUSED_LABEL, (void*)&&ZEND_RECV_INIT_SPEC_CONST_LABEL, (void*)&&ZEND_SEND_VAL_SPEC_CONST_CONST_LABEL, @@ -51897,10 +52610,15 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_CLONE_SPEC_UNUSED_LABEL, (void*)&&ZEND_CLONE_SPEC_CV_LABEL, (void*)&&ZEND_RETURN_BY_REF_SPEC_CONST_LABEL, + (void*)&&ZEND_RETURN_BY_REF_SPEC_CONST_OBSERVER_LABEL, (void*)&&ZEND_RETURN_BY_REF_SPEC_TMP_LABEL, + (void*)&&ZEND_RETURN_BY_REF_SPEC_TMP_OBSERVER_LABEL, (void*)&&ZEND_RETURN_BY_REF_SPEC_VAR_LABEL, + (void*)&&ZEND_RETURN_BY_REF_SPEC_VAR_OBSERVER_LABEL, + (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_RETURN_BY_REF_SPEC_CV_LABEL, + (void*)&&ZEND_RETURN_BY_REF_SPEC_CV_OBSERVER_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_LABEL, @@ -52270,10 +52988,15 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_YIELD_SPEC_CV_UNUSED_LABEL, (void*)&&ZEND_YIELD_SPEC_CV_CV_LABEL, (void*)&&ZEND_GENERATOR_RETURN_SPEC_CONST_LABEL, + (void*)&&ZEND_GENERATOR_RETURN_SPEC_CONST_OBSERVER_LABEL, (void*)&&ZEND_GENERATOR_RETURN_SPEC_TMP_LABEL, + (void*)&&ZEND_GENERATOR_RETURN_SPEC_TMP_OBSERVER_LABEL, (void*)&&ZEND_GENERATOR_RETURN_SPEC_VAR_LABEL, + (void*)&&ZEND_GENERATOR_RETURN_SPEC_VAR_OBSERVER_LABEL, + (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_GENERATOR_RETURN_SPEC_CV_LABEL, + (void*)&&ZEND_GENERATOR_RETURN_SPEC_CV_OBSERVER_LABEL, (void*)&&ZEND_FAST_CALL_SPEC_LABEL, (void*)&&ZEND_FAST_RET_SPEC_LABEL, (void*)&&ZEND_RECV_VARIADIC_SPEC_UNUSED_LABEL, @@ -53433,8 +54156,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) uint32_t call_info = EX_CALL_INFO(); SAVE_OPLINE(); - zend_observer_maybe_fcall_call_end(execute_data, EX(return_value)); - if (EXPECTED((call_info & (ZEND_CALL_CODE|ZEND_CALL_TOP|ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS|ZEND_CALL_ALLOCATED|ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) == 0)) { EG(current_execute_data) = EX(prev_execute_data); i_free_compiled_variables(execute_data); @@ -53826,6 +54547,81 @@ ZEND_API void execute_ex(zend_execute_data *ex) } } } + + goto zend_leave_helper_SPEC_LABEL; +} + + HYBRID_CASE(ZEND_RETURN_SPEC_CONST_OBSERVER): + VM_TRACE(ZEND_RETURN_SPEC_CONST_OBSERVER) +{ + USE_OPLINE + zval *retval_ptr; + zval *return_value; + + retval_ptr = RT_CONSTANT(opline, opline->op1); + return_value = EX(return_value); + if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) { + SAVE_OPLINE(); + retval_ptr = ZVAL_UNDEFINED_OP1(); + if (return_value) { + ZVAL_NULL(return_value); + } + } else if (!return_value) { + if (IS_CONST & (IS_VAR|IS_TMP_VAR)) { + if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) { + SAVE_OPLINE(); + rc_dtor_func(Z_COUNTED_P(retval_ptr)); + } + } + } else { + if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) { + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (IS_CONST == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) { + Z_ADDREF_P(return_value); + } + } + } else if (IS_CONST == IS_CV) { + do { + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) { + if (EXPECTED(!(EX_CALL_INFO() & ZEND_CALL_CODE))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (GC_MAY_LEAK(ref)) { + gc_possible_root(ref); + } + ZVAL_NULL(retval_ptr); + break; + } else { + Z_ADDREF_P(retval_ptr); + } + } else { + retval_ptr = Z_REFVAL_P(retval_ptr); + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } + } + ZVAL_COPY_VALUE(return_value, retval_ptr); + } while (0); + } else /* if (IS_CONST == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(retval_ptr))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + + retval_ptr = Z_REFVAL_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } else { + ZVAL_COPY_VALUE(return_value, retval_ptr); + } + } + } + zend_observer_maybe_fcall_call_end(execute_data, return_value); goto zend_leave_helper_SPEC_LABEL; } @@ -53833,10 +54629,18 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_RETURN_BY_REF_SPEC_CONST) ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_RETURN_BY_REF_SPEC_CONST_OBSERVER): + VM_TRACE(ZEND_RETURN_BY_REF_SPEC_CONST_OBSERVER) + ZEND_RETURN_BY_REF_SPEC_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_CONST): VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_CONST) ZEND_GENERATOR_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_CONST_OBSERVER): + VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_CONST_OBSERVER) + ZEND_GENERATOR_RETURN_SPEC_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_THROW_SPEC_CONST): VM_TRACE(ZEND_THROW_SPEC_CONST) ZEND_THROW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -55347,6 +56151,81 @@ ZEND_API void execute_ex(zend_execute_data *ex) } } } + + goto zend_leave_helper_SPEC_LABEL; +} + + HYBRID_CASE(ZEND_RETURN_SPEC_TMP_OBSERVER): + VM_TRACE(ZEND_RETURN_SPEC_TMP_OBSERVER) +{ + USE_OPLINE + zval *retval_ptr; + zval *return_value; + + retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + return_value = EX(return_value); + if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) { + SAVE_OPLINE(); + retval_ptr = ZVAL_UNDEFINED_OP1(); + if (return_value) { + ZVAL_NULL(return_value); + } + } else if (!return_value) { + if (IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) { + if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) { + SAVE_OPLINE(); + rc_dtor_func(Z_COUNTED_P(retval_ptr)); + } + } + } else { + if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) { + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (IS_TMP_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) { + Z_ADDREF_P(return_value); + } + } + } else if (IS_TMP_VAR == IS_CV) { + do { + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) { + if (EXPECTED(!(EX_CALL_INFO() & ZEND_CALL_CODE))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (GC_MAY_LEAK(ref)) { + gc_possible_root(ref); + } + ZVAL_NULL(retval_ptr); + break; + } else { + Z_ADDREF_P(retval_ptr); + } + } else { + retval_ptr = Z_REFVAL_P(retval_ptr); + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } + } + ZVAL_COPY_VALUE(return_value, retval_ptr); + } while (0); + } else /* if (IS_TMP_VAR == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(retval_ptr))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + + retval_ptr = Z_REFVAL_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } else { + ZVAL_COPY_VALUE(return_value, retval_ptr); + } + } + } + zend_observer_maybe_fcall_call_end(execute_data, return_value); goto zend_leave_helper_SPEC_LABEL; } @@ -55354,10 +56233,18 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_RETURN_BY_REF_SPEC_TMP) ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_RETURN_BY_REF_SPEC_TMP_OBSERVER): + VM_TRACE(ZEND_RETURN_BY_REF_SPEC_TMP_OBSERVER) + ZEND_RETURN_BY_REF_SPEC_TMP_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_TMP): VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_TMP) ZEND_GENERATOR_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_TMP_OBSERVER): + VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_TMP_OBSERVER) + ZEND_GENERATOR_RETURN_SPEC_TMP_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_SEND_USER_SPEC_TMP): VM_TRACE(ZEND_SEND_USER_SPEC_TMP) ZEND_SEND_USER_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -55644,6 +56531,81 @@ ZEND_API void execute_ex(zend_execute_data *ex) } } } + + goto zend_leave_helper_SPEC_LABEL; +} + + HYBRID_CASE(ZEND_RETURN_SPEC_VAR_OBSERVER): + VM_TRACE(ZEND_RETURN_SPEC_VAR_OBSERVER) +{ + USE_OPLINE + zval *retval_ptr; + zval *return_value; + + retval_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + return_value = EX(return_value); + if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) { + SAVE_OPLINE(); + retval_ptr = ZVAL_UNDEFINED_OP1(); + if (return_value) { + ZVAL_NULL(return_value); + } + } else if (!return_value) { + if (IS_VAR & (IS_VAR|IS_TMP_VAR)) { + if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) { + SAVE_OPLINE(); + rc_dtor_func(Z_COUNTED_P(retval_ptr)); + } + } + } else { + if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) { + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) { + Z_ADDREF_P(return_value); + } + } + } else if (IS_VAR == IS_CV) { + do { + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) { + if (EXPECTED(!(EX_CALL_INFO() & ZEND_CALL_CODE))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (GC_MAY_LEAK(ref)) { + gc_possible_root(ref); + } + ZVAL_NULL(retval_ptr); + break; + } else { + Z_ADDREF_P(retval_ptr); + } + } else { + retval_ptr = Z_REFVAL_P(retval_ptr); + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } + } + ZVAL_COPY_VALUE(return_value, retval_ptr); + } while (0); + } else /* if (IS_VAR == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(retval_ptr))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + + retval_ptr = Z_REFVAL_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } else { + ZVAL_COPY_VALUE(return_value, retval_ptr); + } + } + } + zend_observer_maybe_fcall_call_end(execute_data, return_value); goto zend_leave_helper_SPEC_LABEL; } @@ -55651,10 +56613,18 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_RETURN_BY_REF_SPEC_VAR) ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_RETURN_BY_REF_SPEC_VAR_OBSERVER): + VM_TRACE(ZEND_RETURN_BY_REF_SPEC_VAR_OBSERVER) + ZEND_RETURN_BY_REF_SPEC_VAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_VAR): VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_VAR) ZEND_GENERATOR_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_VAR_OBSERVER): + VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_VAR_OBSERVER) + ZEND_GENERATOR_RETURN_SPEC_VAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_SEND_USER_SPEC_VAR): VM_TRACE(ZEND_SEND_USER_SPEC_VAR) ZEND_SEND_USER_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -56757,6 +57727,81 @@ ZEND_API void execute_ex(zend_execute_data *ex) } } } + + goto zend_leave_helper_SPEC_LABEL; +} + + HYBRID_CASE(ZEND_RETURN_SPEC_CV_OBSERVER): + VM_TRACE(ZEND_RETURN_SPEC_CV_OBSERVER) +{ + USE_OPLINE + zval *retval_ptr; + zval *return_value; + + retval_ptr = EX_VAR(opline->op1.var); + return_value = EX(return_value); + if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) { + SAVE_OPLINE(); + retval_ptr = ZVAL_UNDEFINED_OP1(); + if (return_value) { + ZVAL_NULL(return_value); + } + } else if (!return_value) { + if (IS_CV & (IS_VAR|IS_TMP_VAR)) { + if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) { + SAVE_OPLINE(); + rc_dtor_func(Z_COUNTED_P(retval_ptr)); + } + } + } else { + if ((IS_CV & (IS_CONST|IS_TMP_VAR))) { + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (IS_CV == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) { + Z_ADDREF_P(return_value); + } + } + } else if (IS_CV == IS_CV) { + do { + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) { + if (EXPECTED(!(EX_CALL_INFO() & ZEND_CALL_CODE))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (GC_MAY_LEAK(ref)) { + gc_possible_root(ref); + } + ZVAL_NULL(retval_ptr); + break; + } else { + Z_ADDREF_P(retval_ptr); + } + } else { + retval_ptr = Z_REFVAL_P(retval_ptr); + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } + } + ZVAL_COPY_VALUE(return_value, retval_ptr); + } while (0); + } else /* if (IS_CV == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(retval_ptr))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + + retval_ptr = Z_REFVAL_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } else { + ZVAL_COPY_VALUE(return_value, retval_ptr); + } + } + } + zend_observer_maybe_fcall_call_end(execute_data, return_value); goto zend_leave_helper_SPEC_LABEL; } @@ -56764,10 +57809,18 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_RETURN_BY_REF_SPEC_CV) ZEND_RETURN_BY_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_RETURN_BY_REF_SPEC_CV_OBSERVER): + VM_TRACE(ZEND_RETURN_BY_REF_SPEC_CV_OBSERVER) + ZEND_RETURN_BY_REF_SPEC_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_CV): VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_CV) ZEND_GENERATOR_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_CV_OBSERVER): + VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_CV_OBSERVER) + ZEND_GENERATOR_RETURN_SPEC_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_THROW_SPEC_CV): VM_TRACE(ZEND_THROW_SPEC_CV) ZEND_THROW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -59148,10 +60201,15 @@ void zend_vm_init(void) ZEND_DO_FCALL_SPEC_RETVAL_USED_HANDLER, ZEND_INIT_FCALL_SPEC_CONST_HANDLER, ZEND_RETURN_SPEC_CONST_HANDLER, + ZEND_RETURN_SPEC_CONST_OBSERVER_HANDLER, ZEND_RETURN_SPEC_TMP_HANDLER, + ZEND_RETURN_SPEC_TMP_OBSERVER_HANDLER, ZEND_RETURN_SPEC_VAR_HANDLER, + ZEND_RETURN_SPEC_VAR_OBSERVER_HANDLER, + ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_RETURN_SPEC_CV_HANDLER, + ZEND_RETURN_SPEC_CV_OBSERVER_HANDLER, ZEND_RECV_SPEC_UNUSED_HANDLER, ZEND_RECV_INIT_SPEC_CONST_HANDLER, ZEND_SEND_VAL_SPEC_CONST_CONST_HANDLER, @@ -59771,10 +60829,15 @@ void zend_vm_init(void) ZEND_CLONE_SPEC_UNUSED_HANDLER, ZEND_CLONE_SPEC_CV_HANDLER, ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER, + ZEND_RETURN_BY_REF_SPEC_CONST_OBSERVER_HANDLER, ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER, + ZEND_RETURN_BY_REF_SPEC_TMP_OBSERVER_HANDLER, ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER, + ZEND_RETURN_BY_REF_SPEC_VAR_OBSERVER_HANDLER, + ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_RETURN_BY_REF_SPEC_CV_HANDLER, + ZEND_RETURN_BY_REF_SPEC_CV_OBSERVER_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER, @@ -60144,10 +61207,15 @@ void zend_vm_init(void) ZEND_YIELD_SPEC_CV_UNUSED_HANDLER, ZEND_YIELD_SPEC_CV_CV_HANDLER, ZEND_GENERATOR_RETURN_SPEC_CONST_HANDLER, + ZEND_GENERATOR_RETURN_SPEC_CONST_OBSERVER_HANDLER, ZEND_GENERATOR_RETURN_SPEC_TMP_HANDLER, + ZEND_GENERATOR_RETURN_SPEC_TMP_OBSERVER_HANDLER, ZEND_GENERATOR_RETURN_SPEC_VAR_HANDLER, + ZEND_GENERATOR_RETURN_SPEC_VAR_OBSERVER_HANDLER, + ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_GENERATOR_RETURN_SPEC_CV_HANDLER, + ZEND_GENERATOR_RETURN_SPEC_CV_OBSERVER_HANDLER, ZEND_FAST_CALL_SPEC_HANDLER, ZEND_FAST_RET_SPEC_HANDLER, ZEND_RECV_VARIADIC_SPEC_UNUSED_HANDLER, @@ -61282,145 +62350,145 @@ void zend_vm_init(void) 1349, 1350 | SPEC_RULE_RETVAL, 1352, - 1353 | SPEC_RULE_OP1, - 1358, - 1359, - 1360 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1385 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, - 1435 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1460 | SPEC_RULE_OP1, - 1465, - 1466, - 1467 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1492 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1517 | SPEC_RULE_OP1, + 1353 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, + 1363, + 1364, + 1365 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1390 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, + 1440 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1465 | SPEC_RULE_OP1, + 1470, + 1471, + 1472 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1497 | SPEC_RULE_OP1 | SPEC_RULE_OP2, 1522 | SPEC_RULE_OP1, - 1527 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1552 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1577 | SPEC_RULE_OP1, - 1582, - 1583, - 1584 | SPEC_RULE_OP1, - 1589 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1614 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1639 | SPEC_RULE_OP1, - 1644 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1669 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1694 | SPEC_RULE_OP1, - 1699 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1724 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1749 | SPEC_RULE_OP1, - 1754 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1779 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1804 | SPEC_RULE_OP1, - 1809 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1834 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1859 | SPEC_RULE_OP1, - 1864 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1889 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1914 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1939, - 1940 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, - 1950, - 1951, - 1952, - 1953, - 1954, - 1955 | SPEC_RULE_OP2, - 1960, - 1961 | SPEC_RULE_OP1, - 1966 | SPEC_RULE_OP2, - 1971 | SPEC_RULE_OP1, + 1527 | SPEC_RULE_OP1, + 1532 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1557 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1582 | SPEC_RULE_OP1, + 1587, + 1588, + 1589 | SPEC_RULE_OP1, + 1594 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1619 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1644 | SPEC_RULE_OP1, + 1649 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1674 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1699 | SPEC_RULE_OP1, + 1704 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1729 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1754 | SPEC_RULE_OP1, + 1759 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1784 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1809 | SPEC_RULE_OP1, + 1814 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1839 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1864 | SPEC_RULE_OP1, + 1869 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1894 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1919 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1944, + 1945 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, + 1955, + 1956, + 1957, + 1958, + 1959, + 1960 | SPEC_RULE_OP2, + 1965, + 1966 | SPEC_RULE_OP1, + 1971 | SPEC_RULE_OP2, 1976 | SPEC_RULE_OP1, - 1981 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2006 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2031 | SPEC_RULE_OP1, - 2036 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2061 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, - 2111 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2136 | SPEC_RULE_OP2, - 2141, - 2142 | SPEC_RULE_OP1, - 2147 | SPEC_RULE_OP1, - 2152, - 2153 | SPEC_RULE_OP1, - 2158 | SPEC_RULE_OP1, + 1981 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, + 1991 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2016 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2041 | SPEC_RULE_OP1, + 2046 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2071 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, + 2121 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2146 | SPEC_RULE_OP2, + 2151, + 2152 | SPEC_RULE_OP1, + 2157 | SPEC_RULE_OP1, + 2162, 2163 | SPEC_RULE_OP1, - 2168, - 2169, - 2170 | SPEC_RULE_OP2, - 2175 | SPEC_RULE_RETVAL, - 2177 | SPEC_RULE_RETVAL, - 2179 | SPEC_RULE_RETVAL, - 2181 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2181 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2206 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2206 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2231 | SPEC_RULE_OP1, - 2236, - 2237 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2262, - 2263 | SPEC_RULE_OP1, - 2268, - 2269, - 2270, - 2271, + 2168 | SPEC_RULE_OP1, + 2173 | SPEC_RULE_OP1, + 2178, + 2179, + 2180 | SPEC_RULE_OP2, + 2185 | SPEC_RULE_RETVAL, + 2187 | SPEC_RULE_RETVAL, + 2189 | SPEC_RULE_RETVAL, + 2191 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2191 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2216 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2216 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2241 | SPEC_RULE_OP1, + 2246, + 2247 | SPEC_RULE_OP1 | SPEC_RULE_OP2, 2272, - 2273, - 2274, - 2275 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2300, - 2301, - 2302, - 2303 | SPEC_RULE_OP1, - 2308, - 2309 | SPEC_RULE_ISSET, - 2311 | SPEC_RULE_OP2, - 2316, - 2317 | SPEC_RULE_OP1, - 2322, - 2323, - 2324 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2349 | SPEC_RULE_OP1, - 2354, - 2355, - 2356, - 2357, - 2358 | SPEC_RULE_OP1, - 2363, - 2364, - 2365 | SPEC_RULE_OP1, - 2370 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2395, - 2396 | SPEC_RULE_OP1, - 2401, - 2402, - 2403, - 2404, - 2405, - 2406, - 2407, - 2408, - 2409 | SPEC_RULE_OP1, - 2414, - 2415, + 2273 | SPEC_RULE_OP1, + 2278, + 2279, + 2280, + 2281, + 2282, + 2283, + 2284, + 2285 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2310, + 2311, + 2312, + 2313 | SPEC_RULE_OP1, + 2318, + 2319 | SPEC_RULE_ISSET, + 2321 | SPEC_RULE_OP2, + 2326, + 2327 | SPEC_RULE_OP1, + 2332, + 2333, + 2334 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2359 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, + 2369, + 2370, + 2371, + 2372, + 2373 | SPEC_RULE_OP1, + 2378, + 2379, + 2380 | SPEC_RULE_OP1, + 2385 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2410, + 2411 | SPEC_RULE_OP1, 2416, - 2417 | SPEC_RULE_OP2, + 2417, + 2418, + 2419, + 2420, + 2421, 2422, - 2423 | SPEC_RULE_OP1, - 2428 | SPEC_RULE_OP1, - 2433 | SPEC_RULE_OP1, + 2423, + 2424 | SPEC_RULE_OP1, + 2429, + 2430, + 2431, + 2432 | SPEC_RULE_OP2, + 2437, 2438 | SPEC_RULE_OP1, 2443 | SPEC_RULE_OP1, - 2448, - 2449 | SPEC_RULE_OP1, - 2454 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2479 | SPEC_RULE_OP1, - 2484 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2509 | SPEC_RULE_OP1, - 2514 | SPEC_RULE_OP1, - 2519, - 3423 + 2448 | SPEC_RULE_OP1, + 2453 | SPEC_RULE_OP1, + 2458 | SPEC_RULE_OP1, + 2463, + 2464 | SPEC_RULE_OP1, + 2469 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2494 | SPEC_RULE_OP1, + 2499 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2524 | SPEC_RULE_OP1, + 2529 | SPEC_RULE_OP1, + 2534, + 3438 }; #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID) zend_opcode_handler_funcs = labels; @@ -61542,6 +62610,11 @@ static uint32_t ZEND_FASTCALL zend_vm_get_opcode_handler_idx(uint32_t spec, cons } else if (op->result_type == (IS_SMART_BRANCH_JMPNZ|IS_TMP_VAR)) { offset += 2; } + } else if (spec & SPEC_RULE_OBSERVER) { + offset = offset * 2; + if (ZEND_OBSERVER_ENABLED) { + offset += 1; + } } } return (spec & SPEC_START_MASK) + offset; @@ -61585,7 +62658,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 = 2522 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2537 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -61593,7 +62666,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 = 2547 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2562 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -61601,7 +62674,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 = 2572 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2587 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -61612,17 +62685,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 = 2597 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2612 | 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 = 2622 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2637 | 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 = 2647 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2662 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_MUL: @@ -61633,17 +62706,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 = 2672 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2687 | 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 = 2697 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2712 | 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 = 2722 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2737 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_IDENTICAL: @@ -61654,14 +62727,14 @@ 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 = 2747 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2762 | 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 = 2822 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2837 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF))) { - spec = 3047 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3062 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_IDENTICAL: @@ -61672,14 +62745,14 @@ 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 = 2897 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2912 | 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 = 2972 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2987 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF))) { - spec = 3052 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3067 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_EQUAL: @@ -61690,12 +62763,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 = 2747 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2762 | 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 = 2822 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2837 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_EQUAL: @@ -61706,12 +62779,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 = 2897 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2912 | 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 = 2972 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2987 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_SMALLER: @@ -61719,12 +62792,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 = 3057 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3072 | 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 = 3132 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3147 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_IS_SMALLER_OR_EQUAL: @@ -61732,74 +62805,74 @@ 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 = 3207 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3222 | 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 = 3282 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3297 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_QM_ASSIGN: if (op1_info == MAY_BE_LONG) { - spec = 3369 | SPEC_RULE_OP1; + spec = 3384 | SPEC_RULE_OP1; } else if (op1_info == MAY_BE_DOUBLE) { - spec = 3374 | SPEC_RULE_OP1; + spec = 3389 | 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 = 3379 | SPEC_RULE_OP1; + spec = 3394 | SPEC_RULE_OP1; } break; case ZEND_PRE_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3357 | SPEC_RULE_RETVAL; + spec = 3372 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3359 | SPEC_RULE_RETVAL; + spec = 3374 | SPEC_RULE_RETVAL; } break; case ZEND_PRE_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3361 | SPEC_RULE_RETVAL; + spec = 3376 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3363 | SPEC_RULE_RETVAL; + spec = 3378 | SPEC_RULE_RETVAL; } break; case ZEND_POST_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3365; + spec = 3380; } else if (op1_info == MAY_BE_LONG) { - spec = 3366; + spec = 3381; } break; case ZEND_POST_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3367; + spec = 3382; } else if (op1_info == MAY_BE_LONG) { - spec = 3368; + spec = 3383; } break; case ZEND_JMP: if (OP_JMP_ADDR(op, op->op1) > op) { - spec = 2521; + spec = 2536; } break; case ZEND_RECV: if (op->op2.num == MAY_BE_ANY) { - spec = 2520; + spec = 2535; } break; case ZEND_SEND_VAL: if (op->op1_type == IS_CONST && op->op2_type == IS_UNUSED && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3419; + spec = 3434; } break; case ZEND_SEND_VAR_EX: if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3414 | SPEC_RULE_OP1; + spec = 3429 | 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 = 3421 | SPEC_RULE_RETVAL; + spec = 3436 | SPEC_RULE_RETVAL; } break; case ZEND_FETCH_DIM_R: @@ -61807,17 +62880,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 = 3384 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 3399 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_SEND_VAL_EX: if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3420; + spec = 3435; } break; case ZEND_SEND_VAR: if (op->op2_type == IS_UNUSED && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3409 | SPEC_RULE_OP1; + spec = 3424 | SPEC_RULE_OP1; } break; case ZEND_BW_OR: diff --git a/Zend/zend_vm_gen.php b/Zend/zend_vm_gen.php index d05c278c17f85..31466762632da 100755 --- a/Zend/zend_vm_gen.php +++ b/Zend/zend_vm_gen.php @@ -793,6 +793,9 @@ function gen_code($f, $spec, $kind, $code, $op1, $op2, $name, $extra_spec=null) "/opline->extended_value\s*&\s*~\s*ZEND_ISEMPTY/" => isset($extra_spec['ISSET']) ? ($extra_spec['ISSET'] == 0 ? "\\0" : "opline->extended_value") : "\\0", + "/OBSERVER_END_HANDLERS\(\s*([^,]*)\s*,\s*(.*)\s*\)/" => isset($extra_spec['OBSERVER']) ? + ($extra_spec['OBSERVER'] == 0 ? "" : "zend_observer_maybe_fcall_call_end(\\1, \\2)") + : "", ); $code = preg_replace(array_keys($specialized_replacements), array_values($specialized_replacements), $code); @@ -1550,6 +1553,11 @@ function extra_spec_name($extra_spec) { $s .= "_EMPTY"; } } + if (isset($extra_spec["OBSERVER"])) { + if ($extra_spec["OBSERVER"]) { + $s .= "_OBSERVER"; + } + } return $s; } @@ -1573,6 +1581,9 @@ function extra_spec_flags($extra_spec) { if (isset($extra_spec["ISSET"])) { $s[] = "SPEC_RULE_ISSET"; } + if (isset($extra_spec["OBSERVER"])) { + $s[] = "SPEC_RULE_OBSERVER"; + } return $s; } @@ -1771,6 +1782,7 @@ function gen_executor($f, $skl, $spec, $kind, $executor_name, $initializer_name) out($f,"#define SPEC_RULE_SMART_BRANCH 0x00200000\n"); out($f,"#define SPEC_RULE_COMMUTATIVE 0x00800000\n"); out($f,"#define SPEC_RULE_ISSET 0x01000000\n"); + out($f,"#define SPEC_RULE_OBSERVER 0x02000000\n"); out($f,"\n"); out($f,"static const uint32_t *zend_spec_handlers;\n"); out($f,"static const void * const *zend_opcode_handlers;\n"); @@ -2247,6 +2259,9 @@ function parse_spec_rules($def, $lineno, $str) { case "ISSET": $ret["ISSET"] = array(0, 1); break; + case "OBSERVER": + $ret["OBSERVER"] = array(0, 1); + break; default: die("ERROR ($def:$lineno): Wrong specialization rules '$str'\n"); } @@ -2653,7 +2668,8 @@ function gen_vm($def, $skel) { isset($used_extra_spec["RETVAL"]) || isset($used_extra_spec["QUICK_ARG"]) || isset($used_extra_spec["SMART_BRANCH"]) || - isset($used_extra_spec["ISSET"])) { + isset($used_extra_spec["ISSET"]) || + isset($used_extra_spec["OBSERVER"])) { $else = ""; out($f, "\tif (spec & SPEC_EXTRA_MASK) {\n"); @@ -2688,6 +2704,14 @@ function gen_vm($def, $skel) { out($f, "\t\t\t}\n"); $else = "} else "; } + if (isset($used_extra_spec["OBSERVER"])) { + out($f, "\t\t{$else}if (spec & SPEC_RULE_OBSERVER) {\n"); + out($f, "\t\t\toffset = offset * 2;\n"); + out($f, "\t\t\tif (ZEND_OBSERVER_ENABLED) {\n"); + out($f, "\t\t\t\toffset += 1;\n"); + out($f, "\t\t\t}\n"); + $else = "} else "; + } if ($else !== "") { out($f, "\t\t}\n"); } diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h index afcc07a8fdc35..96064eec97bba 100644 --- a/Zend/zend_vm_handlers.h +++ b/Zend/zend_vm_handlers.h @@ -639,827 +639,827 @@ _(1351, ZEND_DO_FCALL_SPEC_RETVAL_USED) \ _(1352, ZEND_INIT_FCALL_SPEC_CONST) \ _(1353, ZEND_RETURN_SPEC_CONST) \ - _(1354, ZEND_RETURN_SPEC_TMP) \ - _(1355, ZEND_RETURN_SPEC_VAR) \ - _(1357, ZEND_RETURN_SPEC_CV) \ - _(1358, ZEND_RECV_SPEC_UNUSED) \ - _(1359, ZEND_RECV_INIT_SPEC_CONST) \ - _(1360, ZEND_SEND_VAL_SPEC_CONST_CONST) \ - _(1363, ZEND_SEND_VAL_SPEC_CONST_UNUSED) \ - _(1365, ZEND_SEND_VAL_SPEC_TMPVAR_CONST) \ - _(1368, ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED) \ + _(1354, ZEND_RETURN_SPEC_CONST_OBSERVER) \ + _(1355, ZEND_RETURN_SPEC_TMP) \ + _(1356, ZEND_RETURN_SPEC_TMP_OBSERVER) \ + _(1357, ZEND_RETURN_SPEC_VAR) \ + _(1358, ZEND_RETURN_SPEC_VAR_OBSERVER) \ + _(1361, ZEND_RETURN_SPEC_CV) \ + _(1362, ZEND_RETURN_SPEC_CV_OBSERVER) \ + _(1363, ZEND_RECV_SPEC_UNUSED) \ + _(1364, ZEND_RECV_INIT_SPEC_CONST) \ + _(1365, ZEND_SEND_VAL_SPEC_CONST_CONST) \ + _(1368, ZEND_SEND_VAL_SPEC_CONST_UNUSED) \ _(1370, ZEND_SEND_VAL_SPEC_TMPVAR_CONST) \ _(1373, ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED) \ - _(1405, ZEND_SEND_VAR_EX_SPEC_VAR_CONST) \ - _(1406, ZEND_SEND_VAR_EX_SPEC_VAR_CONST) \ - _(1411, ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED) \ - _(1412, ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK) \ - _(1425, ZEND_SEND_VAR_EX_SPEC_CV_CONST) \ - _(1426, ZEND_SEND_VAR_EX_SPEC_CV_CONST) \ - _(1431, ZEND_SEND_VAR_EX_SPEC_CV_UNUSED) \ - _(1432, ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK) \ - _(1445, ZEND_SEND_REF_SPEC_VAR_CONST) \ - _(1448, ZEND_SEND_REF_SPEC_VAR_UNUSED) \ - _(1455, ZEND_SEND_REF_SPEC_CV_CONST) \ - _(1458, ZEND_SEND_REF_SPEC_CV_UNUSED) \ - _(1460, ZEND_NEW_SPEC_CONST_UNUSED) \ - _(1462, ZEND_NEW_SPEC_VAR_UNUSED) \ - _(1463, ZEND_NEW_SPEC_UNUSED_UNUSED) \ - _(1465, ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST) \ - _(1466, ZEND_FREE_SPEC_TMPVAR) \ - _(1467, ZEND_INIT_ARRAY_SPEC_CONST_CONST) \ - _(1468, ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR) \ - _(1469, ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR) \ - _(1470, ZEND_INIT_ARRAY_SPEC_CONST_UNUSED) \ - _(1471, ZEND_INIT_ARRAY_SPEC_CONST_CV) \ - _(1472, ZEND_INIT_ARRAY_SPEC_TMP_CONST) \ - _(1473, ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR) \ - _(1474, ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR) \ - _(1475, ZEND_INIT_ARRAY_SPEC_TMP_UNUSED) \ - _(1476, ZEND_INIT_ARRAY_SPEC_TMP_CV) \ - _(1477, ZEND_INIT_ARRAY_SPEC_VAR_CONST) \ - _(1478, ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR) \ - _(1479, ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR) \ - _(1480, ZEND_INIT_ARRAY_SPEC_VAR_UNUSED) \ - _(1481, ZEND_INIT_ARRAY_SPEC_VAR_CV) \ - _(1482, ZEND_INIT_ARRAY_SPEC_UNUSED_CONST) \ - _(1483, ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR) \ - _(1484, ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR) \ - _(1485, ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED) \ - _(1486, ZEND_INIT_ARRAY_SPEC_UNUSED_CV) \ - _(1487, ZEND_INIT_ARRAY_SPEC_CV_CONST) \ - _(1488, ZEND_INIT_ARRAY_SPEC_CV_TMPVAR) \ - _(1489, ZEND_INIT_ARRAY_SPEC_CV_TMPVAR) \ - _(1490, ZEND_INIT_ARRAY_SPEC_CV_UNUSED) \ - _(1491, ZEND_INIT_ARRAY_SPEC_CV_CV) \ - _(1492, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST) \ - _(1493, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR) \ - _(1494, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR) \ - _(1495, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED) \ - _(1496, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV) \ - _(1497, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST) \ - _(1498, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR) \ - _(1499, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR) \ - _(1500, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED) \ - _(1501, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV) \ - _(1502, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST) \ - _(1503, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR) \ - _(1504, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR) \ - _(1505, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED) \ - _(1506, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV) \ - _(1512, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST) \ - _(1513, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR) \ - _(1514, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR) \ - _(1515, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED) \ - _(1516, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV) \ - _(1517, ZEND_INCLUDE_OR_EVAL_SPEC_CONST) \ - _(1518, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR) \ - _(1519, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR) \ - _(1521, ZEND_INCLUDE_OR_EVAL_SPEC_CV) \ - _(1522, ZEND_UNSET_VAR_SPEC_CONST_UNUSED) \ - _(1523, ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED) \ - _(1524, ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED) \ - _(1526, ZEND_UNSET_VAR_SPEC_CV_UNUSED) \ - _(1537, ZEND_UNSET_DIM_SPEC_VAR_CONST) \ - _(1538, ZEND_UNSET_DIM_SPEC_VAR_TMPVAR) \ - _(1539, ZEND_UNSET_DIM_SPEC_VAR_TMPVAR) \ - _(1541, ZEND_UNSET_DIM_SPEC_VAR_CV) \ - _(1547, ZEND_UNSET_DIM_SPEC_CV_CONST) \ - _(1548, ZEND_UNSET_DIM_SPEC_CV_TMPVAR) \ - _(1549, ZEND_UNSET_DIM_SPEC_CV_TMPVAR) \ - _(1551, ZEND_UNSET_DIM_SPEC_CV_CV) \ - _(1562, ZEND_UNSET_OBJ_SPEC_VAR_CONST) \ - _(1563, ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR) \ - _(1564, ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR) \ - _(1566, ZEND_UNSET_OBJ_SPEC_VAR_CV) \ - _(1567, ZEND_UNSET_OBJ_SPEC_UNUSED_CONST) \ - _(1568, ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR) \ - _(1569, ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR) \ - _(1571, ZEND_UNSET_OBJ_SPEC_UNUSED_CV) \ - _(1572, ZEND_UNSET_OBJ_SPEC_CV_CONST) \ - _(1573, ZEND_UNSET_OBJ_SPEC_CV_TMPVAR) \ - _(1574, ZEND_UNSET_OBJ_SPEC_CV_TMPVAR) \ - _(1576, ZEND_UNSET_OBJ_SPEC_CV_CV) \ - _(1577, ZEND_FE_RESET_R_SPEC_CONST) \ - _(1578, ZEND_FE_RESET_R_SPEC_TMP) \ - _(1579, ZEND_FE_RESET_R_SPEC_VAR) \ - _(1581, ZEND_FE_RESET_R_SPEC_CV) \ - _(1582, ZEND_FE_FETCH_R_SPEC_VAR) \ - _(1583, ZEND_EXIT_SPEC) \ - _(1584, ZEND_FETCH_R_SPEC_CONST_UNUSED) \ - _(1585, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \ - _(1586, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \ - _(1588, ZEND_FETCH_R_SPEC_CV_UNUSED) \ - _(1589, ZEND_FETCH_DIM_R_SPEC_CONST_CONST) \ - _(1590, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \ - _(1591, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \ - _(1593, ZEND_FETCH_DIM_R_SPEC_CONST_CV) \ - _(1594, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \ - _(1595, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ - _(1596, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ - _(1598, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \ + _(1375, ZEND_SEND_VAL_SPEC_TMPVAR_CONST) \ + _(1378, ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED) \ + _(1410, ZEND_SEND_VAR_EX_SPEC_VAR_CONST) \ + _(1411, ZEND_SEND_VAR_EX_SPEC_VAR_CONST) \ + _(1416, ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED) \ + _(1417, ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK) \ + _(1430, ZEND_SEND_VAR_EX_SPEC_CV_CONST) \ + _(1431, ZEND_SEND_VAR_EX_SPEC_CV_CONST) \ + _(1436, ZEND_SEND_VAR_EX_SPEC_CV_UNUSED) \ + _(1437, ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK) \ + _(1450, ZEND_SEND_REF_SPEC_VAR_CONST) \ + _(1453, ZEND_SEND_REF_SPEC_VAR_UNUSED) \ + _(1460, ZEND_SEND_REF_SPEC_CV_CONST) \ + _(1463, ZEND_SEND_REF_SPEC_CV_UNUSED) \ + _(1465, ZEND_NEW_SPEC_CONST_UNUSED) \ + _(1467, ZEND_NEW_SPEC_VAR_UNUSED) \ + _(1468, ZEND_NEW_SPEC_UNUSED_UNUSED) \ + _(1470, ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST) \ + _(1471, ZEND_FREE_SPEC_TMPVAR) \ + _(1472, ZEND_INIT_ARRAY_SPEC_CONST_CONST) \ + _(1473, ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR) \ + _(1474, ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR) \ + _(1475, ZEND_INIT_ARRAY_SPEC_CONST_UNUSED) \ + _(1476, ZEND_INIT_ARRAY_SPEC_CONST_CV) \ + _(1477, ZEND_INIT_ARRAY_SPEC_TMP_CONST) \ + _(1478, ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR) \ + _(1479, ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR) \ + _(1480, ZEND_INIT_ARRAY_SPEC_TMP_UNUSED) \ + _(1481, ZEND_INIT_ARRAY_SPEC_TMP_CV) \ + _(1482, ZEND_INIT_ARRAY_SPEC_VAR_CONST) \ + _(1483, ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR) \ + _(1484, ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR) \ + _(1485, ZEND_INIT_ARRAY_SPEC_VAR_UNUSED) \ + _(1486, ZEND_INIT_ARRAY_SPEC_VAR_CV) \ + _(1487, ZEND_INIT_ARRAY_SPEC_UNUSED_CONST) \ + _(1488, ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR) \ + _(1489, ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR) \ + _(1490, ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED) \ + _(1491, ZEND_INIT_ARRAY_SPEC_UNUSED_CV) \ + _(1492, ZEND_INIT_ARRAY_SPEC_CV_CONST) \ + _(1493, ZEND_INIT_ARRAY_SPEC_CV_TMPVAR) \ + _(1494, ZEND_INIT_ARRAY_SPEC_CV_TMPVAR) \ + _(1495, ZEND_INIT_ARRAY_SPEC_CV_UNUSED) \ + _(1496, ZEND_INIT_ARRAY_SPEC_CV_CV) \ + _(1497, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST) \ + _(1498, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR) \ + _(1499, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR) \ + _(1500, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED) \ + _(1501, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV) \ + _(1502, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST) \ + _(1503, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR) \ + _(1504, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR) \ + _(1505, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED) \ + _(1506, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV) \ + _(1507, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST) \ + _(1508, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR) \ + _(1509, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR) \ + _(1510, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED) \ + _(1511, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV) \ + _(1517, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST) \ + _(1518, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR) \ + _(1519, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR) \ + _(1520, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED) \ + _(1521, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV) \ + _(1522, ZEND_INCLUDE_OR_EVAL_SPEC_CONST) \ + _(1523, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR) \ + _(1524, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR) \ + _(1526, ZEND_INCLUDE_OR_EVAL_SPEC_CV) \ + _(1527, ZEND_UNSET_VAR_SPEC_CONST_UNUSED) \ + _(1528, ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED) \ + _(1529, ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED) \ + _(1531, ZEND_UNSET_VAR_SPEC_CV_UNUSED) \ + _(1542, ZEND_UNSET_DIM_SPEC_VAR_CONST) \ + _(1543, ZEND_UNSET_DIM_SPEC_VAR_TMPVAR) \ + _(1544, ZEND_UNSET_DIM_SPEC_VAR_TMPVAR) \ + _(1546, ZEND_UNSET_DIM_SPEC_VAR_CV) \ + _(1552, ZEND_UNSET_DIM_SPEC_CV_CONST) \ + _(1553, ZEND_UNSET_DIM_SPEC_CV_TMPVAR) \ + _(1554, ZEND_UNSET_DIM_SPEC_CV_TMPVAR) \ + _(1556, ZEND_UNSET_DIM_SPEC_CV_CV) \ + _(1567, ZEND_UNSET_OBJ_SPEC_VAR_CONST) \ + _(1568, ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR) \ + _(1569, ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR) \ + _(1571, ZEND_UNSET_OBJ_SPEC_VAR_CV) \ + _(1572, ZEND_UNSET_OBJ_SPEC_UNUSED_CONST) \ + _(1573, ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR) \ + _(1574, ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR) \ + _(1576, ZEND_UNSET_OBJ_SPEC_UNUSED_CV) \ + _(1577, ZEND_UNSET_OBJ_SPEC_CV_CONST) \ + _(1578, ZEND_UNSET_OBJ_SPEC_CV_TMPVAR) \ + _(1579, ZEND_UNSET_OBJ_SPEC_CV_TMPVAR) \ + _(1581, ZEND_UNSET_OBJ_SPEC_CV_CV) \ + _(1582, ZEND_FE_RESET_R_SPEC_CONST) \ + _(1583, ZEND_FE_RESET_R_SPEC_TMP) \ + _(1584, ZEND_FE_RESET_R_SPEC_VAR) \ + _(1586, ZEND_FE_RESET_R_SPEC_CV) \ + _(1587, ZEND_FE_FETCH_R_SPEC_VAR) \ + _(1588, ZEND_EXIT_SPEC) \ + _(1589, ZEND_FETCH_R_SPEC_CONST_UNUSED) \ + _(1590, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \ + _(1591, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \ + _(1593, ZEND_FETCH_R_SPEC_CV_UNUSED) \ + _(1594, ZEND_FETCH_DIM_R_SPEC_CONST_CONST) \ + _(1595, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \ + _(1596, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \ + _(1598, ZEND_FETCH_DIM_R_SPEC_CONST_CV) \ _(1599, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \ _(1600, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ _(1601, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ _(1603, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \ - _(1609, ZEND_FETCH_DIM_R_SPEC_CV_CONST) \ - _(1610, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \ - _(1611, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \ - _(1613, ZEND_FETCH_DIM_R_SPEC_CV_CV) \ - _(1614, ZEND_FETCH_OBJ_R_SPEC_CONST_CONST) \ - _(1615, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \ - _(1616, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \ - _(1618, ZEND_FETCH_OBJ_R_SPEC_CONST_CV) \ - _(1619, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \ - _(1620, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ - _(1621, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ - _(1623, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \ + _(1604, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \ + _(1605, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ + _(1606, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ + _(1608, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \ + _(1614, ZEND_FETCH_DIM_R_SPEC_CV_CONST) \ + _(1615, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \ + _(1616, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \ + _(1618, ZEND_FETCH_DIM_R_SPEC_CV_CV) \ + _(1619, ZEND_FETCH_OBJ_R_SPEC_CONST_CONST) \ + _(1620, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \ + _(1621, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \ + _(1623, ZEND_FETCH_OBJ_R_SPEC_CONST_CV) \ _(1624, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \ _(1625, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ _(1626, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ _(1628, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \ - _(1629, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST) \ - _(1630, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \ - _(1631, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \ - _(1633, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV) \ - _(1634, ZEND_FETCH_OBJ_R_SPEC_CV_CONST) \ - _(1635, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \ - _(1636, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \ - _(1638, ZEND_FETCH_OBJ_R_SPEC_CV_CV) \ - _(1639, ZEND_FETCH_W_SPEC_CONST_UNUSED) \ - _(1640, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \ - _(1641, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \ - _(1643, ZEND_FETCH_W_SPEC_CV_UNUSED) \ - _(1654, ZEND_FETCH_DIM_W_SPEC_VAR_CONST) \ - _(1655, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \ - _(1656, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \ - _(1657, ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED) \ - _(1658, ZEND_FETCH_DIM_W_SPEC_VAR_CV) \ - _(1664, ZEND_FETCH_DIM_W_SPEC_CV_CONST) \ - _(1665, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \ - _(1666, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \ - _(1667, ZEND_FETCH_DIM_W_SPEC_CV_UNUSED) \ - _(1668, ZEND_FETCH_DIM_W_SPEC_CV_CV) \ - _(1679, ZEND_FETCH_OBJ_W_SPEC_VAR_CONST) \ - _(1680, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \ - _(1681, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \ - _(1683, ZEND_FETCH_OBJ_W_SPEC_VAR_CV) \ - _(1684, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST) \ - _(1685, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \ - _(1686, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \ - _(1688, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV) \ - _(1689, ZEND_FETCH_OBJ_W_SPEC_CV_CONST) \ - _(1690, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \ - _(1691, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \ - _(1693, ZEND_FETCH_OBJ_W_SPEC_CV_CV) \ - _(1694, ZEND_FETCH_RW_SPEC_CONST_UNUSED) \ - _(1695, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \ - _(1696, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \ - _(1698, ZEND_FETCH_RW_SPEC_CV_UNUSED) \ - _(1709, ZEND_FETCH_DIM_RW_SPEC_VAR_CONST) \ - _(1710, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \ - _(1711, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \ - _(1712, ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED) \ - _(1713, ZEND_FETCH_DIM_RW_SPEC_VAR_CV) \ - _(1719, ZEND_FETCH_DIM_RW_SPEC_CV_CONST) \ - _(1720, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \ - _(1721, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \ - _(1722, ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED) \ - _(1723, ZEND_FETCH_DIM_RW_SPEC_CV_CV) \ - _(1734, ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST) \ - _(1735, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \ - _(1736, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \ - _(1738, ZEND_FETCH_OBJ_RW_SPEC_VAR_CV) \ - _(1739, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST) \ - _(1740, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \ - _(1741, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \ - _(1743, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV) \ - _(1744, ZEND_FETCH_OBJ_RW_SPEC_CV_CONST) \ - _(1745, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \ - _(1746, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \ - _(1748, ZEND_FETCH_OBJ_RW_SPEC_CV_CV) \ - _(1749, ZEND_FETCH_IS_SPEC_CONST_UNUSED) \ - _(1750, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \ - _(1751, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \ - _(1753, ZEND_FETCH_IS_SPEC_CV_UNUSED) \ - _(1754, ZEND_FETCH_DIM_IS_SPEC_CONST_CONST) \ - _(1755, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \ - _(1756, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \ - _(1758, ZEND_FETCH_DIM_IS_SPEC_CONST_CV) \ - _(1759, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \ - _(1760, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ - _(1761, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ - _(1763, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \ + _(1629, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \ + _(1630, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ + _(1631, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ + _(1633, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \ + _(1634, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST) \ + _(1635, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \ + _(1636, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \ + _(1638, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV) \ + _(1639, ZEND_FETCH_OBJ_R_SPEC_CV_CONST) \ + _(1640, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \ + _(1641, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \ + _(1643, ZEND_FETCH_OBJ_R_SPEC_CV_CV) \ + _(1644, ZEND_FETCH_W_SPEC_CONST_UNUSED) \ + _(1645, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \ + _(1646, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \ + _(1648, ZEND_FETCH_W_SPEC_CV_UNUSED) \ + _(1659, ZEND_FETCH_DIM_W_SPEC_VAR_CONST) \ + _(1660, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \ + _(1661, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \ + _(1662, ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED) \ + _(1663, ZEND_FETCH_DIM_W_SPEC_VAR_CV) \ + _(1669, ZEND_FETCH_DIM_W_SPEC_CV_CONST) \ + _(1670, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \ + _(1671, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \ + _(1672, ZEND_FETCH_DIM_W_SPEC_CV_UNUSED) \ + _(1673, ZEND_FETCH_DIM_W_SPEC_CV_CV) \ + _(1684, ZEND_FETCH_OBJ_W_SPEC_VAR_CONST) \ + _(1685, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \ + _(1686, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \ + _(1688, ZEND_FETCH_OBJ_W_SPEC_VAR_CV) \ + _(1689, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST) \ + _(1690, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \ + _(1691, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \ + _(1693, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV) \ + _(1694, ZEND_FETCH_OBJ_W_SPEC_CV_CONST) \ + _(1695, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \ + _(1696, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \ + _(1698, ZEND_FETCH_OBJ_W_SPEC_CV_CV) \ + _(1699, ZEND_FETCH_RW_SPEC_CONST_UNUSED) \ + _(1700, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \ + _(1701, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \ + _(1703, ZEND_FETCH_RW_SPEC_CV_UNUSED) \ + _(1714, ZEND_FETCH_DIM_RW_SPEC_VAR_CONST) \ + _(1715, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \ + _(1716, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \ + _(1717, ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED) \ + _(1718, ZEND_FETCH_DIM_RW_SPEC_VAR_CV) \ + _(1724, ZEND_FETCH_DIM_RW_SPEC_CV_CONST) \ + _(1725, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \ + _(1726, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \ + _(1727, ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED) \ + _(1728, ZEND_FETCH_DIM_RW_SPEC_CV_CV) \ + _(1739, ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST) \ + _(1740, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \ + _(1741, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \ + _(1743, ZEND_FETCH_OBJ_RW_SPEC_VAR_CV) \ + _(1744, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST) \ + _(1745, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \ + _(1746, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \ + _(1748, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV) \ + _(1749, ZEND_FETCH_OBJ_RW_SPEC_CV_CONST) \ + _(1750, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \ + _(1751, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \ + _(1753, ZEND_FETCH_OBJ_RW_SPEC_CV_CV) \ + _(1754, ZEND_FETCH_IS_SPEC_CONST_UNUSED) \ + _(1755, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \ + _(1756, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \ + _(1758, ZEND_FETCH_IS_SPEC_CV_UNUSED) \ + _(1759, ZEND_FETCH_DIM_IS_SPEC_CONST_CONST) \ + _(1760, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \ + _(1761, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \ + _(1763, ZEND_FETCH_DIM_IS_SPEC_CONST_CV) \ _(1764, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \ _(1765, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ _(1766, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ _(1768, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \ - _(1774, ZEND_FETCH_DIM_IS_SPEC_CV_CONST) \ - _(1775, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \ - _(1776, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \ - _(1778, ZEND_FETCH_DIM_IS_SPEC_CV_CV) \ - _(1779, ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST) \ - _(1780, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \ - _(1781, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \ - _(1783, ZEND_FETCH_OBJ_IS_SPEC_CONST_CV) \ - _(1784, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \ - _(1785, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ - _(1786, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ - _(1788, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \ + _(1769, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \ + _(1770, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ + _(1771, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ + _(1773, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \ + _(1779, ZEND_FETCH_DIM_IS_SPEC_CV_CONST) \ + _(1780, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \ + _(1781, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \ + _(1783, ZEND_FETCH_DIM_IS_SPEC_CV_CV) \ + _(1784, ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST) \ + _(1785, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \ + _(1786, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \ + _(1788, ZEND_FETCH_OBJ_IS_SPEC_CONST_CV) \ _(1789, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \ _(1790, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ _(1791, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ _(1793, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \ - _(1794, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST) \ - _(1795, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \ - _(1796, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \ - _(1798, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV) \ - _(1799, ZEND_FETCH_OBJ_IS_SPEC_CV_CONST) \ - _(1800, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \ - _(1801, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \ - _(1803, ZEND_FETCH_OBJ_IS_SPEC_CV_CV) \ - _(1804, ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED) \ - _(1805, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \ - _(1806, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \ - _(1808, ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED) \ - _(1809, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST) \ - _(1810, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \ - _(1811, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \ - _(1812, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED) \ - _(1813, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV) \ - _(1814, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST) \ - _(1815, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \ - _(1816, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \ - _(1817, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED) \ - _(1818, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV) \ - _(1819, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST) \ - _(1820, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \ - _(1821, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \ - _(1822, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED) \ - _(1823, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV) \ - _(1829, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST) \ - _(1830, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \ - _(1831, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \ - _(1832, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED) \ - _(1833, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV) \ - _(1834, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST) \ - _(1835, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \ - _(1836, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \ - _(1838, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV) \ - _(1839, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST) \ - _(1840, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \ - _(1841, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \ - _(1843, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV) \ - _(1844, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST) \ - _(1845, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \ - _(1846, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \ - _(1848, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV) \ - _(1849, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST) \ - _(1850, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \ - _(1851, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \ - _(1853, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV) \ - _(1854, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST) \ - _(1855, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \ - _(1856, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \ - _(1858, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV) \ - _(1859, ZEND_FETCH_UNSET_SPEC_CONST_UNUSED) \ - _(1860, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \ - _(1861, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \ - _(1863, ZEND_FETCH_UNSET_SPEC_CV_UNUSED) \ - _(1874, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST) \ - _(1875, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \ - _(1876, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \ - _(1878, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV) \ - _(1884, ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST) \ - _(1885, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \ - _(1886, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \ - _(1888, ZEND_FETCH_DIM_UNSET_SPEC_CV_CV) \ - _(1899, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST) \ - _(1900, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \ - _(1901, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \ - _(1903, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV) \ - _(1904, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST) \ - _(1905, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \ - _(1906, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \ - _(1908, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV) \ - _(1909, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST) \ - _(1910, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \ - _(1911, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \ - _(1913, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV) \ - _(1914, ZEND_FETCH_LIST_R_SPEC_CONST_CONST) \ - _(1915, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \ - _(1916, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \ - _(1918, ZEND_FETCH_LIST_R_SPEC_CONST_CV) \ - _(1919, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ - _(1920, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1921, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1923, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ + _(1794, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \ + _(1795, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ + _(1796, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ + _(1798, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \ + _(1799, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST) \ + _(1800, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \ + _(1801, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \ + _(1803, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV) \ + _(1804, ZEND_FETCH_OBJ_IS_SPEC_CV_CONST) \ + _(1805, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \ + _(1806, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \ + _(1808, ZEND_FETCH_OBJ_IS_SPEC_CV_CV) \ + _(1809, ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED) \ + _(1810, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \ + _(1811, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \ + _(1813, ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED) \ + _(1814, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST) \ + _(1815, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \ + _(1816, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \ + _(1817, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED) \ + _(1818, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV) \ + _(1819, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST) \ + _(1820, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \ + _(1821, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \ + _(1822, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED) \ + _(1823, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV) \ + _(1824, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST) \ + _(1825, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \ + _(1826, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \ + _(1827, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED) \ + _(1828, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV) \ + _(1834, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST) \ + _(1835, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \ + _(1836, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \ + _(1837, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED) \ + _(1838, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV) \ + _(1839, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST) \ + _(1840, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \ + _(1841, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \ + _(1843, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV) \ + _(1844, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST) \ + _(1845, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \ + _(1846, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \ + _(1848, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV) \ + _(1849, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST) \ + _(1850, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \ + _(1851, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \ + _(1853, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV) \ + _(1854, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST) \ + _(1855, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \ + _(1856, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \ + _(1858, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV) \ + _(1859, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST) \ + _(1860, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \ + _(1861, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \ + _(1863, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV) \ + _(1864, ZEND_FETCH_UNSET_SPEC_CONST_UNUSED) \ + _(1865, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \ + _(1866, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \ + _(1868, ZEND_FETCH_UNSET_SPEC_CV_UNUSED) \ + _(1879, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST) \ + _(1880, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \ + _(1881, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \ + _(1883, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV) \ + _(1889, ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST) \ + _(1890, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \ + _(1891, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \ + _(1893, ZEND_FETCH_DIM_UNSET_SPEC_CV_CV) \ + _(1904, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST) \ + _(1905, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \ + _(1906, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \ + _(1908, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV) \ + _(1909, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST) \ + _(1910, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \ + _(1911, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \ + _(1913, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV) \ + _(1914, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST) \ + _(1915, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \ + _(1916, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \ + _(1918, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV) \ + _(1919, ZEND_FETCH_LIST_R_SPEC_CONST_CONST) \ + _(1920, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \ + _(1921, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \ + _(1923, ZEND_FETCH_LIST_R_SPEC_CONST_CV) \ _(1924, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ _(1925, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ _(1926, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ _(1928, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ - _(1934, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ - _(1935, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1936, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1938, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ - _(1939, ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST) \ - _(1940, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST) \ - _(1941, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST) \ - _(1946, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED) \ - _(1947, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK) \ - _(1950, ZEND_EXT_STMT_SPEC) \ - _(1951, ZEND_EXT_FCALL_BEGIN_SPEC) \ - _(1952, ZEND_EXT_FCALL_END_SPEC) \ - _(1953, ZEND_EXT_NOP_SPEC) \ - _(1954, ZEND_TICKS_SPEC) \ - _(1955, ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST) \ - _(1958, ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED) \ - _(1960, ZEND_CATCH_SPEC_CONST) \ - _(1961, ZEND_THROW_SPEC_CONST) \ - _(1962, ZEND_THROW_SPEC_TMPVAR) \ - _(1963, ZEND_THROW_SPEC_TMPVAR) \ - _(1965, ZEND_THROW_SPEC_CV) \ - _(1966, ZEND_FETCH_CLASS_SPEC_UNUSED_CONST) \ - _(1967, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \ - _(1968, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \ - _(1969, ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED) \ - _(1970, ZEND_FETCH_CLASS_SPEC_UNUSED_CV) \ - _(1971, ZEND_CLONE_SPEC_CONST) \ - _(1972, ZEND_CLONE_SPEC_TMPVAR) \ - _(1973, ZEND_CLONE_SPEC_TMPVAR) \ - _(1974, ZEND_CLONE_SPEC_UNUSED) \ - _(1975, ZEND_CLONE_SPEC_CV) \ - _(1976, ZEND_RETURN_BY_REF_SPEC_CONST) \ - _(1977, ZEND_RETURN_BY_REF_SPEC_TMP) \ - _(1978, ZEND_RETURN_BY_REF_SPEC_VAR) \ - _(1980, ZEND_RETURN_BY_REF_SPEC_CV) \ - _(1981, ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST) \ - _(1982, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \ - _(1983, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \ - _(1985, ZEND_INIT_METHOD_CALL_SPEC_CONST_CV) \ - _(1986, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \ - _(1987, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ - _(1988, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ - _(1990, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \ - _(1991, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \ - _(1992, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ - _(1993, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ - _(1995, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \ - _(1996, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST) \ - _(1997, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ - _(1998, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ - _(2000, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV) \ - _(2001, ZEND_INIT_METHOD_CALL_SPEC_CV_CONST) \ - _(2002, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \ - _(2003, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \ - _(2005, ZEND_INIT_METHOD_CALL_SPEC_CV_CV) \ - _(2006, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST) \ - _(2007, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \ - _(2008, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \ - _(2009, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED) \ - _(2010, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV) \ - _(2016, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST) \ - _(2017, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \ - _(2018, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \ - _(2019, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED) \ - _(2020, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV) \ - _(2021, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST) \ - _(2022, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ - _(2023, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ - _(2024, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED) \ - _(2025, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV) \ - _(2031, ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED) \ - _(2032, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \ - _(2033, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \ - _(2035, ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED) \ - _(2036, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST) \ - _(2037, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \ - _(2038, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \ - _(2040, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV) \ - _(2041, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \ - _(2042, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2043, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2045, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \ - _(2046, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \ - _(2047, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2048, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2050, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \ - _(2056, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST) \ - _(2057, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \ - _(2058, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \ - _(2060, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV) \ - _(2061, ZEND_SEND_VAL_EX_SPEC_CONST_CONST) \ - _(2062, ZEND_SEND_VAL_EX_SPEC_CONST_CONST) \ - _(2067, ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED) \ - _(2068, ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK) \ - _(2071, ZEND_SEND_VAL_EX_SPEC_TMP_CONST) \ - _(2072, ZEND_SEND_VAL_EX_SPEC_TMP_CONST) \ - _(2077, ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED) \ - _(2078, ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK) \ - _(2121, ZEND_SEND_VAR_SPEC_VAR_CONST) \ - _(2124, ZEND_SEND_VAR_SPEC_VAR_UNUSED) \ - _(2131, ZEND_SEND_VAR_SPEC_CV_CONST) \ - _(2134, ZEND_SEND_VAR_SPEC_CV_UNUSED) \ - _(2136, ZEND_INIT_USER_CALL_SPEC_CONST_CONST) \ - _(2137, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \ - _(2138, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \ - _(2140, ZEND_INIT_USER_CALL_SPEC_CONST_CV) \ - _(2141, ZEND_SEND_ARRAY_SPEC) \ - _(2142, ZEND_SEND_USER_SPEC_CONST) \ - _(2143, ZEND_SEND_USER_SPEC_TMP) \ - _(2144, ZEND_SEND_USER_SPEC_VAR) \ - _(2146, ZEND_SEND_USER_SPEC_CV) \ - _(2147, ZEND_STRLEN_SPEC_CONST) \ - _(2148, ZEND_STRLEN_SPEC_TMPVAR) \ - _(2149, ZEND_STRLEN_SPEC_TMPVAR) \ - _(2151, ZEND_STRLEN_SPEC_CV) \ - _(2152, ZEND_DEFINED_SPEC_CONST) \ - _(2153, ZEND_TYPE_CHECK_SPEC_CONST) \ - _(2154, ZEND_TYPE_CHECK_SPEC_TMPVAR) \ - _(2155, ZEND_TYPE_CHECK_SPEC_TMPVAR) \ - _(2157, ZEND_TYPE_CHECK_SPEC_CV) \ - _(2158, ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED) \ - _(2159, ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED) \ - _(2160, ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED) \ - _(2161, ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED) \ - _(2162, ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED) \ - _(2163, ZEND_FE_RESET_RW_SPEC_CONST) \ - _(2164, ZEND_FE_RESET_RW_SPEC_TMP) \ - _(2165, ZEND_FE_RESET_RW_SPEC_VAR) \ - _(2167, ZEND_FE_RESET_RW_SPEC_CV) \ - _(2168, ZEND_FE_FETCH_RW_SPEC_VAR) \ - _(2169, ZEND_FE_FREE_SPEC_TMPVAR) \ - _(2170, ZEND_INIT_DYNAMIC_CALL_SPEC_CONST) \ - _(2171, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \ - _(2172, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \ - _(2174, ZEND_INIT_DYNAMIC_CALL_SPEC_CV) \ - _(2175, ZEND_DO_ICALL_SPEC_RETVAL_UNUSED) \ - _(2176, ZEND_DO_ICALL_SPEC_RETVAL_USED) \ - _(2177, ZEND_DO_UCALL_SPEC_RETVAL_UNUSED) \ - _(2178, ZEND_DO_UCALL_SPEC_RETVAL_USED) \ - _(2179, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED) \ - _(2180, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED) \ - _(2191, ZEND_PRE_INC_OBJ_SPEC_VAR_CONST) \ - _(2192, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \ - _(2193, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \ - _(2195, ZEND_PRE_INC_OBJ_SPEC_VAR_CV) \ - _(2196, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST) \ - _(2197, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2198, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2200, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV) \ - _(2201, ZEND_PRE_INC_OBJ_SPEC_CV_CONST) \ - _(2202, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \ - _(2203, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \ - _(2205, ZEND_PRE_INC_OBJ_SPEC_CV_CV) \ - _(2216, ZEND_POST_INC_OBJ_SPEC_VAR_CONST) \ - _(2217, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \ - _(2218, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \ - _(2220, ZEND_POST_INC_OBJ_SPEC_VAR_CV) \ - _(2221, ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST) \ - _(2222, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2223, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2225, ZEND_POST_INC_OBJ_SPEC_UNUSED_CV) \ - _(2226, ZEND_POST_INC_OBJ_SPEC_CV_CONST) \ - _(2227, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \ - _(2228, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \ - _(2230, ZEND_POST_INC_OBJ_SPEC_CV_CV) \ - _(2231, ZEND_ECHO_SPEC_CONST) \ - _(2232, ZEND_ECHO_SPEC_TMPVAR) \ - _(2233, ZEND_ECHO_SPEC_TMPVAR) \ - _(2235, ZEND_ECHO_SPEC_CV) \ - _(2242, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \ - _(2244, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \ - _(2245, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \ - _(2247, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \ - _(2249, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \ - _(2250, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \ - _(2257, ZEND_INSTANCEOF_SPEC_CV_CONST) \ - _(2259, ZEND_INSTANCEOF_SPEC_CV_VAR) \ - _(2260, ZEND_INSTANCEOF_SPEC_CV_UNUSED) \ - _(2262, ZEND_GENERATOR_CREATE_SPEC) \ - _(2265, ZEND_MAKE_REF_SPEC_VAR_UNUSED) \ - _(2267, ZEND_MAKE_REF_SPEC_CV_UNUSED) \ - _(2268, ZEND_DECLARE_FUNCTION_SPEC) \ - _(2269, ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED) \ - _(2270, ZEND_DECLARE_CONST_SPEC_CONST_CONST) \ - _(2271, ZEND_DECLARE_CLASS_SPEC_CONST) \ - _(2272, ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST) \ - _(2273, ZEND_DECLARE_ANON_CLASS_SPEC) \ - _(2274, ZEND_ADD_ARRAY_UNPACK_SPEC) \ - _(2275, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST) \ - _(2276, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \ - _(2277, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \ - _(2279, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV) \ - _(2280, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ - _(2281, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2282, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2284, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ - _(2285, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ - _(2286, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2287, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2289, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ - _(2290, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST) \ - _(2291, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2292, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2294, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV) \ - _(2295, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST) \ - _(2296, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ - _(2297, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ - _(2299, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV) \ - _(2300, ZEND_HANDLE_EXCEPTION_SPEC) \ - _(2301, ZEND_USER_OPCODE_SPEC) \ - _(2302, ZEND_ASSERT_CHECK_SPEC) \ - _(2303, ZEND_JMP_SET_SPEC_CONST) \ - _(2304, ZEND_JMP_SET_SPEC_TMP) \ - _(2305, ZEND_JMP_SET_SPEC_VAR) \ - _(2307, ZEND_JMP_SET_SPEC_CV) \ - _(2308, ZEND_UNSET_CV_SPEC_CV_UNUSED) \ - _(2309, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET) \ - _(2310, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY) \ - _(2311, ZEND_FETCH_LIST_W_SPEC_VAR_CONST) \ - _(2312, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ - _(2313, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ - _(2315, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \ - _(2316, ZEND_SEPARATE_SPEC_VAR_UNUSED) \ - _(2318, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \ - _(2319, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \ - _(2320, ZEND_FETCH_CLASS_NAME_SPEC_UNUSED) \ - _(2321, ZEND_FETCH_CLASS_NAME_SPEC_CV) \ - _(2322, ZEND_CALL_TRAMPOLINE_SPEC) \ - _(2323, ZEND_DISCARD_EXCEPTION_SPEC) \ - _(2324, ZEND_YIELD_SPEC_CONST_CONST) \ - _(2325, ZEND_YIELD_SPEC_CONST_TMPVAR) \ - _(2326, ZEND_YIELD_SPEC_CONST_TMPVAR) \ - _(2327, ZEND_YIELD_SPEC_CONST_UNUSED) \ - _(2328, ZEND_YIELD_SPEC_CONST_CV) \ - _(2329, ZEND_YIELD_SPEC_TMP_CONST) \ - _(2330, ZEND_YIELD_SPEC_TMP_TMPVAR) \ - _(2331, ZEND_YIELD_SPEC_TMP_TMPVAR) \ - _(2332, ZEND_YIELD_SPEC_TMP_UNUSED) \ - _(2333, ZEND_YIELD_SPEC_TMP_CV) \ - _(2334, ZEND_YIELD_SPEC_VAR_CONST) \ - _(2335, ZEND_YIELD_SPEC_VAR_TMPVAR) \ - _(2336, ZEND_YIELD_SPEC_VAR_TMPVAR) \ - _(2337, ZEND_YIELD_SPEC_VAR_UNUSED) \ - _(2338, ZEND_YIELD_SPEC_VAR_CV) \ - _(2339, ZEND_YIELD_SPEC_UNUSED_CONST) \ - _(2340, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \ - _(2341, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \ - _(2342, ZEND_YIELD_SPEC_UNUSED_UNUSED) \ - _(2343, ZEND_YIELD_SPEC_UNUSED_CV) \ - _(2344, ZEND_YIELD_SPEC_CV_CONST) \ - _(2345, ZEND_YIELD_SPEC_CV_TMPVAR) \ - _(2346, ZEND_YIELD_SPEC_CV_TMPVAR) \ - _(2347, ZEND_YIELD_SPEC_CV_UNUSED) \ - _(2348, ZEND_YIELD_SPEC_CV_CV) \ - _(2349, ZEND_GENERATOR_RETURN_SPEC_CONST) \ - _(2350, ZEND_GENERATOR_RETURN_SPEC_TMP) \ - _(2351, ZEND_GENERATOR_RETURN_SPEC_VAR) \ - _(2353, ZEND_GENERATOR_RETURN_SPEC_CV) \ - _(2354, ZEND_FAST_CALL_SPEC) \ - _(2355, ZEND_FAST_RET_SPEC) \ - _(2356, ZEND_RECV_VARIADIC_SPEC_UNUSED) \ - _(2357, ZEND_SEND_UNPACK_SPEC) \ - _(2358, ZEND_YIELD_FROM_SPEC_CONST) \ - _(2359, ZEND_YIELD_FROM_SPEC_TMPVAR) \ - _(2360, ZEND_YIELD_FROM_SPEC_TMPVAR) \ - _(2362, ZEND_YIELD_FROM_SPEC_CV) \ - _(2363, ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED) \ - _(2364, ZEND_BIND_GLOBAL_SPEC_CV_CONST) \ - _(2365, ZEND_COALESCE_SPEC_CONST) \ - _(2366, ZEND_COALESCE_SPEC_TMP) \ - _(2367, ZEND_COALESCE_SPEC_VAR) \ - _(2369, ZEND_COALESCE_SPEC_CV) \ - _(2370, ZEND_SPACESHIP_SPEC_CONST_CONST) \ - _(2371, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ - _(2372, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ - _(2374, ZEND_SPACESHIP_SPEC_CONST_CV) \ - _(2375, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ - _(2376, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(2377, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(2379, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ - _(2380, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ - _(2381, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(2382, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(2384, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ - _(2390, ZEND_SPACESHIP_SPEC_CV_CONST) \ - _(2391, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ - _(2392, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ - _(2394, ZEND_SPACESHIP_SPEC_CV_CV) \ - _(2395, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED) \ - _(2396, ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED) \ - _(2399, ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED) \ - _(2401, ZEND_FETCH_STATIC_PROP_R_SPEC) \ - _(2402, ZEND_FETCH_STATIC_PROP_W_SPEC) \ - _(2403, ZEND_FETCH_STATIC_PROP_RW_SPEC) \ - _(2404, ZEND_FETCH_STATIC_PROP_IS_SPEC) \ - _(2405, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC) \ - _(2406, ZEND_FETCH_STATIC_PROP_UNSET_SPEC) \ - _(2407, ZEND_UNSET_STATIC_PROP_SPEC) \ - _(2408, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC) \ - _(2409, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) \ - _(2411, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) \ - _(2412, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST) \ - _(2414, ZEND_BIND_LEXICAL_SPEC_TMP_CV) \ - _(2415, ZEND_BIND_STATIC_SPEC_CV_UNUSED) \ - _(2416, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED) \ - _(2417, ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST) \ - _(2420, ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED) \ - _(2422, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED) \ - _(2423, ZEND_SWITCH_LONG_SPEC_CONST_CONST) \ - _(2424, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(2425, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(2427, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(2428, ZEND_SWITCH_STRING_SPEC_CONST_CONST) \ - _(2429, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(2430, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(2432, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(2433, ZEND_IN_ARRAY_SPEC_CONST_CONST) \ - _(2434, ZEND_IN_ARRAY_SPEC_TMP_CONST) \ - _(2435, ZEND_IN_ARRAY_SPEC_VAR_CONST) \ - _(2437, ZEND_IN_ARRAY_SPEC_CV_CONST) \ - _(2438, ZEND_COUNT_SPEC_CONST_UNUSED) \ - _(2439, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \ - _(2440, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \ - _(2442, ZEND_COUNT_SPEC_CV_UNUSED) \ - _(2443, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \ - _(2444, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \ - _(2445, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \ - _(2446, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED) \ - _(2447, ZEND_GET_CLASS_SPEC_CV_UNUSED) \ - _(2448, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED) \ - _(2449, ZEND_GET_TYPE_SPEC_CONST_UNUSED) \ - _(2450, ZEND_GET_TYPE_SPEC_TMP_UNUSED) \ - _(2451, ZEND_GET_TYPE_SPEC_VAR_UNUSED) \ - _(2453, ZEND_GET_TYPE_SPEC_CV_UNUSED) \ - _(2454, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \ - _(2455, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ - _(2456, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ - _(2458, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \ - _(2459, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ - _(2460, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(2461, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(2463, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ - _(2464, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ - _(2465, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(2466, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(2468, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ - _(2474, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \ - _(2475, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ - _(2476, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ - _(2478, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \ - _(2479, ZEND_MATCH_SPEC_CONST_CONST) \ - _(2480, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ - _(2481, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ - _(2483, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ - _(2489, ZEND_CASE_STRICT_SPEC_TMP_CONST) \ - _(2490, ZEND_CASE_STRICT_SPEC_TMP_TMP) \ - _(2491, ZEND_CASE_STRICT_SPEC_TMP_VAR) \ - _(2493, ZEND_CASE_STRICT_SPEC_TMP_CV) \ - _(2494, ZEND_CASE_STRICT_SPEC_VAR_CONST) \ - _(2495, ZEND_CASE_STRICT_SPEC_VAR_TMP) \ - _(2496, ZEND_CASE_STRICT_SPEC_VAR_VAR) \ - _(2498, ZEND_CASE_STRICT_SPEC_VAR_CV) \ - _(2509, ZEND_MATCH_ERROR_SPEC_CONST_UNUSED) \ - _(2510, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ - _(2511, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ - _(2513, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ - _(2514, ZEND_JMP_NULL_SPEC_CONST) \ - _(2515, ZEND_JMP_NULL_SPEC_TMPVARCV) \ - _(2516, ZEND_JMP_NULL_SPEC_TMPVARCV) \ - _(2518, ZEND_JMP_NULL_SPEC_TMPVARCV) \ - _(2519, ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED) \ - _(2520, ZEND_RECV_NOTYPE_SPEC) \ - _(2521, ZEND_JMP_FORWARD_SPEC) \ - _(2527, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2528, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2529, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2531, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2532, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2533, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2534, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2536, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(1929, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ + _(1930, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ + _(1931, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ + _(1933, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ + _(1939, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ + _(1940, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ + _(1941, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ + _(1943, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ + _(1944, ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST) \ + _(1945, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST) \ + _(1946, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST) \ + _(1951, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED) \ + _(1952, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK) \ + _(1955, ZEND_EXT_STMT_SPEC) \ + _(1956, ZEND_EXT_FCALL_BEGIN_SPEC) \ + _(1957, ZEND_EXT_FCALL_END_SPEC) \ + _(1958, ZEND_EXT_NOP_SPEC) \ + _(1959, ZEND_TICKS_SPEC) \ + _(1960, ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST) \ + _(1963, ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED) \ + _(1965, ZEND_CATCH_SPEC_CONST) \ + _(1966, ZEND_THROW_SPEC_CONST) \ + _(1967, ZEND_THROW_SPEC_TMPVAR) \ + _(1968, ZEND_THROW_SPEC_TMPVAR) \ + _(1970, ZEND_THROW_SPEC_CV) \ + _(1971, ZEND_FETCH_CLASS_SPEC_UNUSED_CONST) \ + _(1972, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \ + _(1973, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \ + _(1974, ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED) \ + _(1975, ZEND_FETCH_CLASS_SPEC_UNUSED_CV) \ + _(1976, ZEND_CLONE_SPEC_CONST) \ + _(1977, ZEND_CLONE_SPEC_TMPVAR) \ + _(1978, ZEND_CLONE_SPEC_TMPVAR) \ + _(1979, ZEND_CLONE_SPEC_UNUSED) \ + _(1980, ZEND_CLONE_SPEC_CV) \ + _(1981, ZEND_RETURN_BY_REF_SPEC_CONST) \ + _(1982, ZEND_RETURN_BY_REF_SPEC_CONST_OBSERVER) \ + _(1983, ZEND_RETURN_BY_REF_SPEC_TMP) \ + _(1984, ZEND_RETURN_BY_REF_SPEC_TMP_OBSERVER) \ + _(1985, ZEND_RETURN_BY_REF_SPEC_VAR) \ + _(1986, ZEND_RETURN_BY_REF_SPEC_VAR_OBSERVER) \ + _(1989, ZEND_RETURN_BY_REF_SPEC_CV) \ + _(1990, ZEND_RETURN_BY_REF_SPEC_CV_OBSERVER) \ + _(1991, ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST) \ + _(1992, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \ + _(1993, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \ + _(1995, ZEND_INIT_METHOD_CALL_SPEC_CONST_CV) \ + _(1996, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \ + _(1997, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ + _(1998, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ + _(2000, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \ + _(2001, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \ + _(2002, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ + _(2003, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ + _(2005, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \ + _(2006, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST) \ + _(2007, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ + _(2008, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ + _(2010, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV) \ + _(2011, ZEND_INIT_METHOD_CALL_SPEC_CV_CONST) \ + _(2012, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \ + _(2013, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \ + _(2015, ZEND_INIT_METHOD_CALL_SPEC_CV_CV) \ + _(2016, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST) \ + _(2017, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \ + _(2018, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \ + _(2019, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED) \ + _(2020, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV) \ + _(2026, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST) \ + _(2027, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \ + _(2028, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \ + _(2029, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED) \ + _(2030, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV) \ + _(2031, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST) \ + _(2032, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ + _(2033, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ + _(2034, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED) \ + _(2035, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV) \ + _(2041, ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED) \ + _(2042, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \ + _(2043, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \ + _(2045, ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED) \ + _(2046, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST) \ + _(2047, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \ + _(2048, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \ + _(2050, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV) \ + _(2051, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \ + _(2052, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2053, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2055, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \ + _(2056, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \ + _(2057, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2058, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2060, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \ + _(2066, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST) \ + _(2067, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \ + _(2068, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \ + _(2070, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV) \ + _(2071, ZEND_SEND_VAL_EX_SPEC_CONST_CONST) \ + _(2072, ZEND_SEND_VAL_EX_SPEC_CONST_CONST) \ + _(2077, ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED) \ + _(2078, ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK) \ + _(2081, ZEND_SEND_VAL_EX_SPEC_TMP_CONST) \ + _(2082, ZEND_SEND_VAL_EX_SPEC_TMP_CONST) \ + _(2087, ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED) \ + _(2088, ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK) \ + _(2131, ZEND_SEND_VAR_SPEC_VAR_CONST) \ + _(2134, ZEND_SEND_VAR_SPEC_VAR_UNUSED) \ + _(2141, ZEND_SEND_VAR_SPEC_CV_CONST) \ + _(2144, ZEND_SEND_VAR_SPEC_CV_UNUSED) \ + _(2146, ZEND_INIT_USER_CALL_SPEC_CONST_CONST) \ + _(2147, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \ + _(2148, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \ + _(2150, ZEND_INIT_USER_CALL_SPEC_CONST_CV) \ + _(2151, ZEND_SEND_ARRAY_SPEC) \ + _(2152, ZEND_SEND_USER_SPEC_CONST) \ + _(2153, ZEND_SEND_USER_SPEC_TMP) \ + _(2154, ZEND_SEND_USER_SPEC_VAR) \ + _(2156, ZEND_SEND_USER_SPEC_CV) \ + _(2157, ZEND_STRLEN_SPEC_CONST) \ + _(2158, ZEND_STRLEN_SPEC_TMPVAR) \ + _(2159, ZEND_STRLEN_SPEC_TMPVAR) \ + _(2161, ZEND_STRLEN_SPEC_CV) \ + _(2162, ZEND_DEFINED_SPEC_CONST) \ + _(2163, ZEND_TYPE_CHECK_SPEC_CONST) \ + _(2164, ZEND_TYPE_CHECK_SPEC_TMPVAR) \ + _(2165, ZEND_TYPE_CHECK_SPEC_TMPVAR) \ + _(2167, ZEND_TYPE_CHECK_SPEC_CV) \ + _(2168, ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED) \ + _(2169, ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED) \ + _(2170, ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED) \ + _(2171, ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED) \ + _(2172, ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED) \ + _(2173, ZEND_FE_RESET_RW_SPEC_CONST) \ + _(2174, ZEND_FE_RESET_RW_SPEC_TMP) \ + _(2175, ZEND_FE_RESET_RW_SPEC_VAR) \ + _(2177, ZEND_FE_RESET_RW_SPEC_CV) \ + _(2178, ZEND_FE_FETCH_RW_SPEC_VAR) \ + _(2179, ZEND_FE_FREE_SPEC_TMPVAR) \ + _(2180, ZEND_INIT_DYNAMIC_CALL_SPEC_CONST) \ + _(2181, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \ + _(2182, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \ + _(2184, ZEND_INIT_DYNAMIC_CALL_SPEC_CV) \ + _(2185, ZEND_DO_ICALL_SPEC_RETVAL_UNUSED) \ + _(2186, ZEND_DO_ICALL_SPEC_RETVAL_USED) \ + _(2187, ZEND_DO_UCALL_SPEC_RETVAL_UNUSED) \ + _(2188, ZEND_DO_UCALL_SPEC_RETVAL_USED) \ + _(2189, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED) \ + _(2190, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED) \ + _(2201, ZEND_PRE_INC_OBJ_SPEC_VAR_CONST) \ + _(2202, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \ + _(2203, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \ + _(2205, ZEND_PRE_INC_OBJ_SPEC_VAR_CV) \ + _(2206, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST) \ + _(2207, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2208, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2210, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV) \ + _(2211, ZEND_PRE_INC_OBJ_SPEC_CV_CONST) \ + _(2212, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \ + _(2213, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \ + _(2215, ZEND_PRE_INC_OBJ_SPEC_CV_CV) \ + _(2226, ZEND_POST_INC_OBJ_SPEC_VAR_CONST) \ + _(2227, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \ + _(2228, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \ + _(2230, ZEND_POST_INC_OBJ_SPEC_VAR_CV) \ + _(2231, ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST) \ + _(2232, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2233, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2235, ZEND_POST_INC_OBJ_SPEC_UNUSED_CV) \ + _(2236, ZEND_POST_INC_OBJ_SPEC_CV_CONST) \ + _(2237, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \ + _(2238, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \ + _(2240, ZEND_POST_INC_OBJ_SPEC_CV_CV) \ + _(2241, ZEND_ECHO_SPEC_CONST) \ + _(2242, ZEND_ECHO_SPEC_TMPVAR) \ + _(2243, ZEND_ECHO_SPEC_TMPVAR) \ + _(2245, ZEND_ECHO_SPEC_CV) \ + _(2252, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \ + _(2254, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \ + _(2255, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \ + _(2257, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \ + _(2259, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \ + _(2260, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \ + _(2267, ZEND_INSTANCEOF_SPEC_CV_CONST) \ + _(2269, ZEND_INSTANCEOF_SPEC_CV_VAR) \ + _(2270, ZEND_INSTANCEOF_SPEC_CV_UNUSED) \ + _(2272, ZEND_GENERATOR_CREATE_SPEC) \ + _(2275, ZEND_MAKE_REF_SPEC_VAR_UNUSED) \ + _(2277, ZEND_MAKE_REF_SPEC_CV_UNUSED) \ + _(2278, ZEND_DECLARE_FUNCTION_SPEC) \ + _(2279, ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED) \ + _(2280, ZEND_DECLARE_CONST_SPEC_CONST_CONST) \ + _(2281, ZEND_DECLARE_CLASS_SPEC_CONST) \ + _(2282, ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST) \ + _(2283, ZEND_DECLARE_ANON_CLASS_SPEC) \ + _(2284, ZEND_ADD_ARRAY_UNPACK_SPEC) \ + _(2285, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST) \ + _(2286, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \ + _(2287, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \ + _(2289, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV) \ + _(2290, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ + _(2291, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2292, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2294, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ + _(2295, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ + _(2296, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2297, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2299, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ + _(2300, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST) \ + _(2301, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2302, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2304, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV) \ + _(2305, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST) \ + _(2306, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ + _(2307, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ + _(2309, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV) \ + _(2310, ZEND_HANDLE_EXCEPTION_SPEC) \ + _(2311, ZEND_USER_OPCODE_SPEC) \ + _(2312, ZEND_ASSERT_CHECK_SPEC) \ + _(2313, ZEND_JMP_SET_SPEC_CONST) \ + _(2314, ZEND_JMP_SET_SPEC_TMP) \ + _(2315, ZEND_JMP_SET_SPEC_VAR) \ + _(2317, ZEND_JMP_SET_SPEC_CV) \ + _(2318, ZEND_UNSET_CV_SPEC_CV_UNUSED) \ + _(2319, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET) \ + _(2320, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY) \ + _(2321, ZEND_FETCH_LIST_W_SPEC_VAR_CONST) \ + _(2322, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ + _(2323, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ + _(2325, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \ + _(2326, ZEND_SEPARATE_SPEC_VAR_UNUSED) \ + _(2328, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \ + _(2329, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \ + _(2330, ZEND_FETCH_CLASS_NAME_SPEC_UNUSED) \ + _(2331, ZEND_FETCH_CLASS_NAME_SPEC_CV) \ + _(2332, ZEND_CALL_TRAMPOLINE_SPEC) \ + _(2333, ZEND_DISCARD_EXCEPTION_SPEC) \ + _(2334, ZEND_YIELD_SPEC_CONST_CONST) \ + _(2335, ZEND_YIELD_SPEC_CONST_TMPVAR) \ + _(2336, ZEND_YIELD_SPEC_CONST_TMPVAR) \ + _(2337, ZEND_YIELD_SPEC_CONST_UNUSED) \ + _(2338, ZEND_YIELD_SPEC_CONST_CV) \ + _(2339, ZEND_YIELD_SPEC_TMP_CONST) \ + _(2340, ZEND_YIELD_SPEC_TMP_TMPVAR) \ + _(2341, ZEND_YIELD_SPEC_TMP_TMPVAR) \ + _(2342, ZEND_YIELD_SPEC_TMP_UNUSED) \ + _(2343, ZEND_YIELD_SPEC_TMP_CV) \ + _(2344, ZEND_YIELD_SPEC_VAR_CONST) \ + _(2345, ZEND_YIELD_SPEC_VAR_TMPVAR) \ + _(2346, ZEND_YIELD_SPEC_VAR_TMPVAR) \ + _(2347, ZEND_YIELD_SPEC_VAR_UNUSED) \ + _(2348, ZEND_YIELD_SPEC_VAR_CV) \ + _(2349, ZEND_YIELD_SPEC_UNUSED_CONST) \ + _(2350, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \ + _(2351, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \ + _(2352, ZEND_YIELD_SPEC_UNUSED_UNUSED) \ + _(2353, ZEND_YIELD_SPEC_UNUSED_CV) \ + _(2354, ZEND_YIELD_SPEC_CV_CONST) \ + _(2355, ZEND_YIELD_SPEC_CV_TMPVAR) \ + _(2356, ZEND_YIELD_SPEC_CV_TMPVAR) \ + _(2357, ZEND_YIELD_SPEC_CV_UNUSED) \ + _(2358, ZEND_YIELD_SPEC_CV_CV) \ + _(2359, ZEND_GENERATOR_RETURN_SPEC_CONST) \ + _(2360, ZEND_GENERATOR_RETURN_SPEC_CONST_OBSERVER) \ + _(2361, ZEND_GENERATOR_RETURN_SPEC_TMP) \ + _(2362, ZEND_GENERATOR_RETURN_SPEC_TMP_OBSERVER) \ + _(2363, ZEND_GENERATOR_RETURN_SPEC_VAR) \ + _(2364, ZEND_GENERATOR_RETURN_SPEC_VAR_OBSERVER) \ + _(2367, ZEND_GENERATOR_RETURN_SPEC_CV) \ + _(2368, ZEND_GENERATOR_RETURN_SPEC_CV_OBSERVER) \ + _(2369, ZEND_FAST_CALL_SPEC) \ + _(2370, ZEND_FAST_RET_SPEC) \ + _(2371, ZEND_RECV_VARIADIC_SPEC_UNUSED) \ + _(2372, ZEND_SEND_UNPACK_SPEC) \ + _(2373, ZEND_YIELD_FROM_SPEC_CONST) \ + _(2374, ZEND_YIELD_FROM_SPEC_TMPVAR) \ + _(2375, ZEND_YIELD_FROM_SPEC_TMPVAR) \ + _(2377, ZEND_YIELD_FROM_SPEC_CV) \ + _(2378, ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED) \ + _(2379, ZEND_BIND_GLOBAL_SPEC_CV_CONST) \ + _(2380, ZEND_COALESCE_SPEC_CONST) \ + _(2381, ZEND_COALESCE_SPEC_TMP) \ + _(2382, ZEND_COALESCE_SPEC_VAR) \ + _(2384, ZEND_COALESCE_SPEC_CV) \ + _(2385, ZEND_SPACESHIP_SPEC_CONST_CONST) \ + _(2386, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ + _(2387, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ + _(2389, ZEND_SPACESHIP_SPEC_CONST_CV) \ + _(2390, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ + _(2391, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ + _(2392, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ + _(2394, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ + _(2395, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ + _(2396, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ + _(2397, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ + _(2399, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ + _(2405, ZEND_SPACESHIP_SPEC_CV_CONST) \ + _(2406, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ + _(2407, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ + _(2409, ZEND_SPACESHIP_SPEC_CV_CV) \ + _(2410, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED) \ + _(2411, ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED) \ + _(2414, ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED) \ + _(2416, ZEND_FETCH_STATIC_PROP_R_SPEC) \ + _(2417, ZEND_FETCH_STATIC_PROP_W_SPEC) \ + _(2418, ZEND_FETCH_STATIC_PROP_RW_SPEC) \ + _(2419, ZEND_FETCH_STATIC_PROP_IS_SPEC) \ + _(2420, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC) \ + _(2421, ZEND_FETCH_STATIC_PROP_UNSET_SPEC) \ + _(2422, ZEND_UNSET_STATIC_PROP_SPEC) \ + _(2423, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC) \ + _(2424, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) \ + _(2426, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) \ + _(2427, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST) \ + _(2429, ZEND_BIND_LEXICAL_SPEC_TMP_CV) \ + _(2430, ZEND_BIND_STATIC_SPEC_CV_UNUSED) \ + _(2431, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED) \ + _(2432, ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST) \ + _(2435, ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED) \ + _(2437, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED) \ + _(2438, ZEND_SWITCH_LONG_SPEC_CONST_CONST) \ + _(2439, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(2440, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(2442, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(2443, ZEND_SWITCH_STRING_SPEC_CONST_CONST) \ + _(2444, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(2445, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(2447, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(2448, ZEND_IN_ARRAY_SPEC_CONST_CONST) \ + _(2449, ZEND_IN_ARRAY_SPEC_TMP_CONST) \ + _(2450, ZEND_IN_ARRAY_SPEC_VAR_CONST) \ + _(2452, ZEND_IN_ARRAY_SPEC_CV_CONST) \ + _(2453, ZEND_COUNT_SPEC_CONST_UNUSED) \ + _(2454, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \ + _(2455, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \ + _(2457, ZEND_COUNT_SPEC_CV_UNUSED) \ + _(2458, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \ + _(2459, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \ + _(2460, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \ + _(2461, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED) \ + _(2462, ZEND_GET_CLASS_SPEC_CV_UNUSED) \ + _(2463, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED) \ + _(2464, ZEND_GET_TYPE_SPEC_CONST_UNUSED) \ + _(2465, ZEND_GET_TYPE_SPEC_TMP_UNUSED) \ + _(2466, ZEND_GET_TYPE_SPEC_VAR_UNUSED) \ + _(2468, ZEND_GET_TYPE_SPEC_CV_UNUSED) \ + _(2469, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \ + _(2470, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ + _(2471, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ + _(2473, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \ + _(2474, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ + _(2475, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(2476, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(2478, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ + _(2479, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ + _(2480, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(2481, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(2483, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ + _(2489, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \ + _(2490, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ + _(2491, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ + _(2493, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \ + _(2494, ZEND_MATCH_SPEC_CONST_CONST) \ + _(2495, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ + _(2496, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ + _(2498, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ + _(2504, ZEND_CASE_STRICT_SPEC_TMP_CONST) \ + _(2505, ZEND_CASE_STRICT_SPEC_TMP_TMP) \ + _(2506, ZEND_CASE_STRICT_SPEC_TMP_VAR) \ + _(2508, ZEND_CASE_STRICT_SPEC_TMP_CV) \ + _(2509, ZEND_CASE_STRICT_SPEC_VAR_CONST) \ + _(2510, ZEND_CASE_STRICT_SPEC_VAR_TMP) \ + _(2511, ZEND_CASE_STRICT_SPEC_VAR_VAR) \ + _(2513, ZEND_CASE_STRICT_SPEC_VAR_CV) \ + _(2524, ZEND_MATCH_ERROR_SPEC_CONST_UNUSED) \ + _(2525, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ + _(2526, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ + _(2528, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ + _(2529, ZEND_JMP_NULL_SPEC_CONST) \ + _(2530, ZEND_JMP_NULL_SPEC_TMPVARCV) \ + _(2531, ZEND_JMP_NULL_SPEC_TMPVARCV) \ + _(2533, ZEND_JMP_NULL_SPEC_TMPVARCV) \ + _(2534, ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED) \ + _(2535, ZEND_RECV_NOTYPE_SPEC) \ + _(2536, ZEND_JMP_FORWARD_SPEC) \ _(2542, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2543, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2544, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2546, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2552, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2553, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2554, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2556, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2557, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2558, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2559, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2561, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2547, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2548, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2549, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2551, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2557, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2558, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2559, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2561, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2567, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ _(2568, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2569, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2571, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2577, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2578, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2579, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2581, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2582, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2583, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2584, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2586, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2572, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2573, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2574, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2576, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2582, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2583, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2584, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2586, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2592, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2593, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2594, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2596, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2598, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2599, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2601, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2602, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2603, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2604, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2606, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2607, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2608, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2609, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2611, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2597, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2598, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2599, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2601, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2607, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2608, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2609, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2611, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2613, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2614, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2616, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ _(2617, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2618, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2619, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2621, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2623, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2624, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2626, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2627, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2628, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2629, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2631, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2632, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2633, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2634, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2636, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2622, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2623, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2624, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2626, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2632, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2633, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2634, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2636, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2638, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2639, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2641, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ _(2642, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ _(2643, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2644, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2646, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2648, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2649, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2651, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2652, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2653, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2654, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2656, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2657, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2658, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2659, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2661, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2647, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2648, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2649, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2651, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2657, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2658, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2659, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2661, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2663, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2664, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2666, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ _(2667, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2668, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2669, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2671, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2677, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2678, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2679, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2681, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2682, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2683, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2684, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2686, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2672, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2673, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2674, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2676, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2682, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2683, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2684, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2686, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2692, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2693, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2694, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2696, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2702, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2703, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2704, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2706, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2707, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2708, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2709, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2711, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2697, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2698, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2699, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2701, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2707, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2708, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2709, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2711, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2717, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ _(2718, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2719, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2721, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2727, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2728, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2729, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2731, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2732, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2733, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2734, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2736, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2722, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2723, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2724, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2726, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2732, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2733, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2734, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2736, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2742, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2743, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2744, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2746, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2762, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2763, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2764, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2765, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2766, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2767, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2768, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2769, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2770, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2774, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2775, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2776, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2747, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2748, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2749, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2751, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2757, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2758, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2759, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2761, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2777, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ _(2778, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ _(2779, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ @@ -1472,30 +1472,30 @@ _(2789, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2790, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(2791, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2807, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2808, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2809, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2810, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2811, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2812, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2813, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2814, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2815, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2819, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2820, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2821, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2837, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2838, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2839, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2840, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2841, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2842, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2843, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2844, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2845, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2849, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2850, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2851, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2792, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2793, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2794, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2795, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2796, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2797, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2798, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2799, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2800, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2804, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2805, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2806, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2822, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2823, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2824, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2825, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2826, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2827, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2828, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2829, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2830, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2834, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2835, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2836, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ _(2852, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2853, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ _(2854, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ @@ -1508,30 +1508,30 @@ _(2864, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2865, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(2866, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2882, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2883, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2884, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2885, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2886, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2887, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2888, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2889, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2890, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2894, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2895, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2896, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2912, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2913, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2914, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2915, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2916, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2917, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2918, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2919, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2920, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2924, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2925, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2926, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2867, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2868, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2869, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2870, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2871, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2872, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2873, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2874, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2875, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2879, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2880, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2881, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2897, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2898, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2899, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2900, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2901, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2902, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2903, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2904, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2905, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2909, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2910, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2911, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ _(2927, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ _(2928, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ _(2929, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ @@ -1544,30 +1544,30 @@ _(2939, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2940, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(2941, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2957, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2958, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2959, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2960, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2961, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2962, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2963, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2964, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2965, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2969, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2970, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2971, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2987, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2988, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2989, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2990, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2991, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2992, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2993, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2994, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2995, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2999, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3000, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3001, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2942, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2943, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2944, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2945, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2946, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2947, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2948, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2949, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2950, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2954, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2955, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2956, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2972, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2973, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2974, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2975, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2976, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2977, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2978, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2979, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2980, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2984, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2985, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2986, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ _(3002, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ _(3003, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ _(3004, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ @@ -1580,43 +1580,43 @@ _(3014, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(3015, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(3016, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3032, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3033, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3034, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3035, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3036, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3037, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3038, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3039, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3040, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3044, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3045, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3046, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3047, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(3051, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(3052, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(3056, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(3060, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3061, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3062, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3063, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3064, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3065, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3069, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3070, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3071, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3072, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3073, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3074, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3075, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3076, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3077, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3078, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3079, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3080, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3084, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3085, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3086, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3017, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3018, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3019, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3020, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3021, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3022, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3023, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3024, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3025, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3029, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3030, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3031, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3047, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3048, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3049, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3050, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3051, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3052, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3053, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3054, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3055, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3059, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3060, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3061, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3062, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3066, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3067, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3071, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3075, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3076, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3077, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3078, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3079, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3080, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3084, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3085, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3086, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ _(3087, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ _(3088, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ _(3089, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ @@ -1629,39 +1629,39 @@ _(3099, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(3100, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(3101, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3117, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3118, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3119, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3120, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3121, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3122, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3123, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3124, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3125, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3129, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3130, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3131, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3135, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3136, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3137, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3138, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3139, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3140, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3144, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3145, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3146, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3147, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3148, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3149, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3150, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3151, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3152, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3153, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3154, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3155, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3159, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3160, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3161, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3102, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3103, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3104, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3105, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3106, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3107, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3108, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3109, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3110, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3114, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3115, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3116, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3132, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3133, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3134, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3135, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3136, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3137, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3138, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3139, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3140, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3144, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3145, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3146, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3150, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3151, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3152, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3153, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3154, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3155, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3159, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3160, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3161, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ _(3162, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ _(3163, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ _(3164, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ @@ -1674,39 +1674,39 @@ _(3174, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(3175, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(3176, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3192, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3193, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3194, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3195, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3196, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3197, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3198, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3199, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3200, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3204, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3205, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3206, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3210, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3211, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3212, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3213, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3214, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3215, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3219, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3220, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3221, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3222, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3223, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3224, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3225, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3226, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3227, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3228, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3229, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3230, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3234, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3235, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3236, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3177, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3178, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3179, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3180, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3181, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3182, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3183, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3184, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3185, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3189, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3190, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3191, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3207, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3208, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3209, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3210, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3211, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3212, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3213, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3214, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3215, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3219, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3220, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3221, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3225, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3226, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3227, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3228, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3229, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3230, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3234, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3235, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3236, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ _(3237, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ _(3238, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ _(3239, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ @@ -1719,39 +1719,39 @@ _(3249, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(3250, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(3251, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3267, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3268, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3269, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3270, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3271, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3272, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3273, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3274, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3275, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3279, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3280, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3281, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3285, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3286, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3287, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3288, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3289, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3290, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3294, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3295, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3296, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3297, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3298, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3299, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3300, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3301, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3302, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3303, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3304, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3305, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3309, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3310, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3311, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3252, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3253, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3254, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3255, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3256, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3257, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3258, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3259, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3260, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3264, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3265, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3266, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3282, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3283, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3284, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3285, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3286, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3287, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3288, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3289, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3290, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3294, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3295, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3296, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3300, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3301, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3302, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3303, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3304, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3305, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3309, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3310, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3311, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ _(3312, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ _(3313, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ _(3314, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ @@ -1764,63 +1764,75 @@ _(3324, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(3325, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(3326, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3342, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3343, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3344, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3345, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3346, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3347, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3348, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3349, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3350, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3354, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3355, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3356, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3357, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3358, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3359, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3360, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ - _(3361, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3362, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3363, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3364, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ - _(3365, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3366, ZEND_POST_INC_LONG_SPEC_CV) \ - _(3367, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3368, ZEND_POST_DEC_LONG_SPEC_CV) \ - _(3369, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ - _(3370, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3371, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3373, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3374, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ - _(3375, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3376, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3378, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3379, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ - _(3380, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3381, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3383, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3385, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3386, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3388, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3389, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(3390, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3391, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3393, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3394, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(3395, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3396, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3398, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3404, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ - _(3405, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3406, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3408, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3411, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ - _(3413, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ - _(3416, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ - _(3418, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ - _(3419, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ - _(3420, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ - _(3421, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ - _(3422, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ - _(3422+1, ZEND_NULL) + _(3327, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3328, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3329, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3330, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3331, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3332, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3333, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3334, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3335, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3339, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3340, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3341, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3357, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3358, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3359, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3360, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3361, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3362, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3363, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3364, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3365, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3369, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3370, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3371, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3372, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3373, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3374, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3375, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ + _(3376, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3377, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3378, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3379, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ + _(3380, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3381, ZEND_POST_INC_LONG_SPEC_CV) \ + _(3382, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3383, ZEND_POST_DEC_LONG_SPEC_CV) \ + _(3384, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ + _(3385, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3386, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3388, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3389, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ + _(3390, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3391, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3393, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3394, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ + _(3395, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3396, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3398, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3400, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3401, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3403, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3404, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3405, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3406, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3408, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3409, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3410, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3411, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3413, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3419, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ + _(3420, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3421, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3423, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3426, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ + _(3428, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ + _(3431, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ + _(3433, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ + _(3434, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ + _(3435, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ + _(3436, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ + _(3437, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ + _(3437+1, ZEND_NULL) From c57324d73898f2afff9aa018c356b08e6fbf5a7b Mon Sep 17 00:00:00 2001 From: Sammy Powers Date: Wed, 26 Aug 2020 10:44:03 -0700 Subject: [PATCH 32/53] Add SPEC(OBSERVER) to DO_FCALL and friends --- Zend/zend_execute.c | 8 - Zend/zend_observer.c | 8 + Zend/zend_observer.h | 14 + Zend/zend_vm_def.h | 18 +- Zend/zend_vm_execute.h | 954 +++++++++++++--- Zend/zend_vm_gen.php | 8 +- Zend/zend_vm_handlers.h | 2365 ++++++++++++++++++++------------------- 7 files changed, 2013 insertions(+), 1362 deletions(-) diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c index 82560bbb33809..b704965000d53 100644 --- a/Zend/zend_execute.c +++ b/Zend/zend_execute.c @@ -3541,14 +3541,6 @@ static zend_always_inline void i_init_func_execute_data(zend_op_array *op_array, EX(run_time_cache) = RUN_TIME_CACHE(op_array); EG(current_execute_data) = execute_data; - - if (ZEND_SHOULD_OBSERVE_FN(op_array->fn_flags) && !(op_array->fn_flags & ZEND_ACC_GENERATOR)) { - void *observer_handlers = ZEND_OBSERVER_HANDLERS(&EX(func)->op_array); - ZEND_ASSERT(observer_handlers); - if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { - zend_observe_fcall_begin(observer_handlers, execute_data); - } - } } /* }}} */ diff --git a/Zend/zend_observer.c b/Zend/zend_observer.c index dcc9ed546fc8f..c8b14ed5949fb 100644 --- a/Zend/zend_observer.c +++ b/Zend/zend_observer.c @@ -21,12 +21,15 @@ #include "zend_extensions.h" #include "zend_llist.h" +#include "zend_vm.h" zend_llist zend_observers_fcall_list; int zend_observer_fcall_op_array_extension = -1; ZEND_TLS zend_arena *fcall_handlers_arena = NULL; +ZEND_API extern inline void zend_observer_maybe_fcall_call_begin( + zend_execute_data *execute_data); ZEND_API extern inline void zend_observer_maybe_fcall_call_end( zend_execute_data *execute_data, zval *return_value); @@ -37,6 +40,11 @@ ZEND_API void zend_observer_fcall_register(zend_observer_fcall_init init) { if (!ZEND_OBSERVER_ENABLED) { zend_observer_fcall_op_array_extension = zend_get_op_array_extension_handle(); + + /* ZEND_CALL_TRAMPOLINE has SPEC(OBSERVER) but zend_init_call_trampoline_op() + * is called before any extensions have registered as an observer. So we + * adjust the offset to the observed handler when we know we need to observe. */ + ZEND_VM_SET_OPCODE_HANDLER(&EG(call_trampoline_op)); } zend_llist_add_element(&zend_observers_fcall_list, &init); } diff --git a/Zend/zend_observer.h b/Zend/zend_observer.h index e344caef3a737..fe7aa5b61607b 100644 --- a/Zend/zend_observer.h +++ b/Zend/zend_observer.h @@ -78,6 +78,20 @@ ZEND_API void zend_observer_fcall_call_end_helper( zend_execute_data *execute_data, zval *return_value); +ZEND_API zend_always_inline void zend_observer_maybe_fcall_call_begin( + zend_execute_data *execute_data) +{ + zend_op_array *op_array = (zend_op_array *)execute_data->func; + if (ZEND_SHOULD_OBSERVE_FN(op_array->fn_flags) && + !(op_array->fn_flags & ZEND_ACC_GENERATOR)) { + void *observer_handlers = ZEND_OBSERVER_HANDLERS(&EX(func)->op_array); + ZEND_ASSERT(observer_handlers); + if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { + zend_observe_fcall_begin(observer_handlers, execute_data); + } + } +} + ZEND_API zend_always_inline void zend_observer_maybe_fcall_call_end( zend_execute_data *execute_data, zval *return_value) diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 05d264d009ce1..661de5b2c04f3 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -3928,7 +3928,7 @@ ZEND_VM_HOT_HANDLER(129, ZEND_DO_ICALL, ANY, ANY, SPEC(RETVAL)) ZEND_VM_CONTINUE(); } -ZEND_VM_HOT_HANDLER(130, ZEND_DO_UCALL, ANY, ANY, SPEC(RETVAL)) +ZEND_VM_HOT_HANDLER(130, ZEND_DO_UCALL, ANY, ANY, SPEC(RETVAL,OBSERVER)) { USE_OPLINE zend_execute_data *call = EX(call); @@ -3948,11 +3948,12 @@ ZEND_VM_HOT_HANDLER(130, ZEND_DO_UCALL, ANY, ANY, SPEC(RETVAL)) call->prev_execute_data = execute_data; execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); + OBSERVER_FCALL_BEGIN_HANDLERS(execute_data); ZEND_VM_ENTER_EX(); } -ZEND_VM_HOT_HANDLER(131, ZEND_DO_FCALL_BY_NAME, ANY, ANY, SPEC(RETVAL)) +ZEND_VM_HOT_HANDLER(131, ZEND_DO_FCALL_BY_NAME, ANY, ANY, SPEC(RETVAL,OBSERVER)) { USE_OPLINE zend_execute_data *call = EX(call); @@ -3971,6 +3972,7 @@ ZEND_VM_HOT_HANDLER(131, ZEND_DO_FCALL_BY_NAME, ANY, ANY, SPEC(RETVAL)) call->prev_execute_data = execute_data; execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); + OBSERVER_FCALL_BEGIN_HANDLERS(execute_data); LOAD_OPLINE_EX(); ZEND_VM_ENTER_EX(); @@ -4042,7 +4044,7 @@ ZEND_VM_C_LABEL(fcall_by_name_end): ZEND_VM_CONTINUE(); } -ZEND_VM_HOT_HANDLER(60, ZEND_DO_FCALL, ANY, ANY, SPEC(RETVAL)) +ZEND_VM_HOT_HANDLER(60, ZEND_DO_FCALL, ANY, ANY, SPEC(RETVAL,OBSERVER)) { USE_OPLINE zend_execute_data *call = EX(call); @@ -4061,6 +4063,7 @@ ZEND_VM_HOT_HANDLER(60, ZEND_DO_FCALL, ANY, ANY, SPEC(RETVAL)) call->prev_execute_data = execute_data; execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 1 EXECUTE_DATA_CC); + OBSERVER_FCALL_BEGIN_HANDLERS(execute_data); if (EXPECTED(zend_execute_ex == execute_ex)) { LOAD_OPLINE_EX(); @@ -4279,7 +4282,7 @@ ZEND_VM_INLINE_HANDLER(62, ZEND_RETURN, CONST|TMP|VAR|CV, ANY, SPEC(OBSERVER)) } } } - OBSERVER_END_HANDLERS(execute_data, return_value); + OBSERVER_FCALL_END_HANDLERS(execute_data, return_value); ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper); } @@ -4340,7 +4343,7 @@ ZEND_VM_COLD_CONST_HANDLER(111, ZEND_RETURN_BY_REF, CONST|TMP|VAR|CV, ANY, SRC, FREE_OP1_VAR_PTR(); } while (0); - OBSERVER_END_HANDLERS(execute_data, EX(return_value)); + OBSERVER_FCALL_END_HANDLERS(execute_data, EX(return_value)); ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper); } @@ -4456,7 +4459,7 @@ ZEND_VM_HANDLER(161, ZEND_GENERATOR_RETURN, CONST|TMP|VAR|CV, ANY, SPEC(OBSERVER } } - OBSERVER_END_HANDLERS(generator->execute_data, &generator->retval); + OBSERVER_FCALL_END_HANDLERS(generator->execute_data, &generator->retval); /* Close the generator to free up resources */ zend_generator_close(generator, 1); @@ -8395,7 +8398,7 @@ ZEND_VM_HANDLER(157, ZEND_FETCH_CLASS_NAME, CV|TMPVAR|UNUSED|CLASS_FETCH, ANY) ZEND_VM_NEXT_OPCODE(); } -ZEND_VM_HANDLER(158, ZEND_CALL_TRAMPOLINE, ANY, ANY) +ZEND_VM_HANDLER(158, ZEND_CALL_TRAMPOLINE, ANY, ANY, SPEC(OBSERVER)) { zend_array *args = NULL; zend_function *fbc = EX(func); @@ -8453,6 +8456,7 @@ ZEND_VM_HANDLER(158, ZEND_CALL_TRAMPOLINE, ANY, ANY) } execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); + OBSERVER_FCALL_BEGIN_HANDLERS(execute_data); if (EXPECTED(zend_execute_ex == execute_ex)) { LOAD_OPLINE_EX(); ZEND_VM_ENTER_EX(); diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index f59bd911b46da..b67eb8bea1498 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -1380,6 +1380,56 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_RETV ZEND_VM_ENTER_EX(); } +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_execute_data *call = EX(call); + zend_function *fbc = call->func; + zval *ret; + + SAVE_OPLINE(); + EX(call) = call->prev_execute_data; + + ret = NULL; + if (0) { + ret = EX_VAR(opline->result.var); + } + + LOAD_OPLINE_EX(); + + call->prev_execute_data = execute_data; + execute_data = call; + i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); + zend_observer_maybe_fcall_call_begin(execute_data); + + ZEND_VM_ENTER_EX(); +} + +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_RETVAL_USED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_execute_data *call = EX(call); + zend_function *fbc = call->func; + zval *ret; + + SAVE_OPLINE(); + EX(call) = call->prev_execute_data; + + ret = NULL; + if (1) { + ret = EX_VAR(opline->result.var); + } + + LOAD_OPLINE_EX(); + + call->prev_execute_data = execute_data; + execute_data = call; + i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); + zend_observer_maybe_fcall_call_begin(execute_data); + + ZEND_VM_ENTER_EX(); +} + static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -1399,6 +1449,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_S call->prev_execute_data = execute_data; execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); + LOAD_OPLINE_EX(); ZEND_VM_ENTER_EX(); @@ -1489,6 +1540,189 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_S call->prev_execute_data = execute_data; execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); + + LOAD_OPLINE_EX(); + + ZEND_VM_ENTER_EX(); + } else { + zval retval; + ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION); + + if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) { + zend_deprecated_function(fbc); + if (UNEXPECTED(EG(exception) != NULL)) { + UNDEF_RESULT(); + if (!1) { + ret = &retval; + ZVAL_UNDEF(ret); + } + goto fcall_by_name_end; + } + } + + call->prev_execute_data = execute_data; + EG(current_execute_data) = call; + +#if ZEND_DEBUG + zend_bool should_throw = zend_internal_call_should_throw(fbc, call); +#endif + + ret = 1 ? EX_VAR(opline->result.var) : &retval; + ZVAL_NULL(ret); + + fbc->internal_function.handler(call, ret); + +#if ZEND_DEBUG + if (!EG(exception) && call->func) { + if (should_throw) { + zend_internal_call_arginfo_violation(call->func); + } + ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) || + zend_verify_internal_return_type(call->func, ret)); + ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) + ? Z_ISREF_P(ret) : !Z_ISREF_P(ret)); + } +#endif + + EG(current_execute_data) = execute_data; + +fcall_by_name_end: + zend_vm_stack_free_args(call); + + uint32_t call_info = ZEND_CALL_INFO(call); + if (UNEXPECTED(call_info & (ZEND_CALL_HAS_EXTRA_NAMED_PARAMS|ZEND_CALL_ALLOCATED))) { + if (call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) { + zend_free_extra_named_params(call->extra_named_params); + } + zend_vm_stack_free_call_frame_ex(call_info, call); + } else { + EG(vm_stack_top) = (zval*)call; + } + + if (!1) { + i_zval_ptr_dtor(ret); + } + } + + if (UNEXPECTED(EG(exception) != NULL)) { + zend_rethrow_exception(execute_data); + HANDLE_EXCEPTION(); + } + ZEND_VM_SET_OPCODE(opline + 1); + ZEND_VM_CONTINUE(); +} + +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_execute_data *call = EX(call); + zend_function *fbc = call->func; + zval *ret; + + SAVE_OPLINE(); + EX(call) = call->prev_execute_data; + + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) { + ret = NULL; + if (0) { + ret = EX_VAR(opline->result.var); + } + + call->prev_execute_data = execute_data; + execute_data = call; + i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); + zend_observer_maybe_fcall_call_begin(execute_data); + LOAD_OPLINE_EX(); + + ZEND_VM_ENTER_EX(); + } else { + zval retval; + ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION); + + if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) { + zend_deprecated_function(fbc); + if (UNEXPECTED(EG(exception) != NULL)) { + UNDEF_RESULT(); + if (!0) { + ret = &retval; + ZVAL_UNDEF(ret); + } + goto fcall_by_name_end; + } + } + + call->prev_execute_data = execute_data; + EG(current_execute_data) = call; + +#if ZEND_DEBUG + zend_bool should_throw = zend_internal_call_should_throw(fbc, call); +#endif + + ret = 0 ? EX_VAR(opline->result.var) : &retval; + ZVAL_NULL(ret); + + fbc->internal_function.handler(call, ret); + +#if ZEND_DEBUG + if (!EG(exception) && call->func) { + if (should_throw) { + zend_internal_call_arginfo_violation(call->func); + } + ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) || + zend_verify_internal_return_type(call->func, ret)); + ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) + ? Z_ISREF_P(ret) : !Z_ISREF_P(ret)); + } +#endif + + EG(current_execute_data) = execute_data; + +fcall_by_name_end: + zend_vm_stack_free_args(call); + + uint32_t call_info = ZEND_CALL_INFO(call); + if (UNEXPECTED(call_info & (ZEND_CALL_HAS_EXTRA_NAMED_PARAMS|ZEND_CALL_ALLOCATED))) { + if (call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) { + zend_free_extra_named_params(call->extra_named_params); + } + zend_vm_stack_free_call_frame_ex(call_info, call); + } else { + EG(vm_stack_top) = (zval*)call; + } + + if (!0) { + i_zval_ptr_dtor(ret); + } + } + + if (UNEXPECTED(EG(exception) != NULL)) { + zend_rethrow_exception(execute_data); + HANDLE_EXCEPTION(); + } + ZEND_VM_SET_OPCODE(opline + 1); + ZEND_VM_CONTINUE(); +} + +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_execute_data *call = EX(call); + zend_function *fbc = call->func; + zval *ret; + + SAVE_OPLINE(); + EX(call) = call->prev_execute_data; + + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) { + ret = NULL; + if (1) { + ret = EX_VAR(opline->result.var); + } + + call->prev_execute_data = execute_data; + execute_data = call; + i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); + zend_observer_maybe_fcall_call_begin(execute_data); LOAD_OPLINE_EX(); ZEND_VM_ENTER_EX(); @@ -1764,6 +1998,212 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETV ZEND_VM_CONTINUE(); } +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_execute_data *call = EX(call); + zend_function *fbc = call->func; + zval *ret; + + SAVE_OPLINE(); + EX(call) = call->prev_execute_data; + + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) { + ret = NULL; + if (0) { + ret = EX_VAR(opline->result.var); + } + + call->prev_execute_data = execute_data; + execute_data = call; + i_init_func_execute_data(&fbc->op_array, ret, 1 EXECUTE_DATA_CC); + zend_observer_maybe_fcall_call_begin(execute_data); + + if (EXPECTED(zend_execute_ex == execute_ex)) { + LOAD_OPLINE_EX(); + ZEND_VM_ENTER_EX(); + } else { + SAVE_OPLINE_EX(); + execute_data = EX(prev_execute_data); + LOAD_OPLINE(); + ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP); + zend_execute_ex(call); + } + } else { + zval retval; + ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION); + + if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) { + zend_deprecated_function(fbc); + if (UNEXPECTED(EG(exception) != NULL)) { + UNDEF_RESULT(); + if (!0) { + ret = &retval; + ZVAL_UNDEF(ret); + } + goto fcall_end; + } + } + + call->prev_execute_data = execute_data; + EG(current_execute_data) = call; + +#if ZEND_DEBUG + zend_bool should_throw = zend_internal_call_should_throw(fbc, call); +#endif + + ret = 0 ? EX_VAR(opline->result.var) : &retval; + ZVAL_NULL(ret); + + if (!zend_execute_internal) { + /* saves one function call if zend_execute_internal is not used */ + fbc->internal_function.handler(call, ret); + } else { + zend_execute_internal(call, ret); + } + +#if ZEND_DEBUG + if (!EG(exception) && call->func) { + if (should_throw) { + zend_internal_call_arginfo_violation(call->func); + } + ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) || + zend_verify_internal_return_type(call->func, ret)); + ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) + ? Z_ISREF_P(ret) : !Z_ISREF_P(ret)); + } +#endif + + EG(current_execute_data) = execute_data; + +fcall_end: + zend_vm_stack_free_args(call); + if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) { + zend_free_extra_named_params(call->extra_named_params); + } + + if (!0) { + i_zval_ptr_dtor(ret); + } + } + + if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_RELEASE_THIS)) { + OBJ_RELEASE(Z_OBJ(call->This)); + } + + zend_vm_stack_free_call_frame(call); + if (UNEXPECTED(EG(exception) != NULL)) { + zend_rethrow_exception(execute_data); + HANDLE_EXCEPTION(); + } + + ZEND_VM_SET_OPCODE(opline + 1); + ZEND_VM_CONTINUE(); +} + +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETVAL_USED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_execute_data *call = EX(call); + zend_function *fbc = call->func; + zval *ret; + + SAVE_OPLINE(); + EX(call) = call->prev_execute_data; + + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) { + ret = NULL; + if (1) { + ret = EX_VAR(opline->result.var); + } + + call->prev_execute_data = execute_data; + execute_data = call; + i_init_func_execute_data(&fbc->op_array, ret, 1 EXECUTE_DATA_CC); + zend_observer_maybe_fcall_call_begin(execute_data); + + if (EXPECTED(zend_execute_ex == execute_ex)) { + LOAD_OPLINE_EX(); + ZEND_VM_ENTER_EX(); + } else { + SAVE_OPLINE_EX(); + execute_data = EX(prev_execute_data); + LOAD_OPLINE(); + ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP); + zend_execute_ex(call); + } + } else { + zval retval; + ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION); + + if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) { + zend_deprecated_function(fbc); + if (UNEXPECTED(EG(exception) != NULL)) { + UNDEF_RESULT(); + if (!1) { + ret = &retval; + ZVAL_UNDEF(ret); + } + goto fcall_end; + } + } + + call->prev_execute_data = execute_data; + EG(current_execute_data) = call; + +#if ZEND_DEBUG + zend_bool should_throw = zend_internal_call_should_throw(fbc, call); +#endif + + ret = 1 ? EX_VAR(opline->result.var) : &retval; + ZVAL_NULL(ret); + + if (!zend_execute_internal) { + /* saves one function call if zend_execute_internal is not used */ + fbc->internal_function.handler(call, ret); + } else { + zend_execute_internal(call, ret); + } + +#if ZEND_DEBUG + if (!EG(exception) && call->func) { + if (should_throw) { + zend_internal_call_arginfo_violation(call->func); + } + ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) || + zend_verify_internal_return_type(call->func, ret)); + ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) + ? Z_ISREF_P(ret) : !Z_ISREF_P(ret)); + } +#endif + + EG(current_execute_data) = execute_data; + +fcall_end: + zend_vm_stack_free_args(call); + if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) { + zend_free_extra_named_params(call->extra_named_params); + } + + if (!1) { + i_zval_ptr_dtor(ret); + } + } + + if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_RELEASE_THIS)) { + OBJ_RELEASE(Z_OBJ(call->This)); + } + + zend_vm_stack_free_call_frame(call); + if (UNEXPECTED(EG(exception) != NULL)) { + zend_rethrow_exception(execute_data); + HANDLE_EXCEPTION(); + } + + ZEND_VM_SET_OPCODE(opline + 1); + ZEND_VM_CONTINUE(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_CREATE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { zval *return_value = EX(return_value); @@ -2881,6 +3321,141 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CALL_TRAMPOLINE_SPEC_HANDLER(Z } execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); + + if (EXPECTED(zend_execute_ex == execute_ex)) { + LOAD_OPLINE_EX(); + ZEND_VM_ENTER_EX(); + } else { + SAVE_OPLINE_EX(); + execute_data = EX(prev_execute_data); + LOAD_OPLINE(); + ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP); + zend_execute_ex(call); + } + } else { + zval retval; + + ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION); + + EG(current_execute_data) = call; + +#if ZEND_DEBUG + zend_bool should_throw = zend_internal_call_should_throw(fbc, call); +#endif + + if (ret == NULL) { + ret = &retval; + } + + ZVAL_NULL(ret); + if (!zend_execute_internal) { + /* saves one function call if zend_execute_internal is not used */ + fbc->internal_function.handler(call, ret); + } else { + zend_execute_internal(call, ret); + } + +#if ZEND_DEBUG + if (!EG(exception) && call->func) { + if (should_throw) { + zend_internal_call_arginfo_violation(call->func); + } + ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) || + zend_verify_internal_return_type(call->func, ret)); + ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) + ? Z_ISREF_P(ret) : !Z_ISREF_P(ret)); + } +#endif + + EG(current_execute_data) = call->prev_execute_data; + + zend_vm_stack_free_args(call); + if (ret == &retval) { + zval_ptr_dtor(ret); + } + } + + execute_data = EG(current_execute_data); + + if (!EX(func) || !ZEND_USER_CODE(EX(func)->type) || (call_info & ZEND_CALL_TOP)) { + ZEND_VM_RETURN(); + } + + if (UNEXPECTED(call_info & ZEND_CALL_RELEASE_THIS)) { + zend_object *object = Z_OBJ(call->This); + OBJ_RELEASE(object); + } + zend_vm_stack_free_call_frame(call); + + if (UNEXPECTED(EG(exception) != NULL)) { + zend_rethrow_exception(execute_data); + HANDLE_EXCEPTION_LEAVE(); + } + + LOAD_OPLINE(); + ZEND_VM_INC_OPCODE(); + ZEND_VM_LEAVE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + zend_array *args = NULL; + zend_function *fbc = EX(func); + zval *ret = EX(return_value); + uint32_t call_info = EX_CALL_INFO() & (ZEND_CALL_NESTED | ZEND_CALL_TOP | ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_EXTRA_NAMED_PARAMS); + uint32_t num_args = EX_NUM_ARGS(); + zend_execute_data *call; + + SAVE_OPLINE(); + + if (num_args) { + zval *p = ZEND_CALL_ARG(execute_data, 1); + zval *end = p + num_args; + + args = zend_new_array(num_args); + zend_hash_real_init_packed(args); + ZEND_HASH_FILL_PACKED(args) { + do { + ZEND_HASH_FILL_ADD(p); + p++; + } while (p != end); + } ZEND_HASH_FILL_END(); + } + + call = execute_data; + execute_data = EG(current_execute_data) = EX(prev_execute_data); + + call->func = (fbc->op_array.fn_flags & ZEND_ACC_STATIC) ? fbc->op_array.scope->__callstatic : fbc->op_array.scope->__call; + ZEND_ASSERT(zend_vm_calc_used_stack(2, call->func) <= (size_t)(((char*)EG(vm_stack_end)) - (char*)call)); + ZEND_CALL_NUM_ARGS(call) = 2; + + ZVAL_STR(ZEND_CALL_ARG(call, 1), fbc->common.function_name); + + zval *call_args = ZEND_CALL_ARG(call, 2); + if (args) { + ZVAL_ARR(call_args, args); + } else { + ZVAL_EMPTY_ARRAY(call_args); + } + if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) { + if (zend_hash_num_elements(Z_ARRVAL_P(call_args)) == 0) { + GC_ADDREF(call->extra_named_params); + ZVAL_ARR(call_args, call->extra_named_params); + } else { + SEPARATE_ARRAY(call_args); + zend_hash_copy(Z_ARRVAL_P(call_args), call->extra_named_params, zval_add_ref); + } + } + zend_free_trampoline(fbc); + fbc = call->func; + + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) { + if (UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + } + execute_data = call; + i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); + zend_observer_maybe_fcall_call_begin(execute_data); if (EXPECTED(zend_execute_ex == execute_ex)) { LOAD_OPLINE_EX(); ZEND_VM_ENTER_EX(); @@ -51980,6 +52555,8 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_LABEL, (void*)&&ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_LABEL, (void*)&&ZEND_DO_FCALL_SPEC_RETVAL_USED_LABEL, + (void*)&&ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_OBSERVER_LABEL, + (void*)&&ZEND_DO_FCALL_SPEC_RETVAL_USED_OBSERVER_LABEL, (void*)&&ZEND_INIT_FCALL_SPEC_CONST_LABEL, (void*)&&ZEND_RETURN_SPEC_CONST_LABEL, (void*)&&ZEND_RETURN_SPEC_CONST_OBSERVER_LABEL, @@ -52817,8 +53394,12 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_DO_ICALL_SPEC_RETVAL_USED_LABEL, (void*)&&ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_LABEL, (void*)&&ZEND_DO_UCALL_SPEC_RETVAL_USED_LABEL, + (void*)&&ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_OBSERVER_LABEL, + (void*)&&ZEND_DO_UCALL_SPEC_RETVAL_USED_OBSERVER_LABEL, (void*)&&ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_LABEL, (void*)&&ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_LABEL, + (void*)&&ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_OBSERVER_LABEL, + (void*)&&ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_OBSERVER_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -52961,6 +53542,7 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_LABEL, (void*)&&ZEND_FETCH_CLASS_NAME_SPEC_CV_LABEL, (void*)&&ZEND_CALL_TRAMPOLINE_SPEC_LABEL, + (void*)&&ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER_LABEL, (void*)&&ZEND_DISCARD_EXCEPTION_SPEC_LABEL, (void*)&&ZEND_YIELD_SPEC_CONST_CONST_LABEL, (void*)&&ZEND_YIELD_SPEC_CONST_TMPVAR_LABEL, @@ -54293,6 +54875,14 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_DO_UCALL_SPEC_RETVAL_USED) ZEND_DO_UCALL_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_OBSERVER): + VM_TRACE(ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_OBSERVER) + ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); + HYBRID_CASE(ZEND_DO_UCALL_SPEC_RETVAL_USED_OBSERVER): + VM_TRACE(ZEND_DO_UCALL_SPEC_RETVAL_USED_OBSERVER) + ZEND_DO_UCALL_SPEC_RETVAL_USED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED): VM_TRACE(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED) ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -54301,6 +54891,14 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED) ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_OBSERVER): + VM_TRACE(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_OBSERVER) + ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); + HYBRID_CASE(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_OBSERVER): + VM_TRACE(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_OBSERVER) + ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_DO_FCALL_SPEC_RETVAL_UNUSED): VM_TRACE(ZEND_DO_FCALL_SPEC_RETVAL_UNUSED) ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -54309,6 +54907,14 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_DO_FCALL_SPEC_RETVAL_USED) ZEND_DO_FCALL_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_OBSERVER): + VM_TRACE(ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_OBSERVER) + ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); + HYBRID_CASE(ZEND_DO_FCALL_SPEC_RETVAL_USED_OBSERVER): + VM_TRACE(ZEND_DO_FCALL_SPEC_RETVAL_USED_OBSERVER) + ZEND_DO_FCALL_SPEC_RETVAL_USED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_GENERATOR_CREATE_SPEC): VM_TRACE(ZEND_GENERATOR_CREATE_SPEC) ZEND_GENERATOR_CREATE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -54405,6 +55011,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_CALL_TRAMPOLINE_SPEC) ZEND_CALL_TRAMPOLINE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER): + VM_TRACE(ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER) + ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_JMP_FORWARD_SPEC): VM_TRACE(ZEND_JMP_FORWARD_SPEC) ZEND_JMP_FORWARD_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -60199,6 +60809,8 @@ void zend_vm_init(void) ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER, ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_HANDLER, ZEND_DO_FCALL_SPEC_RETVAL_USED_HANDLER, + ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_OBSERVER_HANDLER, + ZEND_DO_FCALL_SPEC_RETVAL_USED_OBSERVER_HANDLER, ZEND_INIT_FCALL_SPEC_CONST_HANDLER, ZEND_RETURN_SPEC_CONST_HANDLER, ZEND_RETURN_SPEC_CONST_OBSERVER_HANDLER, @@ -61036,8 +61648,12 @@ void zend_vm_init(void) ZEND_DO_ICALL_SPEC_RETVAL_USED_HANDLER, ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_HANDLER, ZEND_DO_UCALL_SPEC_RETVAL_USED_HANDLER, + ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_OBSERVER_HANDLER, + ZEND_DO_UCALL_SPEC_RETVAL_USED_OBSERVER_HANDLER, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_HANDLER, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_HANDLER, + ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_OBSERVER_HANDLER, + ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_OBSERVER_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, @@ -61180,6 +61796,7 @@ void zend_vm_init(void) ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_HANDLER, ZEND_FETCH_CLASS_NAME_SPEC_CV_HANDLER, ZEND_CALL_TRAMPOLINE_SPEC_HANDLER, + ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER_HANDLER, ZEND_DISCARD_EXCEPTION_SPEC_HANDLER, ZEND_YIELD_SPEC_CONST_CONST_HANDLER, ZEND_YIELD_SPEC_CONST_TMPVAR_HANDLER, @@ -62348,147 +62965,147 @@ void zend_vm_init(void) 1347, 1348, 1349, - 1350 | SPEC_RULE_RETVAL, - 1352, - 1353 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, - 1363, - 1364, - 1365 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1390 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, - 1440 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1465 | SPEC_RULE_OP1, - 1470, - 1471, - 1472 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1497 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1522 | SPEC_RULE_OP1, - 1527 | SPEC_RULE_OP1, - 1532 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1557 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1582 | SPEC_RULE_OP1, - 1587, - 1588, - 1589 | SPEC_RULE_OP1, - 1594 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1619 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1644 | SPEC_RULE_OP1, - 1649 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1674 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1699 | SPEC_RULE_OP1, - 1704 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1729 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1754 | SPEC_RULE_OP1, - 1759 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1784 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1809 | SPEC_RULE_OP1, - 1814 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1839 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1864 | SPEC_RULE_OP1, - 1869 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1894 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1919 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1944, - 1945 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, - 1955, - 1956, + 1350 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, + 1354, + 1355 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, + 1365, + 1366, + 1367 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1392 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, + 1442 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1467 | SPEC_RULE_OP1, + 1472, + 1473, + 1474 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1499 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1524 | SPEC_RULE_OP1, + 1529 | SPEC_RULE_OP1, + 1534 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1559 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1584 | SPEC_RULE_OP1, + 1589, + 1590, + 1591 | SPEC_RULE_OP1, + 1596 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1621 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1646 | SPEC_RULE_OP1, + 1651 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1676 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1701 | SPEC_RULE_OP1, + 1706 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1731 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1756 | SPEC_RULE_OP1, + 1761 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1786 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1811 | SPEC_RULE_OP1, + 1816 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1841 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1866 | SPEC_RULE_OP1, + 1871 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1896 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1921 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1946, + 1947 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, 1957, 1958, 1959, - 1960 | SPEC_RULE_OP2, - 1965, - 1966 | SPEC_RULE_OP1, - 1971 | SPEC_RULE_OP2, - 1976 | SPEC_RULE_OP1, - 1981 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, - 1991 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2016 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2041 | SPEC_RULE_OP1, - 2046 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2071 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, - 2121 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2146 | SPEC_RULE_OP2, - 2151, - 2152 | SPEC_RULE_OP1, - 2157 | SPEC_RULE_OP1, - 2162, - 2163 | SPEC_RULE_OP1, - 2168 | SPEC_RULE_OP1, - 2173 | SPEC_RULE_OP1, - 2178, - 2179, - 2180 | SPEC_RULE_OP2, - 2185 | SPEC_RULE_RETVAL, + 1960, + 1961, + 1962 | SPEC_RULE_OP2, + 1967, + 1968 | SPEC_RULE_OP1, + 1973 | SPEC_RULE_OP2, + 1978 | SPEC_RULE_OP1, + 1983 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, + 1993 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2018 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2043 | SPEC_RULE_OP1, + 2048 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2073 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, + 2123 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2148 | SPEC_RULE_OP2, + 2153, + 2154 | SPEC_RULE_OP1, + 2159 | SPEC_RULE_OP1, + 2164, + 2165 | SPEC_RULE_OP1, + 2170 | SPEC_RULE_OP1, + 2175 | SPEC_RULE_OP1, + 2180, + 2181, + 2182 | SPEC_RULE_OP2, 2187 | SPEC_RULE_RETVAL, - 2189 | SPEC_RULE_RETVAL, - 2191 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2191 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2216 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2216 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2241 | SPEC_RULE_OP1, - 2246, - 2247 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2272, - 2273 | SPEC_RULE_OP1, + 2189 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, + 2193 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, + 2197 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2197 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2222 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2222 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2247 | SPEC_RULE_OP1, + 2252, + 2253 | SPEC_RULE_OP1 | SPEC_RULE_OP2, 2278, - 2279, - 2280, - 2281, - 2282, - 2283, + 2279 | SPEC_RULE_OP1, 2284, - 2285 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2310, - 2311, - 2312, - 2313 | SPEC_RULE_OP1, + 2285, + 2286, + 2287, + 2288, + 2289, + 2290, + 2291 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2316, + 2317, 2318, - 2319 | SPEC_RULE_ISSET, - 2321 | SPEC_RULE_OP2, - 2326, - 2327 | SPEC_RULE_OP1, + 2319 | SPEC_RULE_OP1, + 2324, + 2325 | SPEC_RULE_ISSET, + 2327 | SPEC_RULE_OP2, 2332, - 2333, - 2334 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2359 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, - 2369, - 2370, - 2371, - 2372, - 2373 | SPEC_RULE_OP1, + 2333 | SPEC_RULE_OP1, + 2338 | SPEC_RULE_OBSERVER, + 2340, + 2341 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2366 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, + 2376, + 2377, 2378, 2379, 2380 | SPEC_RULE_OP1, - 2385 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2410, - 2411 | SPEC_RULE_OP1, - 2416, + 2385, + 2386, + 2387 | SPEC_RULE_OP1, + 2392 | SPEC_RULE_OP1 | SPEC_RULE_OP2, 2417, - 2418, - 2419, - 2420, - 2421, - 2422, + 2418 | SPEC_RULE_OP1, 2423, - 2424 | SPEC_RULE_OP1, + 2424, + 2425, + 2426, + 2427, + 2428, 2429, 2430, - 2431, - 2432 | SPEC_RULE_OP2, + 2431 | SPEC_RULE_OP1, + 2436, 2437, - 2438 | SPEC_RULE_OP1, - 2443 | SPEC_RULE_OP1, - 2448 | SPEC_RULE_OP1, - 2453 | SPEC_RULE_OP1, - 2458 | SPEC_RULE_OP1, - 2463, - 2464 | SPEC_RULE_OP1, - 2469 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2494 | SPEC_RULE_OP1, - 2499 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2524 | SPEC_RULE_OP1, - 2529 | SPEC_RULE_OP1, - 2534, - 3438 + 2438, + 2439 | SPEC_RULE_OP2, + 2444, + 2445 | SPEC_RULE_OP1, + 2450 | SPEC_RULE_OP1, + 2455 | SPEC_RULE_OP1, + 2460 | SPEC_RULE_OP1, + 2465 | SPEC_RULE_OP1, + 2470, + 2471 | SPEC_RULE_OP1, + 2476 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2501 | SPEC_RULE_OP1, + 2506 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2531 | SPEC_RULE_OP1, + 2536 | SPEC_RULE_OP1, + 2541, + 3445 }; #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID) zend_opcode_handler_funcs = labels; @@ -62597,6 +63214,9 @@ static uint32_t ZEND_FASTCALL zend_vm_get_opcode_handler_idx(uint32_t spec, cons if (spec & SPEC_EXTRA_MASK) { if (spec & SPEC_RULE_RETVAL) { offset = offset * 2 + (op->result_type != IS_UNUSED); + if ((spec & SPEC_RULE_OBSERVER) && ZEND_OBSERVER_ENABLED) { + offset += 2; + } } else if (spec & SPEC_RULE_QUICK_ARG) { offset = offset * 2 + (op->op2.num <= MAX_ARG_FLAG_NUM); } else if (spec & SPEC_RULE_OP_DATA) { @@ -62658,7 +63278,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 = 2537 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2544 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -62666,7 +63286,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 = 2562 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2569 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -62674,7 +63294,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 = 2587 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2594 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -62685,17 +63305,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 = 2612 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2619 | 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 = 2637 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2644 | 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 = 2662 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2669 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_MUL: @@ -62706,17 +63326,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 = 2687 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2694 | 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 = 2712 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2719 | 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 = 2737 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2744 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_IDENTICAL: @@ -62727,14 +63347,14 @@ 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 = 2762 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2769 | 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 = 2837 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2844 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF))) { - spec = 3062 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3069 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_IDENTICAL: @@ -62745,14 +63365,14 @@ 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 = 2912 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2919 | 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 = 2987 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2994 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF))) { - spec = 3067 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3074 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_EQUAL: @@ -62763,12 +63383,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 = 2762 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2769 | 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 = 2837 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2844 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_EQUAL: @@ -62779,12 +63399,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 = 2912 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2919 | 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 = 2987 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2994 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_SMALLER: @@ -62792,12 +63412,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 = 3072 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3079 | 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 = 3147 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3154 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_IS_SMALLER_OR_EQUAL: @@ -62805,74 +63425,74 @@ 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 = 3222 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3229 | 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 = 3297 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3304 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_QM_ASSIGN: if (op1_info == MAY_BE_LONG) { - spec = 3384 | SPEC_RULE_OP1; + spec = 3391 | SPEC_RULE_OP1; } else if (op1_info == MAY_BE_DOUBLE) { - spec = 3389 | SPEC_RULE_OP1; + spec = 3396 | 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 = 3394 | SPEC_RULE_OP1; + spec = 3401 | SPEC_RULE_OP1; } break; case ZEND_PRE_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3372 | SPEC_RULE_RETVAL; + spec = 3379 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3374 | SPEC_RULE_RETVAL; + spec = 3381 | SPEC_RULE_RETVAL; } break; case ZEND_PRE_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3376 | SPEC_RULE_RETVAL; + spec = 3383 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3378 | SPEC_RULE_RETVAL; + spec = 3385 | SPEC_RULE_RETVAL; } break; case ZEND_POST_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3380; + spec = 3387; } else if (op1_info == MAY_BE_LONG) { - spec = 3381; + spec = 3388; } break; case ZEND_POST_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3382; + spec = 3389; } else if (op1_info == MAY_BE_LONG) { - spec = 3383; + spec = 3390; } break; case ZEND_JMP: if (OP_JMP_ADDR(op, op->op1) > op) { - spec = 2536; + spec = 2543; } break; case ZEND_RECV: if (op->op2.num == MAY_BE_ANY) { - spec = 2535; + spec = 2542; } break; case ZEND_SEND_VAL: if (op->op1_type == IS_CONST && op->op2_type == IS_UNUSED && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3434; + spec = 3441; } break; case ZEND_SEND_VAR_EX: if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3429 | SPEC_RULE_OP1; + spec = 3436 | 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 = 3436 | SPEC_RULE_RETVAL; + spec = 3443 | SPEC_RULE_RETVAL; } break; case ZEND_FETCH_DIM_R: @@ -62880,17 +63500,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 = 3399 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 3406 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_SEND_VAL_EX: if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3435; + spec = 3442; } break; case ZEND_SEND_VAR: if (op->op2_type == IS_UNUSED && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3424 | SPEC_RULE_OP1; + spec = 3431 | SPEC_RULE_OP1; } break; case ZEND_BW_OR: diff --git a/Zend/zend_vm_gen.php b/Zend/zend_vm_gen.php index 31466762632da..0c79812805891 100755 --- a/Zend/zend_vm_gen.php +++ b/Zend/zend_vm_gen.php @@ -793,7 +793,10 @@ function gen_code($f, $spec, $kind, $code, $op1, $op2, $name, $extra_spec=null) "/opline->extended_value\s*&\s*~\s*ZEND_ISEMPTY/" => isset($extra_spec['ISSET']) ? ($extra_spec['ISSET'] == 0 ? "\\0" : "opline->extended_value") : "\\0", - "/OBSERVER_END_HANDLERS\(\s*([^,]*)\s*,\s*(.*)\s*\)/" => isset($extra_spec['OBSERVER']) ? + "/OBSERVER_FCALL_BEGIN_HANDLERS\(\s*(.*)\s*\)/" => isset($extra_spec['OBSERVER']) ? + ($extra_spec['OBSERVER'] == 0 ? "" : "zend_observer_maybe_fcall_call_begin(\\1)") + : "", + "/OBSERVER_FCALL_END_HANDLERS\(\s*([^,]*)\s*,\s*(.*)\s*\)/" => isset($extra_spec['OBSERVER']) ? ($extra_spec['OBSERVER'] == 0 ? "" : "zend_observer_maybe_fcall_call_end(\\1, \\2)") : "", ); @@ -2677,6 +2680,9 @@ function gen_vm($def, $skel) { if (isset($used_extra_spec["RETVAL"])) { out($f, "\t\t{$else}if (spec & SPEC_RULE_RETVAL) {\n"); out($f, "\t\t\toffset = offset * 2 + (op->result_type != IS_UNUSED);\n"); + out($f, "\t\t\tif ((spec & SPEC_RULE_OBSERVER) && ZEND_OBSERVER_ENABLED) {\n"); + out($f, "\t\t\t\toffset += 2;\n"); + out($f, "\t\t\t}\n"); $else = "} else "; } if (isset($used_extra_spec["QUICK_ARG"])) { diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h index 96064eec97bba..05a313f07ecb2 100644 --- a/Zend/zend_vm_handlers.h +++ b/Zend/zend_vm_handlers.h @@ -637,1202 +637,1209 @@ _(1349, ZEND_INIT_FCALL_BY_NAME_SPEC_CONST) \ _(1350, ZEND_DO_FCALL_SPEC_RETVAL_UNUSED) \ _(1351, ZEND_DO_FCALL_SPEC_RETVAL_USED) \ - _(1352, ZEND_INIT_FCALL_SPEC_CONST) \ - _(1353, ZEND_RETURN_SPEC_CONST) \ - _(1354, ZEND_RETURN_SPEC_CONST_OBSERVER) \ - _(1355, ZEND_RETURN_SPEC_TMP) \ - _(1356, ZEND_RETURN_SPEC_TMP_OBSERVER) \ - _(1357, ZEND_RETURN_SPEC_VAR) \ - _(1358, ZEND_RETURN_SPEC_VAR_OBSERVER) \ - _(1361, ZEND_RETURN_SPEC_CV) \ - _(1362, ZEND_RETURN_SPEC_CV_OBSERVER) \ - _(1363, ZEND_RECV_SPEC_UNUSED) \ - _(1364, ZEND_RECV_INIT_SPEC_CONST) \ - _(1365, ZEND_SEND_VAL_SPEC_CONST_CONST) \ - _(1368, ZEND_SEND_VAL_SPEC_CONST_UNUSED) \ - _(1370, ZEND_SEND_VAL_SPEC_TMPVAR_CONST) \ - _(1373, ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED) \ - _(1375, ZEND_SEND_VAL_SPEC_TMPVAR_CONST) \ - _(1378, ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED) \ - _(1410, ZEND_SEND_VAR_EX_SPEC_VAR_CONST) \ - _(1411, ZEND_SEND_VAR_EX_SPEC_VAR_CONST) \ - _(1416, ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED) \ - _(1417, ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK) \ - _(1430, ZEND_SEND_VAR_EX_SPEC_CV_CONST) \ - _(1431, ZEND_SEND_VAR_EX_SPEC_CV_CONST) \ - _(1436, ZEND_SEND_VAR_EX_SPEC_CV_UNUSED) \ - _(1437, ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK) \ - _(1450, ZEND_SEND_REF_SPEC_VAR_CONST) \ - _(1453, ZEND_SEND_REF_SPEC_VAR_UNUSED) \ - _(1460, ZEND_SEND_REF_SPEC_CV_CONST) \ - _(1463, ZEND_SEND_REF_SPEC_CV_UNUSED) \ - _(1465, ZEND_NEW_SPEC_CONST_UNUSED) \ - _(1467, ZEND_NEW_SPEC_VAR_UNUSED) \ - _(1468, ZEND_NEW_SPEC_UNUSED_UNUSED) \ - _(1470, ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST) \ - _(1471, ZEND_FREE_SPEC_TMPVAR) \ - _(1472, ZEND_INIT_ARRAY_SPEC_CONST_CONST) \ - _(1473, ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR) \ - _(1474, ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR) \ - _(1475, ZEND_INIT_ARRAY_SPEC_CONST_UNUSED) \ - _(1476, ZEND_INIT_ARRAY_SPEC_CONST_CV) \ - _(1477, ZEND_INIT_ARRAY_SPEC_TMP_CONST) \ - _(1478, ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR) \ - _(1479, ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR) \ - _(1480, ZEND_INIT_ARRAY_SPEC_TMP_UNUSED) \ - _(1481, ZEND_INIT_ARRAY_SPEC_TMP_CV) \ - _(1482, ZEND_INIT_ARRAY_SPEC_VAR_CONST) \ - _(1483, ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR) \ - _(1484, ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR) \ - _(1485, ZEND_INIT_ARRAY_SPEC_VAR_UNUSED) \ - _(1486, ZEND_INIT_ARRAY_SPEC_VAR_CV) \ - _(1487, ZEND_INIT_ARRAY_SPEC_UNUSED_CONST) \ - _(1488, ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR) \ - _(1489, ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR) \ - _(1490, ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED) \ - _(1491, ZEND_INIT_ARRAY_SPEC_UNUSED_CV) \ - _(1492, ZEND_INIT_ARRAY_SPEC_CV_CONST) \ - _(1493, ZEND_INIT_ARRAY_SPEC_CV_TMPVAR) \ - _(1494, ZEND_INIT_ARRAY_SPEC_CV_TMPVAR) \ - _(1495, ZEND_INIT_ARRAY_SPEC_CV_UNUSED) \ - _(1496, ZEND_INIT_ARRAY_SPEC_CV_CV) \ - _(1497, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST) \ - _(1498, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR) \ - _(1499, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR) \ - _(1500, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED) \ - _(1501, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV) \ - _(1502, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST) \ - _(1503, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR) \ - _(1504, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR) \ - _(1505, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED) \ - _(1506, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV) \ - _(1507, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST) \ - _(1508, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR) \ - _(1509, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR) \ - _(1510, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED) \ - _(1511, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV) \ - _(1517, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST) \ - _(1518, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR) \ - _(1519, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR) \ - _(1520, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED) \ - _(1521, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV) \ - _(1522, ZEND_INCLUDE_OR_EVAL_SPEC_CONST) \ - _(1523, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR) \ - _(1524, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR) \ - _(1526, ZEND_INCLUDE_OR_EVAL_SPEC_CV) \ - _(1527, ZEND_UNSET_VAR_SPEC_CONST_UNUSED) \ - _(1528, ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED) \ - _(1529, ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED) \ - _(1531, ZEND_UNSET_VAR_SPEC_CV_UNUSED) \ - _(1542, ZEND_UNSET_DIM_SPEC_VAR_CONST) \ - _(1543, ZEND_UNSET_DIM_SPEC_VAR_TMPVAR) \ - _(1544, ZEND_UNSET_DIM_SPEC_VAR_TMPVAR) \ - _(1546, ZEND_UNSET_DIM_SPEC_VAR_CV) \ - _(1552, ZEND_UNSET_DIM_SPEC_CV_CONST) \ - _(1553, ZEND_UNSET_DIM_SPEC_CV_TMPVAR) \ - _(1554, ZEND_UNSET_DIM_SPEC_CV_TMPVAR) \ - _(1556, ZEND_UNSET_DIM_SPEC_CV_CV) \ - _(1567, ZEND_UNSET_OBJ_SPEC_VAR_CONST) \ - _(1568, ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR) \ - _(1569, ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR) \ - _(1571, ZEND_UNSET_OBJ_SPEC_VAR_CV) \ - _(1572, ZEND_UNSET_OBJ_SPEC_UNUSED_CONST) \ - _(1573, ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR) \ - _(1574, ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR) \ - _(1576, ZEND_UNSET_OBJ_SPEC_UNUSED_CV) \ - _(1577, ZEND_UNSET_OBJ_SPEC_CV_CONST) \ - _(1578, ZEND_UNSET_OBJ_SPEC_CV_TMPVAR) \ - _(1579, ZEND_UNSET_OBJ_SPEC_CV_TMPVAR) \ - _(1581, ZEND_UNSET_OBJ_SPEC_CV_CV) \ - _(1582, ZEND_FE_RESET_R_SPEC_CONST) \ - _(1583, ZEND_FE_RESET_R_SPEC_TMP) \ - _(1584, ZEND_FE_RESET_R_SPEC_VAR) \ - _(1586, ZEND_FE_RESET_R_SPEC_CV) \ - _(1587, ZEND_FE_FETCH_R_SPEC_VAR) \ - _(1588, ZEND_EXIT_SPEC) \ - _(1589, ZEND_FETCH_R_SPEC_CONST_UNUSED) \ - _(1590, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \ - _(1591, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \ - _(1593, ZEND_FETCH_R_SPEC_CV_UNUSED) \ - _(1594, ZEND_FETCH_DIM_R_SPEC_CONST_CONST) \ - _(1595, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \ - _(1596, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \ - _(1598, ZEND_FETCH_DIM_R_SPEC_CONST_CV) \ - _(1599, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \ - _(1600, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ - _(1601, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ - _(1603, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \ - _(1604, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \ - _(1605, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ - _(1606, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ - _(1608, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \ - _(1614, ZEND_FETCH_DIM_R_SPEC_CV_CONST) \ - _(1615, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \ - _(1616, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \ - _(1618, ZEND_FETCH_DIM_R_SPEC_CV_CV) \ - _(1619, ZEND_FETCH_OBJ_R_SPEC_CONST_CONST) \ - _(1620, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \ - _(1621, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \ - _(1623, ZEND_FETCH_OBJ_R_SPEC_CONST_CV) \ - _(1624, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \ - _(1625, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ - _(1626, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ - _(1628, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \ - _(1629, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \ - _(1630, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ - _(1631, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ - _(1633, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \ - _(1634, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST) \ - _(1635, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \ - _(1636, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \ - _(1638, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV) \ - _(1639, ZEND_FETCH_OBJ_R_SPEC_CV_CONST) \ - _(1640, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \ - _(1641, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \ - _(1643, ZEND_FETCH_OBJ_R_SPEC_CV_CV) \ - _(1644, ZEND_FETCH_W_SPEC_CONST_UNUSED) \ - _(1645, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \ - _(1646, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \ - _(1648, ZEND_FETCH_W_SPEC_CV_UNUSED) \ - _(1659, ZEND_FETCH_DIM_W_SPEC_VAR_CONST) \ - _(1660, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \ - _(1661, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \ - _(1662, ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED) \ - _(1663, ZEND_FETCH_DIM_W_SPEC_VAR_CV) \ - _(1669, ZEND_FETCH_DIM_W_SPEC_CV_CONST) \ - _(1670, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \ - _(1671, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \ - _(1672, ZEND_FETCH_DIM_W_SPEC_CV_UNUSED) \ - _(1673, ZEND_FETCH_DIM_W_SPEC_CV_CV) \ - _(1684, ZEND_FETCH_OBJ_W_SPEC_VAR_CONST) \ - _(1685, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \ - _(1686, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \ - _(1688, ZEND_FETCH_OBJ_W_SPEC_VAR_CV) \ - _(1689, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST) \ - _(1690, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \ - _(1691, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \ - _(1693, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV) \ - _(1694, ZEND_FETCH_OBJ_W_SPEC_CV_CONST) \ - _(1695, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \ - _(1696, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \ - _(1698, ZEND_FETCH_OBJ_W_SPEC_CV_CV) \ - _(1699, ZEND_FETCH_RW_SPEC_CONST_UNUSED) \ - _(1700, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \ - _(1701, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \ - _(1703, ZEND_FETCH_RW_SPEC_CV_UNUSED) \ - _(1714, ZEND_FETCH_DIM_RW_SPEC_VAR_CONST) \ - _(1715, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \ - _(1716, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \ - _(1717, ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED) \ - _(1718, ZEND_FETCH_DIM_RW_SPEC_VAR_CV) \ - _(1724, ZEND_FETCH_DIM_RW_SPEC_CV_CONST) \ - _(1725, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \ - _(1726, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \ - _(1727, ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED) \ - _(1728, ZEND_FETCH_DIM_RW_SPEC_CV_CV) \ - _(1739, ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST) \ - _(1740, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \ - _(1741, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \ - _(1743, ZEND_FETCH_OBJ_RW_SPEC_VAR_CV) \ - _(1744, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST) \ - _(1745, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \ - _(1746, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \ - _(1748, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV) \ - _(1749, ZEND_FETCH_OBJ_RW_SPEC_CV_CONST) \ - _(1750, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \ - _(1751, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \ - _(1753, ZEND_FETCH_OBJ_RW_SPEC_CV_CV) \ - _(1754, ZEND_FETCH_IS_SPEC_CONST_UNUSED) \ - _(1755, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \ - _(1756, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \ - _(1758, ZEND_FETCH_IS_SPEC_CV_UNUSED) \ - _(1759, ZEND_FETCH_DIM_IS_SPEC_CONST_CONST) \ - _(1760, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \ - _(1761, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \ - _(1763, ZEND_FETCH_DIM_IS_SPEC_CONST_CV) \ - _(1764, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \ - _(1765, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ - _(1766, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ - _(1768, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \ - _(1769, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \ - _(1770, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ - _(1771, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ - _(1773, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \ - _(1779, ZEND_FETCH_DIM_IS_SPEC_CV_CONST) \ - _(1780, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \ - _(1781, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \ - _(1783, ZEND_FETCH_DIM_IS_SPEC_CV_CV) \ - _(1784, ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST) \ - _(1785, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \ - _(1786, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \ - _(1788, ZEND_FETCH_OBJ_IS_SPEC_CONST_CV) \ - _(1789, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \ - _(1790, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ - _(1791, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ - _(1793, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \ - _(1794, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \ - _(1795, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ - _(1796, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ - _(1798, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \ - _(1799, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST) \ - _(1800, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \ - _(1801, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \ - _(1803, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV) \ - _(1804, ZEND_FETCH_OBJ_IS_SPEC_CV_CONST) \ - _(1805, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \ - _(1806, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \ - _(1808, ZEND_FETCH_OBJ_IS_SPEC_CV_CV) \ - _(1809, ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED) \ - _(1810, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \ - _(1811, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \ - _(1813, ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED) \ - _(1814, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST) \ - _(1815, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \ - _(1816, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \ - _(1817, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED) \ - _(1818, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV) \ - _(1819, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST) \ - _(1820, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \ - _(1821, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \ - _(1822, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED) \ - _(1823, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV) \ - _(1824, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST) \ - _(1825, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \ - _(1826, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \ - _(1827, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED) \ - _(1828, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV) \ - _(1834, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST) \ - _(1835, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \ - _(1836, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \ - _(1837, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED) \ - _(1838, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV) \ - _(1839, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST) \ - _(1840, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \ - _(1841, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \ - _(1843, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV) \ - _(1844, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST) \ - _(1845, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \ - _(1846, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \ - _(1848, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV) \ - _(1849, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST) \ - _(1850, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \ - _(1851, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \ - _(1853, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV) \ - _(1854, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST) \ - _(1855, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \ - _(1856, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \ - _(1858, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV) \ - _(1859, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST) \ - _(1860, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \ - _(1861, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \ - _(1863, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV) \ - _(1864, ZEND_FETCH_UNSET_SPEC_CONST_UNUSED) \ - _(1865, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \ - _(1866, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \ - _(1868, ZEND_FETCH_UNSET_SPEC_CV_UNUSED) \ - _(1879, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST) \ - _(1880, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \ - _(1881, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \ - _(1883, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV) \ - _(1889, ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST) \ - _(1890, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \ - _(1891, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \ - _(1893, ZEND_FETCH_DIM_UNSET_SPEC_CV_CV) \ - _(1904, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST) \ - _(1905, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \ - _(1906, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \ - _(1908, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV) \ - _(1909, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST) \ - _(1910, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \ - _(1911, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \ - _(1913, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV) \ - _(1914, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST) \ - _(1915, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \ - _(1916, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \ - _(1918, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV) \ - _(1919, ZEND_FETCH_LIST_R_SPEC_CONST_CONST) \ - _(1920, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \ - _(1921, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \ - _(1923, ZEND_FETCH_LIST_R_SPEC_CONST_CV) \ - _(1924, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ - _(1925, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1926, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1928, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ - _(1929, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ - _(1930, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1931, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1933, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ - _(1939, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ - _(1940, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1941, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1943, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ - _(1944, ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST) \ - _(1945, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST) \ - _(1946, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST) \ - _(1951, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED) \ - _(1952, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK) \ - _(1955, ZEND_EXT_STMT_SPEC) \ - _(1956, ZEND_EXT_FCALL_BEGIN_SPEC) \ - _(1957, ZEND_EXT_FCALL_END_SPEC) \ - _(1958, ZEND_EXT_NOP_SPEC) \ - _(1959, ZEND_TICKS_SPEC) \ - _(1960, ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST) \ - _(1963, ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED) \ - _(1965, ZEND_CATCH_SPEC_CONST) \ - _(1966, ZEND_THROW_SPEC_CONST) \ - _(1967, ZEND_THROW_SPEC_TMPVAR) \ - _(1968, ZEND_THROW_SPEC_TMPVAR) \ - _(1970, ZEND_THROW_SPEC_CV) \ - _(1971, ZEND_FETCH_CLASS_SPEC_UNUSED_CONST) \ - _(1972, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \ - _(1973, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \ - _(1974, ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED) \ - _(1975, ZEND_FETCH_CLASS_SPEC_UNUSED_CV) \ - _(1976, ZEND_CLONE_SPEC_CONST) \ - _(1977, ZEND_CLONE_SPEC_TMPVAR) \ - _(1978, ZEND_CLONE_SPEC_TMPVAR) \ - _(1979, ZEND_CLONE_SPEC_UNUSED) \ - _(1980, ZEND_CLONE_SPEC_CV) \ - _(1981, ZEND_RETURN_BY_REF_SPEC_CONST) \ - _(1982, ZEND_RETURN_BY_REF_SPEC_CONST_OBSERVER) \ - _(1983, ZEND_RETURN_BY_REF_SPEC_TMP) \ - _(1984, ZEND_RETURN_BY_REF_SPEC_TMP_OBSERVER) \ - _(1985, ZEND_RETURN_BY_REF_SPEC_VAR) \ - _(1986, ZEND_RETURN_BY_REF_SPEC_VAR_OBSERVER) \ - _(1989, ZEND_RETURN_BY_REF_SPEC_CV) \ - _(1990, ZEND_RETURN_BY_REF_SPEC_CV_OBSERVER) \ - _(1991, ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST) \ - _(1992, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \ - _(1993, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \ - _(1995, ZEND_INIT_METHOD_CALL_SPEC_CONST_CV) \ - _(1996, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \ - _(1997, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ - _(1998, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ - _(2000, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \ - _(2001, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \ - _(2002, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ - _(2003, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ - _(2005, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \ - _(2006, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST) \ - _(2007, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ - _(2008, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ - _(2010, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV) \ - _(2011, ZEND_INIT_METHOD_CALL_SPEC_CV_CONST) \ - _(2012, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \ - _(2013, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \ - _(2015, ZEND_INIT_METHOD_CALL_SPEC_CV_CV) \ - _(2016, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST) \ - _(2017, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \ - _(2018, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \ - _(2019, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED) \ - _(2020, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV) \ - _(2026, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST) \ - _(2027, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \ - _(2028, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \ - _(2029, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED) \ - _(2030, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV) \ - _(2031, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST) \ - _(2032, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ - _(2033, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ - _(2034, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED) \ - _(2035, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV) \ - _(2041, ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED) \ - _(2042, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \ - _(2043, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \ - _(2045, ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED) \ - _(2046, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST) \ - _(2047, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \ - _(2048, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \ - _(2050, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV) \ - _(2051, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \ - _(2052, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2053, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2055, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \ - _(2056, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \ - _(2057, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2058, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2060, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \ - _(2066, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST) \ - _(2067, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \ - _(2068, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \ - _(2070, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV) \ - _(2071, ZEND_SEND_VAL_EX_SPEC_CONST_CONST) \ - _(2072, ZEND_SEND_VAL_EX_SPEC_CONST_CONST) \ - _(2077, ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED) \ - _(2078, ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK) \ - _(2081, ZEND_SEND_VAL_EX_SPEC_TMP_CONST) \ - _(2082, ZEND_SEND_VAL_EX_SPEC_TMP_CONST) \ - _(2087, ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED) \ - _(2088, ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK) \ - _(2131, ZEND_SEND_VAR_SPEC_VAR_CONST) \ - _(2134, ZEND_SEND_VAR_SPEC_VAR_UNUSED) \ - _(2141, ZEND_SEND_VAR_SPEC_CV_CONST) \ - _(2144, ZEND_SEND_VAR_SPEC_CV_UNUSED) \ - _(2146, ZEND_INIT_USER_CALL_SPEC_CONST_CONST) \ - _(2147, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \ - _(2148, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \ - _(2150, ZEND_INIT_USER_CALL_SPEC_CONST_CV) \ - _(2151, ZEND_SEND_ARRAY_SPEC) \ - _(2152, ZEND_SEND_USER_SPEC_CONST) \ - _(2153, ZEND_SEND_USER_SPEC_TMP) \ - _(2154, ZEND_SEND_USER_SPEC_VAR) \ - _(2156, ZEND_SEND_USER_SPEC_CV) \ - _(2157, ZEND_STRLEN_SPEC_CONST) \ - _(2158, ZEND_STRLEN_SPEC_TMPVAR) \ - _(2159, ZEND_STRLEN_SPEC_TMPVAR) \ - _(2161, ZEND_STRLEN_SPEC_CV) \ - _(2162, ZEND_DEFINED_SPEC_CONST) \ - _(2163, ZEND_TYPE_CHECK_SPEC_CONST) \ - _(2164, ZEND_TYPE_CHECK_SPEC_TMPVAR) \ - _(2165, ZEND_TYPE_CHECK_SPEC_TMPVAR) \ - _(2167, ZEND_TYPE_CHECK_SPEC_CV) \ - _(2168, ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED) \ - _(2169, ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED) \ - _(2170, ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED) \ - _(2171, ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED) \ - _(2172, ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED) \ - _(2173, ZEND_FE_RESET_RW_SPEC_CONST) \ - _(2174, ZEND_FE_RESET_RW_SPEC_TMP) \ - _(2175, ZEND_FE_RESET_RW_SPEC_VAR) \ - _(2177, ZEND_FE_RESET_RW_SPEC_CV) \ - _(2178, ZEND_FE_FETCH_RW_SPEC_VAR) \ - _(2179, ZEND_FE_FREE_SPEC_TMPVAR) \ - _(2180, ZEND_INIT_DYNAMIC_CALL_SPEC_CONST) \ - _(2181, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \ - _(2182, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \ - _(2184, ZEND_INIT_DYNAMIC_CALL_SPEC_CV) \ - _(2185, ZEND_DO_ICALL_SPEC_RETVAL_UNUSED) \ - _(2186, ZEND_DO_ICALL_SPEC_RETVAL_USED) \ - _(2187, ZEND_DO_UCALL_SPEC_RETVAL_UNUSED) \ - _(2188, ZEND_DO_UCALL_SPEC_RETVAL_USED) \ - _(2189, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED) \ - _(2190, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED) \ - _(2201, ZEND_PRE_INC_OBJ_SPEC_VAR_CONST) \ - _(2202, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \ - _(2203, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \ - _(2205, ZEND_PRE_INC_OBJ_SPEC_VAR_CV) \ - _(2206, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST) \ - _(2207, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2208, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2210, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV) \ - _(2211, ZEND_PRE_INC_OBJ_SPEC_CV_CONST) \ - _(2212, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \ - _(2213, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \ - _(2215, ZEND_PRE_INC_OBJ_SPEC_CV_CV) \ - _(2226, ZEND_POST_INC_OBJ_SPEC_VAR_CONST) \ - _(2227, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \ - _(2228, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \ - _(2230, ZEND_POST_INC_OBJ_SPEC_VAR_CV) \ - _(2231, ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST) \ - _(2232, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2233, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2235, ZEND_POST_INC_OBJ_SPEC_UNUSED_CV) \ - _(2236, ZEND_POST_INC_OBJ_SPEC_CV_CONST) \ - _(2237, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \ - _(2238, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \ - _(2240, ZEND_POST_INC_OBJ_SPEC_CV_CV) \ - _(2241, ZEND_ECHO_SPEC_CONST) \ - _(2242, ZEND_ECHO_SPEC_TMPVAR) \ - _(2243, ZEND_ECHO_SPEC_TMPVAR) \ - _(2245, ZEND_ECHO_SPEC_CV) \ - _(2252, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \ - _(2254, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \ - _(2255, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \ - _(2257, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \ - _(2259, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \ - _(2260, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \ - _(2267, ZEND_INSTANCEOF_SPEC_CV_CONST) \ - _(2269, ZEND_INSTANCEOF_SPEC_CV_VAR) \ - _(2270, ZEND_INSTANCEOF_SPEC_CV_UNUSED) \ - _(2272, ZEND_GENERATOR_CREATE_SPEC) \ - _(2275, ZEND_MAKE_REF_SPEC_VAR_UNUSED) \ - _(2277, ZEND_MAKE_REF_SPEC_CV_UNUSED) \ - _(2278, ZEND_DECLARE_FUNCTION_SPEC) \ - _(2279, ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED) \ - _(2280, ZEND_DECLARE_CONST_SPEC_CONST_CONST) \ - _(2281, ZEND_DECLARE_CLASS_SPEC_CONST) \ - _(2282, ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST) \ - _(2283, ZEND_DECLARE_ANON_CLASS_SPEC) \ - _(2284, ZEND_ADD_ARRAY_UNPACK_SPEC) \ - _(2285, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST) \ - _(2286, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \ - _(2287, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \ - _(2289, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV) \ - _(2290, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ - _(2291, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2292, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2294, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ - _(2295, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ - _(2296, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(1352, ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_OBSERVER) \ + _(1353, ZEND_DO_FCALL_SPEC_RETVAL_USED_OBSERVER) \ + _(1354, ZEND_INIT_FCALL_SPEC_CONST) \ + _(1355, ZEND_RETURN_SPEC_CONST) \ + _(1356, ZEND_RETURN_SPEC_CONST_OBSERVER) \ + _(1357, ZEND_RETURN_SPEC_TMP) \ + _(1358, ZEND_RETURN_SPEC_TMP_OBSERVER) \ + _(1359, ZEND_RETURN_SPEC_VAR) \ + _(1360, ZEND_RETURN_SPEC_VAR_OBSERVER) \ + _(1363, ZEND_RETURN_SPEC_CV) \ + _(1364, ZEND_RETURN_SPEC_CV_OBSERVER) \ + _(1365, ZEND_RECV_SPEC_UNUSED) \ + _(1366, ZEND_RECV_INIT_SPEC_CONST) \ + _(1367, ZEND_SEND_VAL_SPEC_CONST_CONST) \ + _(1370, ZEND_SEND_VAL_SPEC_CONST_UNUSED) \ + _(1372, ZEND_SEND_VAL_SPEC_TMPVAR_CONST) \ + _(1375, ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED) \ + _(1377, ZEND_SEND_VAL_SPEC_TMPVAR_CONST) \ + _(1380, ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED) \ + _(1412, ZEND_SEND_VAR_EX_SPEC_VAR_CONST) \ + _(1413, ZEND_SEND_VAR_EX_SPEC_VAR_CONST) \ + _(1418, ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED) \ + _(1419, ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK) \ + _(1432, ZEND_SEND_VAR_EX_SPEC_CV_CONST) \ + _(1433, ZEND_SEND_VAR_EX_SPEC_CV_CONST) \ + _(1438, ZEND_SEND_VAR_EX_SPEC_CV_UNUSED) \ + _(1439, ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK) \ + _(1452, ZEND_SEND_REF_SPEC_VAR_CONST) \ + _(1455, ZEND_SEND_REF_SPEC_VAR_UNUSED) \ + _(1462, ZEND_SEND_REF_SPEC_CV_CONST) \ + _(1465, ZEND_SEND_REF_SPEC_CV_UNUSED) \ + _(1467, ZEND_NEW_SPEC_CONST_UNUSED) \ + _(1469, ZEND_NEW_SPEC_VAR_UNUSED) \ + _(1470, ZEND_NEW_SPEC_UNUSED_UNUSED) \ + _(1472, ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST) \ + _(1473, ZEND_FREE_SPEC_TMPVAR) \ + _(1474, ZEND_INIT_ARRAY_SPEC_CONST_CONST) \ + _(1475, ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR) \ + _(1476, ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR) \ + _(1477, ZEND_INIT_ARRAY_SPEC_CONST_UNUSED) \ + _(1478, ZEND_INIT_ARRAY_SPEC_CONST_CV) \ + _(1479, ZEND_INIT_ARRAY_SPEC_TMP_CONST) \ + _(1480, ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR) \ + _(1481, ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR) \ + _(1482, ZEND_INIT_ARRAY_SPEC_TMP_UNUSED) \ + _(1483, ZEND_INIT_ARRAY_SPEC_TMP_CV) \ + _(1484, ZEND_INIT_ARRAY_SPEC_VAR_CONST) \ + _(1485, ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR) \ + _(1486, ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR) \ + _(1487, ZEND_INIT_ARRAY_SPEC_VAR_UNUSED) \ + _(1488, ZEND_INIT_ARRAY_SPEC_VAR_CV) \ + _(1489, ZEND_INIT_ARRAY_SPEC_UNUSED_CONST) \ + _(1490, ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR) \ + _(1491, ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR) \ + _(1492, ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED) \ + _(1493, ZEND_INIT_ARRAY_SPEC_UNUSED_CV) \ + _(1494, ZEND_INIT_ARRAY_SPEC_CV_CONST) \ + _(1495, ZEND_INIT_ARRAY_SPEC_CV_TMPVAR) \ + _(1496, ZEND_INIT_ARRAY_SPEC_CV_TMPVAR) \ + _(1497, ZEND_INIT_ARRAY_SPEC_CV_UNUSED) \ + _(1498, ZEND_INIT_ARRAY_SPEC_CV_CV) \ + _(1499, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST) \ + _(1500, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR) \ + _(1501, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR) \ + _(1502, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED) \ + _(1503, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV) \ + _(1504, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST) \ + _(1505, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR) \ + _(1506, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR) \ + _(1507, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED) \ + _(1508, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV) \ + _(1509, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST) \ + _(1510, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR) \ + _(1511, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR) \ + _(1512, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED) \ + _(1513, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV) \ + _(1519, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST) \ + _(1520, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR) \ + _(1521, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR) \ + _(1522, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED) \ + _(1523, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV) \ + _(1524, ZEND_INCLUDE_OR_EVAL_SPEC_CONST) \ + _(1525, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR) \ + _(1526, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR) \ + _(1528, ZEND_INCLUDE_OR_EVAL_SPEC_CV) \ + _(1529, ZEND_UNSET_VAR_SPEC_CONST_UNUSED) \ + _(1530, ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED) \ + _(1531, ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED) \ + _(1533, ZEND_UNSET_VAR_SPEC_CV_UNUSED) \ + _(1544, ZEND_UNSET_DIM_SPEC_VAR_CONST) \ + _(1545, ZEND_UNSET_DIM_SPEC_VAR_TMPVAR) \ + _(1546, ZEND_UNSET_DIM_SPEC_VAR_TMPVAR) \ + _(1548, ZEND_UNSET_DIM_SPEC_VAR_CV) \ + _(1554, ZEND_UNSET_DIM_SPEC_CV_CONST) \ + _(1555, ZEND_UNSET_DIM_SPEC_CV_TMPVAR) \ + _(1556, ZEND_UNSET_DIM_SPEC_CV_TMPVAR) \ + _(1558, ZEND_UNSET_DIM_SPEC_CV_CV) \ + _(1569, ZEND_UNSET_OBJ_SPEC_VAR_CONST) \ + _(1570, ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR) \ + _(1571, ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR) \ + _(1573, ZEND_UNSET_OBJ_SPEC_VAR_CV) \ + _(1574, ZEND_UNSET_OBJ_SPEC_UNUSED_CONST) \ + _(1575, ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR) \ + _(1576, ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR) \ + _(1578, ZEND_UNSET_OBJ_SPEC_UNUSED_CV) \ + _(1579, ZEND_UNSET_OBJ_SPEC_CV_CONST) \ + _(1580, ZEND_UNSET_OBJ_SPEC_CV_TMPVAR) \ + _(1581, ZEND_UNSET_OBJ_SPEC_CV_TMPVAR) \ + _(1583, ZEND_UNSET_OBJ_SPEC_CV_CV) \ + _(1584, ZEND_FE_RESET_R_SPEC_CONST) \ + _(1585, ZEND_FE_RESET_R_SPEC_TMP) \ + _(1586, ZEND_FE_RESET_R_SPEC_VAR) \ + _(1588, ZEND_FE_RESET_R_SPEC_CV) \ + _(1589, ZEND_FE_FETCH_R_SPEC_VAR) \ + _(1590, ZEND_EXIT_SPEC) \ + _(1591, ZEND_FETCH_R_SPEC_CONST_UNUSED) \ + _(1592, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \ + _(1593, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \ + _(1595, ZEND_FETCH_R_SPEC_CV_UNUSED) \ + _(1596, ZEND_FETCH_DIM_R_SPEC_CONST_CONST) \ + _(1597, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \ + _(1598, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \ + _(1600, ZEND_FETCH_DIM_R_SPEC_CONST_CV) \ + _(1601, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \ + _(1602, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ + _(1603, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ + _(1605, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \ + _(1606, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \ + _(1607, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ + _(1608, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ + _(1610, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \ + _(1616, ZEND_FETCH_DIM_R_SPEC_CV_CONST) \ + _(1617, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \ + _(1618, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \ + _(1620, ZEND_FETCH_DIM_R_SPEC_CV_CV) \ + _(1621, ZEND_FETCH_OBJ_R_SPEC_CONST_CONST) \ + _(1622, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \ + _(1623, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \ + _(1625, ZEND_FETCH_OBJ_R_SPEC_CONST_CV) \ + _(1626, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \ + _(1627, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ + _(1628, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ + _(1630, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \ + _(1631, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \ + _(1632, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ + _(1633, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ + _(1635, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \ + _(1636, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST) \ + _(1637, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \ + _(1638, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \ + _(1640, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV) \ + _(1641, ZEND_FETCH_OBJ_R_SPEC_CV_CONST) \ + _(1642, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \ + _(1643, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \ + _(1645, ZEND_FETCH_OBJ_R_SPEC_CV_CV) \ + _(1646, ZEND_FETCH_W_SPEC_CONST_UNUSED) \ + _(1647, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \ + _(1648, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \ + _(1650, ZEND_FETCH_W_SPEC_CV_UNUSED) \ + _(1661, ZEND_FETCH_DIM_W_SPEC_VAR_CONST) \ + _(1662, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \ + _(1663, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \ + _(1664, ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED) \ + _(1665, ZEND_FETCH_DIM_W_SPEC_VAR_CV) \ + _(1671, ZEND_FETCH_DIM_W_SPEC_CV_CONST) \ + _(1672, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \ + _(1673, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \ + _(1674, ZEND_FETCH_DIM_W_SPEC_CV_UNUSED) \ + _(1675, ZEND_FETCH_DIM_W_SPEC_CV_CV) \ + _(1686, ZEND_FETCH_OBJ_W_SPEC_VAR_CONST) \ + _(1687, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \ + _(1688, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \ + _(1690, ZEND_FETCH_OBJ_W_SPEC_VAR_CV) \ + _(1691, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST) \ + _(1692, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \ + _(1693, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \ + _(1695, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV) \ + _(1696, ZEND_FETCH_OBJ_W_SPEC_CV_CONST) \ + _(1697, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \ + _(1698, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \ + _(1700, ZEND_FETCH_OBJ_W_SPEC_CV_CV) \ + _(1701, ZEND_FETCH_RW_SPEC_CONST_UNUSED) \ + _(1702, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \ + _(1703, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \ + _(1705, ZEND_FETCH_RW_SPEC_CV_UNUSED) \ + _(1716, ZEND_FETCH_DIM_RW_SPEC_VAR_CONST) \ + _(1717, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \ + _(1718, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \ + _(1719, ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED) \ + _(1720, ZEND_FETCH_DIM_RW_SPEC_VAR_CV) \ + _(1726, ZEND_FETCH_DIM_RW_SPEC_CV_CONST) \ + _(1727, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \ + _(1728, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \ + _(1729, ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED) \ + _(1730, ZEND_FETCH_DIM_RW_SPEC_CV_CV) \ + _(1741, ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST) \ + _(1742, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \ + _(1743, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \ + _(1745, ZEND_FETCH_OBJ_RW_SPEC_VAR_CV) \ + _(1746, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST) \ + _(1747, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \ + _(1748, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \ + _(1750, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV) \ + _(1751, ZEND_FETCH_OBJ_RW_SPEC_CV_CONST) \ + _(1752, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \ + _(1753, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \ + _(1755, ZEND_FETCH_OBJ_RW_SPEC_CV_CV) \ + _(1756, ZEND_FETCH_IS_SPEC_CONST_UNUSED) \ + _(1757, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \ + _(1758, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \ + _(1760, ZEND_FETCH_IS_SPEC_CV_UNUSED) \ + _(1761, ZEND_FETCH_DIM_IS_SPEC_CONST_CONST) \ + _(1762, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \ + _(1763, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \ + _(1765, ZEND_FETCH_DIM_IS_SPEC_CONST_CV) \ + _(1766, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \ + _(1767, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ + _(1768, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ + _(1770, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \ + _(1771, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \ + _(1772, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ + _(1773, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ + _(1775, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \ + _(1781, ZEND_FETCH_DIM_IS_SPEC_CV_CONST) \ + _(1782, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \ + _(1783, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \ + _(1785, ZEND_FETCH_DIM_IS_SPEC_CV_CV) \ + _(1786, ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST) \ + _(1787, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \ + _(1788, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \ + _(1790, ZEND_FETCH_OBJ_IS_SPEC_CONST_CV) \ + _(1791, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \ + _(1792, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ + _(1793, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ + _(1795, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \ + _(1796, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \ + _(1797, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ + _(1798, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ + _(1800, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \ + _(1801, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST) \ + _(1802, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \ + _(1803, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \ + _(1805, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV) \ + _(1806, ZEND_FETCH_OBJ_IS_SPEC_CV_CONST) \ + _(1807, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \ + _(1808, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \ + _(1810, ZEND_FETCH_OBJ_IS_SPEC_CV_CV) \ + _(1811, ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED) \ + _(1812, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \ + _(1813, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \ + _(1815, ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED) \ + _(1816, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST) \ + _(1817, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \ + _(1818, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \ + _(1819, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED) \ + _(1820, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV) \ + _(1821, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST) \ + _(1822, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \ + _(1823, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \ + _(1824, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED) \ + _(1825, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV) \ + _(1826, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST) \ + _(1827, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \ + _(1828, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \ + _(1829, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED) \ + _(1830, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV) \ + _(1836, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST) \ + _(1837, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \ + _(1838, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \ + _(1839, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED) \ + _(1840, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV) \ + _(1841, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST) \ + _(1842, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \ + _(1843, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \ + _(1845, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV) \ + _(1846, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST) \ + _(1847, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \ + _(1848, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \ + _(1850, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV) \ + _(1851, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST) \ + _(1852, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \ + _(1853, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \ + _(1855, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV) \ + _(1856, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST) \ + _(1857, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \ + _(1858, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \ + _(1860, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV) \ + _(1861, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST) \ + _(1862, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \ + _(1863, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \ + _(1865, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV) \ + _(1866, ZEND_FETCH_UNSET_SPEC_CONST_UNUSED) \ + _(1867, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \ + _(1868, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \ + _(1870, ZEND_FETCH_UNSET_SPEC_CV_UNUSED) \ + _(1881, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST) \ + _(1882, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \ + _(1883, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \ + _(1885, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV) \ + _(1891, ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST) \ + _(1892, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \ + _(1893, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \ + _(1895, ZEND_FETCH_DIM_UNSET_SPEC_CV_CV) \ + _(1906, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST) \ + _(1907, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \ + _(1908, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \ + _(1910, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV) \ + _(1911, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST) \ + _(1912, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \ + _(1913, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \ + _(1915, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV) \ + _(1916, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST) \ + _(1917, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \ + _(1918, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \ + _(1920, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV) \ + _(1921, ZEND_FETCH_LIST_R_SPEC_CONST_CONST) \ + _(1922, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \ + _(1923, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \ + _(1925, ZEND_FETCH_LIST_R_SPEC_CONST_CV) \ + _(1926, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ + _(1927, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ + _(1928, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ + _(1930, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ + _(1931, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ + _(1932, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ + _(1933, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ + _(1935, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ + _(1941, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ + _(1942, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ + _(1943, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ + _(1945, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ + _(1946, ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST) \ + _(1947, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST) \ + _(1948, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST) \ + _(1953, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED) \ + _(1954, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK) \ + _(1957, ZEND_EXT_STMT_SPEC) \ + _(1958, ZEND_EXT_FCALL_BEGIN_SPEC) \ + _(1959, ZEND_EXT_FCALL_END_SPEC) \ + _(1960, ZEND_EXT_NOP_SPEC) \ + _(1961, ZEND_TICKS_SPEC) \ + _(1962, ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST) \ + _(1965, ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED) \ + _(1967, ZEND_CATCH_SPEC_CONST) \ + _(1968, ZEND_THROW_SPEC_CONST) \ + _(1969, ZEND_THROW_SPEC_TMPVAR) \ + _(1970, ZEND_THROW_SPEC_TMPVAR) \ + _(1972, ZEND_THROW_SPEC_CV) \ + _(1973, ZEND_FETCH_CLASS_SPEC_UNUSED_CONST) \ + _(1974, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \ + _(1975, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \ + _(1976, ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED) \ + _(1977, ZEND_FETCH_CLASS_SPEC_UNUSED_CV) \ + _(1978, ZEND_CLONE_SPEC_CONST) \ + _(1979, ZEND_CLONE_SPEC_TMPVAR) \ + _(1980, ZEND_CLONE_SPEC_TMPVAR) \ + _(1981, ZEND_CLONE_SPEC_UNUSED) \ + _(1982, ZEND_CLONE_SPEC_CV) \ + _(1983, ZEND_RETURN_BY_REF_SPEC_CONST) \ + _(1984, ZEND_RETURN_BY_REF_SPEC_CONST_OBSERVER) \ + _(1985, ZEND_RETURN_BY_REF_SPEC_TMP) \ + _(1986, ZEND_RETURN_BY_REF_SPEC_TMP_OBSERVER) \ + _(1987, ZEND_RETURN_BY_REF_SPEC_VAR) \ + _(1988, ZEND_RETURN_BY_REF_SPEC_VAR_OBSERVER) \ + _(1991, ZEND_RETURN_BY_REF_SPEC_CV) \ + _(1992, ZEND_RETURN_BY_REF_SPEC_CV_OBSERVER) \ + _(1993, ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST) \ + _(1994, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \ + _(1995, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \ + _(1997, ZEND_INIT_METHOD_CALL_SPEC_CONST_CV) \ + _(1998, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \ + _(1999, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ + _(2000, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ + _(2002, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \ + _(2003, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \ + _(2004, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ + _(2005, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ + _(2007, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \ + _(2008, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST) \ + _(2009, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ + _(2010, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ + _(2012, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV) \ + _(2013, ZEND_INIT_METHOD_CALL_SPEC_CV_CONST) \ + _(2014, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \ + _(2015, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \ + _(2017, ZEND_INIT_METHOD_CALL_SPEC_CV_CV) \ + _(2018, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST) \ + _(2019, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \ + _(2020, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \ + _(2021, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED) \ + _(2022, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV) \ + _(2028, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST) \ + _(2029, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \ + _(2030, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \ + _(2031, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED) \ + _(2032, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV) \ + _(2033, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST) \ + _(2034, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ + _(2035, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ + _(2036, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED) \ + _(2037, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV) \ + _(2043, ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED) \ + _(2044, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \ + _(2045, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \ + _(2047, ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED) \ + _(2048, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST) \ + _(2049, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \ + _(2050, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \ + _(2052, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV) \ + _(2053, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \ + _(2054, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2055, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2057, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \ + _(2058, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \ + _(2059, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2060, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2062, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \ + _(2068, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST) \ + _(2069, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \ + _(2070, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \ + _(2072, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV) \ + _(2073, ZEND_SEND_VAL_EX_SPEC_CONST_CONST) \ + _(2074, ZEND_SEND_VAL_EX_SPEC_CONST_CONST) \ + _(2079, ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED) \ + _(2080, ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK) \ + _(2083, ZEND_SEND_VAL_EX_SPEC_TMP_CONST) \ + _(2084, ZEND_SEND_VAL_EX_SPEC_TMP_CONST) \ + _(2089, ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED) \ + _(2090, ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK) \ + _(2133, ZEND_SEND_VAR_SPEC_VAR_CONST) \ + _(2136, ZEND_SEND_VAR_SPEC_VAR_UNUSED) \ + _(2143, ZEND_SEND_VAR_SPEC_CV_CONST) \ + _(2146, ZEND_SEND_VAR_SPEC_CV_UNUSED) \ + _(2148, ZEND_INIT_USER_CALL_SPEC_CONST_CONST) \ + _(2149, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \ + _(2150, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \ + _(2152, ZEND_INIT_USER_CALL_SPEC_CONST_CV) \ + _(2153, ZEND_SEND_ARRAY_SPEC) \ + _(2154, ZEND_SEND_USER_SPEC_CONST) \ + _(2155, ZEND_SEND_USER_SPEC_TMP) \ + _(2156, ZEND_SEND_USER_SPEC_VAR) \ + _(2158, ZEND_SEND_USER_SPEC_CV) \ + _(2159, ZEND_STRLEN_SPEC_CONST) \ + _(2160, ZEND_STRLEN_SPEC_TMPVAR) \ + _(2161, ZEND_STRLEN_SPEC_TMPVAR) \ + _(2163, ZEND_STRLEN_SPEC_CV) \ + _(2164, ZEND_DEFINED_SPEC_CONST) \ + _(2165, ZEND_TYPE_CHECK_SPEC_CONST) \ + _(2166, ZEND_TYPE_CHECK_SPEC_TMPVAR) \ + _(2167, ZEND_TYPE_CHECK_SPEC_TMPVAR) \ + _(2169, ZEND_TYPE_CHECK_SPEC_CV) \ + _(2170, ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED) \ + _(2171, ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED) \ + _(2172, ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED) \ + _(2173, ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED) \ + _(2174, ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED) \ + _(2175, ZEND_FE_RESET_RW_SPEC_CONST) \ + _(2176, ZEND_FE_RESET_RW_SPEC_TMP) \ + _(2177, ZEND_FE_RESET_RW_SPEC_VAR) \ + _(2179, ZEND_FE_RESET_RW_SPEC_CV) \ + _(2180, ZEND_FE_FETCH_RW_SPEC_VAR) \ + _(2181, ZEND_FE_FREE_SPEC_TMPVAR) \ + _(2182, ZEND_INIT_DYNAMIC_CALL_SPEC_CONST) \ + _(2183, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \ + _(2184, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \ + _(2186, ZEND_INIT_DYNAMIC_CALL_SPEC_CV) \ + _(2187, ZEND_DO_ICALL_SPEC_RETVAL_UNUSED) \ + _(2188, ZEND_DO_ICALL_SPEC_RETVAL_USED) \ + _(2189, ZEND_DO_UCALL_SPEC_RETVAL_UNUSED) \ + _(2190, ZEND_DO_UCALL_SPEC_RETVAL_USED) \ + _(2191, ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_OBSERVER) \ + _(2192, ZEND_DO_UCALL_SPEC_RETVAL_USED_OBSERVER) \ + _(2193, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED) \ + _(2194, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED) \ + _(2195, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_OBSERVER) \ + _(2196, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_OBSERVER) \ + _(2207, ZEND_PRE_INC_OBJ_SPEC_VAR_CONST) \ + _(2208, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \ + _(2209, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \ + _(2211, ZEND_PRE_INC_OBJ_SPEC_VAR_CV) \ + _(2212, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST) \ + _(2213, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2214, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2216, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV) \ + _(2217, ZEND_PRE_INC_OBJ_SPEC_CV_CONST) \ + _(2218, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \ + _(2219, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \ + _(2221, ZEND_PRE_INC_OBJ_SPEC_CV_CV) \ + _(2232, ZEND_POST_INC_OBJ_SPEC_VAR_CONST) \ + _(2233, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \ + _(2234, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \ + _(2236, ZEND_POST_INC_OBJ_SPEC_VAR_CV) \ + _(2237, ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST) \ + _(2238, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2239, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2241, ZEND_POST_INC_OBJ_SPEC_UNUSED_CV) \ + _(2242, ZEND_POST_INC_OBJ_SPEC_CV_CONST) \ + _(2243, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \ + _(2244, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \ + _(2246, ZEND_POST_INC_OBJ_SPEC_CV_CV) \ + _(2247, ZEND_ECHO_SPEC_CONST) \ + _(2248, ZEND_ECHO_SPEC_TMPVAR) \ + _(2249, ZEND_ECHO_SPEC_TMPVAR) \ + _(2251, ZEND_ECHO_SPEC_CV) \ + _(2258, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \ + _(2260, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \ + _(2261, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \ + _(2263, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \ + _(2265, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \ + _(2266, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \ + _(2273, ZEND_INSTANCEOF_SPEC_CV_CONST) \ + _(2275, ZEND_INSTANCEOF_SPEC_CV_VAR) \ + _(2276, ZEND_INSTANCEOF_SPEC_CV_UNUSED) \ + _(2278, ZEND_GENERATOR_CREATE_SPEC) \ + _(2281, ZEND_MAKE_REF_SPEC_VAR_UNUSED) \ + _(2283, ZEND_MAKE_REF_SPEC_CV_UNUSED) \ + _(2284, ZEND_DECLARE_FUNCTION_SPEC) \ + _(2285, ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED) \ + _(2286, ZEND_DECLARE_CONST_SPEC_CONST_CONST) \ + _(2287, ZEND_DECLARE_CLASS_SPEC_CONST) \ + _(2288, ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST) \ + _(2289, ZEND_DECLARE_ANON_CLASS_SPEC) \ + _(2290, ZEND_ADD_ARRAY_UNPACK_SPEC) \ + _(2291, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST) \ + _(2292, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \ + _(2293, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \ + _(2295, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV) \ + _(2296, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ _(2297, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2299, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ - _(2300, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST) \ - _(2301, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2302, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2304, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV) \ - _(2305, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST) \ - _(2306, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ - _(2307, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ - _(2309, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV) \ - _(2310, ZEND_HANDLE_EXCEPTION_SPEC) \ - _(2311, ZEND_USER_OPCODE_SPEC) \ - _(2312, ZEND_ASSERT_CHECK_SPEC) \ - _(2313, ZEND_JMP_SET_SPEC_CONST) \ - _(2314, ZEND_JMP_SET_SPEC_TMP) \ - _(2315, ZEND_JMP_SET_SPEC_VAR) \ - _(2317, ZEND_JMP_SET_SPEC_CV) \ - _(2318, ZEND_UNSET_CV_SPEC_CV_UNUSED) \ - _(2319, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET) \ - _(2320, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY) \ - _(2321, ZEND_FETCH_LIST_W_SPEC_VAR_CONST) \ - _(2322, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ - _(2323, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ - _(2325, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \ - _(2326, ZEND_SEPARATE_SPEC_VAR_UNUSED) \ - _(2328, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \ - _(2329, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \ - _(2330, ZEND_FETCH_CLASS_NAME_SPEC_UNUSED) \ - _(2331, ZEND_FETCH_CLASS_NAME_SPEC_CV) \ - _(2332, ZEND_CALL_TRAMPOLINE_SPEC) \ - _(2333, ZEND_DISCARD_EXCEPTION_SPEC) \ - _(2334, ZEND_YIELD_SPEC_CONST_CONST) \ - _(2335, ZEND_YIELD_SPEC_CONST_TMPVAR) \ - _(2336, ZEND_YIELD_SPEC_CONST_TMPVAR) \ - _(2337, ZEND_YIELD_SPEC_CONST_UNUSED) \ - _(2338, ZEND_YIELD_SPEC_CONST_CV) \ - _(2339, ZEND_YIELD_SPEC_TMP_CONST) \ - _(2340, ZEND_YIELD_SPEC_TMP_TMPVAR) \ - _(2341, ZEND_YIELD_SPEC_TMP_TMPVAR) \ - _(2342, ZEND_YIELD_SPEC_TMP_UNUSED) \ - _(2343, ZEND_YIELD_SPEC_TMP_CV) \ - _(2344, ZEND_YIELD_SPEC_VAR_CONST) \ - _(2345, ZEND_YIELD_SPEC_VAR_TMPVAR) \ - _(2346, ZEND_YIELD_SPEC_VAR_TMPVAR) \ - _(2347, ZEND_YIELD_SPEC_VAR_UNUSED) \ - _(2348, ZEND_YIELD_SPEC_VAR_CV) \ - _(2349, ZEND_YIELD_SPEC_UNUSED_CONST) \ - _(2350, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \ - _(2351, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \ - _(2352, ZEND_YIELD_SPEC_UNUSED_UNUSED) \ - _(2353, ZEND_YIELD_SPEC_UNUSED_CV) \ - _(2354, ZEND_YIELD_SPEC_CV_CONST) \ - _(2355, ZEND_YIELD_SPEC_CV_TMPVAR) \ - _(2356, ZEND_YIELD_SPEC_CV_TMPVAR) \ - _(2357, ZEND_YIELD_SPEC_CV_UNUSED) \ - _(2358, ZEND_YIELD_SPEC_CV_CV) \ - _(2359, ZEND_GENERATOR_RETURN_SPEC_CONST) \ - _(2360, ZEND_GENERATOR_RETURN_SPEC_CONST_OBSERVER) \ - _(2361, ZEND_GENERATOR_RETURN_SPEC_TMP) \ - _(2362, ZEND_GENERATOR_RETURN_SPEC_TMP_OBSERVER) \ - _(2363, ZEND_GENERATOR_RETURN_SPEC_VAR) \ - _(2364, ZEND_GENERATOR_RETURN_SPEC_VAR_OBSERVER) \ - _(2367, ZEND_GENERATOR_RETURN_SPEC_CV) \ - _(2368, ZEND_GENERATOR_RETURN_SPEC_CV_OBSERVER) \ - _(2369, ZEND_FAST_CALL_SPEC) \ - _(2370, ZEND_FAST_RET_SPEC) \ - _(2371, ZEND_RECV_VARIADIC_SPEC_UNUSED) \ - _(2372, ZEND_SEND_UNPACK_SPEC) \ - _(2373, ZEND_YIELD_FROM_SPEC_CONST) \ - _(2374, ZEND_YIELD_FROM_SPEC_TMPVAR) \ - _(2375, ZEND_YIELD_FROM_SPEC_TMPVAR) \ - _(2377, ZEND_YIELD_FROM_SPEC_CV) \ - _(2378, ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED) \ - _(2379, ZEND_BIND_GLOBAL_SPEC_CV_CONST) \ - _(2380, ZEND_COALESCE_SPEC_CONST) \ - _(2381, ZEND_COALESCE_SPEC_TMP) \ - _(2382, ZEND_COALESCE_SPEC_VAR) \ - _(2384, ZEND_COALESCE_SPEC_CV) \ - _(2385, ZEND_SPACESHIP_SPEC_CONST_CONST) \ - _(2386, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ - _(2387, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ - _(2389, ZEND_SPACESHIP_SPEC_CONST_CV) \ - _(2390, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ - _(2391, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(2392, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(2394, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ - _(2395, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ - _(2396, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(2397, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(2399, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ - _(2405, ZEND_SPACESHIP_SPEC_CV_CONST) \ - _(2406, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ - _(2407, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ - _(2409, ZEND_SPACESHIP_SPEC_CV_CV) \ - _(2410, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED) \ - _(2411, ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED) \ - _(2414, ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED) \ - _(2416, ZEND_FETCH_STATIC_PROP_R_SPEC) \ - _(2417, ZEND_FETCH_STATIC_PROP_W_SPEC) \ - _(2418, ZEND_FETCH_STATIC_PROP_RW_SPEC) \ - _(2419, ZEND_FETCH_STATIC_PROP_IS_SPEC) \ - _(2420, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC) \ - _(2421, ZEND_FETCH_STATIC_PROP_UNSET_SPEC) \ - _(2422, ZEND_UNSET_STATIC_PROP_SPEC) \ - _(2423, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC) \ - _(2424, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) \ - _(2426, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) \ - _(2427, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST) \ - _(2429, ZEND_BIND_LEXICAL_SPEC_TMP_CV) \ - _(2430, ZEND_BIND_STATIC_SPEC_CV_UNUSED) \ - _(2431, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED) \ - _(2432, ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST) \ - _(2435, ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED) \ - _(2437, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED) \ - _(2438, ZEND_SWITCH_LONG_SPEC_CONST_CONST) \ - _(2439, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(2440, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(2442, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(2443, ZEND_SWITCH_STRING_SPEC_CONST_CONST) \ - _(2444, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(2445, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(2447, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(2448, ZEND_IN_ARRAY_SPEC_CONST_CONST) \ - _(2449, ZEND_IN_ARRAY_SPEC_TMP_CONST) \ - _(2450, ZEND_IN_ARRAY_SPEC_VAR_CONST) \ - _(2452, ZEND_IN_ARRAY_SPEC_CV_CONST) \ - _(2453, ZEND_COUNT_SPEC_CONST_UNUSED) \ - _(2454, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \ - _(2455, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \ - _(2457, ZEND_COUNT_SPEC_CV_UNUSED) \ - _(2458, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \ - _(2459, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \ - _(2460, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \ - _(2461, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED) \ - _(2462, ZEND_GET_CLASS_SPEC_CV_UNUSED) \ - _(2463, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED) \ - _(2464, ZEND_GET_TYPE_SPEC_CONST_UNUSED) \ - _(2465, ZEND_GET_TYPE_SPEC_TMP_UNUSED) \ - _(2466, ZEND_GET_TYPE_SPEC_VAR_UNUSED) \ - _(2468, ZEND_GET_TYPE_SPEC_CV_UNUSED) \ - _(2469, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \ - _(2470, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ - _(2471, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ - _(2473, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \ - _(2474, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ - _(2475, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(2476, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(2478, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ - _(2479, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ - _(2480, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(2481, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(2483, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ - _(2489, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \ - _(2490, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ - _(2491, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ - _(2493, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \ - _(2494, ZEND_MATCH_SPEC_CONST_CONST) \ - _(2495, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ - _(2496, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ - _(2498, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ - _(2504, ZEND_CASE_STRICT_SPEC_TMP_CONST) \ - _(2505, ZEND_CASE_STRICT_SPEC_TMP_TMP) \ - _(2506, ZEND_CASE_STRICT_SPEC_TMP_VAR) \ - _(2508, ZEND_CASE_STRICT_SPEC_TMP_CV) \ - _(2509, ZEND_CASE_STRICT_SPEC_VAR_CONST) \ - _(2510, ZEND_CASE_STRICT_SPEC_VAR_TMP) \ - _(2511, ZEND_CASE_STRICT_SPEC_VAR_VAR) \ - _(2513, ZEND_CASE_STRICT_SPEC_VAR_CV) \ - _(2524, ZEND_MATCH_ERROR_SPEC_CONST_UNUSED) \ - _(2525, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ - _(2526, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ - _(2528, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ - _(2529, ZEND_JMP_NULL_SPEC_CONST) \ - _(2530, ZEND_JMP_NULL_SPEC_TMPVARCV) \ - _(2531, ZEND_JMP_NULL_SPEC_TMPVARCV) \ - _(2533, ZEND_JMP_NULL_SPEC_TMPVARCV) \ - _(2534, ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED) \ - _(2535, ZEND_RECV_NOTYPE_SPEC) \ - _(2536, ZEND_JMP_FORWARD_SPEC) \ - _(2542, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2543, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2544, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2546, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2547, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2548, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2549, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2298, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2300, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ + _(2301, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ + _(2302, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2303, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2305, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ + _(2306, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST) \ + _(2307, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2308, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2310, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV) \ + _(2311, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST) \ + _(2312, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ + _(2313, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ + _(2315, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV) \ + _(2316, ZEND_HANDLE_EXCEPTION_SPEC) \ + _(2317, ZEND_USER_OPCODE_SPEC) \ + _(2318, ZEND_ASSERT_CHECK_SPEC) \ + _(2319, ZEND_JMP_SET_SPEC_CONST) \ + _(2320, ZEND_JMP_SET_SPEC_TMP) \ + _(2321, ZEND_JMP_SET_SPEC_VAR) \ + _(2323, ZEND_JMP_SET_SPEC_CV) \ + _(2324, ZEND_UNSET_CV_SPEC_CV_UNUSED) \ + _(2325, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET) \ + _(2326, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY) \ + _(2327, ZEND_FETCH_LIST_W_SPEC_VAR_CONST) \ + _(2328, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ + _(2329, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ + _(2331, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \ + _(2332, ZEND_SEPARATE_SPEC_VAR_UNUSED) \ + _(2334, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \ + _(2335, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \ + _(2336, ZEND_FETCH_CLASS_NAME_SPEC_UNUSED) \ + _(2337, ZEND_FETCH_CLASS_NAME_SPEC_CV) \ + _(2338, ZEND_CALL_TRAMPOLINE_SPEC) \ + _(2339, ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER) \ + _(2340, ZEND_DISCARD_EXCEPTION_SPEC) \ + _(2341, ZEND_YIELD_SPEC_CONST_CONST) \ + _(2342, ZEND_YIELD_SPEC_CONST_TMPVAR) \ + _(2343, ZEND_YIELD_SPEC_CONST_TMPVAR) \ + _(2344, ZEND_YIELD_SPEC_CONST_UNUSED) \ + _(2345, ZEND_YIELD_SPEC_CONST_CV) \ + _(2346, ZEND_YIELD_SPEC_TMP_CONST) \ + _(2347, ZEND_YIELD_SPEC_TMP_TMPVAR) \ + _(2348, ZEND_YIELD_SPEC_TMP_TMPVAR) \ + _(2349, ZEND_YIELD_SPEC_TMP_UNUSED) \ + _(2350, ZEND_YIELD_SPEC_TMP_CV) \ + _(2351, ZEND_YIELD_SPEC_VAR_CONST) \ + _(2352, ZEND_YIELD_SPEC_VAR_TMPVAR) \ + _(2353, ZEND_YIELD_SPEC_VAR_TMPVAR) \ + _(2354, ZEND_YIELD_SPEC_VAR_UNUSED) \ + _(2355, ZEND_YIELD_SPEC_VAR_CV) \ + _(2356, ZEND_YIELD_SPEC_UNUSED_CONST) \ + _(2357, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \ + _(2358, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \ + _(2359, ZEND_YIELD_SPEC_UNUSED_UNUSED) \ + _(2360, ZEND_YIELD_SPEC_UNUSED_CV) \ + _(2361, ZEND_YIELD_SPEC_CV_CONST) \ + _(2362, ZEND_YIELD_SPEC_CV_TMPVAR) \ + _(2363, ZEND_YIELD_SPEC_CV_TMPVAR) \ + _(2364, ZEND_YIELD_SPEC_CV_UNUSED) \ + _(2365, ZEND_YIELD_SPEC_CV_CV) \ + _(2366, ZEND_GENERATOR_RETURN_SPEC_CONST) \ + _(2367, ZEND_GENERATOR_RETURN_SPEC_CONST_OBSERVER) \ + _(2368, ZEND_GENERATOR_RETURN_SPEC_TMP) \ + _(2369, ZEND_GENERATOR_RETURN_SPEC_TMP_OBSERVER) \ + _(2370, ZEND_GENERATOR_RETURN_SPEC_VAR) \ + _(2371, ZEND_GENERATOR_RETURN_SPEC_VAR_OBSERVER) \ + _(2374, ZEND_GENERATOR_RETURN_SPEC_CV) \ + _(2375, ZEND_GENERATOR_RETURN_SPEC_CV_OBSERVER) \ + _(2376, ZEND_FAST_CALL_SPEC) \ + _(2377, ZEND_FAST_RET_SPEC) \ + _(2378, ZEND_RECV_VARIADIC_SPEC_UNUSED) \ + _(2379, ZEND_SEND_UNPACK_SPEC) \ + _(2380, ZEND_YIELD_FROM_SPEC_CONST) \ + _(2381, ZEND_YIELD_FROM_SPEC_TMPVAR) \ + _(2382, ZEND_YIELD_FROM_SPEC_TMPVAR) \ + _(2384, ZEND_YIELD_FROM_SPEC_CV) \ + _(2385, ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED) \ + _(2386, ZEND_BIND_GLOBAL_SPEC_CV_CONST) \ + _(2387, ZEND_COALESCE_SPEC_CONST) \ + _(2388, ZEND_COALESCE_SPEC_TMP) \ + _(2389, ZEND_COALESCE_SPEC_VAR) \ + _(2391, ZEND_COALESCE_SPEC_CV) \ + _(2392, ZEND_SPACESHIP_SPEC_CONST_CONST) \ + _(2393, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ + _(2394, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ + _(2396, ZEND_SPACESHIP_SPEC_CONST_CV) \ + _(2397, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ + _(2398, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ + _(2399, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ + _(2401, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ + _(2402, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ + _(2403, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ + _(2404, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ + _(2406, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ + _(2412, ZEND_SPACESHIP_SPEC_CV_CONST) \ + _(2413, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ + _(2414, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ + _(2416, ZEND_SPACESHIP_SPEC_CV_CV) \ + _(2417, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED) \ + _(2418, ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED) \ + _(2421, ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED) \ + _(2423, ZEND_FETCH_STATIC_PROP_R_SPEC) \ + _(2424, ZEND_FETCH_STATIC_PROP_W_SPEC) \ + _(2425, ZEND_FETCH_STATIC_PROP_RW_SPEC) \ + _(2426, ZEND_FETCH_STATIC_PROP_IS_SPEC) \ + _(2427, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC) \ + _(2428, ZEND_FETCH_STATIC_PROP_UNSET_SPEC) \ + _(2429, ZEND_UNSET_STATIC_PROP_SPEC) \ + _(2430, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC) \ + _(2431, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) \ + _(2433, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) \ + _(2434, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST) \ + _(2436, ZEND_BIND_LEXICAL_SPEC_TMP_CV) \ + _(2437, ZEND_BIND_STATIC_SPEC_CV_UNUSED) \ + _(2438, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED) \ + _(2439, ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST) \ + _(2442, ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED) \ + _(2444, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED) \ + _(2445, ZEND_SWITCH_LONG_SPEC_CONST_CONST) \ + _(2446, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(2447, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(2449, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(2450, ZEND_SWITCH_STRING_SPEC_CONST_CONST) \ + _(2451, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(2452, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(2454, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(2455, ZEND_IN_ARRAY_SPEC_CONST_CONST) \ + _(2456, ZEND_IN_ARRAY_SPEC_TMP_CONST) \ + _(2457, ZEND_IN_ARRAY_SPEC_VAR_CONST) \ + _(2459, ZEND_IN_ARRAY_SPEC_CV_CONST) \ + _(2460, ZEND_COUNT_SPEC_CONST_UNUSED) \ + _(2461, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \ + _(2462, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \ + _(2464, ZEND_COUNT_SPEC_CV_UNUSED) \ + _(2465, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \ + _(2466, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \ + _(2467, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \ + _(2468, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED) \ + _(2469, ZEND_GET_CLASS_SPEC_CV_UNUSED) \ + _(2470, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED) \ + _(2471, ZEND_GET_TYPE_SPEC_CONST_UNUSED) \ + _(2472, ZEND_GET_TYPE_SPEC_TMP_UNUSED) \ + _(2473, ZEND_GET_TYPE_SPEC_VAR_UNUSED) \ + _(2475, ZEND_GET_TYPE_SPEC_CV_UNUSED) \ + _(2476, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \ + _(2477, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ + _(2478, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ + _(2480, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \ + _(2481, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ + _(2482, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(2483, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(2485, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ + _(2486, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ + _(2487, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(2488, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(2490, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ + _(2496, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \ + _(2497, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ + _(2498, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ + _(2500, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \ + _(2501, ZEND_MATCH_SPEC_CONST_CONST) \ + _(2502, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ + _(2503, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ + _(2505, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ + _(2511, ZEND_CASE_STRICT_SPEC_TMP_CONST) \ + _(2512, ZEND_CASE_STRICT_SPEC_TMP_TMP) \ + _(2513, ZEND_CASE_STRICT_SPEC_TMP_VAR) \ + _(2515, ZEND_CASE_STRICT_SPEC_TMP_CV) \ + _(2516, ZEND_CASE_STRICT_SPEC_VAR_CONST) \ + _(2517, ZEND_CASE_STRICT_SPEC_VAR_TMP) \ + _(2518, ZEND_CASE_STRICT_SPEC_VAR_VAR) \ + _(2520, ZEND_CASE_STRICT_SPEC_VAR_CV) \ + _(2531, ZEND_MATCH_ERROR_SPEC_CONST_UNUSED) \ + _(2532, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ + _(2533, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ + _(2535, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ + _(2536, ZEND_JMP_NULL_SPEC_CONST) \ + _(2537, ZEND_JMP_NULL_SPEC_TMPVARCV) \ + _(2538, ZEND_JMP_NULL_SPEC_TMPVARCV) \ + _(2540, ZEND_JMP_NULL_SPEC_TMPVARCV) \ + _(2541, ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED) \ + _(2542, ZEND_RECV_NOTYPE_SPEC) \ + _(2543, ZEND_JMP_FORWARD_SPEC) \ + _(2549, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2550, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2551, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2557, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2553, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2554, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2555, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2556, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2558, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2559, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2561, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2567, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2568, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2569, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2571, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2572, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2573, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2574, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2564, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2565, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2566, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2568, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2574, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2575, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2576, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2582, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2578, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2579, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2580, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2581, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2583, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2584, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2586, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2592, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2593, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2594, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2596, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2597, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2598, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2599, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2589, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2590, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2591, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2593, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2599, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2600, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2601, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2607, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2603, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2604, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2605, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2606, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2608, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2609, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2611, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2613, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2614, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2616, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2617, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2618, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2619, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2621, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2622, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2623, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2624, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2614, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2615, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2616, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2618, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2620, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2621, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2623, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2624, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2625, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2626, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2632, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2628, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2629, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2630, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2631, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2633, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2634, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2636, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2638, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2639, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2641, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2642, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2643, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2644, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2646, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2647, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2648, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2649, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2639, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2640, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2641, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2643, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2645, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2646, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2648, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2649, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2650, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2651, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2657, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2653, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2654, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2655, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2656, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2658, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2659, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2661, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2663, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2664, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2666, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2667, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2668, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2669, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2671, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2672, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2673, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2674, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2664, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2665, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2666, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2668, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2670, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2671, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2673, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2674, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2675, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2676, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2682, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2678, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2679, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2680, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2681, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2683, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2684, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2686, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2692, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2693, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2694, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2696, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2697, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2698, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2699, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2689, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2690, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2691, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2693, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2699, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2700, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2701, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2707, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2703, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2704, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2705, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2706, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2708, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2709, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2711, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2717, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2718, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2719, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2721, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2722, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2723, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2724, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2714, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2715, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2716, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2718, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2724, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2725, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2726, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2732, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2728, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2729, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2730, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2731, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2733, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2734, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2736, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2742, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2743, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2744, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2746, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2747, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2748, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2749, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2739, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2740, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2741, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2743, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2749, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2750, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2751, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2757, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2753, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2754, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2755, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2756, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2758, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2759, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2761, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2777, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2778, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2779, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2780, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2781, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2782, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2783, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2784, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2785, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2789, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2790, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2791, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2792, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2793, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2794, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2795, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2796, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2797, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2798, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2799, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2800, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2804, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2805, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2806, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2822, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2823, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2824, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2825, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2826, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2827, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2828, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2829, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2830, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2834, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2835, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2836, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2852, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2853, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2854, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2855, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2856, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2857, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2858, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2859, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2860, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2864, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2865, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2866, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2867, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2868, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2869, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2870, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2871, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2872, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2873, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2874, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2875, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2879, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2880, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2881, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2897, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2898, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2899, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2900, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2901, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2902, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2903, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2904, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2905, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2909, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2910, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2911, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2927, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2928, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2929, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2930, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2931, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2932, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2933, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2934, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2935, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2939, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2940, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2941, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2942, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2943, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2944, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2945, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2946, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2947, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2948, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2949, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2950, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2954, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2955, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2956, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2972, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2973, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2974, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2975, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2976, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2977, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2978, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2979, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2980, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2984, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2985, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2986, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3002, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3003, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3004, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3005, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3006, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3007, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3008, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3009, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3010, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3014, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3015, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3016, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3017, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3018, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3019, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3020, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3021, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3022, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3023, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3024, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3025, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3029, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3030, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3031, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3047, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3048, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3049, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3050, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3051, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3052, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3053, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3054, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3055, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3059, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3060, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3061, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3062, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(3066, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(3067, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(3071, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(3075, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3076, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3077, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3078, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3079, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3080, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3084, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3085, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3086, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3087, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3088, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3089, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3090, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3091, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3092, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3093, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3094, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3095, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3099, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3100, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3101, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3102, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3103, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3104, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3105, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3106, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3107, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3108, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3109, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3110, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3114, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3115, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3116, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3132, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3133, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3134, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3135, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3136, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3137, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3138, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3139, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3140, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3144, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3145, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3146, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3150, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3151, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3152, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3153, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3154, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3155, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3159, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3160, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3161, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3162, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3163, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3164, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3165, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3166, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3167, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3168, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3169, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3170, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3174, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3175, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3176, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3177, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3178, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3179, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3180, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3181, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3182, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3183, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3184, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3185, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3189, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3190, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3191, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3207, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3208, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3209, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3210, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3211, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3212, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3213, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3214, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3215, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3219, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3220, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3221, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3225, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3226, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3227, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3228, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3229, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3230, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3234, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3235, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3236, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3237, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3238, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3239, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3240, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3241, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3242, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3243, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3244, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3245, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3249, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3250, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3251, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3252, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3253, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3254, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3255, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3256, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3257, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3258, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3259, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3260, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3264, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3265, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3266, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3282, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3283, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3284, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3285, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3286, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3287, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3288, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3289, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3290, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3294, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3295, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3296, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3300, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3301, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3302, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3303, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3304, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3305, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3309, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3310, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3311, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3312, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3313, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3314, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3315, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3316, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3317, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3318, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3319, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3320, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3324, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3325, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3326, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3327, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3328, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3329, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3330, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3331, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3332, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3333, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3334, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3335, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3339, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3340, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3341, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3357, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3358, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3359, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3360, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3361, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3362, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3363, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3364, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3365, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3369, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3370, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3371, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3372, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3373, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3374, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3375, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ - _(3376, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3377, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3378, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3379, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ - _(3380, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3381, ZEND_POST_INC_LONG_SPEC_CV) \ - _(3382, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3383, ZEND_POST_DEC_LONG_SPEC_CV) \ - _(3384, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ - _(3385, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3386, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3388, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3389, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ - _(3390, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3391, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3393, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3394, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ - _(3395, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3396, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3398, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3400, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3401, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3403, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3404, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(3405, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3406, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3408, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3409, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(3410, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3411, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(2764, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2765, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2766, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2768, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2784, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2785, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2786, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2787, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2788, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2789, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2790, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2791, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2792, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2796, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2797, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2798, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2799, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2800, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2801, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2802, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2803, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2804, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2805, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2806, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2807, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2811, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2812, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2813, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2829, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2830, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2831, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2832, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2833, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2834, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2835, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2836, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2837, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2841, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2842, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2843, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2859, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2860, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2861, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2862, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2863, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2864, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2865, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2866, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2867, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2871, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2872, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2873, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2874, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2875, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2876, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2877, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2878, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2879, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2880, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2881, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2882, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2886, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2887, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2888, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2904, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2905, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2906, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2907, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2908, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2909, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2910, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2911, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2912, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2916, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2917, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2918, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2934, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2935, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2936, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2937, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2938, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2939, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2940, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2941, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2942, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2946, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2947, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2948, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2949, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2950, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2951, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2952, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2953, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2954, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2955, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2956, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2957, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2961, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2962, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2963, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2979, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2980, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2981, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2982, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2983, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2984, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2985, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2986, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2987, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2991, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2992, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2993, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3009, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3010, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3011, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3012, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3013, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3014, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3015, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3016, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3017, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3021, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3022, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3023, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3024, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3025, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3026, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3027, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3028, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3029, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3030, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3031, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3032, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3036, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3037, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3038, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3054, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3055, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3056, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3057, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3058, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3059, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3060, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3061, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3062, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3066, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3067, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3068, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3069, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3073, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3074, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3078, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3082, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3083, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3084, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3085, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3086, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3087, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3091, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3092, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3093, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3094, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3095, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3096, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3097, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3098, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3099, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3100, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3101, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3102, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3106, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3107, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3108, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3109, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3110, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3111, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3112, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3113, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3114, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3115, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3116, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3117, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3121, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3122, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3123, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3139, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3140, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3141, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3142, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3143, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3144, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3145, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3146, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3147, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3151, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3152, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3153, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3157, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3158, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3159, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3160, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3161, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3162, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3166, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3167, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3168, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3169, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3170, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3171, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3172, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3173, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3174, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3175, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3176, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3177, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3181, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3182, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3183, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3184, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3185, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3186, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3187, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3188, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3189, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3190, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3191, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3192, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3196, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3197, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3198, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3214, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3215, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3216, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3217, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3218, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3219, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3220, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3221, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3222, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3226, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3227, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3228, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3232, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3233, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3234, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3235, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3236, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3237, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3241, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3242, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3243, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3244, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3245, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3246, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3247, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3248, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3249, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3250, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3251, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3252, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3256, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3257, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3258, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3259, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3260, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3261, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3262, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3263, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3264, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3265, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3266, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3267, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3271, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3272, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3273, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3289, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3290, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3291, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3292, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3293, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3294, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3295, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3296, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3297, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3301, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3302, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3303, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3307, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3308, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3309, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3310, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3311, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3312, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3316, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3317, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3318, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3319, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3320, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3321, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3322, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3323, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3324, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3325, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3326, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3327, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3331, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3332, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3333, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3334, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3335, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3336, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3337, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3338, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3339, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3340, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3341, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3342, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3346, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3347, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3348, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3364, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3365, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3366, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3367, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3368, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3369, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3370, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3371, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3372, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3376, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3377, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3378, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3379, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3380, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3381, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3382, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ + _(3383, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3384, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3385, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3386, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ + _(3387, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3388, ZEND_POST_INC_LONG_SPEC_CV) \ + _(3389, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3390, ZEND_POST_DEC_LONG_SPEC_CV) \ + _(3391, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ + _(3392, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3393, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3395, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3396, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ + _(3397, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3398, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3400, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3401, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ + _(3402, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3403, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3405, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3407, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3408, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3410, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3411, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3412, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ _(3413, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3419, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ - _(3420, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3421, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3423, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3426, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ - _(3428, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ - _(3431, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ - _(3433, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ - _(3434, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ - _(3435, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ - _(3436, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ - _(3437, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ - _(3437+1, ZEND_NULL) + _(3415, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3416, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3417, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3418, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3420, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3426, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ + _(3427, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3428, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3430, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3433, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ + _(3435, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ + _(3438, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ + _(3440, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ + _(3441, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ + _(3442, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ + _(3443, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ + _(3444, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ + _(3444+1, ZEND_NULL) From e3cdb9f2847a0e3f346c4aa061e73c88e7074a0b Mon Sep 17 00:00:00 2001 From: Sammy Powers Date: Wed, 26 Aug 2020 11:36:35 -0700 Subject: [PATCH 33/53] Add SPEC(OBSERVER) to INCLUDE_OR_EVAL --- Zend/zend_execute.c | 19 +- Zend/zend_vm_def.h | 4 +- Zend/zend_vm_execute.h | 557 +++++++--- Zend/zend_vm_execute.skl | 5 + Zend/zend_vm_gen.php | 3 + Zend/zend_vm_handlers.h | 2084 +++++++++++++++++++------------------- 6 files changed, 1459 insertions(+), 1213 deletions(-) diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c index b704965000d53..e5d74d930abe7 100644 --- a/Zend/zend_execute.c +++ b/Zend/zend_execute.c @@ -3602,12 +3602,8 @@ ZEND_API void ZEND_FASTCALL zend_init_func_run_time_cache(zend_op_array *op_arra } } /* }}} */ -#define ZEND_FAKE_OP_ARRAY ((zend_op_array*)(zend_intptr_t)-1) - static zend_always_inline void i_init_code_execute_data(zend_execute_data *execute_data, zend_op_array *op_array, zval *return_value) /* {{{ */ { - void *ptr = NULL; - ZEND_ASSERT(EX(func) == (zend_function*)op_array); EX(opline) = op_array->opcodes; @@ -3617,6 +3613,8 @@ static zend_always_inline void i_init_code_execute_data(zend_execute_data *execu zend_attach_symbol_table(execute_data); if (!ZEND_MAP_PTR(op_array->run_time_cache)) { + void *ptr = NULL; + ZEND_ASSERT(op_array->fn_flags & ZEND_ACC_HEAP_RT_CACHE); ptr = emalloc(op_array->cache_size + sizeof(void*)); ZEND_MAP_PTR_INIT(op_array->run_time_cache, ptr); @@ -3627,17 +3625,6 @@ static zend_always_inline void i_init_code_execute_data(zend_execute_data *execu EX(run_time_cache) = RUN_TIME_CACHE(op_array); EG(current_execute_data) = execute_data; - - if (ZEND_OBSERVER_ENABLED && op_array != ZEND_FAKE_OP_ARRAY) { - if (ptr != NULL) { - zend_observer_fcall_install((zend_function*)op_array); - } - void *observer_handlers = ZEND_OBSERVER_HANDLERS(op_array); - ZEND_ASSERT(observer_handlers); - if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { - zend_observe_fcall_begin(observer_handlers, execute_data); - } - } } /* }}} */ @@ -4160,6 +4147,8 @@ static zend_never_inline zend_execute_data *zend_init_dynamic_call_array(zend_ar } /* }}} */ +#define ZEND_FAKE_OP_ARRAY ((zend_op_array*)(zend_intptr_t)-1) + static zend_never_inline zend_op_array* ZEND_FASTCALL zend_include_or_eval(zval *inc_filename, int type) /* {{{ */ { zend_op_array *new_op_array = NULL; diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 661de5b2c04f3..2cfcb5bf10bc3 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -6112,7 +6112,7 @@ ZEND_VM_COLD_CONST_HANDLER(51, ZEND_CAST, CONST|TMP|VAR|CV, ANY, TYPE) ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMPVAR|CV, ANY, EVAL) +ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMPVAR|CV, ANY, EVAL, SPEC(OBSERVER)) { USE_OPLINE zend_op_array *new_op_array; @@ -6156,6 +6156,8 @@ ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMPVAR|CV, ANY, EVAL) call->prev_execute_data = execute_data; i_init_code_execute_data(call, new_op_array, return_value); + OBSERVER_FCALL_INSTALL((zend_function*)new_op_array); + OBSERVER_FCALL_BEGIN_HANDLERS(call); if (EXPECTED(zend_execute_ex == execute_ex)) { FREE_OP1(); ZEND_VM_ENTER(); diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index b67eb8bea1498..cf43723127ec7 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -4866,6 +4866,78 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HAN call->prev_execute_data = execute_data; i_init_code_execute_data(call, new_op_array, return_value); + + + if (EXPECTED(zend_execute_ex == execute_ex)) { + + ZEND_VM_ENTER(); + } else { + ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP); + zend_execute_ex(call); + zend_vm_stack_free_call_frame(call); + } + + destroy_op_array(new_op_array); + efree_size(new_op_array, sizeof(zend_op_array)); + if (UNEXPECTED(EG(exception) != NULL)) { + zend_rethrow_exception(execute_data); + + UNDEF_RESULT(); + HANDLE_EXCEPTION(); + } + } else if (RETURN_VALUE_USED(opline)) { + ZVAL_FALSE(EX_VAR(opline->result.var)); + } + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_op_array *new_op_array; + zval *inc_filename; + + SAVE_OPLINE(); + inc_filename = RT_CONSTANT(opline, opline->op1); + new_op_array = zend_include_or_eval(inc_filename, opline->extended_value); + if (UNEXPECTED(EG(exception) != NULL)) { + + if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) { + destroy_op_array(new_op_array); + efree_size(new_op_array, sizeof(zend_op_array)); + } + UNDEF_RESULT(); + HANDLE_EXCEPTION(); + } else if (new_op_array == ZEND_FAKE_OP_ARRAY) { + if (RETURN_VALUE_USED(opline)) { + ZVAL_TRUE(EX_VAR(opline->result.var)); + } + } else if (EXPECTED(new_op_array != NULL)) { + zval *return_value = NULL; + zend_execute_data *call; + + if (RETURN_VALUE_USED(opline)) { + return_value = EX_VAR(opline->result.var); + } + + new_op_array->scope = EX(func)->op_array.scope; + + call = zend_vm_stack_push_call_frame( + (Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE, + (zend_function*)new_op_array, 0, + Z_PTR(EX(This))); + + if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) { + call->symbol_table = EX(symbol_table); + } else { + call->symbol_table = zend_rebuild_symbol_table(); + } + + call->prev_execute_data = execute_data; + i_init_code_execute_data(call, new_op_array, return_value); + zend_observer_fcall_install((zend_function*)new_op_array); + zend_observer_maybe_fcall_call_begin(call); if (EXPECTED(zend_execute_ex == execute_ex)) { ZEND_VM_ENTER(); @@ -14312,6 +14384,78 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HA call->prev_execute_data = execute_data; i_init_code_execute_data(call, new_op_array, return_value); + + + if (EXPECTED(zend_execute_ex == execute_ex)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_ENTER(); + } else { + ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP); + zend_execute_ex(call); + zend_vm_stack_free_call_frame(call); + } + + destroy_op_array(new_op_array); + efree_size(new_op_array, sizeof(zend_op_array)); + if (UNEXPECTED(EG(exception) != NULL)) { + zend_rethrow_exception(execute_data); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + UNDEF_RESULT(); + HANDLE_EXCEPTION(); + } + } else if (RETURN_VALUE_USED(opline)) { + ZVAL_FALSE(EX_VAR(opline->result.var)); + } + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_op_array *new_op_array; + zval *inc_filename; + + SAVE_OPLINE(); + inc_filename = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + new_op_array = zend_include_or_eval(inc_filename, opline->extended_value); + if (UNEXPECTED(EG(exception) != NULL)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) { + destroy_op_array(new_op_array); + efree_size(new_op_array, sizeof(zend_op_array)); + } + UNDEF_RESULT(); + HANDLE_EXCEPTION(); + } else if (new_op_array == ZEND_FAKE_OP_ARRAY) { + if (RETURN_VALUE_USED(opline)) { + ZVAL_TRUE(EX_VAR(opline->result.var)); + } + } else if (EXPECTED(new_op_array != NULL)) { + zval *return_value = NULL; + zend_execute_data *call; + + if (RETURN_VALUE_USED(opline)) { + return_value = EX_VAR(opline->result.var); + } + + new_op_array->scope = EX(func)->op_array.scope; + + call = zend_vm_stack_push_call_frame( + (Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE, + (zend_function*)new_op_array, 0, + Z_PTR(EX(This))); + + if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) { + call->symbol_table = EX(symbol_table); + } else { + call->symbol_table = zend_rebuild_symbol_table(); + } + + call->prev_execute_data = execute_data; + i_init_code_execute_data(call, new_op_array, return_value); + zend_observer_fcall_install((zend_function*)new_op_array); + zend_observer_maybe_fcall_call_begin(call); if (EXPECTED(zend_execute_ex == execute_ex)) { zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); ZEND_VM_ENTER(); @@ -38524,6 +38668,78 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLE call->prev_execute_data = execute_data; i_init_code_execute_data(call, new_op_array, return_value); + + + if (EXPECTED(zend_execute_ex == execute_ex)) { + + ZEND_VM_ENTER(); + } else { + ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP); + zend_execute_ex(call); + zend_vm_stack_free_call_frame(call); + } + + destroy_op_array(new_op_array); + efree_size(new_op_array, sizeof(zend_op_array)); + if (UNEXPECTED(EG(exception) != NULL)) { + zend_rethrow_exception(execute_data); + + UNDEF_RESULT(); + HANDLE_EXCEPTION(); + } + } else if (RETURN_VALUE_USED(opline)) { + ZVAL_FALSE(EX_VAR(opline->result.var)); + } + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_op_array *new_op_array; + zval *inc_filename; + + SAVE_OPLINE(); + inc_filename = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); + new_op_array = zend_include_or_eval(inc_filename, opline->extended_value); + if (UNEXPECTED(EG(exception) != NULL)) { + + if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) { + destroy_op_array(new_op_array); + efree_size(new_op_array, sizeof(zend_op_array)); + } + UNDEF_RESULT(); + HANDLE_EXCEPTION(); + } else if (new_op_array == ZEND_FAKE_OP_ARRAY) { + if (RETURN_VALUE_USED(opline)) { + ZVAL_TRUE(EX_VAR(opline->result.var)); + } + } else if (EXPECTED(new_op_array != NULL)) { + zval *return_value = NULL; + zend_execute_data *call; + + if (RETURN_VALUE_USED(opline)) { + return_value = EX_VAR(opline->result.var); + } + + new_op_array->scope = EX(func)->op_array.scope; + + call = zend_vm_stack_push_call_frame( + (Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE, + (zend_function*)new_op_array, 0, + Z_PTR(EX(This))); + + if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) { + call->symbol_table = EX(symbol_table); + } else { + call->symbol_table = zend_rebuild_symbol_table(); + } + + call->prev_execute_data = execute_data; + i_init_code_execute_data(call, new_op_array, return_value); + zend_observer_fcall_install((zend_function*)new_op_array); + zend_observer_maybe_fcall_call_begin(call); if (EXPECTED(zend_execute_ex == execute_ex)) { ZEND_VM_ENTER(); @@ -52728,10 +52944,15 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_LABEL, (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_LABEL, (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_CONST_LABEL, + (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_CONST_OBSERVER_LABEL, (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_LABEL, + (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_OBSERVER_LABEL, (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_LABEL, + (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_OBSERVER_LABEL, + (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_CV_LABEL, + (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_CV_OBSERVER_LABEL, (void*)&&ZEND_UNSET_VAR_SPEC_CONST_UNUSED_LABEL, (void*)&&ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_LABEL, (void*)&&ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_LABEL, @@ -55279,6 +55500,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INCLUDE_OR_EVAL_SPEC_CONST) ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_INCLUDE_OR_EVAL_SPEC_CONST_OBSERVER): + VM_TRACE(ZEND_INCLUDE_OR_EVAL_SPEC_CONST_OBSERVER) + ZEND_INCLUDE_OR_EVAL_SPEC_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_FE_RESET_R_SPEC_CONST): VM_TRACE(ZEND_FE_RESET_R_SPEC_CONST) ZEND_FE_RESET_R_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -56379,6 +56604,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR) ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_OBSERVER): + VM_TRACE(ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_OBSERVER) + ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_YIELD_FROM_SPEC_TMPVAR): VM_TRACE(ZEND_YIELD_FROM_SPEC_TMPVAR) ZEND_YIELD_FROM_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -58455,6 +58684,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INCLUDE_OR_EVAL_SPEC_CV) ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_INCLUDE_OR_EVAL_SPEC_CV_OBSERVER): + VM_TRACE(ZEND_INCLUDE_OR_EVAL_SPEC_CV_OBSERVER) + ZEND_INCLUDE_OR_EVAL_SPEC_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_FE_RESET_R_SPEC_CV): VM_TRACE(ZEND_FE_RESET_R_SPEC_CV) ZEND_FE_RESET_R_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -59449,7 +59682,12 @@ ZEND_API void zend_execute(zend_op_array *op_array, zval *return_value) } EX(prev_execute_data) = EG(current_execute_data); i_init_code_execute_data(execute_data, op_array, return_value); + if (ZEND_OBSERVER_ENABLED) { + zend_observer_fcall_install((zend_function*)op_array); + zend_observer_maybe_fcall_call_begin(execute_data); + } zend_execute_ex(execute_data); + /* Observer end handlers are called from ZEND_RETURN */ zend_vm_stack_free_call_frame(execute_data); } @@ -60982,10 +61220,15 @@ void zend_vm_init(void) ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER, ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER, + ZEND_INCLUDE_OR_EVAL_SPEC_CONST_OBSERVER_HANDLER, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HANDLER, + ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_OBSERVER_HANDLER, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HANDLER, + ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_OBSERVER_HANDLER, + ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER, + ZEND_INCLUDE_OR_EVAL_SPEC_CV_OBSERVER_HANDLER, ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER, ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_HANDLER, ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_HANDLER, @@ -62978,134 +63221,134 @@ void zend_vm_init(void) 1473, 1474 | SPEC_RULE_OP1 | SPEC_RULE_OP2, 1499 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1524 | SPEC_RULE_OP1, - 1529 | SPEC_RULE_OP1, - 1534 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1559 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1584 | SPEC_RULE_OP1, - 1589, - 1590, - 1591 | SPEC_RULE_OP1, - 1596 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1621 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1646 | SPEC_RULE_OP1, - 1651 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1676 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1701 | SPEC_RULE_OP1, - 1706 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1731 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1756 | SPEC_RULE_OP1, - 1761 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1786 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1811 | SPEC_RULE_OP1, - 1816 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1841 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1866 | SPEC_RULE_OP1, - 1871 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1896 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1921 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1946, - 1947 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, - 1957, - 1958, - 1959, - 1960, - 1961, - 1962 | SPEC_RULE_OP2, - 1967, - 1968 | SPEC_RULE_OP1, - 1973 | SPEC_RULE_OP2, - 1978 | SPEC_RULE_OP1, - 1983 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, - 1993 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2018 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2043 | SPEC_RULE_OP1, - 2048 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2073 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, - 2123 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2148 | SPEC_RULE_OP2, - 2153, - 2154 | SPEC_RULE_OP1, + 1524 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, + 1534 | SPEC_RULE_OP1, + 1539 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1564 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1589 | SPEC_RULE_OP1, + 1594, + 1595, + 1596 | SPEC_RULE_OP1, + 1601 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1626 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1651 | SPEC_RULE_OP1, + 1656 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1681 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1706 | SPEC_RULE_OP1, + 1711 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1736 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1761 | SPEC_RULE_OP1, + 1766 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1791 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1816 | SPEC_RULE_OP1, + 1821 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1846 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1871 | SPEC_RULE_OP1, + 1876 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1901 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1926 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1951, + 1952 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, + 1962, + 1963, + 1964, + 1965, + 1966, + 1967 | SPEC_RULE_OP2, + 1972, + 1973 | SPEC_RULE_OP1, + 1978 | SPEC_RULE_OP2, + 1983 | SPEC_RULE_OP1, + 1988 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, + 1998 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2023 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2048 | SPEC_RULE_OP1, + 2053 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2078 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, + 2128 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2153 | SPEC_RULE_OP2, + 2158, 2159 | SPEC_RULE_OP1, - 2164, - 2165 | SPEC_RULE_OP1, + 2164 | SPEC_RULE_OP1, + 2169, 2170 | SPEC_RULE_OP1, 2175 | SPEC_RULE_OP1, - 2180, - 2181, - 2182 | SPEC_RULE_OP2, - 2187 | SPEC_RULE_RETVAL, - 2189 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, - 2193 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, - 2197 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2197 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2222 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2222 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2247 | SPEC_RULE_OP1, - 2252, - 2253 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2278, - 2279 | SPEC_RULE_OP1, - 2284, - 2285, - 2286, - 2287, - 2288, + 2180 | SPEC_RULE_OP1, + 2185, + 2186, + 2187 | SPEC_RULE_OP2, + 2192 | SPEC_RULE_RETVAL, + 2194 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, + 2198 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, + 2202 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2202 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2227 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2227 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2252 | SPEC_RULE_OP1, + 2257, + 2258 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2283, + 2284 | SPEC_RULE_OP1, 2289, 2290, - 2291 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2316, - 2317, - 2318, - 2319 | SPEC_RULE_OP1, - 2324, - 2325 | SPEC_RULE_ISSET, - 2327 | SPEC_RULE_OP2, - 2332, - 2333 | SPEC_RULE_OP1, - 2338 | SPEC_RULE_OBSERVER, - 2340, - 2341 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2366 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, - 2376, - 2377, - 2378, - 2379, - 2380 | SPEC_RULE_OP1, - 2385, - 2386, - 2387 | SPEC_RULE_OP1, - 2392 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2417, - 2418 | SPEC_RULE_OP1, - 2423, - 2424, - 2425, - 2426, - 2427, + 2291, + 2292, + 2293, + 2294, + 2295, + 2296 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2321, + 2322, + 2323, + 2324 | SPEC_RULE_OP1, + 2329, + 2330 | SPEC_RULE_ISSET, + 2332 | SPEC_RULE_OP2, + 2337, + 2338 | SPEC_RULE_OP1, + 2343 | SPEC_RULE_OBSERVER, + 2345, + 2346 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2371 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, + 2381, + 2382, + 2383, + 2384, + 2385 | SPEC_RULE_OP1, + 2390, + 2391, + 2392 | SPEC_RULE_OP1, + 2397 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2422, + 2423 | SPEC_RULE_OP1, 2428, 2429, 2430, - 2431 | SPEC_RULE_OP1, - 2436, - 2437, - 2438, - 2439 | SPEC_RULE_OP2, - 2444, - 2445 | SPEC_RULE_OP1, + 2431, + 2432, + 2433, + 2434, + 2435, + 2436 | SPEC_RULE_OP1, + 2441, + 2442, + 2443, + 2444 | SPEC_RULE_OP2, + 2449, 2450 | SPEC_RULE_OP1, 2455 | SPEC_RULE_OP1, 2460 | SPEC_RULE_OP1, 2465 | SPEC_RULE_OP1, - 2470, - 2471 | SPEC_RULE_OP1, - 2476 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2501 | SPEC_RULE_OP1, - 2506 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2531 | SPEC_RULE_OP1, + 2470 | SPEC_RULE_OP1, + 2475, + 2476 | SPEC_RULE_OP1, + 2481 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2506 | SPEC_RULE_OP1, + 2511 | SPEC_RULE_OP1 | SPEC_RULE_OP2, 2536 | SPEC_RULE_OP1, - 2541, - 3445 + 2541 | SPEC_RULE_OP1, + 2546, + 3450 }; #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID) zend_opcode_handler_funcs = labels; @@ -63278,7 +63521,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 = 2544 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2549 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -63286,7 +63529,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 = 2569 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2574 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -63294,7 +63537,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 = 2594 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2599 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -63305,17 +63548,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 = 2619 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2624 | 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 = 2644 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2649 | 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 = 2669 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2674 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_MUL: @@ -63326,17 +63569,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 = 2694 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2699 | 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 = 2719 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2724 | 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 = 2744 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2749 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_IDENTICAL: @@ -63347,14 +63590,14 @@ 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 = 2769 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2774 | 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 = 2844 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2849 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF))) { - spec = 3069 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3074 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_IDENTICAL: @@ -63365,14 +63608,14 @@ 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 = 2919 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2924 | 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 = 2994 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2999 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF))) { - spec = 3074 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3079 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_EQUAL: @@ -63383,12 +63626,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 = 2769 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2774 | 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 = 2844 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2849 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_EQUAL: @@ -63399,12 +63642,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 = 2919 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2924 | 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 = 2994 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2999 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_SMALLER: @@ -63412,12 +63655,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 = 3079 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3084 | 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 = 3154 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3159 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_IS_SMALLER_OR_EQUAL: @@ -63425,74 +63668,74 @@ 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 = 3229 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3234 | 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 = 3304 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3309 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_QM_ASSIGN: if (op1_info == MAY_BE_LONG) { - spec = 3391 | SPEC_RULE_OP1; - } else if (op1_info == MAY_BE_DOUBLE) { spec = 3396 | 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))))) { + } else if (op1_info == MAY_BE_DOUBLE) { spec = 3401 | 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 = 3406 | SPEC_RULE_OP1; } break; case ZEND_PRE_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3379 | SPEC_RULE_RETVAL; + spec = 3384 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3381 | SPEC_RULE_RETVAL; + spec = 3386 | SPEC_RULE_RETVAL; } break; case ZEND_PRE_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3383 | SPEC_RULE_RETVAL; + spec = 3388 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3385 | SPEC_RULE_RETVAL; + spec = 3390 | SPEC_RULE_RETVAL; } break; case ZEND_POST_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3387; + spec = 3392; } else if (op1_info == MAY_BE_LONG) { - spec = 3388; + spec = 3393; } break; case ZEND_POST_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3389; + spec = 3394; } else if (op1_info == MAY_BE_LONG) { - spec = 3390; + spec = 3395; } break; case ZEND_JMP: if (OP_JMP_ADDR(op, op->op1) > op) { - spec = 2543; + spec = 2548; } break; case ZEND_RECV: if (op->op2.num == MAY_BE_ANY) { - spec = 2542; + spec = 2547; } break; case ZEND_SEND_VAL: if (op->op1_type == IS_CONST && op->op2_type == IS_UNUSED && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3441; + spec = 3446; } break; case ZEND_SEND_VAR_EX: if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3436 | SPEC_RULE_OP1; + spec = 3441 | 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 = 3443 | SPEC_RULE_RETVAL; + spec = 3448 | SPEC_RULE_RETVAL; } break; case ZEND_FETCH_DIM_R: @@ -63500,17 +63743,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 = 3406 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 3411 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_SEND_VAL_EX: if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3442; + spec = 3447; } break; case ZEND_SEND_VAR: if (op->op2_type == IS_UNUSED && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3431 | SPEC_RULE_OP1; + spec = 3436 | SPEC_RULE_OP1; } break; case ZEND_BW_OR: diff --git a/Zend/zend_vm_execute.skl b/Zend/zend_vm_execute.skl index 170fc300bbb8b..91378719d4c7e 100644 --- a/Zend/zend_vm_execute.skl +++ b/Zend/zend_vm_execute.skl @@ -55,7 +55,12 @@ ZEND_API void zend_{%EXECUTOR_NAME%}(zend_op_array *op_array, zval *return_value } EX(prev_execute_data) = EG(current_execute_data); i_init_code_execute_data(execute_data, op_array, return_value); + if (ZEND_OBSERVER_ENABLED) { + zend_observer_fcall_install((zend_function*)op_array); + zend_observer_maybe_fcall_call_begin(execute_data); + } zend_{%EXECUTOR_NAME%}_ex(execute_data); + /* Observer end handlers are called from ZEND_RETURN */ zend_vm_stack_free_call_frame(execute_data); } diff --git a/Zend/zend_vm_gen.php b/Zend/zend_vm_gen.php index 0c79812805891..c3e3494f9b211 100755 --- a/Zend/zend_vm_gen.php +++ b/Zend/zend_vm_gen.php @@ -793,6 +793,9 @@ function gen_code($f, $spec, $kind, $code, $op1, $op2, $name, $extra_spec=null) "/opline->extended_value\s*&\s*~\s*ZEND_ISEMPTY/" => isset($extra_spec['ISSET']) ? ($extra_spec['ISSET'] == 0 ? "\\0" : "opline->extended_value") : "\\0", + "/OBSERVER_FCALL_INSTALL\(\s*(.*)\s*\)/" => isset($extra_spec['OBSERVER']) ? + ($extra_spec['OBSERVER'] == 0 ? "" : "zend_observer_fcall_install(\\1)") + : "", "/OBSERVER_FCALL_BEGIN_HANDLERS\(\s*(.*)\s*\)/" => isset($extra_spec['OBSERVER']) ? ($extra_spec['OBSERVER'] == 0 ? "" : "zend_observer_maybe_fcall_call_begin(\\1)") : "", diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h index 05a313f07ecb2..26995d3d49c61 100644 --- a/Zend/zend_vm_handlers.h +++ b/Zend/zend_vm_handlers.h @@ -719,1127 +719,1131 @@ _(1522, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED) \ _(1523, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV) \ _(1524, ZEND_INCLUDE_OR_EVAL_SPEC_CONST) \ - _(1525, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR) \ + _(1525, ZEND_INCLUDE_OR_EVAL_SPEC_CONST_OBSERVER) \ _(1526, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR) \ - _(1528, ZEND_INCLUDE_OR_EVAL_SPEC_CV) \ - _(1529, ZEND_UNSET_VAR_SPEC_CONST_UNUSED) \ - _(1530, ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED) \ - _(1531, ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED) \ - _(1533, ZEND_UNSET_VAR_SPEC_CV_UNUSED) \ - _(1544, ZEND_UNSET_DIM_SPEC_VAR_CONST) \ - _(1545, ZEND_UNSET_DIM_SPEC_VAR_TMPVAR) \ - _(1546, ZEND_UNSET_DIM_SPEC_VAR_TMPVAR) \ - _(1548, ZEND_UNSET_DIM_SPEC_VAR_CV) \ - _(1554, ZEND_UNSET_DIM_SPEC_CV_CONST) \ - _(1555, ZEND_UNSET_DIM_SPEC_CV_TMPVAR) \ - _(1556, ZEND_UNSET_DIM_SPEC_CV_TMPVAR) \ - _(1558, ZEND_UNSET_DIM_SPEC_CV_CV) \ - _(1569, ZEND_UNSET_OBJ_SPEC_VAR_CONST) \ - _(1570, ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR) \ - _(1571, ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR) \ - _(1573, ZEND_UNSET_OBJ_SPEC_VAR_CV) \ - _(1574, ZEND_UNSET_OBJ_SPEC_UNUSED_CONST) \ - _(1575, ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR) \ - _(1576, ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR) \ - _(1578, ZEND_UNSET_OBJ_SPEC_UNUSED_CV) \ - _(1579, ZEND_UNSET_OBJ_SPEC_CV_CONST) \ - _(1580, ZEND_UNSET_OBJ_SPEC_CV_TMPVAR) \ - _(1581, ZEND_UNSET_OBJ_SPEC_CV_TMPVAR) \ - _(1583, ZEND_UNSET_OBJ_SPEC_CV_CV) \ - _(1584, ZEND_FE_RESET_R_SPEC_CONST) \ - _(1585, ZEND_FE_RESET_R_SPEC_TMP) \ - _(1586, ZEND_FE_RESET_R_SPEC_VAR) \ - _(1588, ZEND_FE_RESET_R_SPEC_CV) \ - _(1589, ZEND_FE_FETCH_R_SPEC_VAR) \ - _(1590, ZEND_EXIT_SPEC) \ - _(1591, ZEND_FETCH_R_SPEC_CONST_UNUSED) \ - _(1592, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \ - _(1593, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \ - _(1595, ZEND_FETCH_R_SPEC_CV_UNUSED) \ - _(1596, ZEND_FETCH_DIM_R_SPEC_CONST_CONST) \ - _(1597, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \ - _(1598, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \ - _(1600, ZEND_FETCH_DIM_R_SPEC_CONST_CV) \ - _(1601, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \ - _(1602, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ - _(1603, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ - _(1605, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \ + _(1527, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_OBSERVER) \ + _(1528, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR) \ + _(1529, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_OBSERVER) \ + _(1532, ZEND_INCLUDE_OR_EVAL_SPEC_CV) \ + _(1533, ZEND_INCLUDE_OR_EVAL_SPEC_CV_OBSERVER) \ + _(1534, ZEND_UNSET_VAR_SPEC_CONST_UNUSED) \ + _(1535, ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED) \ + _(1536, ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED) \ + _(1538, ZEND_UNSET_VAR_SPEC_CV_UNUSED) \ + _(1549, ZEND_UNSET_DIM_SPEC_VAR_CONST) \ + _(1550, ZEND_UNSET_DIM_SPEC_VAR_TMPVAR) \ + _(1551, ZEND_UNSET_DIM_SPEC_VAR_TMPVAR) \ + _(1553, ZEND_UNSET_DIM_SPEC_VAR_CV) \ + _(1559, ZEND_UNSET_DIM_SPEC_CV_CONST) \ + _(1560, ZEND_UNSET_DIM_SPEC_CV_TMPVAR) \ + _(1561, ZEND_UNSET_DIM_SPEC_CV_TMPVAR) \ + _(1563, ZEND_UNSET_DIM_SPEC_CV_CV) \ + _(1574, ZEND_UNSET_OBJ_SPEC_VAR_CONST) \ + _(1575, ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR) \ + _(1576, ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR) \ + _(1578, ZEND_UNSET_OBJ_SPEC_VAR_CV) \ + _(1579, ZEND_UNSET_OBJ_SPEC_UNUSED_CONST) \ + _(1580, ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR) \ + _(1581, ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR) \ + _(1583, ZEND_UNSET_OBJ_SPEC_UNUSED_CV) \ + _(1584, ZEND_UNSET_OBJ_SPEC_CV_CONST) \ + _(1585, ZEND_UNSET_OBJ_SPEC_CV_TMPVAR) \ + _(1586, ZEND_UNSET_OBJ_SPEC_CV_TMPVAR) \ + _(1588, ZEND_UNSET_OBJ_SPEC_CV_CV) \ + _(1589, ZEND_FE_RESET_R_SPEC_CONST) \ + _(1590, ZEND_FE_RESET_R_SPEC_TMP) \ + _(1591, ZEND_FE_RESET_R_SPEC_VAR) \ + _(1593, ZEND_FE_RESET_R_SPEC_CV) \ + _(1594, ZEND_FE_FETCH_R_SPEC_VAR) \ + _(1595, ZEND_EXIT_SPEC) \ + _(1596, ZEND_FETCH_R_SPEC_CONST_UNUSED) \ + _(1597, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \ + _(1598, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \ + _(1600, ZEND_FETCH_R_SPEC_CV_UNUSED) \ + _(1601, ZEND_FETCH_DIM_R_SPEC_CONST_CONST) \ + _(1602, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \ + _(1603, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \ + _(1605, ZEND_FETCH_DIM_R_SPEC_CONST_CV) \ _(1606, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \ _(1607, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ _(1608, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ _(1610, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \ - _(1616, ZEND_FETCH_DIM_R_SPEC_CV_CONST) \ - _(1617, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \ - _(1618, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \ - _(1620, ZEND_FETCH_DIM_R_SPEC_CV_CV) \ - _(1621, ZEND_FETCH_OBJ_R_SPEC_CONST_CONST) \ - _(1622, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \ - _(1623, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \ - _(1625, ZEND_FETCH_OBJ_R_SPEC_CONST_CV) \ - _(1626, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \ - _(1627, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ - _(1628, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ - _(1630, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \ + _(1611, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \ + _(1612, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ + _(1613, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ + _(1615, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \ + _(1621, ZEND_FETCH_DIM_R_SPEC_CV_CONST) \ + _(1622, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \ + _(1623, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \ + _(1625, ZEND_FETCH_DIM_R_SPEC_CV_CV) \ + _(1626, ZEND_FETCH_OBJ_R_SPEC_CONST_CONST) \ + _(1627, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \ + _(1628, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \ + _(1630, ZEND_FETCH_OBJ_R_SPEC_CONST_CV) \ _(1631, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \ _(1632, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ _(1633, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ _(1635, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \ - _(1636, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST) \ - _(1637, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \ - _(1638, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \ - _(1640, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV) \ - _(1641, ZEND_FETCH_OBJ_R_SPEC_CV_CONST) \ - _(1642, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \ - _(1643, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \ - _(1645, ZEND_FETCH_OBJ_R_SPEC_CV_CV) \ - _(1646, ZEND_FETCH_W_SPEC_CONST_UNUSED) \ - _(1647, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \ - _(1648, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \ - _(1650, ZEND_FETCH_W_SPEC_CV_UNUSED) \ - _(1661, ZEND_FETCH_DIM_W_SPEC_VAR_CONST) \ - _(1662, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \ - _(1663, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \ - _(1664, ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED) \ - _(1665, ZEND_FETCH_DIM_W_SPEC_VAR_CV) \ - _(1671, ZEND_FETCH_DIM_W_SPEC_CV_CONST) \ - _(1672, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \ - _(1673, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \ - _(1674, ZEND_FETCH_DIM_W_SPEC_CV_UNUSED) \ - _(1675, ZEND_FETCH_DIM_W_SPEC_CV_CV) \ - _(1686, ZEND_FETCH_OBJ_W_SPEC_VAR_CONST) \ - _(1687, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \ - _(1688, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \ - _(1690, ZEND_FETCH_OBJ_W_SPEC_VAR_CV) \ - _(1691, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST) \ - _(1692, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \ - _(1693, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \ - _(1695, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV) \ - _(1696, ZEND_FETCH_OBJ_W_SPEC_CV_CONST) \ - _(1697, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \ - _(1698, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \ - _(1700, ZEND_FETCH_OBJ_W_SPEC_CV_CV) \ - _(1701, ZEND_FETCH_RW_SPEC_CONST_UNUSED) \ - _(1702, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \ - _(1703, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \ - _(1705, ZEND_FETCH_RW_SPEC_CV_UNUSED) \ - _(1716, ZEND_FETCH_DIM_RW_SPEC_VAR_CONST) \ - _(1717, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \ - _(1718, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \ - _(1719, ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED) \ - _(1720, ZEND_FETCH_DIM_RW_SPEC_VAR_CV) \ - _(1726, ZEND_FETCH_DIM_RW_SPEC_CV_CONST) \ - _(1727, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \ - _(1728, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \ - _(1729, ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED) \ - _(1730, ZEND_FETCH_DIM_RW_SPEC_CV_CV) \ - _(1741, ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST) \ - _(1742, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \ - _(1743, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \ - _(1745, ZEND_FETCH_OBJ_RW_SPEC_VAR_CV) \ - _(1746, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST) \ - _(1747, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \ - _(1748, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \ - _(1750, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV) \ - _(1751, ZEND_FETCH_OBJ_RW_SPEC_CV_CONST) \ - _(1752, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \ - _(1753, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \ - _(1755, ZEND_FETCH_OBJ_RW_SPEC_CV_CV) \ - _(1756, ZEND_FETCH_IS_SPEC_CONST_UNUSED) \ - _(1757, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \ - _(1758, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \ - _(1760, ZEND_FETCH_IS_SPEC_CV_UNUSED) \ - _(1761, ZEND_FETCH_DIM_IS_SPEC_CONST_CONST) \ - _(1762, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \ - _(1763, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \ - _(1765, ZEND_FETCH_DIM_IS_SPEC_CONST_CV) \ - _(1766, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \ - _(1767, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ - _(1768, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ - _(1770, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \ + _(1636, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \ + _(1637, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ + _(1638, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ + _(1640, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \ + _(1641, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST) \ + _(1642, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \ + _(1643, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \ + _(1645, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV) \ + _(1646, ZEND_FETCH_OBJ_R_SPEC_CV_CONST) \ + _(1647, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \ + _(1648, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \ + _(1650, ZEND_FETCH_OBJ_R_SPEC_CV_CV) \ + _(1651, ZEND_FETCH_W_SPEC_CONST_UNUSED) \ + _(1652, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \ + _(1653, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \ + _(1655, ZEND_FETCH_W_SPEC_CV_UNUSED) \ + _(1666, ZEND_FETCH_DIM_W_SPEC_VAR_CONST) \ + _(1667, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \ + _(1668, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \ + _(1669, ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED) \ + _(1670, ZEND_FETCH_DIM_W_SPEC_VAR_CV) \ + _(1676, ZEND_FETCH_DIM_W_SPEC_CV_CONST) \ + _(1677, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \ + _(1678, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \ + _(1679, ZEND_FETCH_DIM_W_SPEC_CV_UNUSED) \ + _(1680, ZEND_FETCH_DIM_W_SPEC_CV_CV) \ + _(1691, ZEND_FETCH_OBJ_W_SPEC_VAR_CONST) \ + _(1692, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \ + _(1693, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \ + _(1695, ZEND_FETCH_OBJ_W_SPEC_VAR_CV) \ + _(1696, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST) \ + _(1697, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \ + _(1698, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \ + _(1700, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV) \ + _(1701, ZEND_FETCH_OBJ_W_SPEC_CV_CONST) \ + _(1702, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \ + _(1703, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \ + _(1705, ZEND_FETCH_OBJ_W_SPEC_CV_CV) \ + _(1706, ZEND_FETCH_RW_SPEC_CONST_UNUSED) \ + _(1707, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \ + _(1708, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \ + _(1710, ZEND_FETCH_RW_SPEC_CV_UNUSED) \ + _(1721, ZEND_FETCH_DIM_RW_SPEC_VAR_CONST) \ + _(1722, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \ + _(1723, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \ + _(1724, ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED) \ + _(1725, ZEND_FETCH_DIM_RW_SPEC_VAR_CV) \ + _(1731, ZEND_FETCH_DIM_RW_SPEC_CV_CONST) \ + _(1732, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \ + _(1733, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \ + _(1734, ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED) \ + _(1735, ZEND_FETCH_DIM_RW_SPEC_CV_CV) \ + _(1746, ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST) \ + _(1747, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \ + _(1748, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \ + _(1750, ZEND_FETCH_OBJ_RW_SPEC_VAR_CV) \ + _(1751, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST) \ + _(1752, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \ + _(1753, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \ + _(1755, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV) \ + _(1756, ZEND_FETCH_OBJ_RW_SPEC_CV_CONST) \ + _(1757, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \ + _(1758, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \ + _(1760, ZEND_FETCH_OBJ_RW_SPEC_CV_CV) \ + _(1761, ZEND_FETCH_IS_SPEC_CONST_UNUSED) \ + _(1762, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \ + _(1763, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \ + _(1765, ZEND_FETCH_IS_SPEC_CV_UNUSED) \ + _(1766, ZEND_FETCH_DIM_IS_SPEC_CONST_CONST) \ + _(1767, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \ + _(1768, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \ + _(1770, ZEND_FETCH_DIM_IS_SPEC_CONST_CV) \ _(1771, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \ _(1772, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ _(1773, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ _(1775, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \ - _(1781, ZEND_FETCH_DIM_IS_SPEC_CV_CONST) \ - _(1782, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \ - _(1783, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \ - _(1785, ZEND_FETCH_DIM_IS_SPEC_CV_CV) \ - _(1786, ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST) \ - _(1787, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \ - _(1788, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \ - _(1790, ZEND_FETCH_OBJ_IS_SPEC_CONST_CV) \ - _(1791, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \ - _(1792, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ - _(1793, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ - _(1795, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \ + _(1776, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \ + _(1777, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ + _(1778, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ + _(1780, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \ + _(1786, ZEND_FETCH_DIM_IS_SPEC_CV_CONST) \ + _(1787, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \ + _(1788, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \ + _(1790, ZEND_FETCH_DIM_IS_SPEC_CV_CV) \ + _(1791, ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST) \ + _(1792, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \ + _(1793, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \ + _(1795, ZEND_FETCH_OBJ_IS_SPEC_CONST_CV) \ _(1796, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \ _(1797, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ _(1798, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ _(1800, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \ - _(1801, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST) \ - _(1802, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \ - _(1803, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \ - _(1805, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV) \ - _(1806, ZEND_FETCH_OBJ_IS_SPEC_CV_CONST) \ - _(1807, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \ - _(1808, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \ - _(1810, ZEND_FETCH_OBJ_IS_SPEC_CV_CV) \ - _(1811, ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED) \ - _(1812, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \ - _(1813, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \ - _(1815, ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED) \ - _(1816, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST) \ - _(1817, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \ - _(1818, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \ - _(1819, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED) \ - _(1820, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV) \ - _(1821, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST) \ - _(1822, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \ - _(1823, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \ - _(1824, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED) \ - _(1825, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV) \ - _(1826, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST) \ - _(1827, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \ - _(1828, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \ - _(1829, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED) \ - _(1830, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV) \ - _(1836, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST) \ - _(1837, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \ - _(1838, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \ - _(1839, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED) \ - _(1840, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV) \ - _(1841, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST) \ - _(1842, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \ - _(1843, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \ - _(1845, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV) \ - _(1846, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST) \ - _(1847, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \ - _(1848, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \ - _(1850, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV) \ - _(1851, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST) \ - _(1852, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \ - _(1853, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \ - _(1855, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV) \ - _(1856, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST) \ - _(1857, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \ - _(1858, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \ - _(1860, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV) \ - _(1861, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST) \ - _(1862, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \ - _(1863, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \ - _(1865, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV) \ - _(1866, ZEND_FETCH_UNSET_SPEC_CONST_UNUSED) \ - _(1867, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \ - _(1868, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \ - _(1870, ZEND_FETCH_UNSET_SPEC_CV_UNUSED) \ - _(1881, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST) \ - _(1882, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \ - _(1883, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \ - _(1885, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV) \ - _(1891, ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST) \ - _(1892, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \ - _(1893, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \ - _(1895, ZEND_FETCH_DIM_UNSET_SPEC_CV_CV) \ - _(1906, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST) \ - _(1907, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \ - _(1908, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \ - _(1910, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV) \ - _(1911, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST) \ - _(1912, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \ - _(1913, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \ - _(1915, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV) \ - _(1916, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST) \ - _(1917, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \ - _(1918, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \ - _(1920, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV) \ - _(1921, ZEND_FETCH_LIST_R_SPEC_CONST_CONST) \ - _(1922, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \ - _(1923, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \ - _(1925, ZEND_FETCH_LIST_R_SPEC_CONST_CV) \ - _(1926, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ - _(1927, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1928, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1930, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ + _(1801, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \ + _(1802, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ + _(1803, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ + _(1805, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \ + _(1806, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST) \ + _(1807, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \ + _(1808, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \ + _(1810, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV) \ + _(1811, ZEND_FETCH_OBJ_IS_SPEC_CV_CONST) \ + _(1812, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \ + _(1813, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \ + _(1815, ZEND_FETCH_OBJ_IS_SPEC_CV_CV) \ + _(1816, ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED) \ + _(1817, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \ + _(1818, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \ + _(1820, ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED) \ + _(1821, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST) \ + _(1822, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \ + _(1823, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \ + _(1824, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED) \ + _(1825, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV) \ + _(1826, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST) \ + _(1827, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \ + _(1828, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \ + _(1829, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED) \ + _(1830, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV) \ + _(1831, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST) \ + _(1832, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \ + _(1833, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \ + _(1834, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED) \ + _(1835, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV) \ + _(1841, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST) \ + _(1842, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \ + _(1843, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \ + _(1844, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED) \ + _(1845, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV) \ + _(1846, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST) \ + _(1847, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \ + _(1848, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \ + _(1850, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV) \ + _(1851, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST) \ + _(1852, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \ + _(1853, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \ + _(1855, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV) \ + _(1856, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST) \ + _(1857, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \ + _(1858, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \ + _(1860, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV) \ + _(1861, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST) \ + _(1862, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \ + _(1863, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \ + _(1865, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV) \ + _(1866, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST) \ + _(1867, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \ + _(1868, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \ + _(1870, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV) \ + _(1871, ZEND_FETCH_UNSET_SPEC_CONST_UNUSED) \ + _(1872, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \ + _(1873, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \ + _(1875, ZEND_FETCH_UNSET_SPEC_CV_UNUSED) \ + _(1886, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST) \ + _(1887, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \ + _(1888, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \ + _(1890, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV) \ + _(1896, ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST) \ + _(1897, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \ + _(1898, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \ + _(1900, ZEND_FETCH_DIM_UNSET_SPEC_CV_CV) \ + _(1911, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST) \ + _(1912, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \ + _(1913, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \ + _(1915, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV) \ + _(1916, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST) \ + _(1917, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \ + _(1918, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \ + _(1920, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV) \ + _(1921, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST) \ + _(1922, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \ + _(1923, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \ + _(1925, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV) \ + _(1926, ZEND_FETCH_LIST_R_SPEC_CONST_CONST) \ + _(1927, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \ + _(1928, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \ + _(1930, ZEND_FETCH_LIST_R_SPEC_CONST_CV) \ _(1931, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ _(1932, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ _(1933, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ _(1935, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ - _(1941, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ - _(1942, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1943, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1945, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ - _(1946, ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST) \ - _(1947, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST) \ - _(1948, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST) \ - _(1953, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED) \ - _(1954, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK) \ - _(1957, ZEND_EXT_STMT_SPEC) \ - _(1958, ZEND_EXT_FCALL_BEGIN_SPEC) \ - _(1959, ZEND_EXT_FCALL_END_SPEC) \ - _(1960, ZEND_EXT_NOP_SPEC) \ - _(1961, ZEND_TICKS_SPEC) \ - _(1962, ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST) \ - _(1965, ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED) \ - _(1967, ZEND_CATCH_SPEC_CONST) \ - _(1968, ZEND_THROW_SPEC_CONST) \ - _(1969, ZEND_THROW_SPEC_TMPVAR) \ - _(1970, ZEND_THROW_SPEC_TMPVAR) \ - _(1972, ZEND_THROW_SPEC_CV) \ - _(1973, ZEND_FETCH_CLASS_SPEC_UNUSED_CONST) \ - _(1974, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \ - _(1975, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \ - _(1976, ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED) \ - _(1977, ZEND_FETCH_CLASS_SPEC_UNUSED_CV) \ - _(1978, ZEND_CLONE_SPEC_CONST) \ - _(1979, ZEND_CLONE_SPEC_TMPVAR) \ - _(1980, ZEND_CLONE_SPEC_TMPVAR) \ - _(1981, ZEND_CLONE_SPEC_UNUSED) \ - _(1982, ZEND_CLONE_SPEC_CV) \ - _(1983, ZEND_RETURN_BY_REF_SPEC_CONST) \ - _(1984, ZEND_RETURN_BY_REF_SPEC_CONST_OBSERVER) \ - _(1985, ZEND_RETURN_BY_REF_SPEC_TMP) \ - _(1986, ZEND_RETURN_BY_REF_SPEC_TMP_OBSERVER) \ - _(1987, ZEND_RETURN_BY_REF_SPEC_VAR) \ - _(1988, ZEND_RETURN_BY_REF_SPEC_VAR_OBSERVER) \ - _(1991, ZEND_RETURN_BY_REF_SPEC_CV) \ - _(1992, ZEND_RETURN_BY_REF_SPEC_CV_OBSERVER) \ - _(1993, ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST) \ - _(1994, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \ - _(1995, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \ - _(1997, ZEND_INIT_METHOD_CALL_SPEC_CONST_CV) \ - _(1998, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \ - _(1999, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ - _(2000, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ - _(2002, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \ + _(1936, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ + _(1937, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ + _(1938, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ + _(1940, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ + _(1946, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ + _(1947, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ + _(1948, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ + _(1950, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ + _(1951, ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST) \ + _(1952, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST) \ + _(1953, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST) \ + _(1958, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED) \ + _(1959, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK) \ + _(1962, ZEND_EXT_STMT_SPEC) \ + _(1963, ZEND_EXT_FCALL_BEGIN_SPEC) \ + _(1964, ZEND_EXT_FCALL_END_SPEC) \ + _(1965, ZEND_EXT_NOP_SPEC) \ + _(1966, ZEND_TICKS_SPEC) \ + _(1967, ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST) \ + _(1970, ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED) \ + _(1972, ZEND_CATCH_SPEC_CONST) \ + _(1973, ZEND_THROW_SPEC_CONST) \ + _(1974, ZEND_THROW_SPEC_TMPVAR) \ + _(1975, ZEND_THROW_SPEC_TMPVAR) \ + _(1977, ZEND_THROW_SPEC_CV) \ + _(1978, ZEND_FETCH_CLASS_SPEC_UNUSED_CONST) \ + _(1979, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \ + _(1980, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \ + _(1981, ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED) \ + _(1982, ZEND_FETCH_CLASS_SPEC_UNUSED_CV) \ + _(1983, ZEND_CLONE_SPEC_CONST) \ + _(1984, ZEND_CLONE_SPEC_TMPVAR) \ + _(1985, ZEND_CLONE_SPEC_TMPVAR) \ + _(1986, ZEND_CLONE_SPEC_UNUSED) \ + _(1987, ZEND_CLONE_SPEC_CV) \ + _(1988, ZEND_RETURN_BY_REF_SPEC_CONST) \ + _(1989, ZEND_RETURN_BY_REF_SPEC_CONST_OBSERVER) \ + _(1990, ZEND_RETURN_BY_REF_SPEC_TMP) \ + _(1991, ZEND_RETURN_BY_REF_SPEC_TMP_OBSERVER) \ + _(1992, ZEND_RETURN_BY_REF_SPEC_VAR) \ + _(1993, ZEND_RETURN_BY_REF_SPEC_VAR_OBSERVER) \ + _(1996, ZEND_RETURN_BY_REF_SPEC_CV) \ + _(1997, ZEND_RETURN_BY_REF_SPEC_CV_OBSERVER) \ + _(1998, ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST) \ + _(1999, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \ + _(2000, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \ + _(2002, ZEND_INIT_METHOD_CALL_SPEC_CONST_CV) \ _(2003, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \ _(2004, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ _(2005, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ _(2007, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \ - _(2008, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST) \ - _(2009, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ - _(2010, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ - _(2012, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV) \ - _(2013, ZEND_INIT_METHOD_CALL_SPEC_CV_CONST) \ - _(2014, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \ - _(2015, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \ - _(2017, ZEND_INIT_METHOD_CALL_SPEC_CV_CV) \ - _(2018, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST) \ - _(2019, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \ - _(2020, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \ - _(2021, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED) \ - _(2022, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV) \ - _(2028, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST) \ - _(2029, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \ - _(2030, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \ - _(2031, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED) \ - _(2032, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV) \ - _(2033, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST) \ - _(2034, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ - _(2035, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ - _(2036, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED) \ - _(2037, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV) \ - _(2043, ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED) \ - _(2044, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \ - _(2045, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \ - _(2047, ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED) \ - _(2048, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST) \ - _(2049, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \ - _(2050, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \ - _(2052, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV) \ - _(2053, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \ - _(2054, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2055, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2057, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \ + _(2008, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \ + _(2009, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ + _(2010, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ + _(2012, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \ + _(2013, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST) \ + _(2014, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ + _(2015, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ + _(2017, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV) \ + _(2018, ZEND_INIT_METHOD_CALL_SPEC_CV_CONST) \ + _(2019, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \ + _(2020, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \ + _(2022, ZEND_INIT_METHOD_CALL_SPEC_CV_CV) \ + _(2023, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST) \ + _(2024, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \ + _(2025, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \ + _(2026, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED) \ + _(2027, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV) \ + _(2033, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST) \ + _(2034, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \ + _(2035, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \ + _(2036, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED) \ + _(2037, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV) \ + _(2038, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST) \ + _(2039, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ + _(2040, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ + _(2041, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED) \ + _(2042, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV) \ + _(2048, ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED) \ + _(2049, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \ + _(2050, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \ + _(2052, ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED) \ + _(2053, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST) \ + _(2054, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \ + _(2055, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \ + _(2057, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV) \ _(2058, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \ _(2059, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ _(2060, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ _(2062, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \ - _(2068, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST) \ - _(2069, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \ - _(2070, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \ - _(2072, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV) \ - _(2073, ZEND_SEND_VAL_EX_SPEC_CONST_CONST) \ - _(2074, ZEND_SEND_VAL_EX_SPEC_CONST_CONST) \ - _(2079, ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED) \ - _(2080, ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK) \ - _(2083, ZEND_SEND_VAL_EX_SPEC_TMP_CONST) \ - _(2084, ZEND_SEND_VAL_EX_SPEC_TMP_CONST) \ - _(2089, ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED) \ - _(2090, ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK) \ - _(2133, ZEND_SEND_VAR_SPEC_VAR_CONST) \ - _(2136, ZEND_SEND_VAR_SPEC_VAR_UNUSED) \ - _(2143, ZEND_SEND_VAR_SPEC_CV_CONST) \ - _(2146, ZEND_SEND_VAR_SPEC_CV_UNUSED) \ - _(2148, ZEND_INIT_USER_CALL_SPEC_CONST_CONST) \ - _(2149, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \ - _(2150, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \ - _(2152, ZEND_INIT_USER_CALL_SPEC_CONST_CV) \ - _(2153, ZEND_SEND_ARRAY_SPEC) \ - _(2154, ZEND_SEND_USER_SPEC_CONST) \ - _(2155, ZEND_SEND_USER_SPEC_TMP) \ - _(2156, ZEND_SEND_USER_SPEC_VAR) \ - _(2158, ZEND_SEND_USER_SPEC_CV) \ - _(2159, ZEND_STRLEN_SPEC_CONST) \ - _(2160, ZEND_STRLEN_SPEC_TMPVAR) \ - _(2161, ZEND_STRLEN_SPEC_TMPVAR) \ - _(2163, ZEND_STRLEN_SPEC_CV) \ - _(2164, ZEND_DEFINED_SPEC_CONST) \ - _(2165, ZEND_TYPE_CHECK_SPEC_CONST) \ - _(2166, ZEND_TYPE_CHECK_SPEC_TMPVAR) \ - _(2167, ZEND_TYPE_CHECK_SPEC_TMPVAR) \ - _(2169, ZEND_TYPE_CHECK_SPEC_CV) \ - _(2170, ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED) \ - _(2171, ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED) \ - _(2172, ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED) \ - _(2173, ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED) \ - _(2174, ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED) \ - _(2175, ZEND_FE_RESET_RW_SPEC_CONST) \ - _(2176, ZEND_FE_RESET_RW_SPEC_TMP) \ - _(2177, ZEND_FE_RESET_RW_SPEC_VAR) \ - _(2179, ZEND_FE_RESET_RW_SPEC_CV) \ - _(2180, ZEND_FE_FETCH_RW_SPEC_VAR) \ - _(2181, ZEND_FE_FREE_SPEC_TMPVAR) \ - _(2182, ZEND_INIT_DYNAMIC_CALL_SPEC_CONST) \ - _(2183, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \ - _(2184, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \ - _(2186, ZEND_INIT_DYNAMIC_CALL_SPEC_CV) \ - _(2187, ZEND_DO_ICALL_SPEC_RETVAL_UNUSED) \ - _(2188, ZEND_DO_ICALL_SPEC_RETVAL_USED) \ - _(2189, ZEND_DO_UCALL_SPEC_RETVAL_UNUSED) \ - _(2190, ZEND_DO_UCALL_SPEC_RETVAL_USED) \ - _(2191, ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_OBSERVER) \ - _(2192, ZEND_DO_UCALL_SPEC_RETVAL_USED_OBSERVER) \ - _(2193, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED) \ - _(2194, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED) \ - _(2195, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_OBSERVER) \ - _(2196, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_OBSERVER) \ - _(2207, ZEND_PRE_INC_OBJ_SPEC_VAR_CONST) \ - _(2208, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \ - _(2209, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \ - _(2211, ZEND_PRE_INC_OBJ_SPEC_VAR_CV) \ - _(2212, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST) \ - _(2213, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2214, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2216, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV) \ - _(2217, ZEND_PRE_INC_OBJ_SPEC_CV_CONST) \ - _(2218, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \ - _(2219, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \ - _(2221, ZEND_PRE_INC_OBJ_SPEC_CV_CV) \ - _(2232, ZEND_POST_INC_OBJ_SPEC_VAR_CONST) \ - _(2233, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \ - _(2234, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \ - _(2236, ZEND_POST_INC_OBJ_SPEC_VAR_CV) \ - _(2237, ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST) \ - _(2238, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2239, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2241, ZEND_POST_INC_OBJ_SPEC_UNUSED_CV) \ - _(2242, ZEND_POST_INC_OBJ_SPEC_CV_CONST) \ - _(2243, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \ - _(2244, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \ - _(2246, ZEND_POST_INC_OBJ_SPEC_CV_CV) \ - _(2247, ZEND_ECHO_SPEC_CONST) \ - _(2248, ZEND_ECHO_SPEC_TMPVAR) \ - _(2249, ZEND_ECHO_SPEC_TMPVAR) \ - _(2251, ZEND_ECHO_SPEC_CV) \ - _(2258, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \ - _(2260, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \ - _(2261, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \ + _(2063, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \ + _(2064, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2065, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2067, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \ + _(2073, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST) \ + _(2074, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \ + _(2075, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \ + _(2077, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV) \ + _(2078, ZEND_SEND_VAL_EX_SPEC_CONST_CONST) \ + _(2079, ZEND_SEND_VAL_EX_SPEC_CONST_CONST) \ + _(2084, ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED) \ + _(2085, ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK) \ + _(2088, ZEND_SEND_VAL_EX_SPEC_TMP_CONST) \ + _(2089, ZEND_SEND_VAL_EX_SPEC_TMP_CONST) \ + _(2094, ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED) \ + _(2095, ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK) \ + _(2138, ZEND_SEND_VAR_SPEC_VAR_CONST) \ + _(2141, ZEND_SEND_VAR_SPEC_VAR_UNUSED) \ + _(2148, ZEND_SEND_VAR_SPEC_CV_CONST) \ + _(2151, ZEND_SEND_VAR_SPEC_CV_UNUSED) \ + _(2153, ZEND_INIT_USER_CALL_SPEC_CONST_CONST) \ + _(2154, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \ + _(2155, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \ + _(2157, ZEND_INIT_USER_CALL_SPEC_CONST_CV) \ + _(2158, ZEND_SEND_ARRAY_SPEC) \ + _(2159, ZEND_SEND_USER_SPEC_CONST) \ + _(2160, ZEND_SEND_USER_SPEC_TMP) \ + _(2161, ZEND_SEND_USER_SPEC_VAR) \ + _(2163, ZEND_SEND_USER_SPEC_CV) \ + _(2164, ZEND_STRLEN_SPEC_CONST) \ + _(2165, ZEND_STRLEN_SPEC_TMPVAR) \ + _(2166, ZEND_STRLEN_SPEC_TMPVAR) \ + _(2168, ZEND_STRLEN_SPEC_CV) \ + _(2169, ZEND_DEFINED_SPEC_CONST) \ + _(2170, ZEND_TYPE_CHECK_SPEC_CONST) \ + _(2171, ZEND_TYPE_CHECK_SPEC_TMPVAR) \ + _(2172, ZEND_TYPE_CHECK_SPEC_TMPVAR) \ + _(2174, ZEND_TYPE_CHECK_SPEC_CV) \ + _(2175, ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED) \ + _(2176, ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED) \ + _(2177, ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED) \ + _(2178, ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED) \ + _(2179, ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED) \ + _(2180, ZEND_FE_RESET_RW_SPEC_CONST) \ + _(2181, ZEND_FE_RESET_RW_SPEC_TMP) \ + _(2182, ZEND_FE_RESET_RW_SPEC_VAR) \ + _(2184, ZEND_FE_RESET_RW_SPEC_CV) \ + _(2185, ZEND_FE_FETCH_RW_SPEC_VAR) \ + _(2186, ZEND_FE_FREE_SPEC_TMPVAR) \ + _(2187, ZEND_INIT_DYNAMIC_CALL_SPEC_CONST) \ + _(2188, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \ + _(2189, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \ + _(2191, ZEND_INIT_DYNAMIC_CALL_SPEC_CV) \ + _(2192, ZEND_DO_ICALL_SPEC_RETVAL_UNUSED) \ + _(2193, ZEND_DO_ICALL_SPEC_RETVAL_USED) \ + _(2194, ZEND_DO_UCALL_SPEC_RETVAL_UNUSED) \ + _(2195, ZEND_DO_UCALL_SPEC_RETVAL_USED) \ + _(2196, ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_OBSERVER) \ + _(2197, ZEND_DO_UCALL_SPEC_RETVAL_USED_OBSERVER) \ + _(2198, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED) \ + _(2199, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED) \ + _(2200, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_OBSERVER) \ + _(2201, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_OBSERVER) \ + _(2212, ZEND_PRE_INC_OBJ_SPEC_VAR_CONST) \ + _(2213, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \ + _(2214, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \ + _(2216, ZEND_PRE_INC_OBJ_SPEC_VAR_CV) \ + _(2217, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST) \ + _(2218, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2219, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2221, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV) \ + _(2222, ZEND_PRE_INC_OBJ_SPEC_CV_CONST) \ + _(2223, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \ + _(2224, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \ + _(2226, ZEND_PRE_INC_OBJ_SPEC_CV_CV) \ + _(2237, ZEND_POST_INC_OBJ_SPEC_VAR_CONST) \ + _(2238, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \ + _(2239, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \ + _(2241, ZEND_POST_INC_OBJ_SPEC_VAR_CV) \ + _(2242, ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST) \ + _(2243, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2244, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2246, ZEND_POST_INC_OBJ_SPEC_UNUSED_CV) \ + _(2247, ZEND_POST_INC_OBJ_SPEC_CV_CONST) \ + _(2248, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \ + _(2249, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \ + _(2251, ZEND_POST_INC_OBJ_SPEC_CV_CV) \ + _(2252, ZEND_ECHO_SPEC_CONST) \ + _(2253, ZEND_ECHO_SPEC_TMPVAR) \ + _(2254, ZEND_ECHO_SPEC_TMPVAR) \ + _(2256, ZEND_ECHO_SPEC_CV) \ _(2263, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \ _(2265, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \ _(2266, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \ - _(2273, ZEND_INSTANCEOF_SPEC_CV_CONST) \ - _(2275, ZEND_INSTANCEOF_SPEC_CV_VAR) \ - _(2276, ZEND_INSTANCEOF_SPEC_CV_UNUSED) \ - _(2278, ZEND_GENERATOR_CREATE_SPEC) \ - _(2281, ZEND_MAKE_REF_SPEC_VAR_UNUSED) \ - _(2283, ZEND_MAKE_REF_SPEC_CV_UNUSED) \ - _(2284, ZEND_DECLARE_FUNCTION_SPEC) \ - _(2285, ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED) \ - _(2286, ZEND_DECLARE_CONST_SPEC_CONST_CONST) \ - _(2287, ZEND_DECLARE_CLASS_SPEC_CONST) \ - _(2288, ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST) \ - _(2289, ZEND_DECLARE_ANON_CLASS_SPEC) \ - _(2290, ZEND_ADD_ARRAY_UNPACK_SPEC) \ - _(2291, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST) \ - _(2292, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \ - _(2293, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \ - _(2295, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV) \ - _(2296, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ - _(2297, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2298, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2300, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ + _(2268, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \ + _(2270, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \ + _(2271, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \ + _(2278, ZEND_INSTANCEOF_SPEC_CV_CONST) \ + _(2280, ZEND_INSTANCEOF_SPEC_CV_VAR) \ + _(2281, ZEND_INSTANCEOF_SPEC_CV_UNUSED) \ + _(2283, ZEND_GENERATOR_CREATE_SPEC) \ + _(2286, ZEND_MAKE_REF_SPEC_VAR_UNUSED) \ + _(2288, ZEND_MAKE_REF_SPEC_CV_UNUSED) \ + _(2289, ZEND_DECLARE_FUNCTION_SPEC) \ + _(2290, ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED) \ + _(2291, ZEND_DECLARE_CONST_SPEC_CONST_CONST) \ + _(2292, ZEND_DECLARE_CLASS_SPEC_CONST) \ + _(2293, ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST) \ + _(2294, ZEND_DECLARE_ANON_CLASS_SPEC) \ + _(2295, ZEND_ADD_ARRAY_UNPACK_SPEC) \ + _(2296, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST) \ + _(2297, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \ + _(2298, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \ + _(2300, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV) \ _(2301, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ _(2302, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ _(2303, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ _(2305, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ - _(2306, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST) \ - _(2307, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2308, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2310, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV) \ - _(2311, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST) \ - _(2312, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ - _(2313, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ - _(2315, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV) \ - _(2316, ZEND_HANDLE_EXCEPTION_SPEC) \ - _(2317, ZEND_USER_OPCODE_SPEC) \ - _(2318, ZEND_ASSERT_CHECK_SPEC) \ - _(2319, ZEND_JMP_SET_SPEC_CONST) \ - _(2320, ZEND_JMP_SET_SPEC_TMP) \ - _(2321, ZEND_JMP_SET_SPEC_VAR) \ - _(2323, ZEND_JMP_SET_SPEC_CV) \ - _(2324, ZEND_UNSET_CV_SPEC_CV_UNUSED) \ - _(2325, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET) \ - _(2326, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY) \ - _(2327, ZEND_FETCH_LIST_W_SPEC_VAR_CONST) \ - _(2328, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ - _(2329, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ - _(2331, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \ - _(2332, ZEND_SEPARATE_SPEC_VAR_UNUSED) \ - _(2334, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \ - _(2335, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \ - _(2336, ZEND_FETCH_CLASS_NAME_SPEC_UNUSED) \ - _(2337, ZEND_FETCH_CLASS_NAME_SPEC_CV) \ - _(2338, ZEND_CALL_TRAMPOLINE_SPEC) \ - _(2339, ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER) \ - _(2340, ZEND_DISCARD_EXCEPTION_SPEC) \ - _(2341, ZEND_YIELD_SPEC_CONST_CONST) \ - _(2342, ZEND_YIELD_SPEC_CONST_TMPVAR) \ - _(2343, ZEND_YIELD_SPEC_CONST_TMPVAR) \ - _(2344, ZEND_YIELD_SPEC_CONST_UNUSED) \ - _(2345, ZEND_YIELD_SPEC_CONST_CV) \ - _(2346, ZEND_YIELD_SPEC_TMP_CONST) \ - _(2347, ZEND_YIELD_SPEC_TMP_TMPVAR) \ - _(2348, ZEND_YIELD_SPEC_TMP_TMPVAR) \ - _(2349, ZEND_YIELD_SPEC_TMP_UNUSED) \ - _(2350, ZEND_YIELD_SPEC_TMP_CV) \ - _(2351, ZEND_YIELD_SPEC_VAR_CONST) \ - _(2352, ZEND_YIELD_SPEC_VAR_TMPVAR) \ - _(2353, ZEND_YIELD_SPEC_VAR_TMPVAR) \ - _(2354, ZEND_YIELD_SPEC_VAR_UNUSED) \ - _(2355, ZEND_YIELD_SPEC_VAR_CV) \ - _(2356, ZEND_YIELD_SPEC_UNUSED_CONST) \ - _(2357, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \ - _(2358, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \ - _(2359, ZEND_YIELD_SPEC_UNUSED_UNUSED) \ - _(2360, ZEND_YIELD_SPEC_UNUSED_CV) \ - _(2361, ZEND_YIELD_SPEC_CV_CONST) \ - _(2362, ZEND_YIELD_SPEC_CV_TMPVAR) \ - _(2363, ZEND_YIELD_SPEC_CV_TMPVAR) \ - _(2364, ZEND_YIELD_SPEC_CV_UNUSED) \ - _(2365, ZEND_YIELD_SPEC_CV_CV) \ - _(2366, ZEND_GENERATOR_RETURN_SPEC_CONST) \ - _(2367, ZEND_GENERATOR_RETURN_SPEC_CONST_OBSERVER) \ - _(2368, ZEND_GENERATOR_RETURN_SPEC_TMP) \ - _(2369, ZEND_GENERATOR_RETURN_SPEC_TMP_OBSERVER) \ - _(2370, ZEND_GENERATOR_RETURN_SPEC_VAR) \ - _(2371, ZEND_GENERATOR_RETURN_SPEC_VAR_OBSERVER) \ - _(2374, ZEND_GENERATOR_RETURN_SPEC_CV) \ - _(2375, ZEND_GENERATOR_RETURN_SPEC_CV_OBSERVER) \ - _(2376, ZEND_FAST_CALL_SPEC) \ - _(2377, ZEND_FAST_RET_SPEC) \ - _(2378, ZEND_RECV_VARIADIC_SPEC_UNUSED) \ - _(2379, ZEND_SEND_UNPACK_SPEC) \ - _(2380, ZEND_YIELD_FROM_SPEC_CONST) \ - _(2381, ZEND_YIELD_FROM_SPEC_TMPVAR) \ - _(2382, ZEND_YIELD_FROM_SPEC_TMPVAR) \ - _(2384, ZEND_YIELD_FROM_SPEC_CV) \ - _(2385, ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED) \ - _(2386, ZEND_BIND_GLOBAL_SPEC_CV_CONST) \ - _(2387, ZEND_COALESCE_SPEC_CONST) \ - _(2388, ZEND_COALESCE_SPEC_TMP) \ - _(2389, ZEND_COALESCE_SPEC_VAR) \ - _(2391, ZEND_COALESCE_SPEC_CV) \ - _(2392, ZEND_SPACESHIP_SPEC_CONST_CONST) \ - _(2393, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ - _(2394, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ - _(2396, ZEND_SPACESHIP_SPEC_CONST_CV) \ - _(2397, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ - _(2398, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(2399, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(2401, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ + _(2306, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ + _(2307, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2308, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2310, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ + _(2311, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST) \ + _(2312, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2313, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2315, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV) \ + _(2316, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST) \ + _(2317, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ + _(2318, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ + _(2320, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV) \ + _(2321, ZEND_HANDLE_EXCEPTION_SPEC) \ + _(2322, ZEND_USER_OPCODE_SPEC) \ + _(2323, ZEND_ASSERT_CHECK_SPEC) \ + _(2324, ZEND_JMP_SET_SPEC_CONST) \ + _(2325, ZEND_JMP_SET_SPEC_TMP) \ + _(2326, ZEND_JMP_SET_SPEC_VAR) \ + _(2328, ZEND_JMP_SET_SPEC_CV) \ + _(2329, ZEND_UNSET_CV_SPEC_CV_UNUSED) \ + _(2330, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET) \ + _(2331, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY) \ + _(2332, ZEND_FETCH_LIST_W_SPEC_VAR_CONST) \ + _(2333, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ + _(2334, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ + _(2336, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \ + _(2337, ZEND_SEPARATE_SPEC_VAR_UNUSED) \ + _(2339, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \ + _(2340, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \ + _(2341, ZEND_FETCH_CLASS_NAME_SPEC_UNUSED) \ + _(2342, ZEND_FETCH_CLASS_NAME_SPEC_CV) \ + _(2343, ZEND_CALL_TRAMPOLINE_SPEC) \ + _(2344, ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER) \ + _(2345, ZEND_DISCARD_EXCEPTION_SPEC) \ + _(2346, ZEND_YIELD_SPEC_CONST_CONST) \ + _(2347, ZEND_YIELD_SPEC_CONST_TMPVAR) \ + _(2348, ZEND_YIELD_SPEC_CONST_TMPVAR) \ + _(2349, ZEND_YIELD_SPEC_CONST_UNUSED) \ + _(2350, ZEND_YIELD_SPEC_CONST_CV) \ + _(2351, ZEND_YIELD_SPEC_TMP_CONST) \ + _(2352, ZEND_YIELD_SPEC_TMP_TMPVAR) \ + _(2353, ZEND_YIELD_SPEC_TMP_TMPVAR) \ + _(2354, ZEND_YIELD_SPEC_TMP_UNUSED) \ + _(2355, ZEND_YIELD_SPEC_TMP_CV) \ + _(2356, ZEND_YIELD_SPEC_VAR_CONST) \ + _(2357, ZEND_YIELD_SPEC_VAR_TMPVAR) \ + _(2358, ZEND_YIELD_SPEC_VAR_TMPVAR) \ + _(2359, ZEND_YIELD_SPEC_VAR_UNUSED) \ + _(2360, ZEND_YIELD_SPEC_VAR_CV) \ + _(2361, ZEND_YIELD_SPEC_UNUSED_CONST) \ + _(2362, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \ + _(2363, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \ + _(2364, ZEND_YIELD_SPEC_UNUSED_UNUSED) \ + _(2365, ZEND_YIELD_SPEC_UNUSED_CV) \ + _(2366, ZEND_YIELD_SPEC_CV_CONST) \ + _(2367, ZEND_YIELD_SPEC_CV_TMPVAR) \ + _(2368, ZEND_YIELD_SPEC_CV_TMPVAR) \ + _(2369, ZEND_YIELD_SPEC_CV_UNUSED) \ + _(2370, ZEND_YIELD_SPEC_CV_CV) \ + _(2371, ZEND_GENERATOR_RETURN_SPEC_CONST) \ + _(2372, ZEND_GENERATOR_RETURN_SPEC_CONST_OBSERVER) \ + _(2373, ZEND_GENERATOR_RETURN_SPEC_TMP) \ + _(2374, ZEND_GENERATOR_RETURN_SPEC_TMP_OBSERVER) \ + _(2375, ZEND_GENERATOR_RETURN_SPEC_VAR) \ + _(2376, ZEND_GENERATOR_RETURN_SPEC_VAR_OBSERVER) \ + _(2379, ZEND_GENERATOR_RETURN_SPEC_CV) \ + _(2380, ZEND_GENERATOR_RETURN_SPEC_CV_OBSERVER) \ + _(2381, ZEND_FAST_CALL_SPEC) \ + _(2382, ZEND_FAST_RET_SPEC) \ + _(2383, ZEND_RECV_VARIADIC_SPEC_UNUSED) \ + _(2384, ZEND_SEND_UNPACK_SPEC) \ + _(2385, ZEND_YIELD_FROM_SPEC_CONST) \ + _(2386, ZEND_YIELD_FROM_SPEC_TMPVAR) \ + _(2387, ZEND_YIELD_FROM_SPEC_TMPVAR) \ + _(2389, ZEND_YIELD_FROM_SPEC_CV) \ + _(2390, ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED) \ + _(2391, ZEND_BIND_GLOBAL_SPEC_CV_CONST) \ + _(2392, ZEND_COALESCE_SPEC_CONST) \ + _(2393, ZEND_COALESCE_SPEC_TMP) \ + _(2394, ZEND_COALESCE_SPEC_VAR) \ + _(2396, ZEND_COALESCE_SPEC_CV) \ + _(2397, ZEND_SPACESHIP_SPEC_CONST_CONST) \ + _(2398, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ + _(2399, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ + _(2401, ZEND_SPACESHIP_SPEC_CONST_CV) \ _(2402, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ _(2403, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ _(2404, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ _(2406, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ - _(2412, ZEND_SPACESHIP_SPEC_CV_CONST) \ - _(2413, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ - _(2414, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ - _(2416, ZEND_SPACESHIP_SPEC_CV_CV) \ - _(2417, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED) \ - _(2418, ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED) \ - _(2421, ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED) \ - _(2423, ZEND_FETCH_STATIC_PROP_R_SPEC) \ - _(2424, ZEND_FETCH_STATIC_PROP_W_SPEC) \ - _(2425, ZEND_FETCH_STATIC_PROP_RW_SPEC) \ - _(2426, ZEND_FETCH_STATIC_PROP_IS_SPEC) \ - _(2427, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC) \ - _(2428, ZEND_FETCH_STATIC_PROP_UNSET_SPEC) \ - _(2429, ZEND_UNSET_STATIC_PROP_SPEC) \ - _(2430, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC) \ - _(2431, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) \ - _(2433, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) \ - _(2434, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST) \ - _(2436, ZEND_BIND_LEXICAL_SPEC_TMP_CV) \ - _(2437, ZEND_BIND_STATIC_SPEC_CV_UNUSED) \ - _(2438, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED) \ - _(2439, ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST) \ - _(2442, ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED) \ - _(2444, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED) \ - _(2445, ZEND_SWITCH_LONG_SPEC_CONST_CONST) \ - _(2446, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(2447, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(2449, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(2450, ZEND_SWITCH_STRING_SPEC_CONST_CONST) \ - _(2451, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(2452, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(2454, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(2455, ZEND_IN_ARRAY_SPEC_CONST_CONST) \ - _(2456, ZEND_IN_ARRAY_SPEC_TMP_CONST) \ - _(2457, ZEND_IN_ARRAY_SPEC_VAR_CONST) \ - _(2459, ZEND_IN_ARRAY_SPEC_CV_CONST) \ - _(2460, ZEND_COUNT_SPEC_CONST_UNUSED) \ - _(2461, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \ - _(2462, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \ - _(2464, ZEND_COUNT_SPEC_CV_UNUSED) \ - _(2465, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \ - _(2466, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \ - _(2467, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \ - _(2468, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED) \ - _(2469, ZEND_GET_CLASS_SPEC_CV_UNUSED) \ - _(2470, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED) \ - _(2471, ZEND_GET_TYPE_SPEC_CONST_UNUSED) \ - _(2472, ZEND_GET_TYPE_SPEC_TMP_UNUSED) \ - _(2473, ZEND_GET_TYPE_SPEC_VAR_UNUSED) \ - _(2475, ZEND_GET_TYPE_SPEC_CV_UNUSED) \ - _(2476, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \ - _(2477, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ - _(2478, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ - _(2480, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \ - _(2481, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ - _(2482, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(2483, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(2485, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ + _(2407, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ + _(2408, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ + _(2409, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ + _(2411, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ + _(2417, ZEND_SPACESHIP_SPEC_CV_CONST) \ + _(2418, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ + _(2419, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ + _(2421, ZEND_SPACESHIP_SPEC_CV_CV) \ + _(2422, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED) \ + _(2423, ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED) \ + _(2426, ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED) \ + _(2428, ZEND_FETCH_STATIC_PROP_R_SPEC) \ + _(2429, ZEND_FETCH_STATIC_PROP_W_SPEC) \ + _(2430, ZEND_FETCH_STATIC_PROP_RW_SPEC) \ + _(2431, ZEND_FETCH_STATIC_PROP_IS_SPEC) \ + _(2432, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC) \ + _(2433, ZEND_FETCH_STATIC_PROP_UNSET_SPEC) \ + _(2434, ZEND_UNSET_STATIC_PROP_SPEC) \ + _(2435, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC) \ + _(2436, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) \ + _(2438, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) \ + _(2439, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST) \ + _(2441, ZEND_BIND_LEXICAL_SPEC_TMP_CV) \ + _(2442, ZEND_BIND_STATIC_SPEC_CV_UNUSED) \ + _(2443, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED) \ + _(2444, ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST) \ + _(2447, ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED) \ + _(2449, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED) \ + _(2450, ZEND_SWITCH_LONG_SPEC_CONST_CONST) \ + _(2451, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(2452, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(2454, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(2455, ZEND_SWITCH_STRING_SPEC_CONST_CONST) \ + _(2456, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(2457, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(2459, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(2460, ZEND_IN_ARRAY_SPEC_CONST_CONST) \ + _(2461, ZEND_IN_ARRAY_SPEC_TMP_CONST) \ + _(2462, ZEND_IN_ARRAY_SPEC_VAR_CONST) \ + _(2464, ZEND_IN_ARRAY_SPEC_CV_CONST) \ + _(2465, ZEND_COUNT_SPEC_CONST_UNUSED) \ + _(2466, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \ + _(2467, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \ + _(2469, ZEND_COUNT_SPEC_CV_UNUSED) \ + _(2470, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \ + _(2471, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \ + _(2472, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \ + _(2473, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED) \ + _(2474, ZEND_GET_CLASS_SPEC_CV_UNUSED) \ + _(2475, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED) \ + _(2476, ZEND_GET_TYPE_SPEC_CONST_UNUSED) \ + _(2477, ZEND_GET_TYPE_SPEC_TMP_UNUSED) \ + _(2478, ZEND_GET_TYPE_SPEC_VAR_UNUSED) \ + _(2480, ZEND_GET_TYPE_SPEC_CV_UNUSED) \ + _(2481, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \ + _(2482, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ + _(2483, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ + _(2485, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \ _(2486, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ _(2487, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ _(2488, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ _(2490, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ - _(2496, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \ - _(2497, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ - _(2498, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ - _(2500, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \ - _(2501, ZEND_MATCH_SPEC_CONST_CONST) \ - _(2502, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ - _(2503, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ - _(2505, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ - _(2511, ZEND_CASE_STRICT_SPEC_TMP_CONST) \ - _(2512, ZEND_CASE_STRICT_SPEC_TMP_TMP) \ - _(2513, ZEND_CASE_STRICT_SPEC_TMP_VAR) \ - _(2515, ZEND_CASE_STRICT_SPEC_TMP_CV) \ - _(2516, ZEND_CASE_STRICT_SPEC_VAR_CONST) \ - _(2517, ZEND_CASE_STRICT_SPEC_VAR_TMP) \ - _(2518, ZEND_CASE_STRICT_SPEC_VAR_VAR) \ - _(2520, ZEND_CASE_STRICT_SPEC_VAR_CV) \ - _(2531, ZEND_MATCH_ERROR_SPEC_CONST_UNUSED) \ - _(2532, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ - _(2533, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ - _(2535, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ - _(2536, ZEND_JMP_NULL_SPEC_CONST) \ - _(2537, ZEND_JMP_NULL_SPEC_TMPVARCV) \ - _(2538, ZEND_JMP_NULL_SPEC_TMPVARCV) \ - _(2540, ZEND_JMP_NULL_SPEC_TMPVARCV) \ - _(2541, ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED) \ - _(2542, ZEND_RECV_NOTYPE_SPEC) \ - _(2543, ZEND_JMP_FORWARD_SPEC) \ - _(2549, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2550, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2551, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2553, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2491, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ + _(2492, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(2493, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(2495, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ + _(2501, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \ + _(2502, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ + _(2503, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ + _(2505, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \ + _(2506, ZEND_MATCH_SPEC_CONST_CONST) \ + _(2507, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ + _(2508, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ + _(2510, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ + _(2516, ZEND_CASE_STRICT_SPEC_TMP_CONST) \ + _(2517, ZEND_CASE_STRICT_SPEC_TMP_TMP) \ + _(2518, ZEND_CASE_STRICT_SPEC_TMP_VAR) \ + _(2520, ZEND_CASE_STRICT_SPEC_TMP_CV) \ + _(2521, ZEND_CASE_STRICT_SPEC_VAR_CONST) \ + _(2522, ZEND_CASE_STRICT_SPEC_VAR_TMP) \ + _(2523, ZEND_CASE_STRICT_SPEC_VAR_VAR) \ + _(2525, ZEND_CASE_STRICT_SPEC_VAR_CV) \ + _(2536, ZEND_MATCH_ERROR_SPEC_CONST_UNUSED) \ + _(2537, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ + _(2538, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ + _(2540, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ + _(2541, ZEND_JMP_NULL_SPEC_CONST) \ + _(2542, ZEND_JMP_NULL_SPEC_TMPVARCV) \ + _(2543, ZEND_JMP_NULL_SPEC_TMPVARCV) \ + _(2545, ZEND_JMP_NULL_SPEC_TMPVARCV) \ + _(2546, ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED) \ + _(2547, ZEND_RECV_NOTYPE_SPEC) \ + _(2548, ZEND_JMP_FORWARD_SPEC) \ _(2554, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2555, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2556, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2558, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2564, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2565, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2566, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2568, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2574, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2575, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2576, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2578, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2559, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2560, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2561, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2563, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2569, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2570, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2571, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2573, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2579, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ _(2580, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2581, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2583, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2589, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2590, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2591, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2593, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2599, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2600, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2601, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2603, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2584, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2585, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2586, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2588, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2594, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2595, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2596, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2598, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2604, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2605, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2606, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2608, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2614, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2615, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2616, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2618, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2620, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2621, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2623, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2624, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2625, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2626, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2628, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2609, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2610, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2611, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2613, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2619, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2620, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2621, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2623, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2625, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2626, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2628, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ _(2629, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2630, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2631, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2633, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2639, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2640, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2641, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2643, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2645, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2646, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2648, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2649, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2650, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2651, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2653, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2634, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2635, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2636, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2638, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2644, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2645, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2646, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2648, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2650, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2651, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2653, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ _(2654, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ _(2655, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2656, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2658, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2664, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2665, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2666, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2668, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2670, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2671, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2673, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2674, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2675, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2676, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2678, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2659, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2660, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2661, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2663, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2669, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2670, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2671, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2673, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2675, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2676, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2678, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ _(2679, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2680, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2681, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2683, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2689, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2690, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2691, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2693, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2699, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2700, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2701, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2703, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2684, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2685, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2686, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2688, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2694, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2695, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2696, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2698, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2704, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2705, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2706, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2708, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2714, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2715, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2716, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2718, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2724, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2725, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2726, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2728, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2709, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2710, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2711, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2713, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2719, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2720, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2721, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2723, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2729, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ _(2730, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2731, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2733, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2739, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2740, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2741, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2743, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2749, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2750, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2751, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2753, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2734, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2735, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2736, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2738, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2744, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2745, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2746, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2748, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2754, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2755, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2756, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2758, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2764, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2765, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2766, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2768, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2784, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2785, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2786, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2787, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2788, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2789, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2790, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2791, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2792, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2796, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2797, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2798, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2799, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2800, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2801, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2802, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2803, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2804, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2805, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2806, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2807, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2811, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2812, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2813, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2829, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2830, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2831, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2832, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2833, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2834, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2835, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2836, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2837, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2841, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2842, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2843, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2859, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2860, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2861, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2862, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2863, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2864, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2865, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2866, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2867, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2871, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2872, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2873, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2874, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2875, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2876, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2877, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2878, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2879, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2880, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2881, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2882, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2886, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2887, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2888, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2904, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2905, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2906, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2907, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2908, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2909, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2910, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2911, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2912, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2916, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2917, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2918, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2934, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2935, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2936, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2937, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2938, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2939, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2940, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2941, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2942, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2946, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2947, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2948, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2949, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2950, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2951, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2952, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2953, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2954, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2955, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2956, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2957, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2961, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2962, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2963, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2979, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2980, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2981, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2982, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2983, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2984, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2985, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2986, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2987, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2991, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2992, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2993, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3009, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3010, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3011, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3012, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3013, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3014, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3015, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3016, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3017, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3021, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3022, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3023, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3024, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3025, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3026, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3027, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3028, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3029, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3030, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3031, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3032, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3036, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3037, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3038, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3054, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3055, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3056, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3057, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3058, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3059, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3060, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3061, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3062, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3066, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3067, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3068, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3069, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(3073, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(3074, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(3078, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(3082, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3083, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3084, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3085, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3086, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3087, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3091, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3092, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3093, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3094, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3095, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3096, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3097, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3098, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3099, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3100, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3101, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3102, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3106, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3107, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3108, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3109, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3110, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3111, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3112, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3113, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3114, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3115, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3116, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3117, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3121, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3122, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3123, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3139, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3140, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3141, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3142, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3143, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3144, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3145, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3146, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3147, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3151, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3152, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3153, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3157, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3158, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3159, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3160, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3161, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3162, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3166, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3167, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3168, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3169, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3170, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3171, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3172, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3173, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3174, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3175, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3176, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3177, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3181, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3182, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3183, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3184, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3185, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3186, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3187, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3188, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3189, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3190, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3191, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3192, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3196, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3197, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3198, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3214, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3215, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3216, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3217, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3218, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3219, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3220, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3221, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3222, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3226, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3227, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3228, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3232, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3233, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3234, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3235, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3236, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3237, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3241, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3242, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3243, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3244, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3245, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3246, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3247, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3248, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3249, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3250, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3251, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3252, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3256, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3257, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3258, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3259, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3260, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3261, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3262, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3263, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3264, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3265, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3266, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3267, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3271, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3272, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3273, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3289, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3290, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3291, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3292, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3293, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3294, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3295, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3296, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3297, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3301, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3302, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3303, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3307, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3308, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3309, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3310, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3311, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3312, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3316, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3317, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3318, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3319, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3320, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3321, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3322, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3323, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3324, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3325, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3326, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3327, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3331, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3332, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3333, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3334, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3335, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3336, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3337, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3338, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3339, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3340, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3341, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3342, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3346, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3347, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3348, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3364, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3365, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3366, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3367, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3368, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3369, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3370, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3371, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3372, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3376, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3377, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3378, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3379, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3380, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3381, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3382, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ - _(3383, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3384, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3385, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3386, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ - _(3387, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3388, ZEND_POST_INC_LONG_SPEC_CV) \ - _(3389, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3390, ZEND_POST_DEC_LONG_SPEC_CV) \ - _(3391, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ - _(3392, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3393, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3395, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3396, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ - _(3397, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3398, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3400, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3401, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ - _(3402, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3403, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3405, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3407, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3408, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3410, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3411, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(3412, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3413, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3415, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(2759, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2760, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2761, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2763, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2769, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2770, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2771, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2773, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2789, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2790, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2791, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2792, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2793, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2794, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2795, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2796, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2797, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2801, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2802, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2803, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2804, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2805, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2806, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2807, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2808, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2809, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2810, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2811, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2812, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2816, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2817, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2818, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2834, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2835, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2836, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2837, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2838, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2839, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2840, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2841, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2842, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2846, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2847, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2848, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2864, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2865, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2866, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2867, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2868, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2869, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2870, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2871, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2872, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2876, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2877, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2878, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2879, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2880, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2881, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2882, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2883, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2884, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2885, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2886, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2887, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2891, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2892, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2893, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2909, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2910, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2911, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2912, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2913, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2914, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2915, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2916, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2917, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2921, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2922, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2923, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2939, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2940, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2941, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2942, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2943, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2944, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2945, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2946, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2947, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2951, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2952, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2953, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2954, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2955, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2956, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2957, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2958, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2959, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2960, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2961, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2962, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2966, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2967, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2968, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2984, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2985, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2986, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2987, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2988, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2989, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2990, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2991, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2992, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2996, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2997, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2998, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3014, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3015, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3016, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3017, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3018, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3019, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3020, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3021, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3022, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3026, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3027, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3028, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3029, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3030, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3031, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3032, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3033, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3034, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3035, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3036, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3037, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3041, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3042, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3043, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3059, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3060, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3061, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3062, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3063, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3064, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3065, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3066, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3067, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3071, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3072, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3073, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3074, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3078, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3079, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3083, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3087, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3088, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3089, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3090, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3091, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3092, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3096, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3097, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3098, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3099, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3100, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3101, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3102, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3103, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3104, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3105, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3106, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3107, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3111, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3112, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3113, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3114, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3115, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3116, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3117, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3118, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3119, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3120, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3121, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3122, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3126, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3127, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3128, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3144, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3145, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3146, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3147, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3148, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3149, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3150, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3151, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3152, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3156, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3157, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3158, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3162, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3163, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3164, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3165, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3166, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3167, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3171, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3172, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3173, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3174, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3175, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3176, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3177, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3178, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3179, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3180, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3181, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3182, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3186, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3187, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3188, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3189, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3190, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3191, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3192, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3193, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3194, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3195, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3196, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3197, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3201, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3202, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3203, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3219, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3220, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3221, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3222, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3223, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3224, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3225, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3226, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3227, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3231, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3232, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3233, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3237, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3238, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3239, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3240, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3241, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3242, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3246, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3247, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3248, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3249, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3250, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3251, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3252, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3253, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3254, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3255, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3256, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3257, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3261, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3262, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3263, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3264, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3265, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3266, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3267, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3268, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3269, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3270, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3271, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3272, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3276, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3277, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3278, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3294, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3295, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3296, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3297, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3298, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3299, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3300, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3301, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3302, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3306, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3307, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3308, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3312, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3313, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3314, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3315, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3316, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3317, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3321, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3322, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3323, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3324, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3325, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3326, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3327, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3328, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3329, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3330, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3331, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3332, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3336, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3337, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3338, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3339, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3340, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3341, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3342, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3343, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3344, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3345, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3346, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3347, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3351, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3352, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3353, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3369, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3370, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3371, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3372, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3373, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3374, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3375, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3376, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3377, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3381, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3382, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3383, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3384, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3385, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3386, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3387, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ + _(3388, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3389, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3390, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3391, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ + _(3392, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3393, ZEND_POST_INC_LONG_SPEC_CV) \ + _(3394, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3395, ZEND_POST_DEC_LONG_SPEC_CV) \ + _(3396, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ + _(3397, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3398, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3400, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3401, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ + _(3402, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3403, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3405, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3406, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ + _(3407, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3408, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3410, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3412, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3413, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3415, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ _(3416, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ _(3417, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ _(3418, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ _(3420, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3426, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ - _(3427, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3428, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3430, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3433, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ - _(3435, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ - _(3438, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ - _(3440, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ - _(3441, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ - _(3442, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ - _(3443, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ - _(3444, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ - _(3444+1, ZEND_NULL) + _(3421, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3422, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3423, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3425, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3431, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ + _(3432, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3433, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3435, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3438, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ + _(3440, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ + _(3443, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ + _(3445, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ + _(3446, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ + _(3447, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ + _(3448, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ + _(3449, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ + _(3449+1, ZEND_NULL) From 791c921b1fd4aec427851314b82cafa43e2e6ad4 Mon Sep 17 00:00:00 2001 From: Sammy Powers Date: Wed, 26 Aug 2020 13:36:27 -0700 Subject: [PATCH 34/53] Add SPEC(OBSERVER) to fcall INIT handlers --- Zend/zend_execute.c | 6 +- Zend/zend_vm_def.h | 23 +- Zend/zend_vm_execute.h | 4818 ++++++++++++++++++++++++++++++++++++--- Zend/zend_vm_handlers.h | 2469 ++++++++++---------- 4 files changed, 5745 insertions(+), 1571 deletions(-) diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c index e5d74d930abe7..858760535d915 100644 --- a/Zend/zend_execute.c +++ b/Zend/zend_execute.c @@ -3552,10 +3552,6 @@ static zend_always_inline void init_func_run_time_cache_i(zend_op_array *op_arra run_time_cache = zend_arena_alloc(&CG(arena), op_array->cache_size); memset(run_time_cache, 0, op_array->cache_size); ZEND_MAP_PTR_SET(op_array->run_time_cache, run_time_cache); - - if (ZEND_SHOULD_OBSERVE_FN(op_array->fn_flags)) { - zend_observer_fcall_install((zend_function*) op_array); - } } /* }}} */ @@ -3613,7 +3609,7 @@ static zend_always_inline void i_init_code_execute_data(zend_execute_data *execu zend_attach_symbol_table(execute_data); if (!ZEND_MAP_PTR(op_array->run_time_cache)) { - void *ptr = NULL; + void *ptr; ZEND_ASSERT(op_array->fn_flags & ZEND_ACC_HEAP_RT_CACHE); ptr = emalloc(op_array->cache_size + sizeof(void*)); diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 2cfcb5bf10bc3..266c4207d5a0c 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -3383,7 +3383,7 @@ ZEND_VM_C_LABEL(try_class_name): ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -ZEND_VM_HOT_OBJ_HANDLER(112, ZEND_INIT_METHOD_CALL, CONST|TMPVAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, NUM|CACHE_SLOT) +ZEND_VM_HOT_OBJ_HANDLER(112, ZEND_INIT_METHOD_CALL, CONST|TMPVAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, NUM|CACHE_SLOT, SPEC(OBSERVER)) { USE_OPLINE zval *function_name; @@ -3487,6 +3487,7 @@ ZEND_VM_HOT_OBJ_HANDLER(112, ZEND_INIT_METHOD_CALL, CONST|TMPVAR|UNUSED|THIS|CV, } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + OBSERVER_FCALL_INSTALL((zend_function*)&fbc->op_array); } } @@ -3526,7 +3527,7 @@ ZEND_VM_HOT_OBJ_HANDLER(112, ZEND_INIT_METHOD_CALL, CONST|TMPVAR|UNUSED|THIS|CV, ZEND_VM_NEXT_OPCODE(); } -ZEND_VM_HANDLER(113, ZEND_INIT_STATIC_METHOD_CALL, UNUSED|CLASS_FETCH|CONST|VAR, CONST|TMPVAR|UNUSED|CONSTRUCTOR|CV, NUM|CACHE_SLOT) +ZEND_VM_HANDLER(113, ZEND_INIT_STATIC_METHOD_CALL, UNUSED|CLASS_FETCH|CONST|VAR, CONST|TMPVAR|UNUSED|CONSTRUCTOR|CV, NUM|CACHE_SLOT, SPEC(OBSERVER)) { USE_OPLINE zval *function_name; @@ -3609,6 +3610,7 @@ ZEND_VM_HANDLER(113, ZEND_INIT_STATIC_METHOD_CALL, UNUSED|CLASS_FETCH|CONST|VAR, } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + OBSERVER_FCALL_INSTALL((zend_function*)&fbc->op_array); } if (OP2_TYPE != IS_CONST) { FREE_OP2(); @@ -3625,6 +3627,7 @@ ZEND_VM_HANDLER(113, ZEND_INIT_STATIC_METHOD_CALL, UNUSED|CLASS_FETCH|CONST|VAR, fbc = ce->constructor; if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + OBSERVER_FCALL_INSTALL((zend_function*)&fbc->op_array); } } @@ -3658,7 +3661,7 @@ ZEND_VM_HANDLER(113, ZEND_INIT_STATIC_METHOD_CALL, UNUSED|CLASS_FETCH|CONST|VAR, ZEND_VM_NEXT_OPCODE(); } -ZEND_VM_HOT_HANDLER(59, ZEND_INIT_FCALL_BY_NAME, ANY, CONST, NUM|CACHE_SLOT) +ZEND_VM_HOT_HANDLER(59, ZEND_INIT_FCALL_BY_NAME, ANY, CONST, NUM|CACHE_SLOT, SPEC(OBSERVER)) { USE_OPLINE zend_function *fbc; @@ -3675,6 +3678,7 @@ ZEND_VM_HOT_HANDLER(59, ZEND_INIT_FCALL_BY_NAME, ANY, CONST, NUM|CACHE_SLOT) fbc = Z_FUNC_P(func); if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + OBSERVER_FCALL_INSTALL((zend_function*)&fbc->op_array); } CACHE_PTR(opline->result.num, fbc); } @@ -3741,7 +3745,7 @@ ZEND_VM_C_LABEL(try_function_name): ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -ZEND_VM_HANDLER(118, ZEND_INIT_USER_CALL, CONST, CONST|TMPVAR|CV, NUM) +ZEND_VM_HANDLER(118, ZEND_INIT_USER_CALL, CONST, CONST|TMPVAR|CV, NUM, SPEC(OBSERVER)) { USE_OPLINE zval *function_name; @@ -3787,6 +3791,7 @@ ZEND_VM_HANDLER(118, ZEND_INIT_USER_CALL, CONST, CONST|TMPVAR|CV, NUM) if (EXPECTED(func->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&func->op_array))) { init_func_run_time_cache(&func->op_array); + OBSERVER_FCALL_INSTALL((zend_function*)&func->op_array); } } else { zend_type_error("%s(): Argument #1 ($function) must be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error); @@ -3803,7 +3808,7 @@ ZEND_VM_HANDLER(118, ZEND_INIT_USER_CALL, CONST, CONST|TMPVAR|CV, NUM) ZEND_VM_NEXT_OPCODE(); } -ZEND_VM_HOT_HANDLER(69, ZEND_INIT_NS_FCALL_BY_NAME, ANY, CONST, NUM|CACHE_SLOT) +ZEND_VM_HOT_HANDLER(69, ZEND_INIT_NS_FCALL_BY_NAME, ANY, CONST, NUM|CACHE_SLOT, SPEC(OBSERVER)) { USE_OPLINE zval *func_name; @@ -3824,6 +3829,7 @@ ZEND_VM_HOT_HANDLER(69, ZEND_INIT_NS_FCALL_BY_NAME, ANY, CONST, NUM|CACHE_SLOT) fbc = Z_FUNC_P(func); if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + OBSERVER_FCALL_INSTALL((zend_function*)&fbc->op_array); } CACHE_PTR(opline->result.num, fbc); } @@ -3836,7 +3842,7 @@ ZEND_VM_HOT_HANDLER(69, ZEND_INIT_NS_FCALL_BY_NAME, ANY, CONST, NUM|CACHE_SLOT) ZEND_VM_NEXT_OPCODE(); } -ZEND_VM_HOT_HANDLER(61, ZEND_INIT_FCALL, NUM, CONST, NUM|CACHE_SLOT) +ZEND_VM_HOT_HANDLER(61, ZEND_INIT_FCALL, NUM, CONST, NUM|CACHE_SLOT, SPEC(OBSERVER)) { USE_OPLINE zval *fname; @@ -3854,6 +3860,7 @@ ZEND_VM_HOT_HANDLER(61, ZEND_INIT_FCALL, NUM, CONST, NUM|CACHE_SLOT) fbc = Z_FUNC_P(func); if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + OBSERVER_FCALL_INSTALL((zend_function*)&fbc->op_array); } CACHE_PTR(opline->result.num, fbc); } @@ -5580,7 +5587,7 @@ ZEND_VM_C_LABEL(case_double): ZEND_VM_DISPATCH_TO_HELPER(zend_case_helper, op_1, op1, op_2, op2); } -ZEND_VM_HANDLER(68, ZEND_NEW, UNUSED|CLASS_FETCH|CONST|VAR, UNUSED|CACHE_SLOT, NUM) +ZEND_VM_HANDLER(68, ZEND_NEW, UNUSED|CLASS_FETCH|CONST|VAR, UNUSED|CACHE_SLOT, NUM, SPEC(OBSERVER)) { USE_OPLINE zval *result; @@ -5634,6 +5641,7 @@ ZEND_VM_HANDLER(68, ZEND_NEW, UNUSED|CLASS_FETCH|CONST|VAR, UNUSED|CACHE_SLOT, N } else { if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&constructor->op_array))) { init_func_run_time_cache(&constructor->op_array); + OBSERVER_FCALL_INSTALL((zend_function*)&constructor->op_array); } /* We are not handling overloaded classes right now */ call = zend_vm_stack_push_call_frame( @@ -8455,6 +8463,7 @@ ZEND_VM_HANDLER(158, ZEND_CALL_TRAMPOLINE, ANY, ANY, SPEC(OBSERVER)) if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) { if (UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + OBSERVER_FCALL_INSTALL((zend_function*)&fbc->op_array); } execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index cf43723127ec7..c53d1403d754d 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -3318,6 +3318,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CALL_TRAMPOLINE_SPEC_HANDLER(Z if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) { if (UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + } execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); @@ -3452,6 +3453,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER_ if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) { if (UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + zend_observer_fcall_install((zend_function*)&fbc->op_array); } execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); @@ -3568,6 +3570,36 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME fbc = Z_FUNC_P(func); if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + + } + CACHE_PTR(opline->result.num, fbc); + } + call = _zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION, + fbc, opline->extended_value, NULL); + call->prev_execute_data = EX(call); + EX(call) = call; + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_function *fbc; + zval *function_name, *func; + zend_execute_data *call; + + fbc = CACHED_PTR(opline->result.num); + if (UNEXPECTED(fbc == NULL)) { + function_name = (zval*)RT_CONSTANT(opline, opline->op2); + func = zend_hash_find_ex(EG(function_table), Z_STR_P(function_name+1), 1); + if (UNEXPECTED(func == NULL)) { + ZEND_VM_TAIL_CALL(zend_undefined_function_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + } + fbc = Z_FUNC_P(func); + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + zend_observer_fcall_install((zend_function*)&fbc->op_array); } CACHE_PTR(opline->result.num, fbc); } @@ -3654,6 +3686,41 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_NS_FCALL_BY_N fbc = Z_FUNC_P(func); if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + + } + CACHE_PTR(opline->result.num, fbc); + } + + call = _zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION, + fbc, opline->extended_value, NULL); + call->prev_execute_data = EX(call); + EX(call) = call; + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *func_name; + zval *func; + zend_function *fbc; + zend_execute_data *call; + + fbc = CACHED_PTR(opline->result.num); + if (UNEXPECTED(fbc == NULL)) { + func_name = (zval *)RT_CONSTANT(opline, opline->op2); + func = zend_hash_find_ex(EG(function_table), Z_STR_P(func_name + 1), 1); + if (func == NULL) { + func = zend_hash_find_ex(EG(function_table), Z_STR_P(func_name + 2), 1); + if (UNEXPECTED(func == NULL)) { + ZEND_VM_TAIL_CALL(zend_undefined_function_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + } + } + fbc = Z_FUNC_P(func); + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + zend_observer_fcall_install((zend_function*)&fbc->op_array); } CACHE_PTR(opline->result.num, fbc); } @@ -3684,6 +3751,39 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_FCALL_SPEC_CO fbc = Z_FUNC_P(func); if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + + } + CACHE_PTR(opline->result.num, fbc); + } + + call = _zend_vm_stack_push_call_frame_ex( + opline->op1.num, ZEND_CALL_NESTED_FUNCTION, + fbc, opline->extended_value, NULL); + call->prev_execute_data = EX(call); + EX(call) = call; + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_FCALL_SPEC_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *fname; + zval *func; + zend_function *fbc; + zend_execute_data *call; + + fbc = CACHED_PTR(opline->result.num); + if (UNEXPECTED(fbc == NULL)) { + fname = (zval*)RT_CONSTANT(opline, opline->op2); + func = zend_hash_find_ex(EG(function_table), Z_STR_P(fname), 1); + if (UNEXPECTED(func == NULL)) { + ZEND_VM_TAIL_CALL(zend_undefined_function_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + } + fbc = Z_FUNC_P(func); + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + zend_observer_fcall_install((zend_function*)&fbc->op_array); } CACHE_PTR(opline->result.num, fbc); } @@ -6634,6 +6734,150 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_ } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + + } + } + + if (IS_CONST != IS_CONST) { + + } + + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; + if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { + + if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(EG(exception))) { + HANDLE_EXCEPTION(); + } + /* call static method */ + obj = (zend_object*)called_scope; + call_info = ZEND_CALL_NESTED_FUNCTION; + } else if (IS_CONST & (IS_VAR|IS_TMP_VAR|IS_CV)) { + if (IS_CONST == IS_CV) { + GC_ADDREF(obj); /* For $this pointer */ + } else { + zval *free_op1 = EX_VAR(opline->op1.var); + if (free_op1 != object) { + GC_ADDREF(obj); /* For $this pointer */ + zval_ptr_dtor_nogc(free_op1); + } + } + /* CV may be changed indirectly (e.g. when it's a reference) */ + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS; + } + + call = zend_vm_stack_push_call_frame(call_info, + fbc, opline->extended_value, obj); + call->prev_execute_data = EX(call); + EX(call) = call; + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *function_name; + zval *object; + zend_function *fbc; + zend_class_entry *called_scope; + zend_object *obj; + zend_execute_data *call; + uint32_t call_info; + + SAVE_OPLINE(); + + object = RT_CONSTANT(opline, opline->op1); + + if (IS_CONST != IS_CONST) { + function_name = RT_CONSTANT(opline, opline->op2); + } + + if (IS_CONST != IS_CONST && + UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { + do { + if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { + function_name = Z_REFVAL_P(function_name); + if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { + break; + } + } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); + if (UNEXPECTED(EG(exception) != NULL)) { + + HANDLE_EXCEPTION(); + } + } + zend_throw_error(NULL, "Method name must be a string"); + + + HANDLE_EXCEPTION(); + } while (0); + } + + if (IS_CONST != IS_UNUSED) { + do { + if (IS_CONST == IS_CONST || UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) { + object = Z_REFVAL_P(object); + if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { + break; + } + } + if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { + object = ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception) != NULL)) { + if (IS_CONST != IS_CONST) { + + } + HANDLE_EXCEPTION(); + } + } + if (IS_CONST == IS_CONST) { + function_name = RT_CONSTANT(opline, opline->op2); + } + zend_invalid_method_call(object, function_name); + + + HANDLE_EXCEPTION(); + } + } while (0); + } + + obj = Z_OBJ_P(object); + called_scope = obj->ce; + + if (IS_CONST == IS_CONST && + EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { + fbc = CACHED_PTR(opline->result.num + sizeof(void*)); + } else { + zend_object *orig_obj = obj; + + if (IS_CONST == IS_CONST) { + function_name = RT_CONSTANT(opline, opline->op2); + } + + /* First, locate the function. */ + fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + if (UNEXPECTED(fbc == NULL)) { + if (EXPECTED(!EG(exception))) { + zend_undefined_method(obj->ce, Z_STR_P(function_name)); + } + + + HANDLE_EXCEPTION(); + } + if (IS_CONST == IS_CONST && + EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && + EXPECTED(obj == orig_obj)) { + CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); + } + if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) { + /* Reset "object" to trigger reference counting */ + object = NULL; + } + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -6755,6 +6999,141 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_C } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + + } + if (IS_CONST != IS_CONST) { + + } + } else { + if (UNEXPECTED(ce->constructor == NULL)) { + zend_throw_error(NULL, "Cannot call constructor"); + HANDLE_EXCEPTION(); + } + if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { + zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name)); + HANDLE_EXCEPTION(); + } + fbc = ce->constructor; + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + + } + } + + if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) { + if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) { + ce = (zend_class_entry*)Z_OBJ(EX(This)); + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; + } else { + zend_non_static_method_call(fbc); + HANDLE_EXCEPTION(); + } + } else { + /* previous opcode is ZEND_FETCH_CLASS */ + if (IS_CONST == IS_UNUSED + && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT || + (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) { + if (Z_TYPE(EX(This)) == IS_OBJECT) { + ce = Z_OBJCE(EX(This)); + } else { + ce = Z_CE(EX(This)); + } + } + call_info = ZEND_CALL_NESTED_FUNCTION; + } + + call = zend_vm_stack_push_call_frame(call_info, + fbc, opline->extended_value, ce); + call->prev_execute_data = EX(call); + EX(call) = call; + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *function_name; + zend_class_entry *ce; + uint32_t call_info; + zend_function *fbc; + zend_execute_data *call; + + SAVE_OPLINE(); + + if (IS_CONST == IS_CONST) { + /* no function found. try a static method in class */ + ce = CACHED_PTR(opline->result.num); + if (UNEXPECTED(ce == NULL)) { + ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); + if (UNEXPECTED(ce == NULL)) { + + HANDLE_EXCEPTION(); + } + if (IS_CONST != IS_CONST) { + CACHE_PTR(opline->result.num, ce); + } + } + } else if (IS_CONST == IS_UNUSED) { + ce = zend_fetch_class(NULL, opline->op1.num); + if (UNEXPECTED(ce == NULL)) { + + HANDLE_EXCEPTION(); + } + } else { + ce = Z_CE_P(EX_VAR(opline->op1.var)); + } + + if (IS_CONST == IS_CONST && + IS_CONST == IS_CONST && + EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) { + /* nothing to do */ + } else if (IS_CONST != IS_CONST && + IS_CONST == IS_CONST && + EXPECTED(CACHED_PTR(opline->result.num) == ce)) { + fbc = CACHED_PTR(opline->result.num + sizeof(void*)); + } else if (IS_CONST != IS_UNUSED) { + function_name = RT_CONSTANT(opline, opline->op2); + if (IS_CONST != IS_CONST) { + if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { + do { + if (IS_CONST & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) { + function_name = Z_REFVAL_P(function_name); + if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { + break; + } + } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } + } + zend_throw_error(NULL, "Method name must be a string"); + + HANDLE_EXCEPTION(); + } while (0); + } + } + + if (ce->get_static_method) { + fbc = ce->get_static_method(ce, Z_STR_P(function_name)); + } else { + fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + } + if (UNEXPECTED(fbc == NULL)) { + if (EXPECTED(!EG(exception))) { + zend_undefined_method(ce, Z_STR_P(function_name)); + } + + HANDLE_EXCEPTION(); + } + if (IS_CONST == IS_CONST && + EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE)))) { + CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc); + } + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + zend_observer_fcall_install((zend_function*)&fbc->op_array); } if (IS_CONST != IS_CONST) { @@ -6771,6 +7150,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_C fbc = ce->constructor; if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -6849,6 +7229,69 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CONS if (EXPECTED(func->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&func->op_array))) { init_func_run_time_cache(&func->op_array); + + } + } else { + zend_type_error("%s(): Argument #1 ($function) must be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error); + efree(error); + + HANDLE_EXCEPTION(); + } + + call = zend_vm_stack_push_call_frame(call_info, + func, opline->extended_value, object_or_called_scope); + call->prev_execute_data = EX(call); + EX(call) = call; + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *function_name; + zend_fcall_info_cache fcc; + char *error = NULL; + zend_function *func; + void *object_or_called_scope; + zend_execute_data *call; + uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_DYNAMIC; + + SAVE_OPLINE(); + function_name = RT_CONSTANT(opline, opline->op2); + if (zend_is_callable_ex(function_name, NULL, 0, NULL, &fcc, &error)) { + ZEND_ASSERT(!error); + func = fcc.function_handler; + object_or_called_scope = fcc.called_scope; + if (func->common.fn_flags & ZEND_ACC_CLOSURE) { + /* Delay closure destruction until its invocation */ + GC_ADDREF(ZEND_CLOSURE_OBJECT(func)); + call_info |= ZEND_CALL_CLOSURE; + if (func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE) { + call_info |= ZEND_CALL_FAKE_CLOSURE; + } + if (fcc.object) { + object_or_called_scope = fcc.object; + call_info |= ZEND_CALL_HAS_THIS; + } + } else if (fcc.object) { + GC_ADDREF(fcc.object); /* For $this pointer */ + object_or_called_scope = fcc.object; + call_info |= ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS; + } + + if ((IS_CONST & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) { + if (call_info & ZEND_CALL_CLOSURE) { + zend_object_release(ZEND_CLOSURE_OBJECT(func)); + } else if (call_info & ZEND_CALL_RELEASE_THIS) { + zend_object_release(fcc.object); + } + HANDLE_EXCEPTION(); + } + + if (EXPECTED(func->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&func->op_array))) { + init_func_run_time_cache(&func->op_array); + zend_observer_fcall_install((zend_function*)&func->op_array); } } else { zend_type_error("%s(): Argument #1 ($function) must be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error); @@ -8909,6 +9352,150 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_ } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + + } + } + + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + } + + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; + if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { + + if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(EG(exception))) { + HANDLE_EXCEPTION(); + } + /* call static method */ + obj = (zend_object*)called_scope; + call_info = ZEND_CALL_NESTED_FUNCTION; + } else if (IS_CONST & (IS_VAR|IS_TMP_VAR|IS_CV)) { + if (IS_CONST == IS_CV) { + GC_ADDREF(obj); /* For $this pointer */ + } else { + zval *free_op1 = EX_VAR(opline->op1.var); + if (free_op1 != object) { + GC_ADDREF(obj); /* For $this pointer */ + zval_ptr_dtor_nogc(free_op1); + } + } + /* CV may be changed indirectly (e.g. when it's a reference) */ + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS; + } + + call = zend_vm_stack_push_call_frame(call_info, + fbc, opline->extended_value, obj); + call->prev_execute_data = EX(call); + EX(call) = call; + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *function_name; + zval *object; + zend_function *fbc; + zend_class_entry *called_scope; + zend_object *obj; + zend_execute_data *call; + uint32_t call_info; + + SAVE_OPLINE(); + + object = RT_CONSTANT(opline, opline->op1); + + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + } + + if ((IS_TMP_VAR|IS_VAR) != IS_CONST && + UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { + do { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { + function_name = Z_REFVAL_P(function_name); + if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { + break; + } + } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); + if (UNEXPECTED(EG(exception) != NULL)) { + + HANDLE_EXCEPTION(); + } + } + zend_throw_error(NULL, "Method name must be a string"); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + + HANDLE_EXCEPTION(); + } while (0); + } + + if (IS_CONST != IS_UNUSED) { + do { + if (IS_CONST == IS_CONST || UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) { + object = Z_REFVAL_P(object); + if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { + break; + } + } + if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { + object = ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception) != NULL)) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + } + HANDLE_EXCEPTION(); + } + } + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + } + zend_invalid_method_call(object, function_name); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + + HANDLE_EXCEPTION(); + } + } while (0); + } + + obj = Z_OBJ_P(object); + called_scope = obj->ce; + + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && + EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { + fbc = CACHED_PTR(opline->result.num + sizeof(void*)); + } else { + zend_object *orig_obj = obj; + + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + } + + /* First, locate the function. */ + fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + if (UNEXPECTED(fbc == NULL)) { + if (EXPECTED(!EG(exception))) { + zend_undefined_method(obj->ce, Z_STR_P(function_name)); + } + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + + HANDLE_EXCEPTION(); + } + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && + EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && + EXPECTED(obj == orig_obj)) { + CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); + } + if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) { + /* Reset "object" to trigger reference counting */ + object = NULL; + } + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -9030,6 +9617,141 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_C } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + + } + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + } + } else { + if (UNEXPECTED(ce->constructor == NULL)) { + zend_throw_error(NULL, "Cannot call constructor"); + HANDLE_EXCEPTION(); + } + if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { + zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name)); + HANDLE_EXCEPTION(); + } + fbc = ce->constructor; + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + + } + } + + if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) { + if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) { + ce = (zend_class_entry*)Z_OBJ(EX(This)); + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; + } else { + zend_non_static_method_call(fbc); + HANDLE_EXCEPTION(); + } + } else { + /* previous opcode is ZEND_FETCH_CLASS */ + if (IS_CONST == IS_UNUSED + && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT || + (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) { + if (Z_TYPE(EX(This)) == IS_OBJECT) { + ce = Z_OBJCE(EX(This)); + } else { + ce = Z_CE(EX(This)); + } + } + call_info = ZEND_CALL_NESTED_FUNCTION; + } + + call = zend_vm_stack_push_call_frame(call_info, + fbc, opline->extended_value, ce); + call->prev_execute_data = EX(call); + EX(call) = call; + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *function_name; + zend_class_entry *ce; + uint32_t call_info; + zend_function *fbc; + zend_execute_data *call; + + SAVE_OPLINE(); + + if (IS_CONST == IS_CONST) { + /* no function found. try a static method in class */ + ce = CACHED_PTR(opline->result.num); + if (UNEXPECTED(ce == NULL)) { + ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); + if (UNEXPECTED(ce == NULL)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + HANDLE_EXCEPTION(); + } + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + CACHE_PTR(opline->result.num, ce); + } + } + } else if (IS_CONST == IS_UNUSED) { + ce = zend_fetch_class(NULL, opline->op1.num); + if (UNEXPECTED(ce == NULL)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + HANDLE_EXCEPTION(); + } + } else { + ce = Z_CE_P(EX_VAR(opline->op1.var)); + } + + if (IS_CONST == IS_CONST && + (IS_TMP_VAR|IS_VAR) == IS_CONST && + EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) { + /* nothing to do */ + } else if (IS_CONST != IS_CONST && + (IS_TMP_VAR|IS_VAR) == IS_CONST && + EXPECTED(CACHED_PTR(opline->result.num) == ce)) { + fbc = CACHED_PTR(opline->result.num + sizeof(void*)); + } else if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { + do { + if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) { + function_name = Z_REFVAL_P(function_name); + if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { + break; + } + } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } + } + zend_throw_error(NULL, "Method name must be a string"); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + HANDLE_EXCEPTION(); + } while (0); + } + } + + if (ce->get_static_method) { + fbc = ce->get_static_method(ce, Z_STR_P(function_name)); + } else { + fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + } + if (UNEXPECTED(fbc == NULL)) { + if (EXPECTED(!EG(exception))) { + zend_undefined_method(ce, Z_STR_P(function_name)); + } + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + HANDLE_EXCEPTION(); + } + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && + EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE)))) { + CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc); + } + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + zend_observer_fcall_install((zend_function*)&fbc->op_array); } if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); @@ -9046,6 +9768,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_C fbc = ce->constructor; if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -9125,6 +9848,70 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_TMPV if (EXPECTED(func->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&func->op_array))) { init_func_run_time_cache(&func->op_array); + + } + } else { + zend_type_error("%s(): Argument #1 ($function) must be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error); + efree(error); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + HANDLE_EXCEPTION(); + } + + call = zend_vm_stack_push_call_frame(call_info, + func, opline->extended_value, object_or_called_scope); + call->prev_execute_data = EX(call); + EX(call) = call; + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *function_name; + zend_fcall_info_cache fcc; + char *error = NULL; + zend_function *func; + void *object_or_called_scope; + zend_execute_data *call; + uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_DYNAMIC; + + SAVE_OPLINE(); + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (zend_is_callable_ex(function_name, NULL, 0, NULL, &fcc, &error)) { + ZEND_ASSERT(!error); + func = fcc.function_handler; + object_or_called_scope = fcc.called_scope; + if (func->common.fn_flags & ZEND_ACC_CLOSURE) { + /* Delay closure destruction until its invocation */ + GC_ADDREF(ZEND_CLOSURE_OBJECT(func)); + call_info |= ZEND_CALL_CLOSURE; + if (func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE) { + call_info |= ZEND_CALL_FAKE_CLOSURE; + } + if (fcc.object) { + object_or_called_scope = fcc.object; + call_info |= ZEND_CALL_HAS_THIS; + } + } else if (fcc.object) { + GC_ADDREF(fcc.object); /* For $this pointer */ + object_or_called_scope = fcc.object; + call_info |= ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS; + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + if (((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) { + if (call_info & ZEND_CALL_CLOSURE) { + zend_object_release(ZEND_CLOSURE_OBJECT(func)); + } else if (call_info & ZEND_CALL_RELEASE_THIS) { + zend_object_release(fcc.object); + } + HANDLE_EXCEPTION(); + } + + if (EXPECTED(func->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&func->op_array))) { + init_func_run_time_cache(&func->op_array); + zend_observer_fcall_install((zend_function*)&func->op_array); } } else { zend_type_error("%s(): Argument #1 ($function) must be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error); @@ -9771,6 +10558,141 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_C } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + + } + if (IS_UNUSED != IS_CONST) { + + } + } else { + if (UNEXPECTED(ce->constructor == NULL)) { + zend_throw_error(NULL, "Cannot call constructor"); + HANDLE_EXCEPTION(); + } + if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { + zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name)); + HANDLE_EXCEPTION(); + } + fbc = ce->constructor; + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + + } + } + + if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) { + if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) { + ce = (zend_class_entry*)Z_OBJ(EX(This)); + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; + } else { + zend_non_static_method_call(fbc); + HANDLE_EXCEPTION(); + } + } else { + /* previous opcode is ZEND_FETCH_CLASS */ + if (IS_CONST == IS_UNUSED + && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT || + (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) { + if (Z_TYPE(EX(This)) == IS_OBJECT) { + ce = Z_OBJCE(EX(This)); + } else { + ce = Z_CE(EX(This)); + } + } + call_info = ZEND_CALL_NESTED_FUNCTION; + } + + call = zend_vm_stack_push_call_frame(call_info, + fbc, opline->extended_value, ce); + call->prev_execute_data = EX(call); + EX(call) = call; + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *function_name; + zend_class_entry *ce; + uint32_t call_info; + zend_function *fbc; + zend_execute_data *call; + + SAVE_OPLINE(); + + if (IS_CONST == IS_CONST) { + /* no function found. try a static method in class */ + ce = CACHED_PTR(opline->result.num); + if (UNEXPECTED(ce == NULL)) { + ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); + if (UNEXPECTED(ce == NULL)) { + + HANDLE_EXCEPTION(); + } + if (IS_UNUSED != IS_CONST) { + CACHE_PTR(opline->result.num, ce); + } + } + } else if (IS_CONST == IS_UNUSED) { + ce = zend_fetch_class(NULL, opline->op1.num); + if (UNEXPECTED(ce == NULL)) { + + HANDLE_EXCEPTION(); + } + } else { + ce = Z_CE_P(EX_VAR(opline->op1.var)); + } + + if (IS_CONST == IS_CONST && + IS_UNUSED == IS_CONST && + EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) { + /* nothing to do */ + } else if (IS_CONST != IS_CONST && + IS_UNUSED == IS_CONST && + EXPECTED(CACHED_PTR(opline->result.num) == ce)) { + fbc = CACHED_PTR(opline->result.num + sizeof(void*)); + } else if (IS_UNUSED != IS_UNUSED) { + function_name = NULL; + if (IS_UNUSED != IS_CONST) { + if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { + do { + if (IS_UNUSED & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) { + function_name = Z_REFVAL_P(function_name); + if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { + break; + } + } else if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } + } + zend_throw_error(NULL, "Method name must be a string"); + + HANDLE_EXCEPTION(); + } while (0); + } + } + + if (ce->get_static_method) { + fbc = ce->get_static_method(ce, Z_STR_P(function_name)); + } else { + fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_UNUSED == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + } + if (UNEXPECTED(fbc == NULL)) { + if (EXPECTED(!EG(exception))) { + zend_undefined_method(ce, Z_STR_P(function_name)); + } + + HANDLE_EXCEPTION(); + } + if (IS_UNUSED == IS_CONST && + EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE)))) { + CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc); + } + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + zend_observer_fcall_install((zend_function*)&fbc->op_array); } if (IS_UNUSED != IS_CONST) { @@ -9787,6 +10709,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_C fbc = ce->constructor; if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -10039,6 +10962,77 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_CONST_UNUSED_HANDLER( } else { if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&constructor->op_array))) { init_func_run_time_cache(&constructor->op_array); + + } + /* We are not handling overloaded classes right now */ + call = zend_vm_stack_push_call_frame( + ZEND_CALL_FUNCTION | ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS, + constructor, + opline->extended_value, + Z_OBJ_P(result)); + Z_ADDREF_P(result); + } + + call->prev_execute_data = EX(call); + EX(call) = call; + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_CONST_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *result; + zend_function *constructor; + zend_class_entry *ce; + zend_execute_data *call; + + SAVE_OPLINE(); + if (IS_CONST == IS_CONST) { + ce = CACHED_PTR(opline->op2.num); + if (UNEXPECTED(ce == NULL)) { + ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); + if (UNEXPECTED(ce == NULL)) { + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); + } + CACHE_PTR(opline->op2.num, ce); + } + } else if (IS_CONST == IS_UNUSED) { + ce = zend_fetch_class(NULL, opline->op1.num); + if (UNEXPECTED(ce == NULL)) { + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); + } + } else { + ce = Z_CE_P(EX_VAR(opline->op1.var)); + } + + result = EX_VAR(opline->result.var); + if (UNEXPECTED(object_init_ex(result, ce) != SUCCESS)) { + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + + constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result)); + if (constructor == NULL) { + if (UNEXPECTED(EG(exception))) { + HANDLE_EXCEPTION(); + } + + /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next + * opcode is DO_FCALL in case EXT instructions are used. */ + if (EXPECTED(opline->extended_value == 0 && (opline+1)->opcode == ZEND_DO_FCALL)) { + ZEND_VM_NEXT_OPCODE_EX(1, 2); + } + + /* Perform a dummy function call */ + call = zend_vm_stack_push_call_frame( + ZEND_CALL_FUNCTION, (zend_function *) &zend_pass_function, + opline->extended_value, NULL); + } else { + if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&constructor->op_array))) { + init_func_run_time_cache(&constructor->op_array); + zend_observer_fcall_install((zend_function*)&constructor->op_array); } /* We are not handling overloaded classes right now */ call = zend_vm_stack_push_call_frame( @@ -11277,6 +12271,150 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_ } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + + } + } + + if (IS_CV != IS_CONST) { + + } + + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; + if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { + + if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(EG(exception))) { + HANDLE_EXCEPTION(); + } + /* call static method */ + obj = (zend_object*)called_scope; + call_info = ZEND_CALL_NESTED_FUNCTION; + } else if (IS_CONST & (IS_VAR|IS_TMP_VAR|IS_CV)) { + if (IS_CONST == IS_CV) { + GC_ADDREF(obj); /* For $this pointer */ + } else { + zval *free_op1 = EX_VAR(opline->op1.var); + if (free_op1 != object) { + GC_ADDREF(obj); /* For $this pointer */ + zval_ptr_dtor_nogc(free_op1); + } + } + /* CV may be changed indirectly (e.g. when it's a reference) */ + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS; + } + + call = zend_vm_stack_push_call_frame(call_info, + fbc, opline->extended_value, obj); + call->prev_execute_data = EX(call); + EX(call) = call; + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *function_name; + zval *object; + zend_function *fbc; + zend_class_entry *called_scope; + zend_object *obj; + zend_execute_data *call; + uint32_t call_info; + + SAVE_OPLINE(); + + object = RT_CONSTANT(opline, opline->op1); + + if (IS_CV != IS_CONST) { + function_name = EX_VAR(opline->op2.var); + } + + if (IS_CV != IS_CONST && + UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { + do { + if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { + function_name = Z_REFVAL_P(function_name); + if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { + break; + } + } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); + if (UNEXPECTED(EG(exception) != NULL)) { + + HANDLE_EXCEPTION(); + } + } + zend_throw_error(NULL, "Method name must be a string"); + + + HANDLE_EXCEPTION(); + } while (0); + } + + if (IS_CONST != IS_UNUSED) { + do { + if (IS_CONST == IS_CONST || UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) { + object = Z_REFVAL_P(object); + if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { + break; + } + } + if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { + object = ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception) != NULL)) { + if (IS_CV != IS_CONST) { + + } + HANDLE_EXCEPTION(); + } + } + if (IS_CV == IS_CONST) { + function_name = EX_VAR(opline->op2.var); + } + zend_invalid_method_call(object, function_name); + + + HANDLE_EXCEPTION(); + } + } while (0); + } + + obj = Z_OBJ_P(object); + called_scope = obj->ce; + + if (IS_CV == IS_CONST && + EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { + fbc = CACHED_PTR(opline->result.num + sizeof(void*)); + } else { + zend_object *orig_obj = obj; + + if (IS_CV == IS_CONST) { + function_name = EX_VAR(opline->op2.var); + } + + /* First, locate the function. */ + fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + if (UNEXPECTED(fbc == NULL)) { + if (EXPECTED(!EG(exception))) { + zend_undefined_method(obj->ce, Z_STR_P(function_name)); + } + + + HANDLE_EXCEPTION(); + } + if (IS_CV == IS_CONST && + EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && + EXPECTED(obj == orig_obj)) { + CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); + } + if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) { + /* Reset "object" to trigger reference counting */ + object = NULL; + } + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -11398,6 +12536,141 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_C } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + + } + if (IS_CV != IS_CONST) { + + } + } else { + if (UNEXPECTED(ce->constructor == NULL)) { + zend_throw_error(NULL, "Cannot call constructor"); + HANDLE_EXCEPTION(); + } + if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { + zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name)); + HANDLE_EXCEPTION(); + } + fbc = ce->constructor; + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + + } + } + + if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) { + if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) { + ce = (zend_class_entry*)Z_OBJ(EX(This)); + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; + } else { + zend_non_static_method_call(fbc); + HANDLE_EXCEPTION(); + } + } else { + /* previous opcode is ZEND_FETCH_CLASS */ + if (IS_CONST == IS_UNUSED + && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT || + (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) { + if (Z_TYPE(EX(This)) == IS_OBJECT) { + ce = Z_OBJCE(EX(This)); + } else { + ce = Z_CE(EX(This)); + } + } + call_info = ZEND_CALL_NESTED_FUNCTION; + } + + call = zend_vm_stack_push_call_frame(call_info, + fbc, opline->extended_value, ce); + call->prev_execute_data = EX(call); + EX(call) = call; + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *function_name; + zend_class_entry *ce; + uint32_t call_info; + zend_function *fbc; + zend_execute_data *call; + + SAVE_OPLINE(); + + if (IS_CONST == IS_CONST) { + /* no function found. try a static method in class */ + ce = CACHED_PTR(opline->result.num); + if (UNEXPECTED(ce == NULL)) { + ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); + if (UNEXPECTED(ce == NULL)) { + + HANDLE_EXCEPTION(); + } + if (IS_CV != IS_CONST) { + CACHE_PTR(opline->result.num, ce); + } + } + } else if (IS_CONST == IS_UNUSED) { + ce = zend_fetch_class(NULL, opline->op1.num); + if (UNEXPECTED(ce == NULL)) { + + HANDLE_EXCEPTION(); + } + } else { + ce = Z_CE_P(EX_VAR(opline->op1.var)); + } + + if (IS_CONST == IS_CONST && + IS_CV == IS_CONST && + EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) { + /* nothing to do */ + } else if (IS_CONST != IS_CONST && + IS_CV == IS_CONST && + EXPECTED(CACHED_PTR(opline->result.num) == ce)) { + fbc = CACHED_PTR(opline->result.num + sizeof(void*)); + } else if (IS_CV != IS_UNUSED) { + function_name = EX_VAR(opline->op2.var); + if (IS_CV != IS_CONST) { + if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { + do { + if (IS_CV & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) { + function_name = Z_REFVAL_P(function_name); + if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { + break; + } + } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } + } + zend_throw_error(NULL, "Method name must be a string"); + + HANDLE_EXCEPTION(); + } while (0); + } + } + + if (ce->get_static_method) { + fbc = ce->get_static_method(ce, Z_STR_P(function_name)); + } else { + fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + } + if (UNEXPECTED(fbc == NULL)) { + if (EXPECTED(!EG(exception))) { + zend_undefined_method(ce, Z_STR_P(function_name)); + } + + HANDLE_EXCEPTION(); + } + if (IS_CV == IS_CONST && + EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE)))) { + CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc); + } + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + zend_observer_fcall_install((zend_function*)&fbc->op_array); } if (IS_CV != IS_CONST) { @@ -11414,6 +12687,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_C fbc = ce->constructor; if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -11492,6 +12766,69 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CV_H if (EXPECTED(func->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&func->op_array))) { init_func_run_time_cache(&func->op_array); + + } + } else { + zend_type_error("%s(): Argument #1 ($function) must be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error); + efree(error); + + HANDLE_EXCEPTION(); + } + + call = zend_vm_stack_push_call_frame(call_info, + func, opline->extended_value, object_or_called_scope); + call->prev_execute_data = EX(call); + EX(call) = call; + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *function_name; + zend_fcall_info_cache fcc; + char *error = NULL; + zend_function *func; + void *object_or_called_scope; + zend_execute_data *call; + uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_DYNAMIC; + + SAVE_OPLINE(); + function_name = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); + if (zend_is_callable_ex(function_name, NULL, 0, NULL, &fcc, &error)) { + ZEND_ASSERT(!error); + func = fcc.function_handler; + object_or_called_scope = fcc.called_scope; + if (func->common.fn_flags & ZEND_ACC_CLOSURE) { + /* Delay closure destruction until its invocation */ + GC_ADDREF(ZEND_CLOSURE_OBJECT(func)); + call_info |= ZEND_CALL_CLOSURE; + if (func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE) { + call_info |= ZEND_CALL_FAKE_CLOSURE; + } + if (fcc.object) { + object_or_called_scope = fcc.object; + call_info |= ZEND_CALL_HAS_THIS; + } + } else if (fcc.object) { + GC_ADDREF(fcc.object); /* For $this pointer */ + object_or_called_scope = fcc.object; + call_info |= ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS; + } + + if ((IS_CV & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) { + if (call_info & ZEND_CALL_CLOSURE) { + zend_object_release(ZEND_CLOSURE_OBJECT(func)); + } else if (call_info & ZEND_CALL_RELEASE_THIS) { + zend_object_release(fcc.object); + } + HANDLE_EXCEPTION(); + } + + if (EXPECTED(func->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&func->op_array))) { + init_func_run_time_cache(&func->op_array); + zend_observer_fcall_install((zend_function*)&func->op_array); } } else { zend_type_error("%s(): Argument #1 ($function) must be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error); @@ -15712,6 +17049,151 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_C } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + + } + } + + if (IS_CONST != IS_CONST) { + + } + + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; + if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(EG(exception))) { + HANDLE_EXCEPTION(); + } + /* call static method */ + obj = (zend_object*)called_scope; + call_info = ZEND_CALL_NESTED_FUNCTION; + } else if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR|IS_CV)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV) { + GC_ADDREF(obj); /* For $this pointer */ + } else { + zval *free_op1 = EX_VAR(opline->op1.var); + if (free_op1 != object) { + GC_ADDREF(obj); /* For $this pointer */ + zval_ptr_dtor_nogc(free_op1); + } + } + /* CV may be changed indirectly (e.g. when it's a reference) */ + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS; + } + + call = zend_vm_stack_push_call_frame(call_info, + fbc, opline->extended_value, obj); + call->prev_execute_data = EX(call); + EX(call) = call; + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *function_name; + zval *object; + zend_function *fbc; + zend_class_entry *called_scope; + zend_object *obj; + zend_execute_data *call; + uint32_t call_info; + + SAVE_OPLINE(); + + object = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if (IS_CONST != IS_CONST) { + function_name = RT_CONSTANT(opline, opline->op2); + } + + if (IS_CONST != IS_CONST && + UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { + do { + if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { + function_name = Z_REFVAL_P(function_name); + if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { + break; + } + } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); + if (UNEXPECTED(EG(exception) != NULL)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); + } + } + zend_throw_error(NULL, "Method name must be a string"); + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); + } while (0); + } + + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { + do { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) { + object = Z_REFVAL_P(object); + if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { + break; + } + } + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { + object = ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception) != NULL)) { + if (IS_CONST != IS_CONST) { + + } + HANDLE_EXCEPTION(); + } + } + if (IS_CONST == IS_CONST) { + function_name = RT_CONSTANT(opline, opline->op2); + } + zend_invalid_method_call(object, function_name); + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); + } + } while (0); + } + + obj = Z_OBJ_P(object); + called_scope = obj->ce; + + if (IS_CONST == IS_CONST && + EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { + fbc = CACHED_PTR(opline->result.num + sizeof(void*)); + } else { + zend_object *orig_obj = obj; + + if (IS_CONST == IS_CONST) { + function_name = RT_CONSTANT(opline, opline->op2); + } + + /* First, locate the function. */ + fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + if (UNEXPECTED(fbc == NULL)) { + if (EXPECTED(!EG(exception))) { + zend_undefined_method(obj->ce, Z_STR_P(function_name)); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); + } + if (IS_CONST == IS_CONST && + EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && + EXPECTED(obj == orig_obj)) { + CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); + } + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) { + /* Reset "object" to trigger reference counting */ + object = NULL; + } + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -17119,6 +18601,151 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_T } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + + } + } + + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + } + + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; + if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(EG(exception))) { + HANDLE_EXCEPTION(); + } + /* call static method */ + obj = (zend_object*)called_scope; + call_info = ZEND_CALL_NESTED_FUNCTION; + } else if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR|IS_CV)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV) { + GC_ADDREF(obj); /* For $this pointer */ + } else { + zval *free_op1 = EX_VAR(opline->op1.var); + if (free_op1 != object) { + GC_ADDREF(obj); /* For $this pointer */ + zval_ptr_dtor_nogc(free_op1); + } + } + /* CV may be changed indirectly (e.g. when it's a reference) */ + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS; + } + + call = zend_vm_stack_push_call_frame(call_info, + fbc, opline->extended_value, obj); + call->prev_execute_data = EX(call); + EX(call) = call; + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *function_name; + zval *object; + zend_function *fbc; + zend_class_entry *called_scope; + zend_object *obj; + zend_execute_data *call; + uint32_t call_info; + + SAVE_OPLINE(); + + object = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + } + + if ((IS_TMP_VAR|IS_VAR) != IS_CONST && + UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { + do { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { + function_name = Z_REFVAL_P(function_name); + if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { + break; + } + } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); + if (UNEXPECTED(EG(exception) != NULL)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); + } + } + zend_throw_error(NULL, "Method name must be a string"); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); + } while (0); + } + + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { + do { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) { + object = Z_REFVAL_P(object); + if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { + break; + } + } + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { + object = ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception) != NULL)) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + } + HANDLE_EXCEPTION(); + } + } + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + } + zend_invalid_method_call(object, function_name); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); + } + } while (0); + } + + obj = Z_OBJ_P(object); + called_scope = obj->ce; + + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && + EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { + fbc = CACHED_PTR(opline->result.num + sizeof(void*)); + } else { + zend_object *orig_obj = obj; + + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + } + + /* First, locate the function. */ + fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + if (UNEXPECTED(fbc == NULL)) { + if (EXPECTED(!EG(exception))) { + zend_undefined_method(obj->ce, Z_STR_P(function_name)); + } + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); + } + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && + EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && + EXPECTED(obj == orig_obj)) { + CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); + } + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) { + /* Reset "object" to trigger reference counting */ + object = NULL; + } + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -18419,6 +20046,151 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_C } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + + } + } + + if (IS_CV != IS_CONST) { + + } + + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; + if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(EG(exception))) { + HANDLE_EXCEPTION(); + } + /* call static method */ + obj = (zend_object*)called_scope; + call_info = ZEND_CALL_NESTED_FUNCTION; + } else if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR|IS_CV)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV) { + GC_ADDREF(obj); /* For $this pointer */ + } else { + zval *free_op1 = EX_VAR(opline->op1.var); + if (free_op1 != object) { + GC_ADDREF(obj); /* For $this pointer */ + zval_ptr_dtor_nogc(free_op1); + } + } + /* CV may be changed indirectly (e.g. when it's a reference) */ + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS; + } + + call = zend_vm_stack_push_call_frame(call_info, + fbc, opline->extended_value, obj); + call->prev_execute_data = EX(call); + EX(call) = call; + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *function_name; + zval *object; + zend_function *fbc; + zend_class_entry *called_scope; + zend_object *obj; + zend_execute_data *call; + uint32_t call_info; + + SAVE_OPLINE(); + + object = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if (IS_CV != IS_CONST) { + function_name = EX_VAR(opline->op2.var); + } + + if (IS_CV != IS_CONST && + UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { + do { + if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { + function_name = Z_REFVAL_P(function_name); + if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { + break; + } + } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); + if (UNEXPECTED(EG(exception) != NULL)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); + } + } + zend_throw_error(NULL, "Method name must be a string"); + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); + } while (0); + } + + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { + do { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) { + object = Z_REFVAL_P(object); + if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { + break; + } + } + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { + object = ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception) != NULL)) { + if (IS_CV != IS_CONST) { + + } + HANDLE_EXCEPTION(); + } + } + if (IS_CV == IS_CONST) { + function_name = EX_VAR(opline->op2.var); + } + zend_invalid_method_call(object, function_name); + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); + } + } while (0); + } + + obj = Z_OBJ_P(object); + called_scope = obj->ce; + + if (IS_CV == IS_CONST && + EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { + fbc = CACHED_PTR(opline->result.num + sizeof(void*)); + } else { + zend_object *orig_obj = obj; + + if (IS_CV == IS_CONST) { + function_name = EX_VAR(opline->op2.var); + } + + /* First, locate the function. */ + fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + if (UNEXPECTED(fbc == NULL)) { + if (EXPECTED(!EG(exception))) { + zend_undefined_method(obj->ce, Z_STR_P(function_name)); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); + } + if (IS_CV == IS_CONST && + EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && + EXPECTED(obj == orig_obj)) { + CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); + } + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) { + /* Reset "object" to trigger reference counting */ + object = NULL; + } + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -24262,6 +26034,141 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_V } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + + } + if (IS_CONST != IS_CONST) { + + } + } else { + if (UNEXPECTED(ce->constructor == NULL)) { + zend_throw_error(NULL, "Cannot call constructor"); + HANDLE_EXCEPTION(); + } + if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { + zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name)); + HANDLE_EXCEPTION(); + } + fbc = ce->constructor; + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + + } + } + + if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) { + if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) { + ce = (zend_class_entry*)Z_OBJ(EX(This)); + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; + } else { + zend_non_static_method_call(fbc); + HANDLE_EXCEPTION(); + } + } else { + /* previous opcode is ZEND_FETCH_CLASS */ + if (IS_VAR == IS_UNUSED + && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT || + (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) { + if (Z_TYPE(EX(This)) == IS_OBJECT) { + ce = Z_OBJCE(EX(This)); + } else { + ce = Z_CE(EX(This)); + } + } + call_info = ZEND_CALL_NESTED_FUNCTION; + } + + call = zend_vm_stack_push_call_frame(call_info, + fbc, opline->extended_value, ce); + call->prev_execute_data = EX(call); + EX(call) = call; + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *function_name; + zend_class_entry *ce; + uint32_t call_info; + zend_function *fbc; + zend_execute_data *call; + + SAVE_OPLINE(); + + if (IS_VAR == IS_CONST) { + /* no function found. try a static method in class */ + ce = CACHED_PTR(opline->result.num); + if (UNEXPECTED(ce == NULL)) { + ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); + if (UNEXPECTED(ce == NULL)) { + + HANDLE_EXCEPTION(); + } + if (IS_CONST != IS_CONST) { + CACHE_PTR(opline->result.num, ce); + } + } + } else if (IS_VAR == IS_UNUSED) { + ce = zend_fetch_class(NULL, opline->op1.num); + if (UNEXPECTED(ce == NULL)) { + + HANDLE_EXCEPTION(); + } + } else { + ce = Z_CE_P(EX_VAR(opline->op1.var)); + } + + if (IS_VAR == IS_CONST && + IS_CONST == IS_CONST && + EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) { + /* nothing to do */ + } else if (IS_VAR != IS_CONST && + IS_CONST == IS_CONST && + EXPECTED(CACHED_PTR(opline->result.num) == ce)) { + fbc = CACHED_PTR(opline->result.num + sizeof(void*)); + } else if (IS_CONST != IS_UNUSED) { + function_name = RT_CONSTANT(opline, opline->op2); + if (IS_CONST != IS_CONST) { + if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { + do { + if (IS_CONST & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) { + function_name = Z_REFVAL_P(function_name); + if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { + break; + } + } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } + } + zend_throw_error(NULL, "Method name must be a string"); + + HANDLE_EXCEPTION(); + } while (0); + } + } + + if (ce->get_static_method) { + fbc = ce->get_static_method(ce, Z_STR_P(function_name)); + } else { + fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + } + if (UNEXPECTED(fbc == NULL)) { + if (EXPECTED(!EG(exception))) { + zend_undefined_method(ce, Z_STR_P(function_name)); + } + + HANDLE_EXCEPTION(); + } + if (IS_CONST == IS_CONST && + EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE)))) { + CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc); + } + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + zend_observer_fcall_install((zend_function*)&fbc->op_array); } if (IS_CONST != IS_CONST) { @@ -24278,6 +26185,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_V fbc = ce->constructor; if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -26773,6 +28681,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_V } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + } if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); @@ -26789,6 +28698,141 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_V fbc = ce->constructor; if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + + } + } + + if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) { + if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) { + ce = (zend_class_entry*)Z_OBJ(EX(This)); + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; + } else { + zend_non_static_method_call(fbc); + HANDLE_EXCEPTION(); + } + } else { + /* previous opcode is ZEND_FETCH_CLASS */ + if (IS_VAR == IS_UNUSED + && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT || + (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) { + if (Z_TYPE(EX(This)) == IS_OBJECT) { + ce = Z_OBJCE(EX(This)); + } else { + ce = Z_CE(EX(This)); + } + } + call_info = ZEND_CALL_NESTED_FUNCTION; + } + + call = zend_vm_stack_push_call_frame(call_info, + fbc, opline->extended_value, ce); + call->prev_execute_data = EX(call); + EX(call) = call; + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *function_name; + zend_class_entry *ce; + uint32_t call_info; + zend_function *fbc; + zend_execute_data *call; + + SAVE_OPLINE(); + + if (IS_VAR == IS_CONST) { + /* no function found. try a static method in class */ + ce = CACHED_PTR(opline->result.num); + if (UNEXPECTED(ce == NULL)) { + ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); + if (UNEXPECTED(ce == NULL)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + HANDLE_EXCEPTION(); + } + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + CACHE_PTR(opline->result.num, ce); + } + } + } else if (IS_VAR == IS_UNUSED) { + ce = zend_fetch_class(NULL, opline->op1.num); + if (UNEXPECTED(ce == NULL)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + HANDLE_EXCEPTION(); + } + } else { + ce = Z_CE_P(EX_VAR(opline->op1.var)); + } + + if (IS_VAR == IS_CONST && + (IS_TMP_VAR|IS_VAR) == IS_CONST && + EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) { + /* nothing to do */ + } else if (IS_VAR != IS_CONST && + (IS_TMP_VAR|IS_VAR) == IS_CONST && + EXPECTED(CACHED_PTR(opline->result.num) == ce)) { + fbc = CACHED_PTR(opline->result.num + sizeof(void*)); + } else if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { + do { + if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) { + function_name = Z_REFVAL_P(function_name); + if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { + break; + } + } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } + } + zend_throw_error(NULL, "Method name must be a string"); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + HANDLE_EXCEPTION(); + } while (0); + } + } + + if (ce->get_static_method) { + fbc = ce->get_static_method(ce, Z_STR_P(function_name)); + } else { + fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + } + if (UNEXPECTED(fbc == NULL)) { + if (EXPECTED(!EG(exception))) { + zend_undefined_method(ce, Z_STR_P(function_name)); + } + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + HANDLE_EXCEPTION(); + } + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && + EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE)))) { + CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc); + } + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + zend_observer_fcall_install((zend_function*)&fbc->op_array); + } + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + } + } else { + if (UNEXPECTED(ce->constructor == NULL)) { + zend_throw_error(NULL, "Cannot call constructor"); + HANDLE_EXCEPTION(); + } + if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { + zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name)); + HANDLE_EXCEPTION(); + } + fbc = ce->constructor; + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -27760,7 +29804,120 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_ ZEND_VM_NEXT_OPCODE_EX(1, 2); } -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object_ptr, *orig_object_ptr; + zval *value; + zval *variable_ptr; + zval *dim; + + SAVE_OPLINE(); + orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { +try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); + if (IS_UNUSED == IS_UNUSED) { + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + ZVAL_DEREF(value); + } + variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value); + if (UNEXPECTED(variable_ptr == NULL)) { + zend_cannot_add_element(); + goto assign_dim_error; + } else if (IS_VAR == IS_CV) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + } else if (IS_VAR == IS_VAR) { + zval *free_op_data = EX_VAR((opline+1)->op1.var); + if (value != free_op_data) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + zval_ptr_dtor_nogc(free_op_data); + } + } else if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } + } else { + dim = NULL; + if (IS_UNUSED == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; + } + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES()); + } + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + } else { + if (EXPECTED(Z_ISREF_P(object_ptr))) { + object_ptr = Z_REFVAL_P(object_ptr); + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { + goto try_assign_dim_array; + } + } + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = NULL; + value = _get_zval_ptr_var_deref((opline+1)->op1.var EXECUTE_DATA_CC); + + if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + dim++; + } + zend_assign_to_object_dim(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); + + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { + if (IS_UNUSED == IS_UNUSED) { + zend_use_new_element_for_string(); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + } else { + dim = NULL; + value = _get_zval_ptr_var_deref((opline+1)->op1.var EXECUTE_DATA_CC); + zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + } + } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { + if (Z_ISREF_P(orig_object_ptr) + && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr)) + && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) { + dim = NULL; + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + } else { + ZVAL_ARR(object_ptr, zend_new_array(8)); + goto try_assign_dim_array; + } + } else { + zend_use_scalar_as_array(); + dim = NULL; +assign_dim_error: + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } + } + } + if (IS_UNUSED != IS_UNUSED) { + + } + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + /* assign_dim has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object_ptr, *orig_object_ptr; @@ -27775,19 +29932,19 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_ try_assign_dim_array: SEPARATE_ARRAY(object_ptr); if (IS_UNUSED == IS_UNUSED) { - value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); - if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_CV == IS_CV || IS_CV == IS_VAR) { ZVAL_DEREF(value); } variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value); if (UNEXPECTED(variable_ptr == NULL)) { zend_cannot_add_element(); goto assign_dim_error; - } else if (IS_VAR == IS_CV) { + } else if (IS_CV == IS_CV) { if (Z_REFCOUNTED_P(value)) { Z_ADDREF_P(value); } - } else if (IS_VAR == IS_VAR) { + } else if (IS_CV == IS_VAR) { zval *free_op_data = EX_VAR((opline+1)->op1.var); if (value != free_op_data) { if (Z_REFCOUNTED_P(value)) { @@ -27795,7 +29952,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_ } zval_ptr_dtor_nogc(free_op_data); } - } else if (IS_VAR == IS_CONST) { + } else if (IS_CV == IS_CONST) { if (UNEXPECTED(Z_REFCOUNTED_P(value))) { Z_ADDREF_P(value); } @@ -27810,8 +29967,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_ if (UNEXPECTED(variable_ptr == NULL)) { goto assign_dim_error; } - value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); - value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES()); + value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC); + value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES()); } if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(EX_VAR(opline->result.var), value); @@ -27825,31 +29982,30 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_ } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { dim = NULL; - value = _get_zval_ptr_var_deref((opline+1)->op1.var EXECUTE_DATA_CC); + value = _get_zval_ptr_cv_deref_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC); if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { dim++; } zend_assign_to_object_dim(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (IS_UNUSED == IS_UNUSED) { zend_use_new_element_for_string(); - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); } else { dim = NULL; - value = _get_zval_ptr_var_deref((opline+1)->op1.var EXECUTE_DATA_CC); + value = _get_zval_ptr_cv_deref_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC); zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { if (Z_ISREF_P(orig_object_ptr) && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr)) && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) { dim = NULL; - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); } else { ZVAL_ARR(object_ptr, zend_new_array(8)); @@ -27859,7 +30015,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_ zend_use_scalar_as_array(); dim = NULL; assign_dim_error: - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_NULL(EX_VAR(opline->result.var)); } @@ -27873,119 +30029,141 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_ ZEND_VM_NEXT_OPCODE_EX(1, 2); } -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *object_ptr, *orig_object_ptr; - zval *value; - zval *variable_ptr; - zval *dim; + zval *function_name; + zend_class_entry *ce; + uint32_t call_info; + zend_function *fbc; + zend_execute_data *call; SAVE_OPLINE(); - orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { -try_assign_dim_array: - SEPARATE_ARRAY(object_ptr); - if (IS_UNUSED == IS_UNUSED) { - value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC); - if (IS_CV == IS_CV || IS_CV == IS_VAR) { - ZVAL_DEREF(value); - } - variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value); - if (UNEXPECTED(variable_ptr == NULL)) { - zend_cannot_add_element(); - goto assign_dim_error; - } else if (IS_CV == IS_CV) { - if (Z_REFCOUNTED_P(value)) { - Z_ADDREF_P(value); - } - } else if (IS_CV == IS_VAR) { - zval *free_op_data = EX_VAR((opline+1)->op1.var); - if (value != free_op_data) { - if (Z_REFCOUNTED_P(value)) { - Z_ADDREF_P(value); - } - zval_ptr_dtor_nogc(free_op_data); - } - } else if (IS_CV == IS_CONST) { - if (UNEXPECTED(Z_REFCOUNTED_P(value))) { - Z_ADDREF_P(value); - } - } - } else { - dim = NULL; - if (IS_UNUSED == IS_CONST) { - variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); - } else { - variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + if (IS_VAR == IS_CONST) { + /* no function found. try a static method in class */ + ce = CACHED_PTR(opline->result.num); + if (UNEXPECTED(ce == NULL)) { + ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); + if (UNEXPECTED(ce == NULL)) { + + HANDLE_EXCEPTION(); } - if (UNEXPECTED(variable_ptr == NULL)) { - goto assign_dim_error; + if (IS_UNUSED != IS_CONST) { + CACHE_PTR(opline->result.num, ce); } - value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC); - value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES()); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); + } else if (IS_VAR == IS_UNUSED) { + ce = zend_fetch_class(NULL, opline->op1.num); + if (UNEXPECTED(ce == NULL)) { + + HANDLE_EXCEPTION(); } } else { - if (EXPECTED(Z_ISREF_P(object_ptr))) { - object_ptr = Z_REFVAL_P(object_ptr); - if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { - goto try_assign_dim_array; + ce = Z_CE_P(EX_VAR(opline->op1.var)); + } + + if (IS_VAR == IS_CONST && + IS_UNUSED == IS_CONST && + EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) { + /* nothing to do */ + } else if (IS_VAR != IS_CONST && + IS_UNUSED == IS_CONST && + EXPECTED(CACHED_PTR(opline->result.num) == ce)) { + fbc = CACHED_PTR(opline->result.num + sizeof(void*)); + } else if (IS_UNUSED != IS_UNUSED) { + function_name = NULL; + if (IS_UNUSED != IS_CONST) { + if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { + do { + if (IS_UNUSED & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) { + function_name = Z_REFVAL_P(function_name); + if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { + break; + } + } else if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } + } + zend_throw_error(NULL, "Method name must be a string"); + + HANDLE_EXCEPTION(); + } while (0); } } - if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { - dim = NULL; - value = _get_zval_ptr_cv_deref_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC); - if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { - dim++; + if (ce->get_static_method) { + fbc = ce->get_static_method(ce, Z_STR_P(function_name)); + } else { + fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_UNUSED == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + } + if (UNEXPECTED(fbc == NULL)) { + if (EXPECTED(!EG(exception))) { + zend_undefined_method(ce, Z_STR_P(function_name)); } - zend_assign_to_object_dim(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); - } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { - if (IS_UNUSED == IS_UNUSED) { - zend_use_new_element_for_string(); + HANDLE_EXCEPTION(); + } + if (IS_UNUSED == IS_CONST && + EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE)))) { + CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc); + } + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); - UNDEF_RESULT(); - } else { - dim = NULL; - value = _get_zval_ptr_cv_deref_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC); - zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); + } + if (IS_UNUSED != IS_CONST) { - } - } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { - if (Z_ISREF_P(orig_object_ptr) - && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr)) - && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) { - dim = NULL; + } + } else { + if (UNEXPECTED(ce->constructor == NULL)) { + zend_throw_error(NULL, "Cannot call constructor"); + HANDLE_EXCEPTION(); + } + if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { + zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name)); + HANDLE_EXCEPTION(); + } + fbc = ce->constructor; + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); - UNDEF_RESULT(); - } else { - ZVAL_ARR(object_ptr, zend_new_array(8)); - goto try_assign_dim_array; - } - } else { - zend_use_scalar_as_array(); - dim = NULL; -assign_dim_error: + } + } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) { + if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) { + ce = (zend_class_entry*)Z_OBJ(EX(This)); + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; + } else { + zend_non_static_method_call(fbc); + HANDLE_EXCEPTION(); + } + } else { + /* previous opcode is ZEND_FETCH_CLASS */ + if (IS_VAR == IS_UNUSED + && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT || + (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) { + if (Z_TYPE(EX(This)) == IS_OBJECT) { + ce = Z_OBJCE(EX(This)); + } else { + ce = Z_CE(EX(This)); } } + call_info = ZEND_CALL_NESTED_FUNCTION; } - if (IS_UNUSED != IS_UNUSED) { - } - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - /* assign_dim has two opcodes! */ - ZEND_VM_NEXT_OPCODE_EX(1, 2); + call = zend_vm_stack_push_call_frame(call_info, + fbc, opline->extended_value, ce); + call->prev_execute_data = EX(call); + EX(call) = call; + + ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *function_name; @@ -28068,6 +30246,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_V } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + zend_observer_fcall_install((zend_function*)&fbc->op_array); } if (IS_UNUSED != IS_CONST) { @@ -28084,6 +30263,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_V fbc = ce->constructor; if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -28488,30 +30668,91 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_HA ZEND_VM_NEXT_OPCODE(); } -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *varptr, *arg; + uint32_t arg_num; + + if (IS_UNUSED == IS_CONST) { + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + HANDLE_EXCEPTION(); + } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + arg_num = opline->op2.num; + } + + if (EXPECTED(1)) { + if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { + goto send_var_by_ref; + } + } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { +send_var_by_ref: + varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + if (Z_ISREF_P(varptr)) { + Z_ADDREF_P(varptr); + } else { + ZVAL_MAKE_REF_EX(varptr, 2); + } + ZVAL_REF(arg, Z_REF_P(varptr)); + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE(); + } + + varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + ZVAL_NULL(arg); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + + if (IS_VAR == IS_CV) { + ZVAL_COPY_DEREF(arg, varptr); + } else /* if (IS_VAR == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(varptr))) { + zend_refcounted *ref = Z_COUNTED_P(varptr); + + varptr = Z_REFVAL_P(varptr); + ZVAL_COPY_VALUE(arg, varptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(arg)) { + Z_ADDREF_P(arg); + } + } else { + ZVAL_COPY_VALUE(arg, varptr); + } + } + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *varptr, *arg; - uint32_t arg_num; if (IS_UNUSED == IS_CONST) { + // TODO: Would it make sense to share the cache slot with CHECK_FUNC_ARG? SAVE_OPLINE(); zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + uint32_t arg_num; arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); if (UNEXPECTED(!arg)) { HANDLE_EXCEPTION(); } } else { arg = ZEND_CALL_VAR(EX(call), opline->result.var); - arg_num = opline->op2.num; } - if (EXPECTED(1)) { - if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { - goto send_var_by_ref; - } - } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { -send_var_by_ref: + if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) { varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); if (Z_ISREF_P(varptr)) { Z_ADDREF_P(varptr); @@ -28525,86 +30766,95 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_V } varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) { - SAVE_OPLINE(); - ZVAL_UNDEFINED_OP1(); - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - ZVAL_NULL(arg); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } - if (IS_VAR == IS_CV) { - ZVAL_COPY_DEREF(arg, varptr); - } else /* if (IS_VAR == IS_VAR) */ { - if (UNEXPECTED(Z_ISREF_P(varptr))) { - zend_refcounted *ref = Z_COUNTED_P(varptr); + if (UNEXPECTED(Z_ISREF_P(varptr))) { + zend_refcounted *ref = Z_COUNTED_P(varptr); - varptr = Z_REFVAL_P(varptr); - ZVAL_COPY_VALUE(arg, varptr); - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else if (Z_OPT_REFCOUNTED_P(arg)) { - Z_ADDREF_P(arg); - } - } else { - ZVAL_COPY_VALUE(arg, varptr); + varptr = Z_REFVAL_P(varptr); + ZVAL_COPY_VALUE(arg, varptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(arg)) { + Z_ADDREF_P(arg); } + } else { + ZVAL_COPY_VALUE(arg, varptr); } ZEND_VM_NEXT_OPCODE(); } -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *varptr, *arg; + zval *result; + zend_function *constructor; + zend_class_entry *ce; + zend_execute_data *call; - if (IS_UNUSED == IS_CONST) { - // TODO: Would it make sense to share the cache slot with CHECK_FUNC_ARG? - SAVE_OPLINE(); - zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); - uint32_t arg_num; - arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); - if (UNEXPECTED(!arg)) { + SAVE_OPLINE(); + if (IS_VAR == IS_CONST) { + ce = CACHED_PTR(opline->op2.num); + if (UNEXPECTED(ce == NULL)) { + ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); + if (UNEXPECTED(ce == NULL)) { + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); + } + CACHE_PTR(opline->op2.num, ce); + } + } else if (IS_VAR == IS_UNUSED) { + ce = zend_fetch_class(NULL, opline->op1.num); + if (UNEXPECTED(ce == NULL)) { + ZVAL_UNDEF(EX_VAR(opline->result.var)); HANDLE_EXCEPTION(); } } else { - arg = ZEND_CALL_VAR(EX(call), opline->result.var); + ce = Z_CE_P(EX_VAR(opline->op1.var)); } - if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) { - varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - if (Z_ISREF_P(varptr)) { - Z_ADDREF_P(varptr); - } else { - ZVAL_MAKE_REF_EX(varptr, 2); - } - ZVAL_REF(arg, Z_REF_P(varptr)); - - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE(); + result = EX_VAR(opline->result.var); + if (UNEXPECTED(object_init_ex(result, ce) != SUCCESS)) { + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); } - varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - - if (UNEXPECTED(Z_ISREF_P(varptr))) { - zend_refcounted *ref = Z_COUNTED_P(varptr); + constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result)); + if (constructor == NULL) { + if (UNEXPECTED(EG(exception))) { + HANDLE_EXCEPTION(); + } - varptr = Z_REFVAL_P(varptr); - ZVAL_COPY_VALUE(arg, varptr); - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else if (Z_OPT_REFCOUNTED_P(arg)) { - Z_ADDREF_P(arg); + /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next + * opcode is DO_FCALL in case EXT instructions are used. */ + if (EXPECTED(opline->extended_value == 0 && (opline+1)->opcode == ZEND_DO_FCALL)) { + ZEND_VM_NEXT_OPCODE_EX(1, 2); } + + /* Perform a dummy function call */ + call = zend_vm_stack_push_call_frame( + ZEND_CALL_FUNCTION, (zend_function *) &zend_pass_function, + opline->extended_value, NULL); } else { - ZVAL_COPY_VALUE(arg, varptr); + if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&constructor->op_array))) { + init_func_run_time_cache(&constructor->op_array); + + } + /* We are not handling overloaded classes right now */ + call = zend_vm_stack_push_call_frame( + ZEND_CALL_FUNCTION | ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS, + constructor, + opline->extended_value, + Z_OBJ_P(result)); + Z_ADDREF_P(result); } + call->prev_execute_data = EX(call); + EX(call) = call; ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_VAR_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *result; @@ -28658,6 +30908,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_VAR_UNUSED_HANDLER(ZE } else { if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&constructor->op_array))) { init_func_run_time_cache(&constructor->op_array); + zend_observer_fcall_install((zend_function*)&constructor->op_array); } /* We are not handling overloaded classes right now */ call = zend_vm_stack_push_call_frame( @@ -30779,6 +33030,141 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_V } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + + } + if (IS_CV != IS_CONST) { + + } + } else { + if (UNEXPECTED(ce->constructor == NULL)) { + zend_throw_error(NULL, "Cannot call constructor"); + HANDLE_EXCEPTION(); + } + if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { + zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name)); + HANDLE_EXCEPTION(); + } + fbc = ce->constructor; + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + + } + } + + if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) { + if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) { + ce = (zend_class_entry*)Z_OBJ(EX(This)); + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; + } else { + zend_non_static_method_call(fbc); + HANDLE_EXCEPTION(); + } + } else { + /* previous opcode is ZEND_FETCH_CLASS */ + if (IS_VAR == IS_UNUSED + && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT || + (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) { + if (Z_TYPE(EX(This)) == IS_OBJECT) { + ce = Z_OBJCE(EX(This)); + } else { + ce = Z_CE(EX(This)); + } + } + call_info = ZEND_CALL_NESTED_FUNCTION; + } + + call = zend_vm_stack_push_call_frame(call_info, + fbc, opline->extended_value, ce); + call->prev_execute_data = EX(call); + EX(call) = call; + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *function_name; + zend_class_entry *ce; + uint32_t call_info; + zend_function *fbc; + zend_execute_data *call; + + SAVE_OPLINE(); + + if (IS_VAR == IS_CONST) { + /* no function found. try a static method in class */ + ce = CACHED_PTR(opline->result.num); + if (UNEXPECTED(ce == NULL)) { + ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); + if (UNEXPECTED(ce == NULL)) { + + HANDLE_EXCEPTION(); + } + if (IS_CV != IS_CONST) { + CACHE_PTR(opline->result.num, ce); + } + } + } else if (IS_VAR == IS_UNUSED) { + ce = zend_fetch_class(NULL, opline->op1.num); + if (UNEXPECTED(ce == NULL)) { + + HANDLE_EXCEPTION(); + } + } else { + ce = Z_CE_P(EX_VAR(opline->op1.var)); + } + + if (IS_VAR == IS_CONST && + IS_CV == IS_CONST && + EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) { + /* nothing to do */ + } else if (IS_VAR != IS_CONST && + IS_CV == IS_CONST && + EXPECTED(CACHED_PTR(opline->result.num) == ce)) { + fbc = CACHED_PTR(opline->result.num + sizeof(void*)); + } else if (IS_CV != IS_UNUSED) { + function_name = EX_VAR(opline->op2.var); + if (IS_CV != IS_CONST) { + if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { + do { + if (IS_CV & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) { + function_name = Z_REFVAL_P(function_name); + if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { + break; + } + } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } + } + zend_throw_error(NULL, "Method name must be a string"); + + HANDLE_EXCEPTION(); + } while (0); + } + } + + if (ce->get_static_method) { + fbc = ce->get_static_method(ce, Z_STR_P(function_name)); + } else { + fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + } + if (UNEXPECTED(fbc == NULL)) { + if (EXPECTED(!EG(exception))) { + zend_undefined_method(ce, Z_STR_P(function_name)); + } + + HANDLE_EXCEPTION(); + } + if (IS_CV == IS_CONST && + EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE)))) { + CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc); + } + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + zend_observer_fcall_install((zend_function*)&fbc->op_array); } if (IS_CV != IS_CONST) { @@ -30795,6 +33181,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_V fbc = ce->constructor; if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -32803,6 +35190,150 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_S } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + + } + } + + if (IS_CONST != IS_CONST) { + + } + + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; + if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { + + if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(EG(exception))) { + HANDLE_EXCEPTION(); + } + /* call static method */ + obj = (zend_object*)called_scope; + call_info = ZEND_CALL_NESTED_FUNCTION; + } else if (IS_UNUSED & (IS_VAR|IS_TMP_VAR|IS_CV)) { + if (IS_UNUSED == IS_CV) { + GC_ADDREF(obj); /* For $this pointer */ + } else { + zval *free_op1 = EX_VAR(opline->op1.var); + if (free_op1 != object) { + GC_ADDREF(obj); /* For $this pointer */ + zval_ptr_dtor_nogc(free_op1); + } + } + /* CV may be changed indirectly (e.g. when it's a reference) */ + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS; + } + + call = zend_vm_stack_push_call_frame(call_info, + fbc, opline->extended_value, obj); + call->prev_execute_data = EX(call); + EX(call) = call; + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *function_name; + zval *object; + zend_function *fbc; + zend_class_entry *called_scope; + zend_object *obj; + zend_execute_data *call; + uint32_t call_info; + + SAVE_OPLINE(); + + object = &EX(This); + + if (IS_CONST != IS_CONST) { + function_name = RT_CONSTANT(opline, opline->op2); + } + + if (IS_CONST != IS_CONST && + UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { + do { + if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { + function_name = Z_REFVAL_P(function_name); + if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { + break; + } + } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); + if (UNEXPECTED(EG(exception) != NULL)) { + + HANDLE_EXCEPTION(); + } + } + zend_throw_error(NULL, "Method name must be a string"); + + + HANDLE_EXCEPTION(); + } while (0); + } + + if (IS_UNUSED != IS_UNUSED) { + do { + if (IS_UNUSED == IS_CONST || UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) { + object = Z_REFVAL_P(object); + if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { + break; + } + } + if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { + object = ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception) != NULL)) { + if (IS_CONST != IS_CONST) { + + } + HANDLE_EXCEPTION(); + } + } + if (IS_CONST == IS_CONST) { + function_name = RT_CONSTANT(opline, opline->op2); + } + zend_invalid_method_call(object, function_name); + + + HANDLE_EXCEPTION(); + } + } while (0); + } + + obj = Z_OBJ_P(object); + called_scope = obj->ce; + + if (IS_CONST == IS_CONST && + EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { + fbc = CACHED_PTR(opline->result.num + sizeof(void*)); + } else { + zend_object *orig_obj = obj; + + if (IS_CONST == IS_CONST) { + function_name = RT_CONSTANT(opline, opline->op2); + } + + /* First, locate the function. */ + fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + if (UNEXPECTED(fbc == NULL)) { + if (EXPECTED(!EG(exception))) { + zend_undefined_method(obj->ce, Z_STR_P(function_name)); + } + + + HANDLE_EXCEPTION(); + } + if (IS_CONST == IS_CONST && + EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && + EXPECTED(obj == orig_obj)) { + CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); + } + if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) { + /* Reset "object" to trigger reference counting */ + object = NULL; + } + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -32924,6 +35455,141 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_U } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + + } + if (IS_CONST != IS_CONST) { + + } + } else { + if (UNEXPECTED(ce->constructor == NULL)) { + zend_throw_error(NULL, "Cannot call constructor"); + HANDLE_EXCEPTION(); + } + if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { + zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name)); + HANDLE_EXCEPTION(); + } + fbc = ce->constructor; + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + + } + } + + if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) { + if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) { + ce = (zend_class_entry*)Z_OBJ(EX(This)); + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; + } else { + zend_non_static_method_call(fbc); + HANDLE_EXCEPTION(); + } + } else { + /* previous opcode is ZEND_FETCH_CLASS */ + if (IS_UNUSED == IS_UNUSED + && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT || + (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) { + if (Z_TYPE(EX(This)) == IS_OBJECT) { + ce = Z_OBJCE(EX(This)); + } else { + ce = Z_CE(EX(This)); + } + } + call_info = ZEND_CALL_NESTED_FUNCTION; + } + + call = zend_vm_stack_push_call_frame(call_info, + fbc, opline->extended_value, ce); + call->prev_execute_data = EX(call); + EX(call) = call; + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *function_name; + zend_class_entry *ce; + uint32_t call_info; + zend_function *fbc; + zend_execute_data *call; + + SAVE_OPLINE(); + + if (IS_UNUSED == IS_CONST) { + /* no function found. try a static method in class */ + ce = CACHED_PTR(opline->result.num); + if (UNEXPECTED(ce == NULL)) { + ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); + if (UNEXPECTED(ce == NULL)) { + + HANDLE_EXCEPTION(); + } + if (IS_CONST != IS_CONST) { + CACHE_PTR(opline->result.num, ce); + } + } + } else if (IS_UNUSED == IS_UNUSED) { + ce = zend_fetch_class(NULL, opline->op1.num); + if (UNEXPECTED(ce == NULL)) { + + HANDLE_EXCEPTION(); + } + } else { + ce = Z_CE_P(EX_VAR(opline->op1.var)); + } + + if (IS_UNUSED == IS_CONST && + IS_CONST == IS_CONST && + EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) { + /* nothing to do */ + } else if (IS_UNUSED != IS_CONST && + IS_CONST == IS_CONST && + EXPECTED(CACHED_PTR(opline->result.num) == ce)) { + fbc = CACHED_PTR(opline->result.num + sizeof(void*)); + } else if (IS_CONST != IS_UNUSED) { + function_name = RT_CONSTANT(opline, opline->op2); + if (IS_CONST != IS_CONST) { + if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { + do { + if (IS_CONST & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) { + function_name = Z_REFVAL_P(function_name); + if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { + break; + } + } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } + } + zend_throw_error(NULL, "Method name must be a string"); + + HANDLE_EXCEPTION(); + } while (0); + } + } + + if (ce->get_static_method) { + fbc = ce->get_static_method(ce, Z_STR_P(function_name)); + } else { + fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + } + if (UNEXPECTED(fbc == NULL)) { + if (EXPECTED(!EG(exception))) { + zend_undefined_method(ce, Z_STR_P(function_name)); + } + + HANDLE_EXCEPTION(); + } + if (IS_CONST == IS_CONST && + EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE)))) { + CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc); + } + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + zend_observer_fcall_install((zend_function*)&fbc->op_array); } if (IS_CONST != IS_CONST) { @@ -32940,6 +35606,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_U fbc = ce->constructor; if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -34699,6 +37366,150 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_T } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + + } + } + + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + } + + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; + if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { + + if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(EG(exception))) { + HANDLE_EXCEPTION(); + } + /* call static method */ + obj = (zend_object*)called_scope; + call_info = ZEND_CALL_NESTED_FUNCTION; + } else if (IS_UNUSED & (IS_VAR|IS_TMP_VAR|IS_CV)) { + if (IS_UNUSED == IS_CV) { + GC_ADDREF(obj); /* For $this pointer */ + } else { + zval *free_op1 = EX_VAR(opline->op1.var); + if (free_op1 != object) { + GC_ADDREF(obj); /* For $this pointer */ + zval_ptr_dtor_nogc(free_op1); + } + } + /* CV may be changed indirectly (e.g. when it's a reference) */ + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS; + } + + call = zend_vm_stack_push_call_frame(call_info, + fbc, opline->extended_value, obj); + call->prev_execute_data = EX(call); + EX(call) = call; + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *function_name; + zval *object; + zend_function *fbc; + zend_class_entry *called_scope; + zend_object *obj; + zend_execute_data *call; + uint32_t call_info; + + SAVE_OPLINE(); + + object = &EX(This); + + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + } + + if ((IS_TMP_VAR|IS_VAR) != IS_CONST && + UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { + do { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { + function_name = Z_REFVAL_P(function_name); + if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { + break; + } + } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); + if (UNEXPECTED(EG(exception) != NULL)) { + + HANDLE_EXCEPTION(); + } + } + zend_throw_error(NULL, "Method name must be a string"); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + + HANDLE_EXCEPTION(); + } while (0); + } + + if (IS_UNUSED != IS_UNUSED) { + do { + if (IS_UNUSED == IS_CONST || UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) { + object = Z_REFVAL_P(object); + if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { + break; + } + } + if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { + object = ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception) != NULL)) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + } + HANDLE_EXCEPTION(); + } + } + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + } + zend_invalid_method_call(object, function_name); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + + HANDLE_EXCEPTION(); + } + } while (0); + } + + obj = Z_OBJ_P(object); + called_scope = obj->ce; + + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && + EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { + fbc = CACHED_PTR(opline->result.num + sizeof(void*)); + } else { + zend_object *orig_obj = obj; + + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + } + + /* First, locate the function. */ + fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + if (UNEXPECTED(fbc == NULL)) { + if (EXPECTED(!EG(exception))) { + zend_undefined_method(obj->ce, Z_STR_P(function_name)); + } + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + + HANDLE_EXCEPTION(); + } + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && + EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && + EXPECTED(obj == orig_obj)) { + CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); + } + if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) { + /* Reset "object" to trigger reference counting */ + object = NULL; + } + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -34820,6 +37631,141 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_U } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + + } + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + } + } else { + if (UNEXPECTED(ce->constructor == NULL)) { + zend_throw_error(NULL, "Cannot call constructor"); + HANDLE_EXCEPTION(); + } + if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { + zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name)); + HANDLE_EXCEPTION(); + } + fbc = ce->constructor; + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + + } + } + + if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) { + if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) { + ce = (zend_class_entry*)Z_OBJ(EX(This)); + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; + } else { + zend_non_static_method_call(fbc); + HANDLE_EXCEPTION(); + } + } else { + /* previous opcode is ZEND_FETCH_CLASS */ + if (IS_UNUSED == IS_UNUSED + && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT || + (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) { + if (Z_TYPE(EX(This)) == IS_OBJECT) { + ce = Z_OBJCE(EX(This)); + } else { + ce = Z_CE(EX(This)); + } + } + call_info = ZEND_CALL_NESTED_FUNCTION; + } + + call = zend_vm_stack_push_call_frame(call_info, + fbc, opline->extended_value, ce); + call->prev_execute_data = EX(call); + EX(call) = call; + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *function_name; + zend_class_entry *ce; + uint32_t call_info; + zend_function *fbc; + zend_execute_data *call; + + SAVE_OPLINE(); + + if (IS_UNUSED == IS_CONST) { + /* no function found. try a static method in class */ + ce = CACHED_PTR(opline->result.num); + if (UNEXPECTED(ce == NULL)) { + ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); + if (UNEXPECTED(ce == NULL)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + HANDLE_EXCEPTION(); + } + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + CACHE_PTR(opline->result.num, ce); + } + } + } else if (IS_UNUSED == IS_UNUSED) { + ce = zend_fetch_class(NULL, opline->op1.num); + if (UNEXPECTED(ce == NULL)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + HANDLE_EXCEPTION(); + } + } else { + ce = Z_CE_P(EX_VAR(opline->op1.var)); + } + + if (IS_UNUSED == IS_CONST && + (IS_TMP_VAR|IS_VAR) == IS_CONST && + EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) { + /* nothing to do */ + } else if (IS_UNUSED != IS_CONST && + (IS_TMP_VAR|IS_VAR) == IS_CONST && + EXPECTED(CACHED_PTR(opline->result.num) == ce)) { + fbc = CACHED_PTR(opline->result.num + sizeof(void*)); + } else if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { + do { + if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) { + function_name = Z_REFVAL_P(function_name); + if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { + break; + } + } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } + } + zend_throw_error(NULL, "Method name must be a string"); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + HANDLE_EXCEPTION(); + } while (0); + } + } + + if (ce->get_static_method) { + fbc = ce->get_static_method(ce, Z_STR_P(function_name)); + } else { + fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + } + if (UNEXPECTED(fbc == NULL)) { + if (EXPECTED(!EG(exception))) { + zend_undefined_method(ce, Z_STR_P(function_name)); + } + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + HANDLE_EXCEPTION(); + } + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && + EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE)))) { + CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc); + } + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + zend_observer_fcall_install((zend_function*)&fbc->op_array); } if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); @@ -34836,6 +37782,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_U fbc = ce->constructor; if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -35234,6 +38181,141 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_U } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + + } + if (IS_UNUSED != IS_CONST) { + + } + } else { + if (UNEXPECTED(ce->constructor == NULL)) { + zend_throw_error(NULL, "Cannot call constructor"); + HANDLE_EXCEPTION(); + } + if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { + zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name)); + HANDLE_EXCEPTION(); + } + fbc = ce->constructor; + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + + } + } + + if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) { + if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) { + ce = (zend_class_entry*)Z_OBJ(EX(This)); + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; + } else { + zend_non_static_method_call(fbc); + HANDLE_EXCEPTION(); + } + } else { + /* previous opcode is ZEND_FETCH_CLASS */ + if (IS_UNUSED == IS_UNUSED + && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT || + (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) { + if (Z_TYPE(EX(This)) == IS_OBJECT) { + ce = Z_OBJCE(EX(This)); + } else { + ce = Z_CE(EX(This)); + } + } + call_info = ZEND_CALL_NESTED_FUNCTION; + } + + call = zend_vm_stack_push_call_frame(call_info, + fbc, opline->extended_value, ce); + call->prev_execute_data = EX(call); + EX(call) = call; + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *function_name; + zend_class_entry *ce; + uint32_t call_info; + zend_function *fbc; + zend_execute_data *call; + + SAVE_OPLINE(); + + if (IS_UNUSED == IS_CONST) { + /* no function found. try a static method in class */ + ce = CACHED_PTR(opline->result.num); + if (UNEXPECTED(ce == NULL)) { + ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); + if (UNEXPECTED(ce == NULL)) { + + HANDLE_EXCEPTION(); + } + if (IS_UNUSED != IS_CONST) { + CACHE_PTR(opline->result.num, ce); + } + } + } else if (IS_UNUSED == IS_UNUSED) { + ce = zend_fetch_class(NULL, opline->op1.num); + if (UNEXPECTED(ce == NULL)) { + + HANDLE_EXCEPTION(); + } + } else { + ce = Z_CE_P(EX_VAR(opline->op1.var)); + } + + if (IS_UNUSED == IS_CONST && + IS_UNUSED == IS_CONST && + EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) { + /* nothing to do */ + } else if (IS_UNUSED != IS_CONST && + IS_UNUSED == IS_CONST && + EXPECTED(CACHED_PTR(opline->result.num) == ce)) { + fbc = CACHED_PTR(opline->result.num + sizeof(void*)); + } else if (IS_UNUSED != IS_UNUSED) { + function_name = NULL; + if (IS_UNUSED != IS_CONST) { + if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { + do { + if (IS_UNUSED & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) { + function_name = Z_REFVAL_P(function_name); + if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { + break; + } + } else if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } + } + zend_throw_error(NULL, "Method name must be a string"); + + HANDLE_EXCEPTION(); + } while (0); + } + } + + if (ce->get_static_method) { + fbc = ce->get_static_method(ce, Z_STR_P(function_name)); + } else { + fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_UNUSED == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + } + if (UNEXPECTED(fbc == NULL)) { + if (EXPECTED(!EG(exception))) { + zend_undefined_method(ce, Z_STR_P(function_name)); + } + + HANDLE_EXCEPTION(); + } + if (IS_UNUSED == IS_CONST && + EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE)))) { + CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc); + } + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + zend_observer_fcall_install((zend_function*)&fbc->op_array); } if (IS_UNUSED != IS_CONST) { @@ -35250,6 +38332,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_U fbc = ce->constructor; if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -35481,6 +38564,77 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_UNUSED_UNUSED_HANDLER } else { if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&constructor->op_array))) { init_func_run_time_cache(&constructor->op_array); + + } + /* We are not handling overloaded classes right now */ + call = zend_vm_stack_push_call_frame( + ZEND_CALL_FUNCTION | ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS, + constructor, + opline->extended_value, + Z_OBJ_P(result)); + Z_ADDREF_P(result); + } + + call->prev_execute_data = EX(call); + EX(call) = call; + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_UNUSED_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *result; + zend_function *constructor; + zend_class_entry *ce; + zend_execute_data *call; + + SAVE_OPLINE(); + if (IS_UNUSED == IS_CONST) { + ce = CACHED_PTR(opline->op2.num); + if (UNEXPECTED(ce == NULL)) { + ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); + if (UNEXPECTED(ce == NULL)) { + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); + } + CACHE_PTR(opline->op2.num, ce); + } + } else if (IS_UNUSED == IS_UNUSED) { + ce = zend_fetch_class(NULL, opline->op1.num); + if (UNEXPECTED(ce == NULL)) { + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); + } + } else { + ce = Z_CE_P(EX_VAR(opline->op1.var)); + } + + result = EX_VAR(opline->result.var); + if (UNEXPECTED(object_init_ex(result, ce) != SUCCESS)) { + ZVAL_UNDEF(result); + HANDLE_EXCEPTION(); + } + + constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result)); + if (constructor == NULL) { + if (UNEXPECTED(EG(exception))) { + HANDLE_EXCEPTION(); + } + + /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next + * opcode is DO_FCALL in case EXT instructions are used. */ + if (EXPECTED(opline->extended_value == 0 && (opline+1)->opcode == ZEND_DO_FCALL)) { + ZEND_VM_NEXT_OPCODE_EX(1, 2); + } + + /* Perform a dummy function call */ + call = zend_vm_stack_push_call_frame( + ZEND_CALL_FUNCTION, (zend_function *) &zend_pass_function, + opline->extended_value, NULL); + } else { + if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&constructor->op_array))) { + init_func_run_time_cache(&constructor->op_array); + zend_observer_fcall_install((zend_function*)&constructor->op_array); } /* We are not handling overloaded classes right now */ call = zend_vm_stack_push_call_frame( @@ -37173,6 +40327,150 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_C } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + + } + } + + if (IS_CV != IS_CONST) { + + } + + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; + if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { + + if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(EG(exception))) { + HANDLE_EXCEPTION(); + } + /* call static method */ + obj = (zend_object*)called_scope; + call_info = ZEND_CALL_NESTED_FUNCTION; + } else if (IS_UNUSED & (IS_VAR|IS_TMP_VAR|IS_CV)) { + if (IS_UNUSED == IS_CV) { + GC_ADDREF(obj); /* For $this pointer */ + } else { + zval *free_op1 = EX_VAR(opline->op1.var); + if (free_op1 != object) { + GC_ADDREF(obj); /* For $this pointer */ + zval_ptr_dtor_nogc(free_op1); + } + } + /* CV may be changed indirectly (e.g. when it's a reference) */ + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS; + } + + call = zend_vm_stack_push_call_frame(call_info, + fbc, opline->extended_value, obj); + call->prev_execute_data = EX(call); + EX(call) = call; + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *function_name; + zval *object; + zend_function *fbc; + zend_class_entry *called_scope; + zend_object *obj; + zend_execute_data *call; + uint32_t call_info; + + SAVE_OPLINE(); + + object = &EX(This); + + if (IS_CV != IS_CONST) { + function_name = EX_VAR(opline->op2.var); + } + + if (IS_CV != IS_CONST && + UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { + do { + if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { + function_name = Z_REFVAL_P(function_name); + if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { + break; + } + } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); + if (UNEXPECTED(EG(exception) != NULL)) { + + HANDLE_EXCEPTION(); + } + } + zend_throw_error(NULL, "Method name must be a string"); + + + HANDLE_EXCEPTION(); + } while (0); + } + + if (IS_UNUSED != IS_UNUSED) { + do { + if (IS_UNUSED == IS_CONST || UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) { + object = Z_REFVAL_P(object); + if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { + break; + } + } + if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { + object = ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception) != NULL)) { + if (IS_CV != IS_CONST) { + + } + HANDLE_EXCEPTION(); + } + } + if (IS_CV == IS_CONST) { + function_name = EX_VAR(opline->op2.var); + } + zend_invalid_method_call(object, function_name); + + + HANDLE_EXCEPTION(); + } + } while (0); + } + + obj = Z_OBJ_P(object); + called_scope = obj->ce; + + if (IS_CV == IS_CONST && + EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { + fbc = CACHED_PTR(opline->result.num + sizeof(void*)); + } else { + zend_object *orig_obj = obj; + + if (IS_CV == IS_CONST) { + function_name = EX_VAR(opline->op2.var); + } + + /* First, locate the function. */ + fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + if (UNEXPECTED(fbc == NULL)) { + if (EXPECTED(!EG(exception))) { + zend_undefined_method(obj->ce, Z_STR_P(function_name)); + } + + + HANDLE_EXCEPTION(); + } + if (IS_CV == IS_CONST && + EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && + EXPECTED(obj == orig_obj)) { + CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); + } + if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) { + /* Reset "object" to trigger reference counting */ + object = NULL; + } + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -37294,6 +40592,141 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_U } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + + } + if (IS_CV != IS_CONST) { + + } + } else { + if (UNEXPECTED(ce->constructor == NULL)) { + zend_throw_error(NULL, "Cannot call constructor"); + HANDLE_EXCEPTION(); + } + if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { + zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name)); + HANDLE_EXCEPTION(); + } + fbc = ce->constructor; + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + + } + } + + if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) { + if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) { + ce = (zend_class_entry*)Z_OBJ(EX(This)); + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; + } else { + zend_non_static_method_call(fbc); + HANDLE_EXCEPTION(); + } + } else { + /* previous opcode is ZEND_FETCH_CLASS */ + if (IS_UNUSED == IS_UNUSED + && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT || + (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) { + if (Z_TYPE(EX(This)) == IS_OBJECT) { + ce = Z_OBJCE(EX(This)); + } else { + ce = Z_CE(EX(This)); + } + } + call_info = ZEND_CALL_NESTED_FUNCTION; + } + + call = zend_vm_stack_push_call_frame(call_info, + fbc, opline->extended_value, ce); + call->prev_execute_data = EX(call); + EX(call) = call; + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *function_name; + zend_class_entry *ce; + uint32_t call_info; + zend_function *fbc; + zend_execute_data *call; + + SAVE_OPLINE(); + + if (IS_UNUSED == IS_CONST) { + /* no function found. try a static method in class */ + ce = CACHED_PTR(opline->result.num); + if (UNEXPECTED(ce == NULL)) { + ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); + if (UNEXPECTED(ce == NULL)) { + + HANDLE_EXCEPTION(); + } + if (IS_CV != IS_CONST) { + CACHE_PTR(opline->result.num, ce); + } + } + } else if (IS_UNUSED == IS_UNUSED) { + ce = zend_fetch_class(NULL, opline->op1.num); + if (UNEXPECTED(ce == NULL)) { + + HANDLE_EXCEPTION(); + } + } else { + ce = Z_CE_P(EX_VAR(opline->op1.var)); + } + + if (IS_UNUSED == IS_CONST && + IS_CV == IS_CONST && + EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) { + /* nothing to do */ + } else if (IS_UNUSED != IS_CONST && + IS_CV == IS_CONST && + EXPECTED(CACHED_PTR(opline->result.num) == ce)) { + fbc = CACHED_PTR(opline->result.num + sizeof(void*)); + } else if (IS_CV != IS_UNUSED) { + function_name = EX_VAR(opline->op2.var); + if (IS_CV != IS_CONST) { + if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { + do { + if (IS_CV & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) { + function_name = Z_REFVAL_P(function_name); + if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { + break; + } + } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } + } + zend_throw_error(NULL, "Method name must be a string"); + + HANDLE_EXCEPTION(); + } while (0); + } + } + + if (ce->get_static_method) { + fbc = ce->get_static_method(ce, Z_STR_P(function_name)); + } else { + fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + } + if (UNEXPECTED(fbc == NULL)) { + if (EXPECTED(!EG(exception))) { + zend_undefined_method(ce, Z_STR_P(function_name)); + } + + HANDLE_EXCEPTION(); + } + if (IS_CV == IS_CONST && + EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE)))) { + CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc); + } + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + zend_observer_fcall_install((zend_function*)&fbc->op_array); } if (IS_CV != IS_CONST) { @@ -37310,6 +40743,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_U fbc = ce->constructor; if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -42093,6 +45527,150 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_S } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + + } + } + + if (IS_CONST != IS_CONST) { + + } + + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; + if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { + + if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(EG(exception))) { + HANDLE_EXCEPTION(); + } + /* call static method */ + obj = (zend_object*)called_scope; + call_info = ZEND_CALL_NESTED_FUNCTION; + } else if (IS_CV & (IS_VAR|IS_TMP_VAR|IS_CV)) { + if (IS_CV == IS_CV) { + GC_ADDREF(obj); /* For $this pointer */ + } else { + zval *free_op1 = EX_VAR(opline->op1.var); + if (free_op1 != object) { + GC_ADDREF(obj); /* For $this pointer */ + zval_ptr_dtor_nogc(free_op1); + } + } + /* CV may be changed indirectly (e.g. when it's a reference) */ + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS; + } + + call = zend_vm_stack_push_call_frame(call_info, + fbc, opline->extended_value, obj); + call->prev_execute_data = EX(call); + EX(call) = call; + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *function_name; + zval *object; + zend_function *fbc; + zend_class_entry *called_scope; + zend_object *obj; + zend_execute_data *call; + uint32_t call_info; + + SAVE_OPLINE(); + + object = EX_VAR(opline->op1.var); + + if (IS_CONST != IS_CONST) { + function_name = RT_CONSTANT(opline, opline->op2); + } + + if (IS_CONST != IS_CONST && + UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { + do { + if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { + function_name = Z_REFVAL_P(function_name); + if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { + break; + } + } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); + if (UNEXPECTED(EG(exception) != NULL)) { + + HANDLE_EXCEPTION(); + } + } + zend_throw_error(NULL, "Method name must be a string"); + + + HANDLE_EXCEPTION(); + } while (0); + } + + if (IS_CV != IS_UNUSED) { + do { + if (IS_CV == IS_CONST || UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) { + object = Z_REFVAL_P(object); + if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { + break; + } + } + if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { + object = ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception) != NULL)) { + if (IS_CONST != IS_CONST) { + + } + HANDLE_EXCEPTION(); + } + } + if (IS_CONST == IS_CONST) { + function_name = RT_CONSTANT(opline, opline->op2); + } + zend_invalid_method_call(object, function_name); + + + HANDLE_EXCEPTION(); + } + } while (0); + } + + obj = Z_OBJ_P(object); + called_scope = obj->ce; + + if (IS_CONST == IS_CONST && + EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { + fbc = CACHED_PTR(opline->result.num + sizeof(void*)); + } else { + zend_object *orig_obj = obj; + + if (IS_CONST == IS_CONST) { + function_name = RT_CONSTANT(opline, opline->op2); + } + + /* First, locate the function. */ + fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + if (UNEXPECTED(fbc == NULL)) { + if (EXPECTED(!EG(exception))) { + zend_undefined_method(obj->ce, Z_STR_P(function_name)); + } + + + HANDLE_EXCEPTION(); + } + if (IS_CONST == IS_CONST && + EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && + EXPECTED(obj == orig_obj)) { + CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); + } + if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) { + /* Reset "object" to trigger reference counting */ + object = NULL; + } + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -45665,6 +49243,150 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVA } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + + } + } + + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + } + + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; + if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { + + if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(EG(exception))) { + HANDLE_EXCEPTION(); + } + /* call static method */ + obj = (zend_object*)called_scope; + call_info = ZEND_CALL_NESTED_FUNCTION; + } else if (IS_CV & (IS_VAR|IS_TMP_VAR|IS_CV)) { + if (IS_CV == IS_CV) { + GC_ADDREF(obj); /* For $this pointer */ + } else { + zval *free_op1 = EX_VAR(opline->op1.var); + if (free_op1 != object) { + GC_ADDREF(obj); /* For $this pointer */ + zval_ptr_dtor_nogc(free_op1); + } + } + /* CV may be changed indirectly (e.g. when it's a reference) */ + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS; + } + + call = zend_vm_stack_push_call_frame(call_info, + fbc, opline->extended_value, obj); + call->prev_execute_data = EX(call); + EX(call) = call; + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *function_name; + zval *object; + zend_function *fbc; + zend_class_entry *called_scope; + zend_object *obj; + zend_execute_data *call; + uint32_t call_info; + + SAVE_OPLINE(); + + object = EX_VAR(opline->op1.var); + + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + } + + if ((IS_TMP_VAR|IS_VAR) != IS_CONST && + UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { + do { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { + function_name = Z_REFVAL_P(function_name); + if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { + break; + } + } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); + if (UNEXPECTED(EG(exception) != NULL)) { + + HANDLE_EXCEPTION(); + } + } + zend_throw_error(NULL, "Method name must be a string"); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + + HANDLE_EXCEPTION(); + } while (0); + } + + if (IS_CV != IS_UNUSED) { + do { + if (IS_CV == IS_CONST || UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) { + object = Z_REFVAL_P(object); + if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { + break; + } + } + if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { + object = ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception) != NULL)) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + } + HANDLE_EXCEPTION(); + } + } + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + } + zend_invalid_method_call(object, function_name); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + + HANDLE_EXCEPTION(); + } + } while (0); + } + + obj = Z_OBJ_P(object); + called_scope = obj->ce; + + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && + EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { + fbc = CACHED_PTR(opline->result.num + sizeof(void*)); + } else { + zend_object *orig_obj = obj; + + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + } + + /* First, locate the function. */ + fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + if (UNEXPECTED(fbc == NULL)) { + if (EXPECTED(!EG(exception))) { + zend_undefined_method(obj->ce, Z_STR_P(function_name)); + } + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + + HANDLE_EXCEPTION(); + } + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && + EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && + EXPECTED(obj == orig_obj)) { + CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); + } + if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) { + /* Reset "object" to trigger reference counting */ + object = NULL; + } + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -50774,6 +54496,150 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HA } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); + + } + } + + if (IS_CV != IS_CONST) { + + } + + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; + if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { + + if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(EG(exception))) { + HANDLE_EXCEPTION(); + } + /* call static method */ + obj = (zend_object*)called_scope; + call_info = ZEND_CALL_NESTED_FUNCTION; + } else if (IS_CV & (IS_VAR|IS_TMP_VAR|IS_CV)) { + if (IS_CV == IS_CV) { + GC_ADDREF(obj); /* For $this pointer */ + } else { + zval *free_op1 = EX_VAR(opline->op1.var); + if (free_op1 != object) { + GC_ADDREF(obj); /* For $this pointer */ + zval_ptr_dtor_nogc(free_op1); + } + } + /* CV may be changed indirectly (e.g. when it's a reference) */ + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS; + } + + call = zend_vm_stack_push_call_frame(call_info, + fbc, opline->extended_value, obj); + call->prev_execute_data = EX(call); + EX(call) = call; + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *function_name; + zval *object; + zend_function *fbc; + zend_class_entry *called_scope; + zend_object *obj; + zend_execute_data *call; + uint32_t call_info; + + SAVE_OPLINE(); + + object = EX_VAR(opline->op1.var); + + if (IS_CV != IS_CONST) { + function_name = EX_VAR(opline->op2.var); + } + + if (IS_CV != IS_CONST && + UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { + do { + if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { + function_name = Z_REFVAL_P(function_name); + if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { + break; + } + } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); + if (UNEXPECTED(EG(exception) != NULL)) { + + HANDLE_EXCEPTION(); + } + } + zend_throw_error(NULL, "Method name must be a string"); + + + HANDLE_EXCEPTION(); + } while (0); + } + + if (IS_CV != IS_UNUSED) { + do { + if (IS_CV == IS_CONST || UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) { + object = Z_REFVAL_P(object); + if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { + break; + } + } + if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { + object = ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception) != NULL)) { + if (IS_CV != IS_CONST) { + + } + HANDLE_EXCEPTION(); + } + } + if (IS_CV == IS_CONST) { + function_name = EX_VAR(opline->op2.var); + } + zend_invalid_method_call(object, function_name); + + + HANDLE_EXCEPTION(); + } + } while (0); + } + + obj = Z_OBJ_P(object); + called_scope = obj->ce; + + if (IS_CV == IS_CONST && + EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { + fbc = CACHED_PTR(opline->result.num + sizeof(void*)); + } else { + zend_object *orig_obj = obj; + + if (IS_CV == IS_CONST) { + function_name = EX_VAR(opline->op2.var); + } + + /* First, locate the function. */ + fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + if (UNEXPECTED(fbc == NULL)) { + if (EXPECTED(!EG(exception))) { + zend_undefined_method(obj->ce, Z_STR_P(function_name)); + } + + + HANDLE_EXCEPTION(); + } + if (IS_CV == IS_CONST && + EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && + EXPECTED(obj == orig_obj)) { + CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); + } + if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) { + /* Reset "object" to trigger reference counting */ + object = NULL; + } + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -52769,11 +56635,13 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_BEGIN_SILENCE_SPEC_LABEL, (void*)&&ZEND_END_SILENCE_SPEC_TMP_LABEL, (void*)&&ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_LABEL, + (void*)&&ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_OBSERVER_LABEL, (void*)&&ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_LABEL, (void*)&&ZEND_DO_FCALL_SPEC_RETVAL_USED_LABEL, (void*)&&ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_OBSERVER_LABEL, (void*)&&ZEND_DO_FCALL_SPEC_RETVAL_USED_OBSERVER_LABEL, (void*)&&ZEND_INIT_FCALL_SPEC_CONST_LABEL, + (void*)&&ZEND_INIT_FCALL_SPEC_CONST_OBSERVER_LABEL, (void*)&&ZEND_RETURN_SPEC_CONST_LABEL, (void*)&&ZEND_RETURN_SPEC_CONST_OBSERVER_LABEL, (void*)&&ZEND_RETURN_SPEC_TMP_LABEL, @@ -52887,11 +56755,17 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_SEND_REF_SPEC_CV_UNUSED_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NEW_SPEC_CONST_UNUSED_LABEL, + (void*)&&ZEND_NEW_SPEC_CONST_UNUSED_OBSERVER_LABEL, + (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NEW_SPEC_VAR_UNUSED_LABEL, + (void*)&&ZEND_NEW_SPEC_VAR_UNUSED_OBSERVER_LABEL, (void*)&&ZEND_NEW_SPEC_UNUSED_UNUSED_LABEL, + (void*)&&ZEND_NEW_SPEC_UNUSED_UNUSED_OBSERVER_LABEL, + (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_LABEL, + (void*)&&ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_OBSERVER_LABEL, (void*)&&ZEND_FREE_SPEC_TMPVAR_LABEL, (void*)&&ZEND_INIT_ARRAY_SPEC_CONST_CONST_LABEL, (void*)&&ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_LABEL, @@ -53418,50 +57292,100 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_RETURN_BY_REF_SPEC_CV_LABEL, (void*)&&ZEND_RETURN_BY_REF_SPEC_CV_OBSERVER_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_LABEL, + (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_OBSERVER_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_LABEL, + (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_OBSERVER_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_LABEL, + (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_OBSERVER_LABEL, + (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_LABEL, + (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_OBSERVER_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_LABEL, + (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_OBSERVER_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_LABEL, + (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_OBSERVER_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_LABEL, + (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_OBSERVER_LABEL, + (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_LABEL, + (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_OBSERVER_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_LABEL, + (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_OBSERVER_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_LABEL, + (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_OBSERVER_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_LABEL, + (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_OBSERVER_LABEL, + (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_LABEL, + (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_OBSERVER_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_LABEL, + (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_OBSERVER_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_LABEL, + (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_OBSERVER_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_LABEL, + (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_OBSERVER_LABEL, + (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_LABEL, + (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_OBSERVER_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_LABEL, + (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_OBSERVER_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_OBSERVER_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_OBSERVER_LABEL, + (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_CV_LABEL, + (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_CV_OBSERVER_LABEL, (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_LABEL, + (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_OBSERVER_LABEL, (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_LABEL, + (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_OBSERVER_LABEL, (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_LABEL, + (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_OBSERVER_LABEL, (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_LABEL, + (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_OBSERVER_LABEL, (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_LABEL, + (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_OBSERVER_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_LABEL, + (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_OBSERVER_LABEL, (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_LABEL, + (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_OBSERVER_LABEL, (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_LABEL, + (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_OBSERVER_LABEL, (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_LABEL, + (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_OBSERVER_LABEL, (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_LABEL, + (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_OBSERVER_LABEL, (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_LABEL, + (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_OBSERVER_LABEL, (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_LABEL, + (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_OBSERVER_LABEL, (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_LABEL, + (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_OBSERVER_LABEL, (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_LABEL, + (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_OBSERVER_LABEL, (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_LABEL, + (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_OBSERVER_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -53573,10 +57497,15 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_SEND_VAR_SPEC_CV_UNUSED_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_CONST_LABEL, + (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_CONST_OBSERVER_LABEL, (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_LABEL, + (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_OBSERVER_LABEL, (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_LABEL, + (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_OBSERVER_LABEL, + (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_CV_LABEL, + (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_CV_OBSERVER_LABEL, (void*)&&ZEND_SEND_ARRAY_SPEC_LABEL, (void*)&&ZEND_SEND_USER_SPEC_CONST_LABEL, (void*)&&ZEND_SEND_USER_SPEC_TMP_LABEL, @@ -55244,6 +59173,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INIT_FCALL_BY_NAME_SPEC_CONST) ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_OBSERVER): + VM_TRACE(ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_OBSERVER) + ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_INIT_DYNAMIC_CALL_SPEC_CONST): VM_TRACE(ZEND_INIT_DYNAMIC_CALL_SPEC_CONST) ZEND_INIT_DYNAMIC_CALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -55252,10 +59185,18 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST) ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_OBSERVER): + VM_TRACE(ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_OBSERVER) + ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_INIT_FCALL_SPEC_CONST): VM_TRACE(ZEND_INIT_FCALL_SPEC_CONST) ZEND_INIT_FCALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_FCALL_SPEC_CONST_OBSERVER): + VM_TRACE(ZEND_INIT_FCALL_SPEC_CONST_OBSERVER) + ZEND_INIT_FCALL_SPEC_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_RECV_INIT_SPEC_CONST): VM_TRACE(ZEND_RECV_INIT_SPEC_CONST) ZEND_RECV_INIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -55680,14 +59621,26 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST) ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_OBSERVER): + VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_OBSERVER) + ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST): VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST) ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_OBSERVER): + VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_OBSERVER) + ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_INIT_USER_CALL_SPEC_CONST_CONST): VM_TRACE(ZEND_INIT_USER_CALL_SPEC_CONST_CONST) ZEND_INIT_USER_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_USER_CALL_SPEC_CONST_CONST_OBSERVER): + VM_TRACE(ZEND_INIT_USER_CALL_SPEC_CONST_CONST_OBSERVER) + ZEND_INIT_USER_CALL_SPEC_CONST_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_SEND_VAL_SPEC_CONST_CONST): VM_TRACE(ZEND_SEND_VAL_SPEC_CONST_CONST) ZEND_SEND_VAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -55908,14 +59861,26 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_OBSERVER): + VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_OBSERVER) + ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR): VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_OBSERVER): + VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_OBSERVER) + ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR): VM_TRACE(ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_OBSERVER): + VM_TRACE(ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_OBSERVER) + ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR): VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR) ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -55972,6 +59937,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED) ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_OBSERVER): + VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_OBSERVER) + ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED): VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED) ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -55992,6 +59961,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_NEW_SPEC_CONST_UNUSED) ZEND_NEW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_NEW_SPEC_CONST_UNUSED_OBSERVER): + VM_TRACE(ZEND_NEW_SPEC_CONST_UNUSED_OBSERVER) + ZEND_NEW_SPEC_CONST_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED): VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED) ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -56088,14 +60061,26 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CONST_CV) ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_OBSERVER): + VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_OBSERVER) + ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV): VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV) ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_OBSERVER): + VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_OBSERVER) + ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_INIT_USER_CALL_SPEC_CONST_CV): VM_TRACE(ZEND_INIT_USER_CALL_SPEC_CONST_CV) ZEND_INIT_USER_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_USER_CALL_SPEC_CONST_CV_OBSERVER): + VM_TRACE(ZEND_INIT_USER_CALL_SPEC_CONST_CV_OBSERVER) + ZEND_INIT_USER_CALL_SPEC_CONST_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV): VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV) ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -56692,6 +60677,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_OBSERVER): + VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_OBSERVER) + ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_SEND_VAL_SPEC_TMPVAR_CONST): VM_TRACE(ZEND_SEND_VAL_SPEC_TMPVAR_CONST) ZEND_SEND_VAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -56792,6 +60781,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_OBSERVER): + VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_OBSERVER) + ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_CASE_SPEC_TMPVAR_TMPVAR): VM_TRACE(ZEND_CASE_SPEC_TMPVAR_TMPVAR) ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -56904,6 +60897,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_OBSERVER): + VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_OBSERVER) + ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_CASE_SPEC_TMPVAR_CV): VM_TRACE(ZEND_CASE_SPEC_TMPVAR_CV) ZEND_CASE_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -57624,6 +61621,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST) ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_OBSERVER): + VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_OBSERVER) + ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_SEND_VAR_SPEC_VAR_CONST): VM_TRACE(ZEND_SEND_VAR_SPEC_VAR_CONST) ZEND_SEND_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -57776,6 +61777,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_OBSERVER): + VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_OBSERVER) + ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR): VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR) ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -57876,6 +61881,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED) ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_OBSERVER): + VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_OBSERVER) + ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED): VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED) ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -57916,6 +61925,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_NEW_SPEC_VAR_UNUSED) ZEND_NEW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_NEW_SPEC_VAR_UNUSED_OBSERVER): + VM_TRACE(ZEND_NEW_SPEC_VAR_UNUSED_OBSERVER) + ZEND_NEW_SPEC_VAR_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED): VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED) ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -58060,6 +62073,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV) ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_OBSERVER): + VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_OBSERVER) + ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV): VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV) ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -58168,10 +62185,18 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST) ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_OBSERVER): + VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_OBSERVER) + ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST): VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST) ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_OBSERVER): + VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_OBSERVER) + ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST): VM_TRACE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST) ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -58272,10 +62297,18 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_OBSERVER): + VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_OBSERVER) + ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR): VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_OBSERVER): + VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_OBSERVER) + ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR): VM_TRACE(ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR) ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -58300,6 +62333,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED) ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_OBSERVER): + VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_OBSERVER) + ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED): VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED) ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -58320,6 +62357,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_NEW_SPEC_UNUSED_UNUSED) ZEND_NEW_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_NEW_SPEC_UNUSED_UNUSED_OBSERVER): + VM_TRACE(ZEND_NEW_SPEC_UNUSED_UNUSED_OBSERVER) + ZEND_NEW_SPEC_UNUSED_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED): VM_TRACE(ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED) ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -58424,10 +62465,18 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV) ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_OBSERVER): + VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_OBSERVER) + ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV): VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV) ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_OBSERVER): + VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_OBSERVER) + ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_UNUSED_CV): VM_TRACE(ZEND_INIT_ARRAY_SPEC_UNUSED_CV) ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -58952,6 +63001,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CV_CONST) ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_OBSERVER): + VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_OBSERVER) + ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_SEND_VAR_SPEC_CV_CONST): VM_TRACE(ZEND_SEND_VAR_SPEC_CV_CONST) ZEND_SEND_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -59184,6 +63237,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_OBSERVER): + VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_OBSERVER) + ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR): VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR) ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -59576,6 +63633,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CV_CV) ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CV_CV_OBSERVER): + VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CV_CV_OBSERVER) + ZEND_INIT_METHOD_CALL_SPEC_CV_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV): VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV) ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -61045,11 +65106,13 @@ void zend_vm_init(void) ZEND_BEGIN_SILENCE_SPEC_HANDLER, ZEND_END_SILENCE_SPEC_TMP_HANDLER, ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER, + ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_OBSERVER_HANDLER, ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_HANDLER, ZEND_DO_FCALL_SPEC_RETVAL_USED_HANDLER, ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_OBSERVER_HANDLER, ZEND_DO_FCALL_SPEC_RETVAL_USED_OBSERVER_HANDLER, ZEND_INIT_FCALL_SPEC_CONST_HANDLER, + ZEND_INIT_FCALL_SPEC_CONST_OBSERVER_HANDLER, ZEND_RETURN_SPEC_CONST_HANDLER, ZEND_RETURN_SPEC_CONST_OBSERVER_HANDLER, ZEND_RETURN_SPEC_TMP_HANDLER, @@ -61163,11 +65226,17 @@ void zend_vm_init(void) ZEND_SEND_REF_SPEC_CV_UNUSED_HANDLER, ZEND_NULL_HANDLER, ZEND_NEW_SPEC_CONST_UNUSED_HANDLER, + ZEND_NEW_SPEC_CONST_UNUSED_OBSERVER_HANDLER, + ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NEW_SPEC_VAR_UNUSED_HANDLER, + ZEND_NEW_SPEC_VAR_UNUSED_OBSERVER_HANDLER, ZEND_NEW_SPEC_UNUSED_UNUSED_HANDLER, + ZEND_NEW_SPEC_UNUSED_UNUSED_OBSERVER_HANDLER, + ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER, + ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_OBSERVER_HANDLER, ZEND_FREE_SPEC_TMPVAR_HANDLER, ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER, ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_HANDLER, @@ -61694,50 +65763,100 @@ void zend_vm_init(void) ZEND_RETURN_BY_REF_SPEC_CV_HANDLER, ZEND_RETURN_BY_REF_SPEC_CV_OBSERVER_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_OBSERVER_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_OBSERVER_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_OBSERVER_HANDLER, + ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_OBSERVER_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_OBSERVER_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_OBSERVER_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_OBSERVER_HANDLER, + ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_OBSERVER_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_OBSERVER_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_OBSERVER_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_OBSERVER_HANDLER, + ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_OBSERVER_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_OBSERVER_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_OBSERVER_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_OBSERVER_HANDLER, + ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_OBSERVER_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_OBSERVER_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_OBSERVER_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_OBSERVER_HANDLER, + ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_CV_CV_OBSERVER_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER, + ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_OBSERVER_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER, + ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_OBSERVER_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER, + ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_OBSERVER_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER, + ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_OBSERVER_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER, + ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_OBSERVER_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER, + ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_OBSERVER_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER, + ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_OBSERVER_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER, + ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_OBSERVER_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER, + ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_OBSERVER_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER, + ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_OBSERVER_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER, + ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_OBSERVER_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER, + ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_OBSERVER_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER, + ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_OBSERVER_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_HANDLER, + ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_OBSERVER_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_HANDLER, + ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_OBSERVER_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, @@ -61849,10 +65968,15 @@ void zend_vm_init(void) ZEND_SEND_VAR_SPEC_CV_UNUSED_HANDLER, ZEND_NULL_HANDLER, ZEND_INIT_USER_CALL_SPEC_CONST_CONST_HANDLER, + ZEND_INIT_USER_CALL_SPEC_CONST_CONST_OBSERVER_HANDLER, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER, + ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_OBSERVER_HANDLER, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER, + ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_OBSERVER_HANDLER, + ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_INIT_USER_CALL_SPEC_CONST_CV_HANDLER, + ZEND_INIT_USER_CALL_SPEC_CONST_CV_OBSERVER_HANDLER, ZEND_SEND_ARRAY_SPEC_HANDLER, ZEND_SEND_USER_SPEC_CONST_HANDLER, ZEND_SEND_USER_SPEC_TMP_HANDLER, @@ -63207,148 +67331,148 @@ void zend_vm_init(void) 1342 | SPEC_RULE_OP2, 1347, 1348, - 1349, - 1350 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, - 1354, - 1355 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, - 1365, - 1366, - 1367 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1392 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, - 1442 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1467 | SPEC_RULE_OP1, - 1472, - 1473, - 1474 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1499 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1524 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, - 1534 | SPEC_RULE_OP1, - 1539 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1564 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1589 | SPEC_RULE_OP1, - 1594, - 1595, - 1596 | SPEC_RULE_OP1, - 1601 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1626 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1651 | SPEC_RULE_OP1, - 1656 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1681 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1706 | SPEC_RULE_OP1, - 1711 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1736 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1761 | SPEC_RULE_OP1, - 1766 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1791 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1816 | SPEC_RULE_OP1, - 1821 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1846 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1871 | SPEC_RULE_OP1, - 1876 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1901 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1926 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1951, - 1952 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, - 1962, - 1963, - 1964, - 1965, - 1966, - 1967 | SPEC_RULE_OP2, + 1349 | SPEC_RULE_OBSERVER, + 1351 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, + 1355 | SPEC_RULE_OBSERVER, + 1357 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, + 1367, + 1368, + 1369 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1394 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, + 1444 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1469 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, + 1479 | SPEC_RULE_OBSERVER, + 1481, + 1482 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1507 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1532 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, + 1542 | SPEC_RULE_OP1, + 1547 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1572 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1597 | SPEC_RULE_OP1, + 1602, + 1603, + 1604 | SPEC_RULE_OP1, + 1609 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1634 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1659 | SPEC_RULE_OP1, + 1664 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1689 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1714 | SPEC_RULE_OP1, + 1719 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1744 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1769 | SPEC_RULE_OP1, + 1774 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1799 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1824 | SPEC_RULE_OP1, + 1829 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1854 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1879 | SPEC_RULE_OP1, + 1884 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1909 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1934 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1959, + 1960 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, + 1970, + 1971, 1972, - 1973 | SPEC_RULE_OP1, - 1978 | SPEC_RULE_OP2, - 1983 | SPEC_RULE_OP1, - 1988 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, - 1998 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2023 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2048 | SPEC_RULE_OP1, - 2053 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2078 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, - 2128 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2153 | SPEC_RULE_OP2, - 2158, - 2159 | SPEC_RULE_OP1, - 2164 | SPEC_RULE_OP1, - 2169, - 2170 | SPEC_RULE_OP1, - 2175 | SPEC_RULE_OP1, - 2180 | SPEC_RULE_OP1, - 2185, - 2186, - 2187 | SPEC_RULE_OP2, - 2192 | SPEC_RULE_RETVAL, - 2194 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, - 2198 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, - 2202 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2202 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2227 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2227 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2252 | SPEC_RULE_OP1, - 2257, - 2258 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2283, - 2284 | SPEC_RULE_OP1, - 2289, - 2290, - 2291, - 2292, - 2293, - 2294, - 2295, - 2296 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2321, - 2322, - 2323, - 2324 | SPEC_RULE_OP1, - 2329, - 2330 | SPEC_RULE_ISSET, - 2332 | SPEC_RULE_OP2, - 2337, - 2338 | SPEC_RULE_OP1, - 2343 | SPEC_RULE_OBSERVER, - 2345, - 2346 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2371 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, - 2381, - 2382, - 2383, + 1973, + 1974, + 1975 | SPEC_RULE_OP2, + 1980, + 1981 | SPEC_RULE_OP1, + 1986 | SPEC_RULE_OP2, + 1991 | SPEC_RULE_OP1, + 1996 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, + 2006 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OBSERVER, + 2056 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OBSERVER, + 2106 | SPEC_RULE_OP1, + 2111 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2136 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, + 2186 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2211 | SPEC_RULE_OP2 | SPEC_RULE_OBSERVER, + 2221, + 2222 | SPEC_RULE_OP1, + 2227 | SPEC_RULE_OP1, + 2232, + 2233 | SPEC_RULE_OP1, + 2238 | SPEC_RULE_OP1, + 2243 | SPEC_RULE_OP1, + 2248, + 2249, + 2250 | SPEC_RULE_OP2, + 2255 | SPEC_RULE_RETVAL, + 2257 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, + 2261 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, + 2265 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2265 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2290 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2290 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2315 | SPEC_RULE_OP1, + 2320, + 2321 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2346, + 2347 | SPEC_RULE_OP1, + 2352, + 2353, + 2354, + 2355, + 2356, + 2357, + 2358, + 2359 | SPEC_RULE_OP1 | SPEC_RULE_OP2, 2384, - 2385 | SPEC_RULE_OP1, - 2390, - 2391, - 2392 | SPEC_RULE_OP1, - 2397 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2422, - 2423 | SPEC_RULE_OP1, - 2428, - 2429, - 2430, - 2431, - 2432, - 2433, - 2434, - 2435, - 2436 | SPEC_RULE_OP1, - 2441, - 2442, - 2443, - 2444 | SPEC_RULE_OP2, - 2449, - 2450 | SPEC_RULE_OP1, + 2385, + 2386, + 2387 | SPEC_RULE_OP1, + 2392, + 2393 | SPEC_RULE_ISSET, + 2395 | SPEC_RULE_OP2, + 2400, + 2401 | SPEC_RULE_OP1, + 2406 | SPEC_RULE_OBSERVER, + 2408, + 2409 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2434 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, + 2444, + 2445, + 2446, + 2447, + 2448 | SPEC_RULE_OP1, + 2453, + 2454, 2455 | SPEC_RULE_OP1, - 2460 | SPEC_RULE_OP1, - 2465 | SPEC_RULE_OP1, - 2470 | SPEC_RULE_OP1, - 2475, - 2476 | SPEC_RULE_OP1, - 2481 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2506 | SPEC_RULE_OP1, - 2511 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2536 | SPEC_RULE_OP1, - 2541 | SPEC_RULE_OP1, - 2546, - 3450 + 2460 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2485, + 2486 | SPEC_RULE_OP1, + 2491, + 2492, + 2493, + 2494, + 2495, + 2496, + 2497, + 2498, + 2499 | SPEC_RULE_OP1, + 2504, + 2505, + 2506, + 2507 | SPEC_RULE_OP2, + 2512, + 2513 | SPEC_RULE_OP1, + 2518 | SPEC_RULE_OP1, + 2523 | SPEC_RULE_OP1, + 2528 | SPEC_RULE_OP1, + 2533 | SPEC_RULE_OP1, + 2538, + 2539 | SPEC_RULE_OP1, + 2544 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2569 | SPEC_RULE_OP1, + 2574 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2599 | SPEC_RULE_OP1, + 2604 | SPEC_RULE_OP1, + 2609, + 3513 }; #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID) zend_opcode_handler_funcs = labels; @@ -63521,7 +67645,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 = 2549 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2612 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -63529,7 +67653,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 = 2574 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2637 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -63537,7 +67661,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 = 2599 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2662 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -63548,17 +67672,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 = 2624 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2687 | 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 = 2649 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2712 | 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 = 2674 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2737 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_MUL: @@ -63569,17 +67693,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 = 2699 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2762 | 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 = 2724 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2787 | 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 = 2749 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2812 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_IDENTICAL: @@ -63590,14 +67714,14 @@ 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 = 2774 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2837 | 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 = 2849 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2912 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF))) { - spec = 3074 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3137 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_IDENTICAL: @@ -63608,14 +67732,14 @@ 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 = 2924 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2987 | 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 = 2999 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3062 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF))) { - spec = 3079 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3142 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_EQUAL: @@ -63626,12 +67750,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 = 2774 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2837 | 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 = 2849 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2912 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_EQUAL: @@ -63642,12 +67766,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 = 2924 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2987 | 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 = 2999 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3062 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_SMALLER: @@ -63655,12 +67779,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 = 3084 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3147 | 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 = 3159 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3222 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_IS_SMALLER_OR_EQUAL: @@ -63668,74 +67792,74 @@ 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 = 3234 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3297 | 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 = 3309 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3372 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_QM_ASSIGN: if (op1_info == MAY_BE_LONG) { - spec = 3396 | SPEC_RULE_OP1; + spec = 3459 | SPEC_RULE_OP1; } else if (op1_info == MAY_BE_DOUBLE) { - spec = 3401 | SPEC_RULE_OP1; + spec = 3464 | 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 = 3406 | SPEC_RULE_OP1; + spec = 3469 | SPEC_RULE_OP1; } break; case ZEND_PRE_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3384 | SPEC_RULE_RETVAL; + spec = 3447 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3386 | SPEC_RULE_RETVAL; + spec = 3449 | SPEC_RULE_RETVAL; } break; case ZEND_PRE_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3388 | SPEC_RULE_RETVAL; + spec = 3451 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3390 | SPEC_RULE_RETVAL; + spec = 3453 | SPEC_RULE_RETVAL; } break; case ZEND_POST_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3392; + spec = 3455; } else if (op1_info == MAY_BE_LONG) { - spec = 3393; + spec = 3456; } break; case ZEND_POST_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3394; + spec = 3457; } else if (op1_info == MAY_BE_LONG) { - spec = 3395; + spec = 3458; } break; case ZEND_JMP: if (OP_JMP_ADDR(op, op->op1) > op) { - spec = 2548; + spec = 2611; } break; case ZEND_RECV: if (op->op2.num == MAY_BE_ANY) { - spec = 2547; + spec = 2610; } break; case ZEND_SEND_VAL: if (op->op1_type == IS_CONST && op->op2_type == IS_UNUSED && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3446; + spec = 3509; } break; case ZEND_SEND_VAR_EX: if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3441 | SPEC_RULE_OP1; + spec = 3504 | 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 = 3448 | SPEC_RULE_RETVAL; + spec = 3511 | SPEC_RULE_RETVAL; } break; case ZEND_FETCH_DIM_R: @@ -63743,17 +67867,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 = 3411 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 3474 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_SEND_VAL_EX: if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3447; + spec = 3510; } break; case ZEND_SEND_VAR: if (op->op2_type == IS_UNUSED && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3436 | SPEC_RULE_OP1; + spec = 3499 | SPEC_RULE_OP1; } break; case ZEND_BW_OR: diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h index 26995d3d49c61..a7514bb7a3afe 100644 --- a/Zend/zend_vm_handlers.h +++ b/Zend/zend_vm_handlers.h @@ -635,1215 +635,1260 @@ _(1347, ZEND_BEGIN_SILENCE_SPEC) \ _(1348, ZEND_END_SILENCE_SPEC_TMP) \ _(1349, ZEND_INIT_FCALL_BY_NAME_SPEC_CONST) \ - _(1350, ZEND_DO_FCALL_SPEC_RETVAL_UNUSED) \ - _(1351, ZEND_DO_FCALL_SPEC_RETVAL_USED) \ - _(1352, ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_OBSERVER) \ - _(1353, ZEND_DO_FCALL_SPEC_RETVAL_USED_OBSERVER) \ - _(1354, ZEND_INIT_FCALL_SPEC_CONST) \ - _(1355, ZEND_RETURN_SPEC_CONST) \ - _(1356, ZEND_RETURN_SPEC_CONST_OBSERVER) \ - _(1357, ZEND_RETURN_SPEC_TMP) \ - _(1358, ZEND_RETURN_SPEC_TMP_OBSERVER) \ - _(1359, ZEND_RETURN_SPEC_VAR) \ - _(1360, ZEND_RETURN_SPEC_VAR_OBSERVER) \ - _(1363, ZEND_RETURN_SPEC_CV) \ - _(1364, ZEND_RETURN_SPEC_CV_OBSERVER) \ - _(1365, ZEND_RECV_SPEC_UNUSED) \ - _(1366, ZEND_RECV_INIT_SPEC_CONST) \ - _(1367, ZEND_SEND_VAL_SPEC_CONST_CONST) \ - _(1370, ZEND_SEND_VAL_SPEC_CONST_UNUSED) \ - _(1372, ZEND_SEND_VAL_SPEC_TMPVAR_CONST) \ - _(1375, ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED) \ - _(1377, ZEND_SEND_VAL_SPEC_TMPVAR_CONST) \ - _(1380, ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED) \ - _(1412, ZEND_SEND_VAR_EX_SPEC_VAR_CONST) \ - _(1413, ZEND_SEND_VAR_EX_SPEC_VAR_CONST) \ - _(1418, ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED) \ - _(1419, ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK) \ - _(1432, ZEND_SEND_VAR_EX_SPEC_CV_CONST) \ - _(1433, ZEND_SEND_VAR_EX_SPEC_CV_CONST) \ - _(1438, ZEND_SEND_VAR_EX_SPEC_CV_UNUSED) \ - _(1439, ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK) \ - _(1452, ZEND_SEND_REF_SPEC_VAR_CONST) \ - _(1455, ZEND_SEND_REF_SPEC_VAR_UNUSED) \ - _(1462, ZEND_SEND_REF_SPEC_CV_CONST) \ - _(1465, ZEND_SEND_REF_SPEC_CV_UNUSED) \ - _(1467, ZEND_NEW_SPEC_CONST_UNUSED) \ - _(1469, ZEND_NEW_SPEC_VAR_UNUSED) \ - _(1470, ZEND_NEW_SPEC_UNUSED_UNUSED) \ - _(1472, ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST) \ - _(1473, ZEND_FREE_SPEC_TMPVAR) \ - _(1474, ZEND_INIT_ARRAY_SPEC_CONST_CONST) \ - _(1475, ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR) \ - _(1476, ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR) \ - _(1477, ZEND_INIT_ARRAY_SPEC_CONST_UNUSED) \ - _(1478, ZEND_INIT_ARRAY_SPEC_CONST_CV) \ - _(1479, ZEND_INIT_ARRAY_SPEC_TMP_CONST) \ - _(1480, ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR) \ - _(1481, ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR) \ - _(1482, ZEND_INIT_ARRAY_SPEC_TMP_UNUSED) \ - _(1483, ZEND_INIT_ARRAY_SPEC_TMP_CV) \ - _(1484, ZEND_INIT_ARRAY_SPEC_VAR_CONST) \ - _(1485, ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR) \ - _(1486, ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR) \ - _(1487, ZEND_INIT_ARRAY_SPEC_VAR_UNUSED) \ - _(1488, ZEND_INIT_ARRAY_SPEC_VAR_CV) \ - _(1489, ZEND_INIT_ARRAY_SPEC_UNUSED_CONST) \ - _(1490, ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR) \ - _(1491, ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR) \ - _(1492, ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED) \ - _(1493, ZEND_INIT_ARRAY_SPEC_UNUSED_CV) \ - _(1494, ZEND_INIT_ARRAY_SPEC_CV_CONST) \ - _(1495, ZEND_INIT_ARRAY_SPEC_CV_TMPVAR) \ - _(1496, ZEND_INIT_ARRAY_SPEC_CV_TMPVAR) \ - _(1497, ZEND_INIT_ARRAY_SPEC_CV_UNUSED) \ - _(1498, ZEND_INIT_ARRAY_SPEC_CV_CV) \ - _(1499, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST) \ - _(1500, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR) \ - _(1501, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR) \ - _(1502, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED) \ - _(1503, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV) \ - _(1504, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST) \ - _(1505, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR) \ - _(1506, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR) \ - _(1507, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED) \ - _(1508, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV) \ - _(1509, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST) \ - _(1510, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR) \ - _(1511, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR) \ - _(1512, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED) \ - _(1513, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV) \ - _(1519, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST) \ - _(1520, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR) \ - _(1521, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR) \ - _(1522, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED) \ - _(1523, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV) \ - _(1524, ZEND_INCLUDE_OR_EVAL_SPEC_CONST) \ - _(1525, ZEND_INCLUDE_OR_EVAL_SPEC_CONST_OBSERVER) \ - _(1526, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR) \ - _(1527, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_OBSERVER) \ - _(1528, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR) \ - _(1529, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_OBSERVER) \ - _(1532, ZEND_INCLUDE_OR_EVAL_SPEC_CV) \ - _(1533, ZEND_INCLUDE_OR_EVAL_SPEC_CV_OBSERVER) \ - _(1534, ZEND_UNSET_VAR_SPEC_CONST_UNUSED) \ - _(1535, ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED) \ - _(1536, ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED) \ - _(1538, ZEND_UNSET_VAR_SPEC_CV_UNUSED) \ - _(1549, ZEND_UNSET_DIM_SPEC_VAR_CONST) \ - _(1550, ZEND_UNSET_DIM_SPEC_VAR_TMPVAR) \ - _(1551, ZEND_UNSET_DIM_SPEC_VAR_TMPVAR) \ - _(1553, ZEND_UNSET_DIM_SPEC_VAR_CV) \ - _(1559, ZEND_UNSET_DIM_SPEC_CV_CONST) \ - _(1560, ZEND_UNSET_DIM_SPEC_CV_TMPVAR) \ - _(1561, ZEND_UNSET_DIM_SPEC_CV_TMPVAR) \ - _(1563, ZEND_UNSET_DIM_SPEC_CV_CV) \ - _(1574, ZEND_UNSET_OBJ_SPEC_VAR_CONST) \ - _(1575, ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR) \ - _(1576, ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR) \ - _(1578, ZEND_UNSET_OBJ_SPEC_VAR_CV) \ - _(1579, ZEND_UNSET_OBJ_SPEC_UNUSED_CONST) \ - _(1580, ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR) \ - _(1581, ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR) \ - _(1583, ZEND_UNSET_OBJ_SPEC_UNUSED_CV) \ - _(1584, ZEND_UNSET_OBJ_SPEC_CV_CONST) \ - _(1585, ZEND_UNSET_OBJ_SPEC_CV_TMPVAR) \ - _(1586, ZEND_UNSET_OBJ_SPEC_CV_TMPVAR) \ - _(1588, ZEND_UNSET_OBJ_SPEC_CV_CV) \ - _(1589, ZEND_FE_RESET_R_SPEC_CONST) \ - _(1590, ZEND_FE_RESET_R_SPEC_TMP) \ - _(1591, ZEND_FE_RESET_R_SPEC_VAR) \ - _(1593, ZEND_FE_RESET_R_SPEC_CV) \ - _(1594, ZEND_FE_FETCH_R_SPEC_VAR) \ - _(1595, ZEND_EXIT_SPEC) \ - _(1596, ZEND_FETCH_R_SPEC_CONST_UNUSED) \ - _(1597, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \ - _(1598, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \ - _(1600, ZEND_FETCH_R_SPEC_CV_UNUSED) \ - _(1601, ZEND_FETCH_DIM_R_SPEC_CONST_CONST) \ - _(1602, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \ - _(1603, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \ - _(1605, ZEND_FETCH_DIM_R_SPEC_CONST_CV) \ - _(1606, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \ - _(1607, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ - _(1608, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ - _(1610, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \ - _(1611, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \ - _(1612, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ - _(1613, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ - _(1615, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \ - _(1621, ZEND_FETCH_DIM_R_SPEC_CV_CONST) \ - _(1622, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \ - _(1623, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \ - _(1625, ZEND_FETCH_DIM_R_SPEC_CV_CV) \ - _(1626, ZEND_FETCH_OBJ_R_SPEC_CONST_CONST) \ - _(1627, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \ - _(1628, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \ - _(1630, ZEND_FETCH_OBJ_R_SPEC_CONST_CV) \ - _(1631, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \ - _(1632, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ - _(1633, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ - _(1635, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \ - _(1636, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \ - _(1637, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ - _(1638, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ - _(1640, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \ - _(1641, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST) \ - _(1642, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \ - _(1643, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \ - _(1645, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV) \ - _(1646, ZEND_FETCH_OBJ_R_SPEC_CV_CONST) \ - _(1647, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \ - _(1648, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \ - _(1650, ZEND_FETCH_OBJ_R_SPEC_CV_CV) \ - _(1651, ZEND_FETCH_W_SPEC_CONST_UNUSED) \ - _(1652, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \ - _(1653, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \ - _(1655, ZEND_FETCH_W_SPEC_CV_UNUSED) \ - _(1666, ZEND_FETCH_DIM_W_SPEC_VAR_CONST) \ - _(1667, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \ - _(1668, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \ - _(1669, ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED) \ - _(1670, ZEND_FETCH_DIM_W_SPEC_VAR_CV) \ - _(1676, ZEND_FETCH_DIM_W_SPEC_CV_CONST) \ - _(1677, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \ - _(1678, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \ - _(1679, ZEND_FETCH_DIM_W_SPEC_CV_UNUSED) \ - _(1680, ZEND_FETCH_DIM_W_SPEC_CV_CV) \ - _(1691, ZEND_FETCH_OBJ_W_SPEC_VAR_CONST) \ - _(1692, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \ - _(1693, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \ - _(1695, ZEND_FETCH_OBJ_W_SPEC_VAR_CV) \ - _(1696, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST) \ - _(1697, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \ - _(1698, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \ - _(1700, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV) \ - _(1701, ZEND_FETCH_OBJ_W_SPEC_CV_CONST) \ - _(1702, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \ - _(1703, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \ - _(1705, ZEND_FETCH_OBJ_W_SPEC_CV_CV) \ - _(1706, ZEND_FETCH_RW_SPEC_CONST_UNUSED) \ - _(1707, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \ - _(1708, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \ - _(1710, ZEND_FETCH_RW_SPEC_CV_UNUSED) \ - _(1721, ZEND_FETCH_DIM_RW_SPEC_VAR_CONST) \ - _(1722, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \ - _(1723, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \ - _(1724, ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED) \ - _(1725, ZEND_FETCH_DIM_RW_SPEC_VAR_CV) \ - _(1731, ZEND_FETCH_DIM_RW_SPEC_CV_CONST) \ - _(1732, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \ - _(1733, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \ - _(1734, ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED) \ - _(1735, ZEND_FETCH_DIM_RW_SPEC_CV_CV) \ - _(1746, ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST) \ - _(1747, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \ - _(1748, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \ - _(1750, ZEND_FETCH_OBJ_RW_SPEC_VAR_CV) \ - _(1751, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST) \ - _(1752, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \ - _(1753, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \ - _(1755, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV) \ - _(1756, ZEND_FETCH_OBJ_RW_SPEC_CV_CONST) \ - _(1757, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \ - _(1758, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \ - _(1760, ZEND_FETCH_OBJ_RW_SPEC_CV_CV) \ - _(1761, ZEND_FETCH_IS_SPEC_CONST_UNUSED) \ - _(1762, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \ - _(1763, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \ - _(1765, ZEND_FETCH_IS_SPEC_CV_UNUSED) \ - _(1766, ZEND_FETCH_DIM_IS_SPEC_CONST_CONST) \ - _(1767, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \ - _(1768, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \ - _(1770, ZEND_FETCH_DIM_IS_SPEC_CONST_CV) \ - _(1771, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \ - _(1772, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ - _(1773, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ - _(1775, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \ - _(1776, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \ - _(1777, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ - _(1778, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ - _(1780, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \ - _(1786, ZEND_FETCH_DIM_IS_SPEC_CV_CONST) \ - _(1787, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \ - _(1788, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \ - _(1790, ZEND_FETCH_DIM_IS_SPEC_CV_CV) \ - _(1791, ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST) \ - _(1792, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \ - _(1793, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \ - _(1795, ZEND_FETCH_OBJ_IS_SPEC_CONST_CV) \ - _(1796, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \ - _(1797, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ - _(1798, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ - _(1800, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \ - _(1801, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \ - _(1802, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ - _(1803, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ - _(1805, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \ - _(1806, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST) \ - _(1807, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \ - _(1808, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \ - _(1810, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV) \ - _(1811, ZEND_FETCH_OBJ_IS_SPEC_CV_CONST) \ - _(1812, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \ - _(1813, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \ - _(1815, ZEND_FETCH_OBJ_IS_SPEC_CV_CV) \ - _(1816, ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED) \ - _(1817, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \ - _(1818, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \ - _(1820, ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED) \ - _(1821, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST) \ - _(1822, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \ - _(1823, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \ - _(1824, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED) \ - _(1825, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV) \ - _(1826, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST) \ - _(1827, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \ - _(1828, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \ - _(1829, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED) \ - _(1830, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV) \ - _(1831, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST) \ - _(1832, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \ - _(1833, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \ - _(1834, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED) \ - _(1835, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV) \ - _(1841, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST) \ - _(1842, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \ - _(1843, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \ - _(1844, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED) \ - _(1845, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV) \ - _(1846, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST) \ - _(1847, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \ - _(1848, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \ - _(1850, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV) \ - _(1851, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST) \ - _(1852, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \ - _(1853, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \ - _(1855, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV) \ - _(1856, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST) \ - _(1857, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \ - _(1858, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \ - _(1860, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV) \ - _(1861, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST) \ - _(1862, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \ - _(1863, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \ - _(1865, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV) \ - _(1866, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST) \ - _(1867, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \ - _(1868, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \ - _(1870, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV) \ - _(1871, ZEND_FETCH_UNSET_SPEC_CONST_UNUSED) \ - _(1872, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \ - _(1873, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \ - _(1875, ZEND_FETCH_UNSET_SPEC_CV_UNUSED) \ - _(1886, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST) \ - _(1887, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \ - _(1888, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \ - _(1890, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV) \ - _(1896, ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST) \ - _(1897, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \ - _(1898, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \ - _(1900, ZEND_FETCH_DIM_UNSET_SPEC_CV_CV) \ - _(1911, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST) \ - _(1912, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \ - _(1913, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \ - _(1915, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV) \ - _(1916, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST) \ - _(1917, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \ - _(1918, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \ - _(1920, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV) \ - _(1921, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST) \ - _(1922, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \ - _(1923, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \ - _(1925, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV) \ - _(1926, ZEND_FETCH_LIST_R_SPEC_CONST_CONST) \ - _(1927, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \ - _(1928, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \ - _(1930, ZEND_FETCH_LIST_R_SPEC_CONST_CV) \ - _(1931, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ - _(1932, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1933, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1935, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ - _(1936, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ - _(1937, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1938, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1940, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ - _(1946, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ - _(1947, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1948, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1950, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ - _(1951, ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST) \ - _(1952, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST) \ - _(1953, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST) \ - _(1958, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED) \ - _(1959, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK) \ - _(1962, ZEND_EXT_STMT_SPEC) \ - _(1963, ZEND_EXT_FCALL_BEGIN_SPEC) \ - _(1964, ZEND_EXT_FCALL_END_SPEC) \ - _(1965, ZEND_EXT_NOP_SPEC) \ - _(1966, ZEND_TICKS_SPEC) \ - _(1967, ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST) \ - _(1970, ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED) \ - _(1972, ZEND_CATCH_SPEC_CONST) \ - _(1973, ZEND_THROW_SPEC_CONST) \ - _(1974, ZEND_THROW_SPEC_TMPVAR) \ - _(1975, ZEND_THROW_SPEC_TMPVAR) \ - _(1977, ZEND_THROW_SPEC_CV) \ - _(1978, ZEND_FETCH_CLASS_SPEC_UNUSED_CONST) \ - _(1979, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \ - _(1980, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \ - _(1981, ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED) \ - _(1982, ZEND_FETCH_CLASS_SPEC_UNUSED_CV) \ - _(1983, ZEND_CLONE_SPEC_CONST) \ - _(1984, ZEND_CLONE_SPEC_TMPVAR) \ - _(1985, ZEND_CLONE_SPEC_TMPVAR) \ - _(1986, ZEND_CLONE_SPEC_UNUSED) \ - _(1987, ZEND_CLONE_SPEC_CV) \ - _(1988, ZEND_RETURN_BY_REF_SPEC_CONST) \ - _(1989, ZEND_RETURN_BY_REF_SPEC_CONST_OBSERVER) \ - _(1990, ZEND_RETURN_BY_REF_SPEC_TMP) \ - _(1991, ZEND_RETURN_BY_REF_SPEC_TMP_OBSERVER) \ - _(1992, ZEND_RETURN_BY_REF_SPEC_VAR) \ - _(1993, ZEND_RETURN_BY_REF_SPEC_VAR_OBSERVER) \ - _(1996, ZEND_RETURN_BY_REF_SPEC_CV) \ - _(1997, ZEND_RETURN_BY_REF_SPEC_CV_OBSERVER) \ - _(1998, ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST) \ - _(1999, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \ - _(2000, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \ - _(2002, ZEND_INIT_METHOD_CALL_SPEC_CONST_CV) \ - _(2003, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \ - _(2004, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ - _(2005, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ - _(2007, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \ - _(2008, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \ - _(2009, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ - _(2010, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ - _(2012, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \ - _(2013, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST) \ - _(2014, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ - _(2015, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ - _(2017, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV) \ - _(2018, ZEND_INIT_METHOD_CALL_SPEC_CV_CONST) \ - _(2019, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \ - _(2020, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \ - _(2022, ZEND_INIT_METHOD_CALL_SPEC_CV_CV) \ - _(2023, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST) \ - _(2024, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \ - _(2025, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \ - _(2026, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED) \ - _(2027, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV) \ - _(2033, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST) \ - _(2034, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \ - _(2035, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \ - _(2036, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED) \ - _(2037, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV) \ - _(2038, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST) \ - _(2039, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ - _(2040, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ - _(2041, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED) \ - _(2042, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV) \ - _(2048, ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED) \ - _(2049, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \ - _(2050, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \ - _(2052, ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED) \ - _(2053, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST) \ - _(2054, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \ - _(2055, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \ - _(2057, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV) \ - _(2058, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \ - _(2059, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2060, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2062, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \ - _(2063, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \ - _(2064, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2065, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2067, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \ - _(2073, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST) \ - _(2074, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \ - _(2075, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \ - _(2077, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV) \ - _(2078, ZEND_SEND_VAL_EX_SPEC_CONST_CONST) \ - _(2079, ZEND_SEND_VAL_EX_SPEC_CONST_CONST) \ - _(2084, ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED) \ - _(2085, ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK) \ - _(2088, ZEND_SEND_VAL_EX_SPEC_TMP_CONST) \ - _(2089, ZEND_SEND_VAL_EX_SPEC_TMP_CONST) \ - _(2094, ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED) \ - _(2095, ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK) \ - _(2138, ZEND_SEND_VAR_SPEC_VAR_CONST) \ - _(2141, ZEND_SEND_VAR_SPEC_VAR_UNUSED) \ - _(2148, ZEND_SEND_VAR_SPEC_CV_CONST) \ - _(2151, ZEND_SEND_VAR_SPEC_CV_UNUSED) \ - _(2153, ZEND_INIT_USER_CALL_SPEC_CONST_CONST) \ - _(2154, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \ - _(2155, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \ - _(2157, ZEND_INIT_USER_CALL_SPEC_CONST_CV) \ - _(2158, ZEND_SEND_ARRAY_SPEC) \ - _(2159, ZEND_SEND_USER_SPEC_CONST) \ - _(2160, ZEND_SEND_USER_SPEC_TMP) \ - _(2161, ZEND_SEND_USER_SPEC_VAR) \ - _(2163, ZEND_SEND_USER_SPEC_CV) \ - _(2164, ZEND_STRLEN_SPEC_CONST) \ - _(2165, ZEND_STRLEN_SPEC_TMPVAR) \ - _(2166, ZEND_STRLEN_SPEC_TMPVAR) \ - _(2168, ZEND_STRLEN_SPEC_CV) \ - _(2169, ZEND_DEFINED_SPEC_CONST) \ - _(2170, ZEND_TYPE_CHECK_SPEC_CONST) \ - _(2171, ZEND_TYPE_CHECK_SPEC_TMPVAR) \ - _(2172, ZEND_TYPE_CHECK_SPEC_TMPVAR) \ - _(2174, ZEND_TYPE_CHECK_SPEC_CV) \ - _(2175, ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED) \ - _(2176, ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED) \ - _(2177, ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED) \ - _(2178, ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED) \ - _(2179, ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED) \ - _(2180, ZEND_FE_RESET_RW_SPEC_CONST) \ - _(2181, ZEND_FE_RESET_RW_SPEC_TMP) \ - _(2182, ZEND_FE_RESET_RW_SPEC_VAR) \ - _(2184, ZEND_FE_RESET_RW_SPEC_CV) \ - _(2185, ZEND_FE_FETCH_RW_SPEC_VAR) \ - _(2186, ZEND_FE_FREE_SPEC_TMPVAR) \ - _(2187, ZEND_INIT_DYNAMIC_CALL_SPEC_CONST) \ - _(2188, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \ - _(2189, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \ - _(2191, ZEND_INIT_DYNAMIC_CALL_SPEC_CV) \ - _(2192, ZEND_DO_ICALL_SPEC_RETVAL_UNUSED) \ - _(2193, ZEND_DO_ICALL_SPEC_RETVAL_USED) \ - _(2194, ZEND_DO_UCALL_SPEC_RETVAL_UNUSED) \ - _(2195, ZEND_DO_UCALL_SPEC_RETVAL_USED) \ - _(2196, ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_OBSERVER) \ - _(2197, ZEND_DO_UCALL_SPEC_RETVAL_USED_OBSERVER) \ - _(2198, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED) \ - _(2199, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED) \ - _(2200, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_OBSERVER) \ - _(2201, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_OBSERVER) \ - _(2212, ZEND_PRE_INC_OBJ_SPEC_VAR_CONST) \ - _(2213, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \ - _(2214, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \ - _(2216, ZEND_PRE_INC_OBJ_SPEC_VAR_CV) \ - _(2217, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST) \ - _(2218, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2219, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2221, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV) \ - _(2222, ZEND_PRE_INC_OBJ_SPEC_CV_CONST) \ - _(2223, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \ - _(2224, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \ - _(2226, ZEND_PRE_INC_OBJ_SPEC_CV_CV) \ - _(2237, ZEND_POST_INC_OBJ_SPEC_VAR_CONST) \ - _(2238, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \ - _(2239, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \ - _(2241, ZEND_POST_INC_OBJ_SPEC_VAR_CV) \ - _(2242, ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST) \ - _(2243, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2244, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2246, ZEND_POST_INC_OBJ_SPEC_UNUSED_CV) \ - _(2247, ZEND_POST_INC_OBJ_SPEC_CV_CONST) \ - _(2248, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \ - _(2249, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \ - _(2251, ZEND_POST_INC_OBJ_SPEC_CV_CV) \ - _(2252, ZEND_ECHO_SPEC_CONST) \ - _(2253, ZEND_ECHO_SPEC_TMPVAR) \ - _(2254, ZEND_ECHO_SPEC_TMPVAR) \ - _(2256, ZEND_ECHO_SPEC_CV) \ - _(2263, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \ - _(2265, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \ - _(2266, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \ - _(2268, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \ - _(2270, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \ - _(2271, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \ - _(2278, ZEND_INSTANCEOF_SPEC_CV_CONST) \ - _(2280, ZEND_INSTANCEOF_SPEC_CV_VAR) \ - _(2281, ZEND_INSTANCEOF_SPEC_CV_UNUSED) \ - _(2283, ZEND_GENERATOR_CREATE_SPEC) \ - _(2286, ZEND_MAKE_REF_SPEC_VAR_UNUSED) \ - _(2288, ZEND_MAKE_REF_SPEC_CV_UNUSED) \ - _(2289, ZEND_DECLARE_FUNCTION_SPEC) \ - _(2290, ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED) \ - _(2291, ZEND_DECLARE_CONST_SPEC_CONST_CONST) \ - _(2292, ZEND_DECLARE_CLASS_SPEC_CONST) \ - _(2293, ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST) \ - _(2294, ZEND_DECLARE_ANON_CLASS_SPEC) \ - _(2295, ZEND_ADD_ARRAY_UNPACK_SPEC) \ - _(2296, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST) \ - _(2297, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \ - _(2298, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \ - _(2300, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV) \ - _(2301, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ - _(2302, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2303, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2305, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ - _(2306, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ - _(2307, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2308, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2310, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ - _(2311, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST) \ - _(2312, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2313, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2315, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV) \ - _(2316, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST) \ - _(2317, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ - _(2318, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ - _(2320, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV) \ - _(2321, ZEND_HANDLE_EXCEPTION_SPEC) \ - _(2322, ZEND_USER_OPCODE_SPEC) \ - _(2323, ZEND_ASSERT_CHECK_SPEC) \ - _(2324, ZEND_JMP_SET_SPEC_CONST) \ - _(2325, ZEND_JMP_SET_SPEC_TMP) \ - _(2326, ZEND_JMP_SET_SPEC_VAR) \ - _(2328, ZEND_JMP_SET_SPEC_CV) \ - _(2329, ZEND_UNSET_CV_SPEC_CV_UNUSED) \ - _(2330, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET) \ - _(2331, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY) \ - _(2332, ZEND_FETCH_LIST_W_SPEC_VAR_CONST) \ - _(2333, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ - _(2334, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ - _(2336, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \ - _(2337, ZEND_SEPARATE_SPEC_VAR_UNUSED) \ - _(2339, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \ - _(2340, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \ - _(2341, ZEND_FETCH_CLASS_NAME_SPEC_UNUSED) \ - _(2342, ZEND_FETCH_CLASS_NAME_SPEC_CV) \ - _(2343, ZEND_CALL_TRAMPOLINE_SPEC) \ - _(2344, ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER) \ - _(2345, ZEND_DISCARD_EXCEPTION_SPEC) \ - _(2346, ZEND_YIELD_SPEC_CONST_CONST) \ - _(2347, ZEND_YIELD_SPEC_CONST_TMPVAR) \ - _(2348, ZEND_YIELD_SPEC_CONST_TMPVAR) \ - _(2349, ZEND_YIELD_SPEC_CONST_UNUSED) \ - _(2350, ZEND_YIELD_SPEC_CONST_CV) \ - _(2351, ZEND_YIELD_SPEC_TMP_CONST) \ - _(2352, ZEND_YIELD_SPEC_TMP_TMPVAR) \ - _(2353, ZEND_YIELD_SPEC_TMP_TMPVAR) \ - _(2354, ZEND_YIELD_SPEC_TMP_UNUSED) \ - _(2355, ZEND_YIELD_SPEC_TMP_CV) \ - _(2356, ZEND_YIELD_SPEC_VAR_CONST) \ - _(2357, ZEND_YIELD_SPEC_VAR_TMPVAR) \ - _(2358, ZEND_YIELD_SPEC_VAR_TMPVAR) \ - _(2359, ZEND_YIELD_SPEC_VAR_UNUSED) \ - _(2360, ZEND_YIELD_SPEC_VAR_CV) \ - _(2361, ZEND_YIELD_SPEC_UNUSED_CONST) \ - _(2362, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \ - _(2363, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \ - _(2364, ZEND_YIELD_SPEC_UNUSED_UNUSED) \ - _(2365, ZEND_YIELD_SPEC_UNUSED_CV) \ - _(2366, ZEND_YIELD_SPEC_CV_CONST) \ - _(2367, ZEND_YIELD_SPEC_CV_TMPVAR) \ - _(2368, ZEND_YIELD_SPEC_CV_TMPVAR) \ - _(2369, ZEND_YIELD_SPEC_CV_UNUSED) \ - _(2370, ZEND_YIELD_SPEC_CV_CV) \ - _(2371, ZEND_GENERATOR_RETURN_SPEC_CONST) \ - _(2372, ZEND_GENERATOR_RETURN_SPEC_CONST_OBSERVER) \ - _(2373, ZEND_GENERATOR_RETURN_SPEC_TMP) \ - _(2374, ZEND_GENERATOR_RETURN_SPEC_TMP_OBSERVER) \ - _(2375, ZEND_GENERATOR_RETURN_SPEC_VAR) \ - _(2376, ZEND_GENERATOR_RETURN_SPEC_VAR_OBSERVER) \ - _(2379, ZEND_GENERATOR_RETURN_SPEC_CV) \ - _(2380, ZEND_GENERATOR_RETURN_SPEC_CV_OBSERVER) \ - _(2381, ZEND_FAST_CALL_SPEC) \ - _(2382, ZEND_FAST_RET_SPEC) \ - _(2383, ZEND_RECV_VARIADIC_SPEC_UNUSED) \ - _(2384, ZEND_SEND_UNPACK_SPEC) \ - _(2385, ZEND_YIELD_FROM_SPEC_CONST) \ - _(2386, ZEND_YIELD_FROM_SPEC_TMPVAR) \ - _(2387, ZEND_YIELD_FROM_SPEC_TMPVAR) \ - _(2389, ZEND_YIELD_FROM_SPEC_CV) \ - _(2390, ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED) \ - _(2391, ZEND_BIND_GLOBAL_SPEC_CV_CONST) \ - _(2392, ZEND_COALESCE_SPEC_CONST) \ - _(2393, ZEND_COALESCE_SPEC_TMP) \ - _(2394, ZEND_COALESCE_SPEC_VAR) \ - _(2396, ZEND_COALESCE_SPEC_CV) \ - _(2397, ZEND_SPACESHIP_SPEC_CONST_CONST) \ - _(2398, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ - _(2399, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ - _(2401, ZEND_SPACESHIP_SPEC_CONST_CV) \ - _(2402, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ - _(2403, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(2404, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(2406, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ - _(2407, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ - _(2408, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(2409, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(2411, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ - _(2417, ZEND_SPACESHIP_SPEC_CV_CONST) \ - _(2418, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ - _(2419, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ - _(2421, ZEND_SPACESHIP_SPEC_CV_CV) \ - _(2422, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED) \ - _(2423, ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED) \ - _(2426, ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED) \ - _(2428, ZEND_FETCH_STATIC_PROP_R_SPEC) \ - _(2429, ZEND_FETCH_STATIC_PROP_W_SPEC) \ - _(2430, ZEND_FETCH_STATIC_PROP_RW_SPEC) \ - _(2431, ZEND_FETCH_STATIC_PROP_IS_SPEC) \ - _(2432, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC) \ - _(2433, ZEND_FETCH_STATIC_PROP_UNSET_SPEC) \ - _(2434, ZEND_UNSET_STATIC_PROP_SPEC) \ - _(2435, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC) \ - _(2436, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) \ - _(2438, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) \ - _(2439, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST) \ - _(2441, ZEND_BIND_LEXICAL_SPEC_TMP_CV) \ - _(2442, ZEND_BIND_STATIC_SPEC_CV_UNUSED) \ - _(2443, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED) \ - _(2444, ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST) \ - _(2447, ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED) \ - _(2449, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED) \ - _(2450, ZEND_SWITCH_LONG_SPEC_CONST_CONST) \ - _(2451, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(2452, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(2454, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(2455, ZEND_SWITCH_STRING_SPEC_CONST_CONST) \ - _(2456, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(2457, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(2459, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(2460, ZEND_IN_ARRAY_SPEC_CONST_CONST) \ - _(2461, ZEND_IN_ARRAY_SPEC_TMP_CONST) \ - _(2462, ZEND_IN_ARRAY_SPEC_VAR_CONST) \ - _(2464, ZEND_IN_ARRAY_SPEC_CV_CONST) \ - _(2465, ZEND_COUNT_SPEC_CONST_UNUSED) \ - _(2466, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \ - _(2467, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \ - _(2469, ZEND_COUNT_SPEC_CV_UNUSED) \ - _(2470, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \ - _(2471, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \ - _(2472, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \ - _(2473, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED) \ - _(2474, ZEND_GET_CLASS_SPEC_CV_UNUSED) \ - _(2475, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED) \ - _(2476, ZEND_GET_TYPE_SPEC_CONST_UNUSED) \ - _(2477, ZEND_GET_TYPE_SPEC_TMP_UNUSED) \ - _(2478, ZEND_GET_TYPE_SPEC_VAR_UNUSED) \ - _(2480, ZEND_GET_TYPE_SPEC_CV_UNUSED) \ - _(2481, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \ - _(2482, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ - _(2483, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ - _(2485, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \ - _(2486, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ - _(2487, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(2488, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(2490, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ - _(2491, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ - _(2492, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(2493, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(2495, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ - _(2501, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \ - _(2502, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ - _(2503, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ - _(2505, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \ - _(2506, ZEND_MATCH_SPEC_CONST_CONST) \ - _(2507, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ - _(2508, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ - _(2510, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ - _(2516, ZEND_CASE_STRICT_SPEC_TMP_CONST) \ - _(2517, ZEND_CASE_STRICT_SPEC_TMP_TMP) \ - _(2518, ZEND_CASE_STRICT_SPEC_TMP_VAR) \ - _(2520, ZEND_CASE_STRICT_SPEC_TMP_CV) \ - _(2521, ZEND_CASE_STRICT_SPEC_VAR_CONST) \ - _(2522, ZEND_CASE_STRICT_SPEC_VAR_TMP) \ - _(2523, ZEND_CASE_STRICT_SPEC_VAR_VAR) \ - _(2525, ZEND_CASE_STRICT_SPEC_VAR_CV) \ - _(2536, ZEND_MATCH_ERROR_SPEC_CONST_UNUSED) \ - _(2537, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ - _(2538, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ - _(2540, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ - _(2541, ZEND_JMP_NULL_SPEC_CONST) \ - _(2542, ZEND_JMP_NULL_SPEC_TMPVARCV) \ - _(2543, ZEND_JMP_NULL_SPEC_TMPVARCV) \ - _(2545, ZEND_JMP_NULL_SPEC_TMPVARCV) \ - _(2546, ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED) \ - _(2547, ZEND_RECV_NOTYPE_SPEC) \ - _(2548, ZEND_JMP_FORWARD_SPEC) \ - _(2554, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2555, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2556, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2558, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2559, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2560, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2561, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2563, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2569, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2570, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2571, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2573, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2579, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2580, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2581, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2583, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2584, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2585, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2586, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2588, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2594, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2595, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2596, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2598, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2604, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2605, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2606, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2608, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2609, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2610, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2611, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2613, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2619, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2620, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2621, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2623, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2625, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2626, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2628, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2629, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2630, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2631, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2633, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2634, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2635, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2636, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2638, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2644, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2645, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2646, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2648, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2650, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2651, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2653, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2654, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2655, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2656, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2658, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2659, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2660, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2661, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2663, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2669, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2670, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2671, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2673, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2675, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2676, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2678, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2679, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2680, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2681, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2683, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2684, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2685, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2686, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2688, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2694, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2695, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2696, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2698, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2704, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2705, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2706, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2708, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2709, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2710, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2711, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2713, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2719, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2720, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2721, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2723, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2729, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2730, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2731, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2733, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2734, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2735, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2736, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2738, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2744, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2745, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2746, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2748, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2754, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2755, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2756, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2758, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2759, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2760, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2761, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2763, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2769, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2770, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2771, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2773, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2789, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2790, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2791, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2792, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2793, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2794, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2795, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2796, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2797, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2801, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2802, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2803, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2804, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2805, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2806, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2807, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2808, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2809, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2810, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2811, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2812, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2816, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2817, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2818, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2834, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2835, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2836, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2837, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2838, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2839, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2840, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2841, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2842, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2846, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2847, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2848, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2864, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2865, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2866, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2867, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2868, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2869, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2870, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2871, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2872, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2876, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2877, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2878, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2879, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2880, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2881, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2882, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2883, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2884, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2885, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2886, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2887, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2891, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2892, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2893, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2909, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2910, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2911, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2912, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2913, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2914, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2915, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2916, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2917, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2921, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2922, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2923, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2939, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2940, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2941, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2942, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2943, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2944, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2945, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2946, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2947, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2951, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2952, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2953, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2954, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2955, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2956, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2957, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2958, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2959, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2960, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2961, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2962, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2966, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2967, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2968, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2984, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2985, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2986, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2987, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2988, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2989, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2990, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2991, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2992, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2996, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2997, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2998, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3014, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3015, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3016, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3017, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3018, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3019, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3020, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3021, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3022, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3026, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3027, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3028, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3029, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3030, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3031, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3032, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3033, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3034, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3035, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3036, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3037, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3041, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3042, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3043, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3059, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3060, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3061, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3062, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3063, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3064, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3065, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3066, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3067, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3071, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3072, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3073, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3074, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(3078, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(3079, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(3083, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(3087, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3088, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3089, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3090, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3091, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3092, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3096, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3097, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3098, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3099, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3100, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3101, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3102, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3103, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3104, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3105, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3106, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3107, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3111, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3112, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3113, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3114, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3115, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3116, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3117, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3118, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3119, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3120, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3121, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3122, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3126, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3127, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3128, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3144, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3145, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3146, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3147, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3148, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3149, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3150, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3151, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3152, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3156, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3157, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3158, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3162, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3163, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3164, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3165, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3166, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3167, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3171, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3172, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3173, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3174, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3175, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3176, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3177, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3178, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3179, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3180, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3181, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3182, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3186, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3187, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3188, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3189, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3190, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3191, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3192, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3193, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3194, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3195, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3196, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3197, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3201, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3202, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3203, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3219, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3220, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3221, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3222, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3223, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3224, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3225, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3226, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3227, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3231, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3232, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3233, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3237, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3238, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3239, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3240, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3241, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3242, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3246, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3247, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3248, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3249, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3250, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3251, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3252, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3253, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3254, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3255, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3256, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3257, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3261, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3262, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3263, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3264, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3265, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3266, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3267, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3268, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3269, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3270, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3271, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3272, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3276, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3277, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3278, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3294, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3295, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3296, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3297, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3298, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3299, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3300, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3301, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3302, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3306, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3307, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3308, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3312, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3313, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3314, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3315, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3316, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3317, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3321, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3322, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3323, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3324, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3325, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3326, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3327, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3328, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3329, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3330, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3331, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3332, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3336, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3337, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3338, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3339, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3340, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3341, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3342, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3343, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3344, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3345, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3346, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3347, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3351, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3352, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3353, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3369, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3370, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3371, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3372, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3373, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3374, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3375, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3376, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3377, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3381, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3382, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3383, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3384, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3385, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3386, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3387, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ - _(3388, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3389, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3390, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3391, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ - _(3392, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3393, ZEND_POST_INC_LONG_SPEC_CV) \ - _(3394, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3395, ZEND_POST_DEC_LONG_SPEC_CV) \ - _(3396, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ - _(3397, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3398, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3400, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3401, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ - _(3402, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3403, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3405, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3406, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ - _(3407, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3408, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3410, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3412, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3413, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3415, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3416, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(3417, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3418, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3420, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3421, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(3422, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3423, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3425, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3431, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ - _(3432, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3433, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3435, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3438, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ - _(3440, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ - _(3443, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ - _(3445, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ - _(3446, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ - _(3447, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ - _(3448, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ - _(3449, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ - _(3449+1, ZEND_NULL) + _(1350, ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_OBSERVER) \ + _(1351, ZEND_DO_FCALL_SPEC_RETVAL_UNUSED) \ + _(1352, ZEND_DO_FCALL_SPEC_RETVAL_USED) \ + _(1353, ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_OBSERVER) \ + _(1354, ZEND_DO_FCALL_SPEC_RETVAL_USED_OBSERVER) \ + _(1355, ZEND_INIT_FCALL_SPEC_CONST) \ + _(1356, ZEND_INIT_FCALL_SPEC_CONST_OBSERVER) \ + _(1357, ZEND_RETURN_SPEC_CONST) \ + _(1358, ZEND_RETURN_SPEC_CONST_OBSERVER) \ + _(1359, ZEND_RETURN_SPEC_TMP) \ + _(1360, ZEND_RETURN_SPEC_TMP_OBSERVER) \ + _(1361, ZEND_RETURN_SPEC_VAR) \ + _(1362, ZEND_RETURN_SPEC_VAR_OBSERVER) \ + _(1365, ZEND_RETURN_SPEC_CV) \ + _(1366, ZEND_RETURN_SPEC_CV_OBSERVER) \ + _(1367, ZEND_RECV_SPEC_UNUSED) \ + _(1368, ZEND_RECV_INIT_SPEC_CONST) \ + _(1369, ZEND_SEND_VAL_SPEC_CONST_CONST) \ + _(1372, ZEND_SEND_VAL_SPEC_CONST_UNUSED) \ + _(1374, ZEND_SEND_VAL_SPEC_TMPVAR_CONST) \ + _(1377, ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED) \ + _(1379, ZEND_SEND_VAL_SPEC_TMPVAR_CONST) \ + _(1382, ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED) \ + _(1414, ZEND_SEND_VAR_EX_SPEC_VAR_CONST) \ + _(1415, ZEND_SEND_VAR_EX_SPEC_VAR_CONST) \ + _(1420, ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED) \ + _(1421, ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK) \ + _(1434, ZEND_SEND_VAR_EX_SPEC_CV_CONST) \ + _(1435, ZEND_SEND_VAR_EX_SPEC_CV_CONST) \ + _(1440, ZEND_SEND_VAR_EX_SPEC_CV_UNUSED) \ + _(1441, ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK) \ + _(1454, ZEND_SEND_REF_SPEC_VAR_CONST) \ + _(1457, ZEND_SEND_REF_SPEC_VAR_UNUSED) \ + _(1464, ZEND_SEND_REF_SPEC_CV_CONST) \ + _(1467, ZEND_SEND_REF_SPEC_CV_UNUSED) \ + _(1469, ZEND_NEW_SPEC_CONST_UNUSED) \ + _(1470, ZEND_NEW_SPEC_CONST_UNUSED_OBSERVER) \ + _(1473, ZEND_NEW_SPEC_VAR_UNUSED) \ + _(1474, ZEND_NEW_SPEC_VAR_UNUSED_OBSERVER) \ + _(1475, ZEND_NEW_SPEC_UNUSED_UNUSED) \ + _(1476, ZEND_NEW_SPEC_UNUSED_UNUSED_OBSERVER) \ + _(1479, ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST) \ + _(1480, ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_OBSERVER) \ + _(1481, ZEND_FREE_SPEC_TMPVAR) \ + _(1482, ZEND_INIT_ARRAY_SPEC_CONST_CONST) \ + _(1483, ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR) \ + _(1484, ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR) \ + _(1485, ZEND_INIT_ARRAY_SPEC_CONST_UNUSED) \ + _(1486, ZEND_INIT_ARRAY_SPEC_CONST_CV) \ + _(1487, ZEND_INIT_ARRAY_SPEC_TMP_CONST) \ + _(1488, ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR) \ + _(1489, ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR) \ + _(1490, ZEND_INIT_ARRAY_SPEC_TMP_UNUSED) \ + _(1491, ZEND_INIT_ARRAY_SPEC_TMP_CV) \ + _(1492, ZEND_INIT_ARRAY_SPEC_VAR_CONST) \ + _(1493, ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR) \ + _(1494, ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR) \ + _(1495, ZEND_INIT_ARRAY_SPEC_VAR_UNUSED) \ + _(1496, ZEND_INIT_ARRAY_SPEC_VAR_CV) \ + _(1497, ZEND_INIT_ARRAY_SPEC_UNUSED_CONST) \ + _(1498, ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR) \ + _(1499, ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR) \ + _(1500, ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED) \ + _(1501, ZEND_INIT_ARRAY_SPEC_UNUSED_CV) \ + _(1502, ZEND_INIT_ARRAY_SPEC_CV_CONST) \ + _(1503, ZEND_INIT_ARRAY_SPEC_CV_TMPVAR) \ + _(1504, ZEND_INIT_ARRAY_SPEC_CV_TMPVAR) \ + _(1505, ZEND_INIT_ARRAY_SPEC_CV_UNUSED) \ + _(1506, ZEND_INIT_ARRAY_SPEC_CV_CV) \ + _(1507, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST) \ + _(1508, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR) \ + _(1509, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR) \ + _(1510, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED) \ + _(1511, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV) \ + _(1512, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST) \ + _(1513, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR) \ + _(1514, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR) \ + _(1515, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED) \ + _(1516, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV) \ + _(1517, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST) \ + _(1518, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR) \ + _(1519, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR) \ + _(1520, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED) \ + _(1521, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV) \ + _(1527, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST) \ + _(1528, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR) \ + _(1529, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR) \ + _(1530, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED) \ + _(1531, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV) \ + _(1532, ZEND_INCLUDE_OR_EVAL_SPEC_CONST) \ + _(1533, ZEND_INCLUDE_OR_EVAL_SPEC_CONST_OBSERVER) \ + _(1534, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR) \ + _(1535, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_OBSERVER) \ + _(1536, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR) \ + _(1537, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_OBSERVER) \ + _(1540, ZEND_INCLUDE_OR_EVAL_SPEC_CV) \ + _(1541, ZEND_INCLUDE_OR_EVAL_SPEC_CV_OBSERVER) \ + _(1542, ZEND_UNSET_VAR_SPEC_CONST_UNUSED) \ + _(1543, ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED) \ + _(1544, ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED) \ + _(1546, ZEND_UNSET_VAR_SPEC_CV_UNUSED) \ + _(1557, ZEND_UNSET_DIM_SPEC_VAR_CONST) \ + _(1558, ZEND_UNSET_DIM_SPEC_VAR_TMPVAR) \ + _(1559, ZEND_UNSET_DIM_SPEC_VAR_TMPVAR) \ + _(1561, ZEND_UNSET_DIM_SPEC_VAR_CV) \ + _(1567, ZEND_UNSET_DIM_SPEC_CV_CONST) \ + _(1568, ZEND_UNSET_DIM_SPEC_CV_TMPVAR) \ + _(1569, ZEND_UNSET_DIM_SPEC_CV_TMPVAR) \ + _(1571, ZEND_UNSET_DIM_SPEC_CV_CV) \ + _(1582, ZEND_UNSET_OBJ_SPEC_VAR_CONST) \ + _(1583, ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR) \ + _(1584, ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR) \ + _(1586, ZEND_UNSET_OBJ_SPEC_VAR_CV) \ + _(1587, ZEND_UNSET_OBJ_SPEC_UNUSED_CONST) \ + _(1588, ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR) \ + _(1589, ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR) \ + _(1591, ZEND_UNSET_OBJ_SPEC_UNUSED_CV) \ + _(1592, ZEND_UNSET_OBJ_SPEC_CV_CONST) \ + _(1593, ZEND_UNSET_OBJ_SPEC_CV_TMPVAR) \ + _(1594, ZEND_UNSET_OBJ_SPEC_CV_TMPVAR) \ + _(1596, ZEND_UNSET_OBJ_SPEC_CV_CV) \ + _(1597, ZEND_FE_RESET_R_SPEC_CONST) \ + _(1598, ZEND_FE_RESET_R_SPEC_TMP) \ + _(1599, ZEND_FE_RESET_R_SPEC_VAR) \ + _(1601, ZEND_FE_RESET_R_SPEC_CV) \ + _(1602, ZEND_FE_FETCH_R_SPEC_VAR) \ + _(1603, ZEND_EXIT_SPEC) \ + _(1604, ZEND_FETCH_R_SPEC_CONST_UNUSED) \ + _(1605, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \ + _(1606, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \ + _(1608, ZEND_FETCH_R_SPEC_CV_UNUSED) \ + _(1609, ZEND_FETCH_DIM_R_SPEC_CONST_CONST) \ + _(1610, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \ + _(1611, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \ + _(1613, ZEND_FETCH_DIM_R_SPEC_CONST_CV) \ + _(1614, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \ + _(1615, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ + _(1616, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ + _(1618, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \ + _(1619, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \ + _(1620, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ + _(1621, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ + _(1623, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \ + _(1629, ZEND_FETCH_DIM_R_SPEC_CV_CONST) \ + _(1630, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \ + _(1631, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \ + _(1633, ZEND_FETCH_DIM_R_SPEC_CV_CV) \ + _(1634, ZEND_FETCH_OBJ_R_SPEC_CONST_CONST) \ + _(1635, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \ + _(1636, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \ + _(1638, ZEND_FETCH_OBJ_R_SPEC_CONST_CV) \ + _(1639, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \ + _(1640, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ + _(1641, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ + _(1643, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \ + _(1644, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \ + _(1645, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ + _(1646, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ + _(1648, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \ + _(1649, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST) \ + _(1650, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \ + _(1651, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \ + _(1653, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV) \ + _(1654, ZEND_FETCH_OBJ_R_SPEC_CV_CONST) \ + _(1655, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \ + _(1656, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \ + _(1658, ZEND_FETCH_OBJ_R_SPEC_CV_CV) \ + _(1659, ZEND_FETCH_W_SPEC_CONST_UNUSED) \ + _(1660, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \ + _(1661, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \ + _(1663, ZEND_FETCH_W_SPEC_CV_UNUSED) \ + _(1674, ZEND_FETCH_DIM_W_SPEC_VAR_CONST) \ + _(1675, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \ + _(1676, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \ + _(1677, ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED) \ + _(1678, ZEND_FETCH_DIM_W_SPEC_VAR_CV) \ + _(1684, ZEND_FETCH_DIM_W_SPEC_CV_CONST) \ + _(1685, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \ + _(1686, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \ + _(1687, ZEND_FETCH_DIM_W_SPEC_CV_UNUSED) \ + _(1688, ZEND_FETCH_DIM_W_SPEC_CV_CV) \ + _(1699, ZEND_FETCH_OBJ_W_SPEC_VAR_CONST) \ + _(1700, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \ + _(1701, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \ + _(1703, ZEND_FETCH_OBJ_W_SPEC_VAR_CV) \ + _(1704, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST) \ + _(1705, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \ + _(1706, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \ + _(1708, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV) \ + _(1709, ZEND_FETCH_OBJ_W_SPEC_CV_CONST) \ + _(1710, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \ + _(1711, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \ + _(1713, ZEND_FETCH_OBJ_W_SPEC_CV_CV) \ + _(1714, ZEND_FETCH_RW_SPEC_CONST_UNUSED) \ + _(1715, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \ + _(1716, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \ + _(1718, ZEND_FETCH_RW_SPEC_CV_UNUSED) \ + _(1729, ZEND_FETCH_DIM_RW_SPEC_VAR_CONST) \ + _(1730, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \ + _(1731, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \ + _(1732, ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED) \ + _(1733, ZEND_FETCH_DIM_RW_SPEC_VAR_CV) \ + _(1739, ZEND_FETCH_DIM_RW_SPEC_CV_CONST) \ + _(1740, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \ + _(1741, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \ + _(1742, ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED) \ + _(1743, ZEND_FETCH_DIM_RW_SPEC_CV_CV) \ + _(1754, ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST) \ + _(1755, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \ + _(1756, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \ + _(1758, ZEND_FETCH_OBJ_RW_SPEC_VAR_CV) \ + _(1759, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST) \ + _(1760, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \ + _(1761, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \ + _(1763, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV) \ + _(1764, ZEND_FETCH_OBJ_RW_SPEC_CV_CONST) \ + _(1765, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \ + _(1766, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \ + _(1768, ZEND_FETCH_OBJ_RW_SPEC_CV_CV) \ + _(1769, ZEND_FETCH_IS_SPEC_CONST_UNUSED) \ + _(1770, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \ + _(1771, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \ + _(1773, ZEND_FETCH_IS_SPEC_CV_UNUSED) \ + _(1774, ZEND_FETCH_DIM_IS_SPEC_CONST_CONST) \ + _(1775, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \ + _(1776, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \ + _(1778, ZEND_FETCH_DIM_IS_SPEC_CONST_CV) \ + _(1779, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \ + _(1780, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ + _(1781, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ + _(1783, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \ + _(1784, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \ + _(1785, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ + _(1786, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ + _(1788, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \ + _(1794, ZEND_FETCH_DIM_IS_SPEC_CV_CONST) \ + _(1795, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \ + _(1796, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \ + _(1798, ZEND_FETCH_DIM_IS_SPEC_CV_CV) \ + _(1799, ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST) \ + _(1800, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \ + _(1801, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \ + _(1803, ZEND_FETCH_OBJ_IS_SPEC_CONST_CV) \ + _(1804, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \ + _(1805, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ + _(1806, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ + _(1808, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \ + _(1809, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \ + _(1810, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ + _(1811, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ + _(1813, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \ + _(1814, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST) \ + _(1815, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \ + _(1816, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \ + _(1818, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV) \ + _(1819, ZEND_FETCH_OBJ_IS_SPEC_CV_CONST) \ + _(1820, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \ + _(1821, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \ + _(1823, ZEND_FETCH_OBJ_IS_SPEC_CV_CV) \ + _(1824, ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED) \ + _(1825, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \ + _(1826, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \ + _(1828, ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED) \ + _(1829, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST) \ + _(1830, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \ + _(1831, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \ + _(1832, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED) \ + _(1833, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV) \ + _(1834, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST) \ + _(1835, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \ + _(1836, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \ + _(1837, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED) \ + _(1838, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV) \ + _(1839, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST) \ + _(1840, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \ + _(1841, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \ + _(1842, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED) \ + _(1843, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV) \ + _(1849, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST) \ + _(1850, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \ + _(1851, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \ + _(1852, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED) \ + _(1853, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV) \ + _(1854, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST) \ + _(1855, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \ + _(1856, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \ + _(1858, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV) \ + _(1859, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST) \ + _(1860, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \ + _(1861, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \ + _(1863, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV) \ + _(1864, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST) \ + _(1865, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \ + _(1866, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \ + _(1868, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV) \ + _(1869, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST) \ + _(1870, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \ + _(1871, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \ + _(1873, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV) \ + _(1874, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST) \ + _(1875, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \ + _(1876, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \ + _(1878, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV) \ + _(1879, ZEND_FETCH_UNSET_SPEC_CONST_UNUSED) \ + _(1880, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \ + _(1881, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \ + _(1883, ZEND_FETCH_UNSET_SPEC_CV_UNUSED) \ + _(1894, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST) \ + _(1895, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \ + _(1896, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \ + _(1898, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV) \ + _(1904, ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST) \ + _(1905, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \ + _(1906, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \ + _(1908, ZEND_FETCH_DIM_UNSET_SPEC_CV_CV) \ + _(1919, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST) \ + _(1920, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \ + _(1921, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \ + _(1923, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV) \ + _(1924, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST) \ + _(1925, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \ + _(1926, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \ + _(1928, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV) \ + _(1929, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST) \ + _(1930, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \ + _(1931, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \ + _(1933, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV) \ + _(1934, ZEND_FETCH_LIST_R_SPEC_CONST_CONST) \ + _(1935, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \ + _(1936, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \ + _(1938, ZEND_FETCH_LIST_R_SPEC_CONST_CV) \ + _(1939, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ + _(1940, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ + _(1941, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ + _(1943, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ + _(1944, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ + _(1945, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ + _(1946, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ + _(1948, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ + _(1954, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ + _(1955, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ + _(1956, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ + _(1958, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ + _(1959, ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST) \ + _(1960, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST) \ + _(1961, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST) \ + _(1966, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED) \ + _(1967, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK) \ + _(1970, ZEND_EXT_STMT_SPEC) \ + _(1971, ZEND_EXT_FCALL_BEGIN_SPEC) \ + _(1972, ZEND_EXT_FCALL_END_SPEC) \ + _(1973, ZEND_EXT_NOP_SPEC) \ + _(1974, ZEND_TICKS_SPEC) \ + _(1975, ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST) \ + _(1978, ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED) \ + _(1980, ZEND_CATCH_SPEC_CONST) \ + _(1981, ZEND_THROW_SPEC_CONST) \ + _(1982, ZEND_THROW_SPEC_TMPVAR) \ + _(1983, ZEND_THROW_SPEC_TMPVAR) \ + _(1985, ZEND_THROW_SPEC_CV) \ + _(1986, ZEND_FETCH_CLASS_SPEC_UNUSED_CONST) \ + _(1987, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \ + _(1988, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \ + _(1989, ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED) \ + _(1990, ZEND_FETCH_CLASS_SPEC_UNUSED_CV) \ + _(1991, ZEND_CLONE_SPEC_CONST) \ + _(1992, ZEND_CLONE_SPEC_TMPVAR) \ + _(1993, ZEND_CLONE_SPEC_TMPVAR) \ + _(1994, ZEND_CLONE_SPEC_UNUSED) \ + _(1995, ZEND_CLONE_SPEC_CV) \ + _(1996, ZEND_RETURN_BY_REF_SPEC_CONST) \ + _(1997, ZEND_RETURN_BY_REF_SPEC_CONST_OBSERVER) \ + _(1998, ZEND_RETURN_BY_REF_SPEC_TMP) \ + _(1999, ZEND_RETURN_BY_REF_SPEC_TMP_OBSERVER) \ + _(2000, ZEND_RETURN_BY_REF_SPEC_VAR) \ + _(2001, ZEND_RETURN_BY_REF_SPEC_VAR_OBSERVER) \ + _(2004, ZEND_RETURN_BY_REF_SPEC_CV) \ + _(2005, ZEND_RETURN_BY_REF_SPEC_CV_OBSERVER) \ + _(2006, ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST) \ + _(2007, ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_OBSERVER) \ + _(2008, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \ + _(2009, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_OBSERVER) \ + _(2010, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \ + _(2011, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_OBSERVER) \ + _(2014, ZEND_INIT_METHOD_CALL_SPEC_CONST_CV) \ + _(2015, ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_OBSERVER) \ + _(2016, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \ + _(2017, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_OBSERVER) \ + _(2018, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ + _(2019, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_OBSERVER) \ + _(2020, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ + _(2021, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_OBSERVER) \ + _(2024, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \ + _(2025, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_OBSERVER) \ + _(2026, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \ + _(2027, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_OBSERVER) \ + _(2028, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ + _(2029, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_OBSERVER) \ + _(2030, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ + _(2031, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_OBSERVER) \ + _(2034, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \ + _(2035, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_OBSERVER) \ + _(2036, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST) \ + _(2037, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_OBSERVER) \ + _(2038, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ + _(2039, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_OBSERVER) \ + _(2040, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ + _(2041, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_OBSERVER) \ + _(2044, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV) \ + _(2045, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_OBSERVER) \ + _(2046, ZEND_INIT_METHOD_CALL_SPEC_CV_CONST) \ + _(2047, ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_OBSERVER) \ + _(2048, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \ + _(2049, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_OBSERVER) \ + _(2050, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \ + _(2051, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_OBSERVER) \ + _(2054, ZEND_INIT_METHOD_CALL_SPEC_CV_CV) \ + _(2055, ZEND_INIT_METHOD_CALL_SPEC_CV_CV_OBSERVER) \ + _(2056, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST) \ + _(2057, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_OBSERVER) \ + _(2058, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \ + _(2059, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_OBSERVER) \ + _(2060, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \ + _(2061, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_OBSERVER) \ + _(2062, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED) \ + _(2063, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_OBSERVER) \ + _(2064, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV) \ + _(2065, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_OBSERVER) \ + _(2076, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST) \ + _(2077, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_OBSERVER) \ + _(2078, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \ + _(2079, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_OBSERVER) \ + _(2080, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \ + _(2081, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_OBSERVER) \ + _(2082, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED) \ + _(2083, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_OBSERVER) \ + _(2084, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV) \ + _(2085, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_OBSERVER) \ + _(2086, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST) \ + _(2087, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_OBSERVER) \ + _(2088, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ + _(2089, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_OBSERVER) \ + _(2090, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ + _(2091, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_OBSERVER) \ + _(2092, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED) \ + _(2093, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_OBSERVER) \ + _(2094, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV) \ + _(2095, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_OBSERVER) \ + _(2106, ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED) \ + _(2107, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \ + _(2108, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \ + _(2110, ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED) \ + _(2111, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST) \ + _(2112, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \ + _(2113, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \ + _(2115, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV) \ + _(2116, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \ + _(2117, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2118, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2120, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \ + _(2121, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \ + _(2122, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2123, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2125, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \ + _(2131, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST) \ + _(2132, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \ + _(2133, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \ + _(2135, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV) \ + _(2136, ZEND_SEND_VAL_EX_SPEC_CONST_CONST) \ + _(2137, ZEND_SEND_VAL_EX_SPEC_CONST_CONST) \ + _(2142, ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED) \ + _(2143, ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK) \ + _(2146, ZEND_SEND_VAL_EX_SPEC_TMP_CONST) \ + _(2147, ZEND_SEND_VAL_EX_SPEC_TMP_CONST) \ + _(2152, ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED) \ + _(2153, ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK) \ + _(2196, ZEND_SEND_VAR_SPEC_VAR_CONST) \ + _(2199, ZEND_SEND_VAR_SPEC_VAR_UNUSED) \ + _(2206, ZEND_SEND_VAR_SPEC_CV_CONST) \ + _(2209, ZEND_SEND_VAR_SPEC_CV_UNUSED) \ + _(2211, ZEND_INIT_USER_CALL_SPEC_CONST_CONST) \ + _(2212, ZEND_INIT_USER_CALL_SPEC_CONST_CONST_OBSERVER) \ + _(2213, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \ + _(2214, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_OBSERVER) \ + _(2215, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \ + _(2216, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_OBSERVER) \ + _(2219, ZEND_INIT_USER_CALL_SPEC_CONST_CV) \ + _(2220, ZEND_INIT_USER_CALL_SPEC_CONST_CV_OBSERVER) \ + _(2221, ZEND_SEND_ARRAY_SPEC) \ + _(2222, ZEND_SEND_USER_SPEC_CONST) \ + _(2223, ZEND_SEND_USER_SPEC_TMP) \ + _(2224, ZEND_SEND_USER_SPEC_VAR) \ + _(2226, ZEND_SEND_USER_SPEC_CV) \ + _(2227, ZEND_STRLEN_SPEC_CONST) \ + _(2228, ZEND_STRLEN_SPEC_TMPVAR) \ + _(2229, ZEND_STRLEN_SPEC_TMPVAR) \ + _(2231, ZEND_STRLEN_SPEC_CV) \ + _(2232, ZEND_DEFINED_SPEC_CONST) \ + _(2233, ZEND_TYPE_CHECK_SPEC_CONST) \ + _(2234, ZEND_TYPE_CHECK_SPEC_TMPVAR) \ + _(2235, ZEND_TYPE_CHECK_SPEC_TMPVAR) \ + _(2237, ZEND_TYPE_CHECK_SPEC_CV) \ + _(2238, ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED) \ + _(2239, ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED) \ + _(2240, ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED) \ + _(2241, ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED) \ + _(2242, ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED) \ + _(2243, ZEND_FE_RESET_RW_SPEC_CONST) \ + _(2244, ZEND_FE_RESET_RW_SPEC_TMP) \ + _(2245, ZEND_FE_RESET_RW_SPEC_VAR) \ + _(2247, ZEND_FE_RESET_RW_SPEC_CV) \ + _(2248, ZEND_FE_FETCH_RW_SPEC_VAR) \ + _(2249, ZEND_FE_FREE_SPEC_TMPVAR) \ + _(2250, ZEND_INIT_DYNAMIC_CALL_SPEC_CONST) \ + _(2251, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \ + _(2252, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \ + _(2254, ZEND_INIT_DYNAMIC_CALL_SPEC_CV) \ + _(2255, ZEND_DO_ICALL_SPEC_RETVAL_UNUSED) \ + _(2256, ZEND_DO_ICALL_SPEC_RETVAL_USED) \ + _(2257, ZEND_DO_UCALL_SPEC_RETVAL_UNUSED) \ + _(2258, ZEND_DO_UCALL_SPEC_RETVAL_USED) \ + _(2259, ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_OBSERVER) \ + _(2260, ZEND_DO_UCALL_SPEC_RETVAL_USED_OBSERVER) \ + _(2261, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED) \ + _(2262, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED) \ + _(2263, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_OBSERVER) \ + _(2264, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_OBSERVER) \ + _(2275, ZEND_PRE_INC_OBJ_SPEC_VAR_CONST) \ + _(2276, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \ + _(2277, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \ + _(2279, ZEND_PRE_INC_OBJ_SPEC_VAR_CV) \ + _(2280, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST) \ + _(2281, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2282, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2284, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV) \ + _(2285, ZEND_PRE_INC_OBJ_SPEC_CV_CONST) \ + _(2286, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \ + _(2287, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \ + _(2289, ZEND_PRE_INC_OBJ_SPEC_CV_CV) \ + _(2300, ZEND_POST_INC_OBJ_SPEC_VAR_CONST) \ + _(2301, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \ + _(2302, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \ + _(2304, ZEND_POST_INC_OBJ_SPEC_VAR_CV) \ + _(2305, ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST) \ + _(2306, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2307, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2309, ZEND_POST_INC_OBJ_SPEC_UNUSED_CV) \ + _(2310, ZEND_POST_INC_OBJ_SPEC_CV_CONST) \ + _(2311, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \ + _(2312, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \ + _(2314, ZEND_POST_INC_OBJ_SPEC_CV_CV) \ + _(2315, ZEND_ECHO_SPEC_CONST) \ + _(2316, ZEND_ECHO_SPEC_TMPVAR) \ + _(2317, ZEND_ECHO_SPEC_TMPVAR) \ + _(2319, ZEND_ECHO_SPEC_CV) \ + _(2326, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \ + _(2328, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \ + _(2329, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \ + _(2331, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \ + _(2333, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \ + _(2334, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \ + _(2341, ZEND_INSTANCEOF_SPEC_CV_CONST) \ + _(2343, ZEND_INSTANCEOF_SPEC_CV_VAR) \ + _(2344, ZEND_INSTANCEOF_SPEC_CV_UNUSED) \ + _(2346, ZEND_GENERATOR_CREATE_SPEC) \ + _(2349, ZEND_MAKE_REF_SPEC_VAR_UNUSED) \ + _(2351, ZEND_MAKE_REF_SPEC_CV_UNUSED) \ + _(2352, ZEND_DECLARE_FUNCTION_SPEC) \ + _(2353, ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED) \ + _(2354, ZEND_DECLARE_CONST_SPEC_CONST_CONST) \ + _(2355, ZEND_DECLARE_CLASS_SPEC_CONST) \ + _(2356, ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST) \ + _(2357, ZEND_DECLARE_ANON_CLASS_SPEC) \ + _(2358, ZEND_ADD_ARRAY_UNPACK_SPEC) \ + _(2359, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST) \ + _(2360, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \ + _(2361, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \ + _(2363, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV) \ + _(2364, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ + _(2365, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2366, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2368, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ + _(2369, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ + _(2370, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2371, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2373, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ + _(2374, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST) \ + _(2375, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2376, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2378, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV) \ + _(2379, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST) \ + _(2380, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ + _(2381, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ + _(2383, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV) \ + _(2384, ZEND_HANDLE_EXCEPTION_SPEC) \ + _(2385, ZEND_USER_OPCODE_SPEC) \ + _(2386, ZEND_ASSERT_CHECK_SPEC) \ + _(2387, ZEND_JMP_SET_SPEC_CONST) \ + _(2388, ZEND_JMP_SET_SPEC_TMP) \ + _(2389, ZEND_JMP_SET_SPEC_VAR) \ + _(2391, ZEND_JMP_SET_SPEC_CV) \ + _(2392, ZEND_UNSET_CV_SPEC_CV_UNUSED) \ + _(2393, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET) \ + _(2394, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY) \ + _(2395, ZEND_FETCH_LIST_W_SPEC_VAR_CONST) \ + _(2396, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ + _(2397, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ + _(2399, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \ + _(2400, ZEND_SEPARATE_SPEC_VAR_UNUSED) \ + _(2402, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \ + _(2403, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \ + _(2404, ZEND_FETCH_CLASS_NAME_SPEC_UNUSED) \ + _(2405, ZEND_FETCH_CLASS_NAME_SPEC_CV) \ + _(2406, ZEND_CALL_TRAMPOLINE_SPEC) \ + _(2407, ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER) \ + _(2408, ZEND_DISCARD_EXCEPTION_SPEC) \ + _(2409, ZEND_YIELD_SPEC_CONST_CONST) \ + _(2410, ZEND_YIELD_SPEC_CONST_TMPVAR) \ + _(2411, ZEND_YIELD_SPEC_CONST_TMPVAR) \ + _(2412, ZEND_YIELD_SPEC_CONST_UNUSED) \ + _(2413, ZEND_YIELD_SPEC_CONST_CV) \ + _(2414, ZEND_YIELD_SPEC_TMP_CONST) \ + _(2415, ZEND_YIELD_SPEC_TMP_TMPVAR) \ + _(2416, ZEND_YIELD_SPEC_TMP_TMPVAR) \ + _(2417, ZEND_YIELD_SPEC_TMP_UNUSED) \ + _(2418, ZEND_YIELD_SPEC_TMP_CV) \ + _(2419, ZEND_YIELD_SPEC_VAR_CONST) \ + _(2420, ZEND_YIELD_SPEC_VAR_TMPVAR) \ + _(2421, ZEND_YIELD_SPEC_VAR_TMPVAR) \ + _(2422, ZEND_YIELD_SPEC_VAR_UNUSED) \ + _(2423, ZEND_YIELD_SPEC_VAR_CV) \ + _(2424, ZEND_YIELD_SPEC_UNUSED_CONST) \ + _(2425, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \ + _(2426, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \ + _(2427, ZEND_YIELD_SPEC_UNUSED_UNUSED) \ + _(2428, ZEND_YIELD_SPEC_UNUSED_CV) \ + _(2429, ZEND_YIELD_SPEC_CV_CONST) \ + _(2430, ZEND_YIELD_SPEC_CV_TMPVAR) \ + _(2431, ZEND_YIELD_SPEC_CV_TMPVAR) \ + _(2432, ZEND_YIELD_SPEC_CV_UNUSED) \ + _(2433, ZEND_YIELD_SPEC_CV_CV) \ + _(2434, ZEND_GENERATOR_RETURN_SPEC_CONST) \ + _(2435, ZEND_GENERATOR_RETURN_SPEC_CONST_OBSERVER) \ + _(2436, ZEND_GENERATOR_RETURN_SPEC_TMP) \ + _(2437, ZEND_GENERATOR_RETURN_SPEC_TMP_OBSERVER) \ + _(2438, ZEND_GENERATOR_RETURN_SPEC_VAR) \ + _(2439, ZEND_GENERATOR_RETURN_SPEC_VAR_OBSERVER) \ + _(2442, ZEND_GENERATOR_RETURN_SPEC_CV) \ + _(2443, ZEND_GENERATOR_RETURN_SPEC_CV_OBSERVER) \ + _(2444, ZEND_FAST_CALL_SPEC) \ + _(2445, ZEND_FAST_RET_SPEC) \ + _(2446, ZEND_RECV_VARIADIC_SPEC_UNUSED) \ + _(2447, ZEND_SEND_UNPACK_SPEC) \ + _(2448, ZEND_YIELD_FROM_SPEC_CONST) \ + _(2449, ZEND_YIELD_FROM_SPEC_TMPVAR) \ + _(2450, ZEND_YIELD_FROM_SPEC_TMPVAR) \ + _(2452, ZEND_YIELD_FROM_SPEC_CV) \ + _(2453, ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED) \ + _(2454, ZEND_BIND_GLOBAL_SPEC_CV_CONST) \ + _(2455, ZEND_COALESCE_SPEC_CONST) \ + _(2456, ZEND_COALESCE_SPEC_TMP) \ + _(2457, ZEND_COALESCE_SPEC_VAR) \ + _(2459, ZEND_COALESCE_SPEC_CV) \ + _(2460, ZEND_SPACESHIP_SPEC_CONST_CONST) \ + _(2461, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ + _(2462, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ + _(2464, ZEND_SPACESHIP_SPEC_CONST_CV) \ + _(2465, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ + _(2466, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ + _(2467, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ + _(2469, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ + _(2470, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ + _(2471, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ + _(2472, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ + _(2474, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ + _(2480, ZEND_SPACESHIP_SPEC_CV_CONST) \ + _(2481, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ + _(2482, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ + _(2484, ZEND_SPACESHIP_SPEC_CV_CV) \ + _(2485, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED) \ + _(2486, ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED) \ + _(2489, ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED) \ + _(2491, ZEND_FETCH_STATIC_PROP_R_SPEC) \ + _(2492, ZEND_FETCH_STATIC_PROP_W_SPEC) \ + _(2493, ZEND_FETCH_STATIC_PROP_RW_SPEC) \ + _(2494, ZEND_FETCH_STATIC_PROP_IS_SPEC) \ + _(2495, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC) \ + _(2496, ZEND_FETCH_STATIC_PROP_UNSET_SPEC) \ + _(2497, ZEND_UNSET_STATIC_PROP_SPEC) \ + _(2498, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC) \ + _(2499, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) \ + _(2501, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) \ + _(2502, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST) \ + _(2504, ZEND_BIND_LEXICAL_SPEC_TMP_CV) \ + _(2505, ZEND_BIND_STATIC_SPEC_CV_UNUSED) \ + _(2506, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED) \ + _(2507, ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST) \ + _(2510, ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED) \ + _(2512, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED) \ + _(2513, ZEND_SWITCH_LONG_SPEC_CONST_CONST) \ + _(2514, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(2515, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(2517, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(2518, ZEND_SWITCH_STRING_SPEC_CONST_CONST) \ + _(2519, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(2520, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(2522, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(2523, ZEND_IN_ARRAY_SPEC_CONST_CONST) \ + _(2524, ZEND_IN_ARRAY_SPEC_TMP_CONST) \ + _(2525, ZEND_IN_ARRAY_SPEC_VAR_CONST) \ + _(2527, ZEND_IN_ARRAY_SPEC_CV_CONST) \ + _(2528, ZEND_COUNT_SPEC_CONST_UNUSED) \ + _(2529, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \ + _(2530, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \ + _(2532, ZEND_COUNT_SPEC_CV_UNUSED) \ + _(2533, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \ + _(2534, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \ + _(2535, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \ + _(2536, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED) \ + _(2537, ZEND_GET_CLASS_SPEC_CV_UNUSED) \ + _(2538, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED) \ + _(2539, ZEND_GET_TYPE_SPEC_CONST_UNUSED) \ + _(2540, ZEND_GET_TYPE_SPEC_TMP_UNUSED) \ + _(2541, ZEND_GET_TYPE_SPEC_VAR_UNUSED) \ + _(2543, ZEND_GET_TYPE_SPEC_CV_UNUSED) \ + _(2544, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \ + _(2545, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ + _(2546, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ + _(2548, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \ + _(2549, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ + _(2550, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(2551, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(2553, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ + _(2554, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ + _(2555, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(2556, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(2558, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ + _(2564, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \ + _(2565, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ + _(2566, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ + _(2568, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \ + _(2569, ZEND_MATCH_SPEC_CONST_CONST) \ + _(2570, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ + _(2571, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ + _(2573, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ + _(2579, ZEND_CASE_STRICT_SPEC_TMP_CONST) \ + _(2580, ZEND_CASE_STRICT_SPEC_TMP_TMP) \ + _(2581, ZEND_CASE_STRICT_SPEC_TMP_VAR) \ + _(2583, ZEND_CASE_STRICT_SPEC_TMP_CV) \ + _(2584, ZEND_CASE_STRICT_SPEC_VAR_CONST) \ + _(2585, ZEND_CASE_STRICT_SPEC_VAR_TMP) \ + _(2586, ZEND_CASE_STRICT_SPEC_VAR_VAR) \ + _(2588, ZEND_CASE_STRICT_SPEC_VAR_CV) \ + _(2599, ZEND_MATCH_ERROR_SPEC_CONST_UNUSED) \ + _(2600, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ + _(2601, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ + _(2603, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ + _(2604, ZEND_JMP_NULL_SPEC_CONST) \ + _(2605, ZEND_JMP_NULL_SPEC_TMPVARCV) \ + _(2606, ZEND_JMP_NULL_SPEC_TMPVARCV) \ + _(2608, ZEND_JMP_NULL_SPEC_TMPVARCV) \ + _(2609, ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED) \ + _(2610, ZEND_RECV_NOTYPE_SPEC) \ + _(2611, ZEND_JMP_FORWARD_SPEC) \ + _(2617, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2618, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2619, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2621, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2622, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2623, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2624, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2626, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2632, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2633, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2634, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2636, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2642, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2643, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2644, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2646, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2647, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2648, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2649, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2651, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2657, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2658, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2659, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2661, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2667, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2668, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2669, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2671, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2672, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2673, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2674, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2676, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2682, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2683, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2684, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2686, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2688, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2689, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2691, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2692, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2693, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2694, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2696, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2697, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2698, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2699, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2701, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2707, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2708, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2709, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2711, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2713, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2714, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2716, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2717, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2718, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2719, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2721, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2722, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2723, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2724, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2726, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2732, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2733, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2734, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2736, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2738, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2739, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2741, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2742, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2743, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2744, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2746, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2747, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2748, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2749, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2751, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2757, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2758, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2759, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2761, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2767, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2768, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2769, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2771, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2772, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2773, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2774, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2776, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2782, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2783, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2784, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2786, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2792, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2793, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2794, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2796, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2797, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2798, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2799, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2801, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2807, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2808, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2809, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2811, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2817, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2818, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2819, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2821, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2822, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2823, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2824, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2826, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2832, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2833, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2834, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2836, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2852, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2853, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2854, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2855, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2856, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2857, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2858, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2859, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2860, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2864, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2865, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2866, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2867, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2868, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2869, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2870, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2871, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2872, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2873, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2874, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2875, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2879, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2880, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2881, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2897, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2898, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2899, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2900, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2901, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2902, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2903, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2904, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2905, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2909, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2910, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2911, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2927, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2928, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2929, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2930, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2931, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2932, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2933, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2934, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2935, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2939, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2940, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2941, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2942, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2943, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2944, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2945, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2946, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2947, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2948, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2949, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2950, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2954, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2955, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2956, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2972, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2973, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2974, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2975, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2976, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2977, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2978, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2979, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2980, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2984, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2985, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2986, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3002, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3003, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3004, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3005, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3006, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3007, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3008, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3009, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3010, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3014, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3015, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3016, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3017, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3018, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3019, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3020, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3021, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3022, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3023, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3024, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3025, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3029, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3030, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3031, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3047, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3048, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3049, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3050, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3051, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3052, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3053, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3054, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3055, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3059, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3060, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3061, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3077, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3078, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3079, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3080, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3081, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3082, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3083, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3084, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3085, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3089, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3090, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3091, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3092, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3093, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3094, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3095, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3096, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3097, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3098, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3099, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3100, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3104, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3105, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3106, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3122, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3123, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3124, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3125, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3126, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3127, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3128, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3129, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3130, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3134, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3135, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3136, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3137, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3141, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3142, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3146, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3150, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3151, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3152, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3153, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3154, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3155, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3159, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3160, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3161, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3162, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3163, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3164, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3165, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3166, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3167, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3168, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3169, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3170, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3174, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3175, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3176, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3177, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3178, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3179, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3180, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3181, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3182, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3183, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3184, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3185, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3189, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3190, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3191, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3207, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3208, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3209, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3210, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3211, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3212, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3213, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3214, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3215, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3219, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3220, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3221, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3225, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3226, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3227, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3228, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3229, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3230, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3234, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3235, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3236, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3237, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3238, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3239, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3240, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3241, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3242, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3243, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3244, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3245, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3249, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3250, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3251, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3252, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3253, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3254, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3255, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3256, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3257, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3258, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3259, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3260, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3264, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3265, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3266, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3282, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3283, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3284, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3285, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3286, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3287, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3288, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3289, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3290, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3294, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3295, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3296, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3300, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3301, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3302, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3303, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3304, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3305, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3309, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3310, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3311, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3312, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3313, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3314, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3315, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3316, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3317, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3318, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3319, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3320, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3324, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3325, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3326, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3327, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3328, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3329, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3330, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3331, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3332, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3333, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3334, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3335, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3339, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3340, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3341, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3357, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3358, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3359, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3360, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3361, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3362, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3363, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3364, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3365, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3369, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3370, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3371, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3375, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3376, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3377, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3378, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3379, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3380, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3384, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3385, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3386, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3387, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3388, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3389, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3390, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3391, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3392, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3393, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3394, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3395, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3399, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3400, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3401, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3402, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3403, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3404, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3405, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3406, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3407, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3408, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3409, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3410, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3414, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3415, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3416, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3432, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3433, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3434, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3435, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3436, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3437, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3438, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3439, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3440, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3444, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3445, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3446, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3447, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3448, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3449, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3450, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ + _(3451, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3452, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3453, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3454, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ + _(3455, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3456, ZEND_POST_INC_LONG_SPEC_CV) \ + _(3457, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3458, ZEND_POST_DEC_LONG_SPEC_CV) \ + _(3459, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ + _(3460, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3461, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3463, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3464, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ + _(3465, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3466, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3468, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3469, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ + _(3470, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3471, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3473, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3475, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3476, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3478, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3479, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3480, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3481, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3483, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3484, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3485, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3486, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3488, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3494, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ + _(3495, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3496, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3498, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3501, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ + _(3503, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ + _(3506, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ + _(3508, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ + _(3509, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ + _(3510, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ + _(3511, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ + _(3512, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ + _(3512+1, ZEND_NULL) From 0f78895fd24fed1dc8526b4cabecd2ac5dfec3e5 Mon Sep 17 00:00:00 2001 From: Sammy Powers Date: Wed, 26 Aug 2020 13:45:50 -0700 Subject: [PATCH 35/53] Add test for observing eval --- ext/zend_test/tests/observer_eval_01.phpt | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 ext/zend_test/tests/observer_eval_01.phpt diff --git a/ext/zend_test/tests/observer_eval_01.phpt b/ext/zend_test/tests/observer_eval_01.phpt new file mode 100644 index 0000000000000..a99976b837eba --- /dev/null +++ b/ext/zend_test/tests/observer_eval_01.phpt @@ -0,0 +1,19 @@ +--TEST-- +Observer: Basic eval observability +--INI-- +zend_test.observer.enabled=1 +zend_test.observer.observe_all=1 +--FILE-- + +--EXPECTF-- + + + + + +Foo eval +DONE + From bf56f27b8c864dcb086202238a12a1463b62c166 Mon Sep 17 00:00:00 2001 From: Sammy Powers Date: Wed, 26 Aug 2020 14:16:37 -0700 Subject: [PATCH 36/53] Add SPEC(OBSERVER) to ZEND_HANDLE_EXCEPTION --- Zend/zend_observer.c | 6 + Zend/zend_vm_def.h | 3 +- Zend/zend_vm_execute.h | 221 +-- Zend/zend_vm_handlers.h | 1205 +++++++++-------- ext/zend_test/test.c | 3 + .../tests/observer_exception_01.phpt | 44 + 6 files changed, 799 insertions(+), 683 deletions(-) create mode 100644 ext/zend_test/tests/observer_exception_01.phpt diff --git a/Zend/zend_observer.c b/Zend/zend_observer.c index c8b14ed5949fb..19a61d311a89e 100644 --- a/Zend/zend_observer.c +++ b/Zend/zend_observer.c @@ -45,6 +45,12 @@ ZEND_API void zend_observer_fcall_register(zend_observer_fcall_init init) { * is called before any extensions have registered as an observer. So we * adjust the offset to the observed handler when we know we need to observe. */ ZEND_VM_SET_OPCODE_HANDLER(&EG(call_trampoline_op)); + + /* ZEND_HANDLE_EXCEPTION also has SPEC(OBSERVER) and no observer extensions + * exist when zend_init_exception_op() is called. */ + ZEND_VM_SET_OPCODE_HANDLER(EG(exception_op)); + ZEND_VM_SET_OPCODE_HANDLER(EG(exception_op)+1); + ZEND_VM_SET_OPCODE_HANDLER(EG(exception_op)+2); } zend_llist_add_element(&zend_observers_fcall_list, &init); } diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 266c4207d5a0c..573b727a2d2ab 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -7677,7 +7677,7 @@ ZEND_VM_HELPER(zend_dispatch_try_catch_finally_helper, ANY, ANY, uint32_t try_ca } } -ZEND_VM_HANDLER(149, ZEND_HANDLE_EXCEPTION, ANY, ANY) +ZEND_VM_HANDLER(149, ZEND_HANDLE_EXCEPTION, ANY, ANY, SPEC(OBSERVER)) { const zend_op *throw_op = EG(opline_before_exception); uint32_t throw_op_num = throw_op - EX(func)->op_array.opcodes; @@ -7706,6 +7706,7 @@ ZEND_VM_HANDLER(149, ZEND_HANDLE_EXCEPTION, ANY, ANY) } } + OBSERVER_FCALL_END_HANDLERS(execute_data, EX(return_value)); cleanup_unfinished_calls(execute_data, throw_op_num); if (throw_op->result_type & (IS_VAR | IS_TMP_VAR)) { diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index c53d1403d754d..c2a0fecd4497a 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -3150,6 +3150,61 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_HANDLE_EXCEPTION_SPEC_HANDLER( ZEND_VM_TAIL_CALL(zend_dispatch_try_catch_finally_helper_SPEC(current_try_catch_offset, throw_op_num ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC)); } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_HANDLE_EXCEPTION_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + const zend_op *throw_op = EG(opline_before_exception); + uint32_t throw_op_num = throw_op - EX(func)->op_array.opcodes; + int i, current_try_catch_offset = -1; + + if ((throw_op->opcode == ZEND_FREE || throw_op->opcode == ZEND_FE_FREE) + && throw_op->extended_value & ZEND_FREE_ON_RETURN) { + /* exceptions thrown because of loop var destruction on return/break/... + * are logically thrown at the end of the foreach loop, so adjust the + * throw_op_num. + */ + const zend_live_range *range = find_live_range( + &EX(func)->op_array, throw_op_num, throw_op->op1.var); + throw_op_num = range->end; + } + + /* Find the innermost try/catch/finally the exception was thrown in */ + for (i = 0; i < EX(func)->op_array.last_try_catch; i++) { + zend_try_catch_element *try_catch = &EX(func)->op_array.try_catch_array[i]; + if (try_catch->try_op > throw_op_num) { + /* further blocks will not be relevant... */ + break; + } + if (throw_op_num < try_catch->catch_op || throw_op_num < try_catch->finally_end) { + current_try_catch_offset = i; + } + } + + zend_observer_maybe_fcall_call_end(execute_data, EX(return_value)); + cleanup_unfinished_calls(execute_data, throw_op_num); + + if (throw_op->result_type & (IS_VAR | IS_TMP_VAR)) { + switch (throw_op->opcode) { + case ZEND_ADD_ARRAY_ELEMENT: + case ZEND_ADD_ARRAY_UNPACK: + case ZEND_ROPE_INIT: + case ZEND_ROPE_ADD: + break; /* exception while building structures, live range handling will free those */ + + case ZEND_FETCH_CLASS: + case ZEND_DECLARE_ANON_CLASS: + break; /* return value is zend_class_entry pointer */ + + default: + /* smart branch opcodes may not initialize result */ + if (!zend_is_smart_branch(throw_op)) { + zval_ptr_dtor_nogc(EX_VAR(throw_op->result.var)); + } + } + } + + ZEND_VM_TAIL_CALL(zend_dispatch_try_catch_finally_helper_SPEC(current_try_catch_offset, throw_op_num ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC)); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_USER_OPCODE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -57670,6 +57725,7 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_LABEL, (void*)&&ZEND_HANDLE_EXCEPTION_SPEC_LABEL, + (void*)&&ZEND_HANDLE_EXCEPTION_SPEC_OBSERVER_LABEL, (void*)&&ZEND_USER_OPCODE_SPEC_LABEL, (void*)&&ZEND_ASSERT_CHECK_SPEC_LABEL, (void*)&&ZEND_JMP_SET_SPEC_CONST_LABEL, @@ -59137,6 +59193,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_HANDLE_EXCEPTION_SPEC) ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_HANDLE_EXCEPTION_SPEC_OBSERVER): + VM_TRACE(ZEND_HANDLE_EXCEPTION_SPEC_OBSERVER) + ZEND_HANDLE_EXCEPTION_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_USER_OPCODE_SPEC): VM_TRACE(ZEND_USER_OPCODE_SPEC) ZEND_USER_OPCODE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -66141,6 +66201,7 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER, ZEND_HANDLE_EXCEPTION_SPEC_HANDLER, + ZEND_HANDLE_EXCEPTION_SPEC_OBSERVER_HANDLER, ZEND_USER_OPCODE_SPEC_HANDLER, ZEND_ASSERT_CHECK_SPEC_HANDLER, ZEND_JMP_SET_SPEC_CONST_HANDLER, @@ -67421,31 +67482,30 @@ void zend_vm_init(void) 2357, 2358, 2359 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2384, - 2385, + 2384 | SPEC_RULE_OBSERVER, 2386, - 2387 | SPEC_RULE_OP1, - 2392, - 2393 | SPEC_RULE_ISSET, - 2395 | SPEC_RULE_OP2, - 2400, - 2401 | SPEC_RULE_OP1, - 2406 | SPEC_RULE_OBSERVER, - 2408, - 2409 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2434 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, - 2444, + 2387, + 2388 | SPEC_RULE_OP1, + 2393, + 2394 | SPEC_RULE_ISSET, + 2396 | SPEC_RULE_OP2, + 2401, + 2402 | SPEC_RULE_OP1, + 2407 | SPEC_RULE_OBSERVER, + 2409, + 2410 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2435 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, 2445, 2446, 2447, - 2448 | SPEC_RULE_OP1, - 2453, + 2448, + 2449 | SPEC_RULE_OP1, 2454, - 2455 | SPEC_RULE_OP1, - 2460 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2485, - 2486 | SPEC_RULE_OP1, - 2491, + 2455, + 2456 | SPEC_RULE_OP1, + 2461 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2486, + 2487 | SPEC_RULE_OP1, 2492, 2493, 2494, @@ -67453,26 +67513,27 @@ void zend_vm_init(void) 2496, 2497, 2498, - 2499 | SPEC_RULE_OP1, - 2504, + 2499, + 2500 | SPEC_RULE_OP1, 2505, 2506, - 2507 | SPEC_RULE_OP2, - 2512, - 2513 | SPEC_RULE_OP1, - 2518 | SPEC_RULE_OP1, - 2523 | SPEC_RULE_OP1, - 2528 | SPEC_RULE_OP1, - 2533 | SPEC_RULE_OP1, - 2538, - 2539 | SPEC_RULE_OP1, - 2544 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2569 | SPEC_RULE_OP1, - 2574 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2599 | SPEC_RULE_OP1, - 2604 | SPEC_RULE_OP1, - 2609, - 3513 + 2507, + 2508 | SPEC_RULE_OP2, + 2513, + 2514 | SPEC_RULE_OP1, + 2519 | SPEC_RULE_OP1, + 2524 | SPEC_RULE_OP1, + 2529 | SPEC_RULE_OP1, + 2534 | SPEC_RULE_OP1, + 2539, + 2540 | SPEC_RULE_OP1, + 2545 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2570 | SPEC_RULE_OP1, + 2575 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2600 | SPEC_RULE_OP1, + 2605 | SPEC_RULE_OP1, + 2610, + 3514 }; #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID) zend_opcode_handler_funcs = labels; @@ -67645,7 +67706,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 = 2612 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2613 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -67653,7 +67714,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 = 2637 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2638 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -67661,7 +67722,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 = 2662 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2663 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -67672,17 +67733,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 = 2687 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2688 | 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 = 2712 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2713 | 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 = 2737 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2738 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_MUL: @@ -67693,17 +67754,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 = 2762 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2763 | 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 = 2787 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2788 | 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 = 2812 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2813 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_IDENTICAL: @@ -67714,14 +67775,14 @@ 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 = 2837 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2838 | 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 = 2912 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2913 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF))) { - spec = 3137 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3138 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_IDENTICAL: @@ -67732,14 +67793,14 @@ 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 = 2987 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2988 | 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 = 3062 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3063 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF))) { - spec = 3142 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3143 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_EQUAL: @@ -67750,12 +67811,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 = 2837 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2838 | 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 = 2912 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2913 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_EQUAL: @@ -67766,12 +67827,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 = 2987 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2988 | 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 = 3062 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3063 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_SMALLER: @@ -67779,12 +67840,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 = 3147 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3148 | 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 = 3222 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3223 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_IS_SMALLER_OR_EQUAL: @@ -67792,74 +67853,74 @@ 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 = 3297 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3298 | 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 = 3372 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3373 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_QM_ASSIGN: if (op1_info == MAY_BE_LONG) { - spec = 3459 | SPEC_RULE_OP1; + spec = 3460 | SPEC_RULE_OP1; } else if (op1_info == MAY_BE_DOUBLE) { - spec = 3464 | SPEC_RULE_OP1; + spec = 3465 | 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 = 3469 | SPEC_RULE_OP1; + spec = 3470 | SPEC_RULE_OP1; } break; case ZEND_PRE_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3447 | SPEC_RULE_RETVAL; + spec = 3448 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3449 | SPEC_RULE_RETVAL; + spec = 3450 | SPEC_RULE_RETVAL; } break; case ZEND_PRE_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3451 | SPEC_RULE_RETVAL; + spec = 3452 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3453 | SPEC_RULE_RETVAL; + spec = 3454 | SPEC_RULE_RETVAL; } break; case ZEND_POST_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3455; - } else if (op1_info == MAY_BE_LONG) { spec = 3456; + } else if (op1_info == MAY_BE_LONG) { + spec = 3457; } break; case ZEND_POST_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3457; - } else if (op1_info == MAY_BE_LONG) { spec = 3458; + } else if (op1_info == MAY_BE_LONG) { + spec = 3459; } break; case ZEND_JMP: if (OP_JMP_ADDR(op, op->op1) > op) { - spec = 2611; + spec = 2612; } break; case ZEND_RECV: if (op->op2.num == MAY_BE_ANY) { - spec = 2610; + spec = 2611; } break; case ZEND_SEND_VAL: if (op->op1_type == IS_CONST && op->op2_type == IS_UNUSED && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3509; + spec = 3510; } break; case ZEND_SEND_VAR_EX: if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3504 | SPEC_RULE_OP1; + spec = 3505 | 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 = 3511 | SPEC_RULE_RETVAL; + spec = 3512 | SPEC_RULE_RETVAL; } break; case ZEND_FETCH_DIM_R: @@ -67867,17 +67928,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 = 3474 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 3475 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_SEND_VAL_EX: if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3510; + spec = 3511; } break; case ZEND_SEND_VAR: if (op->op2_type == IS_UNUSED && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3499 | SPEC_RULE_OP1; + spec = 3500 | SPEC_RULE_OP1; } break; case ZEND_BW_OR: diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h index a7514bb7a3afe..3cf762bc825da 100644 --- a/Zend/zend_vm_handlers.h +++ b/Zend/zend_vm_handlers.h @@ -1230,665 +1230,666 @@ _(2381, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ _(2383, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV) \ _(2384, ZEND_HANDLE_EXCEPTION_SPEC) \ - _(2385, ZEND_USER_OPCODE_SPEC) \ - _(2386, ZEND_ASSERT_CHECK_SPEC) \ - _(2387, ZEND_JMP_SET_SPEC_CONST) \ - _(2388, ZEND_JMP_SET_SPEC_TMP) \ - _(2389, ZEND_JMP_SET_SPEC_VAR) \ - _(2391, ZEND_JMP_SET_SPEC_CV) \ - _(2392, ZEND_UNSET_CV_SPEC_CV_UNUSED) \ - _(2393, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET) \ - _(2394, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY) \ - _(2395, ZEND_FETCH_LIST_W_SPEC_VAR_CONST) \ - _(2396, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ + _(2385, ZEND_HANDLE_EXCEPTION_SPEC_OBSERVER) \ + _(2386, ZEND_USER_OPCODE_SPEC) \ + _(2387, ZEND_ASSERT_CHECK_SPEC) \ + _(2388, ZEND_JMP_SET_SPEC_CONST) \ + _(2389, ZEND_JMP_SET_SPEC_TMP) \ + _(2390, ZEND_JMP_SET_SPEC_VAR) \ + _(2392, ZEND_JMP_SET_SPEC_CV) \ + _(2393, ZEND_UNSET_CV_SPEC_CV_UNUSED) \ + _(2394, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET) \ + _(2395, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY) \ + _(2396, ZEND_FETCH_LIST_W_SPEC_VAR_CONST) \ _(2397, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ - _(2399, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \ - _(2400, ZEND_SEPARATE_SPEC_VAR_UNUSED) \ - _(2402, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \ + _(2398, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ + _(2400, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \ + _(2401, ZEND_SEPARATE_SPEC_VAR_UNUSED) \ _(2403, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \ - _(2404, ZEND_FETCH_CLASS_NAME_SPEC_UNUSED) \ - _(2405, ZEND_FETCH_CLASS_NAME_SPEC_CV) \ - _(2406, ZEND_CALL_TRAMPOLINE_SPEC) \ - _(2407, ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER) \ - _(2408, ZEND_DISCARD_EXCEPTION_SPEC) \ - _(2409, ZEND_YIELD_SPEC_CONST_CONST) \ - _(2410, ZEND_YIELD_SPEC_CONST_TMPVAR) \ + _(2404, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \ + _(2405, ZEND_FETCH_CLASS_NAME_SPEC_UNUSED) \ + _(2406, ZEND_FETCH_CLASS_NAME_SPEC_CV) \ + _(2407, ZEND_CALL_TRAMPOLINE_SPEC) \ + _(2408, ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER) \ + _(2409, ZEND_DISCARD_EXCEPTION_SPEC) \ + _(2410, ZEND_YIELD_SPEC_CONST_CONST) \ _(2411, ZEND_YIELD_SPEC_CONST_TMPVAR) \ - _(2412, ZEND_YIELD_SPEC_CONST_UNUSED) \ - _(2413, ZEND_YIELD_SPEC_CONST_CV) \ - _(2414, ZEND_YIELD_SPEC_TMP_CONST) \ - _(2415, ZEND_YIELD_SPEC_TMP_TMPVAR) \ + _(2412, ZEND_YIELD_SPEC_CONST_TMPVAR) \ + _(2413, ZEND_YIELD_SPEC_CONST_UNUSED) \ + _(2414, ZEND_YIELD_SPEC_CONST_CV) \ + _(2415, ZEND_YIELD_SPEC_TMP_CONST) \ _(2416, ZEND_YIELD_SPEC_TMP_TMPVAR) \ - _(2417, ZEND_YIELD_SPEC_TMP_UNUSED) \ - _(2418, ZEND_YIELD_SPEC_TMP_CV) \ - _(2419, ZEND_YIELD_SPEC_VAR_CONST) \ - _(2420, ZEND_YIELD_SPEC_VAR_TMPVAR) \ + _(2417, ZEND_YIELD_SPEC_TMP_TMPVAR) \ + _(2418, ZEND_YIELD_SPEC_TMP_UNUSED) \ + _(2419, ZEND_YIELD_SPEC_TMP_CV) \ + _(2420, ZEND_YIELD_SPEC_VAR_CONST) \ _(2421, ZEND_YIELD_SPEC_VAR_TMPVAR) \ - _(2422, ZEND_YIELD_SPEC_VAR_UNUSED) \ - _(2423, ZEND_YIELD_SPEC_VAR_CV) \ - _(2424, ZEND_YIELD_SPEC_UNUSED_CONST) \ - _(2425, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \ + _(2422, ZEND_YIELD_SPEC_VAR_TMPVAR) \ + _(2423, ZEND_YIELD_SPEC_VAR_UNUSED) \ + _(2424, ZEND_YIELD_SPEC_VAR_CV) \ + _(2425, ZEND_YIELD_SPEC_UNUSED_CONST) \ _(2426, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \ - _(2427, ZEND_YIELD_SPEC_UNUSED_UNUSED) \ - _(2428, ZEND_YIELD_SPEC_UNUSED_CV) \ - _(2429, ZEND_YIELD_SPEC_CV_CONST) \ - _(2430, ZEND_YIELD_SPEC_CV_TMPVAR) \ + _(2427, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \ + _(2428, ZEND_YIELD_SPEC_UNUSED_UNUSED) \ + _(2429, ZEND_YIELD_SPEC_UNUSED_CV) \ + _(2430, ZEND_YIELD_SPEC_CV_CONST) \ _(2431, ZEND_YIELD_SPEC_CV_TMPVAR) \ - _(2432, ZEND_YIELD_SPEC_CV_UNUSED) \ - _(2433, ZEND_YIELD_SPEC_CV_CV) \ - _(2434, ZEND_GENERATOR_RETURN_SPEC_CONST) \ - _(2435, ZEND_GENERATOR_RETURN_SPEC_CONST_OBSERVER) \ - _(2436, ZEND_GENERATOR_RETURN_SPEC_TMP) \ - _(2437, ZEND_GENERATOR_RETURN_SPEC_TMP_OBSERVER) \ - _(2438, ZEND_GENERATOR_RETURN_SPEC_VAR) \ - _(2439, ZEND_GENERATOR_RETURN_SPEC_VAR_OBSERVER) \ - _(2442, ZEND_GENERATOR_RETURN_SPEC_CV) \ - _(2443, ZEND_GENERATOR_RETURN_SPEC_CV_OBSERVER) \ - _(2444, ZEND_FAST_CALL_SPEC) \ - _(2445, ZEND_FAST_RET_SPEC) \ - _(2446, ZEND_RECV_VARIADIC_SPEC_UNUSED) \ - _(2447, ZEND_SEND_UNPACK_SPEC) \ - _(2448, ZEND_YIELD_FROM_SPEC_CONST) \ - _(2449, ZEND_YIELD_FROM_SPEC_TMPVAR) \ + _(2432, ZEND_YIELD_SPEC_CV_TMPVAR) \ + _(2433, ZEND_YIELD_SPEC_CV_UNUSED) \ + _(2434, ZEND_YIELD_SPEC_CV_CV) \ + _(2435, ZEND_GENERATOR_RETURN_SPEC_CONST) \ + _(2436, ZEND_GENERATOR_RETURN_SPEC_CONST_OBSERVER) \ + _(2437, ZEND_GENERATOR_RETURN_SPEC_TMP) \ + _(2438, ZEND_GENERATOR_RETURN_SPEC_TMP_OBSERVER) \ + _(2439, ZEND_GENERATOR_RETURN_SPEC_VAR) \ + _(2440, ZEND_GENERATOR_RETURN_SPEC_VAR_OBSERVER) \ + _(2443, ZEND_GENERATOR_RETURN_SPEC_CV) \ + _(2444, ZEND_GENERATOR_RETURN_SPEC_CV_OBSERVER) \ + _(2445, ZEND_FAST_CALL_SPEC) \ + _(2446, ZEND_FAST_RET_SPEC) \ + _(2447, ZEND_RECV_VARIADIC_SPEC_UNUSED) \ + _(2448, ZEND_SEND_UNPACK_SPEC) \ + _(2449, ZEND_YIELD_FROM_SPEC_CONST) \ _(2450, ZEND_YIELD_FROM_SPEC_TMPVAR) \ - _(2452, ZEND_YIELD_FROM_SPEC_CV) \ - _(2453, ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED) \ - _(2454, ZEND_BIND_GLOBAL_SPEC_CV_CONST) \ - _(2455, ZEND_COALESCE_SPEC_CONST) \ - _(2456, ZEND_COALESCE_SPEC_TMP) \ - _(2457, ZEND_COALESCE_SPEC_VAR) \ - _(2459, ZEND_COALESCE_SPEC_CV) \ - _(2460, ZEND_SPACESHIP_SPEC_CONST_CONST) \ - _(2461, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ + _(2451, ZEND_YIELD_FROM_SPEC_TMPVAR) \ + _(2453, ZEND_YIELD_FROM_SPEC_CV) \ + _(2454, ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED) \ + _(2455, ZEND_BIND_GLOBAL_SPEC_CV_CONST) \ + _(2456, ZEND_COALESCE_SPEC_CONST) \ + _(2457, ZEND_COALESCE_SPEC_TMP) \ + _(2458, ZEND_COALESCE_SPEC_VAR) \ + _(2460, ZEND_COALESCE_SPEC_CV) \ + _(2461, ZEND_SPACESHIP_SPEC_CONST_CONST) \ _(2462, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ - _(2464, ZEND_SPACESHIP_SPEC_CONST_CV) \ - _(2465, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ - _(2466, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ + _(2463, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ + _(2465, ZEND_SPACESHIP_SPEC_CONST_CV) \ + _(2466, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ _(2467, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(2469, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ - _(2470, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ - _(2471, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ + _(2468, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ + _(2470, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ + _(2471, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ _(2472, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(2474, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ - _(2480, ZEND_SPACESHIP_SPEC_CV_CONST) \ - _(2481, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ + _(2473, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ + _(2475, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ + _(2481, ZEND_SPACESHIP_SPEC_CV_CONST) \ _(2482, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ - _(2484, ZEND_SPACESHIP_SPEC_CV_CV) \ - _(2485, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED) \ - _(2486, ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED) \ - _(2489, ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED) \ - _(2491, ZEND_FETCH_STATIC_PROP_R_SPEC) \ - _(2492, ZEND_FETCH_STATIC_PROP_W_SPEC) \ - _(2493, ZEND_FETCH_STATIC_PROP_RW_SPEC) \ - _(2494, ZEND_FETCH_STATIC_PROP_IS_SPEC) \ - _(2495, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC) \ - _(2496, ZEND_FETCH_STATIC_PROP_UNSET_SPEC) \ - _(2497, ZEND_UNSET_STATIC_PROP_SPEC) \ - _(2498, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC) \ - _(2499, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) \ - _(2501, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) \ - _(2502, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST) \ - _(2504, ZEND_BIND_LEXICAL_SPEC_TMP_CV) \ - _(2505, ZEND_BIND_STATIC_SPEC_CV_UNUSED) \ - _(2506, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED) \ - _(2507, ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST) \ - _(2510, ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED) \ - _(2512, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED) \ - _(2513, ZEND_SWITCH_LONG_SPEC_CONST_CONST) \ - _(2514, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(2483, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ + _(2485, ZEND_SPACESHIP_SPEC_CV_CV) \ + _(2486, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED) \ + _(2487, ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED) \ + _(2490, ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED) \ + _(2492, ZEND_FETCH_STATIC_PROP_R_SPEC) \ + _(2493, ZEND_FETCH_STATIC_PROP_W_SPEC) \ + _(2494, ZEND_FETCH_STATIC_PROP_RW_SPEC) \ + _(2495, ZEND_FETCH_STATIC_PROP_IS_SPEC) \ + _(2496, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC) \ + _(2497, ZEND_FETCH_STATIC_PROP_UNSET_SPEC) \ + _(2498, ZEND_UNSET_STATIC_PROP_SPEC) \ + _(2499, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC) \ + _(2500, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) \ + _(2502, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) \ + _(2503, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST) \ + _(2505, ZEND_BIND_LEXICAL_SPEC_TMP_CV) \ + _(2506, ZEND_BIND_STATIC_SPEC_CV_UNUSED) \ + _(2507, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED) \ + _(2508, ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST) \ + _(2511, ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED) \ + _(2513, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED) \ + _(2514, ZEND_SWITCH_LONG_SPEC_CONST_CONST) \ _(2515, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(2517, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(2518, ZEND_SWITCH_STRING_SPEC_CONST_CONST) \ - _(2519, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(2516, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(2518, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(2519, ZEND_SWITCH_STRING_SPEC_CONST_CONST) \ _(2520, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(2522, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(2523, ZEND_IN_ARRAY_SPEC_CONST_CONST) \ - _(2524, ZEND_IN_ARRAY_SPEC_TMP_CONST) \ - _(2525, ZEND_IN_ARRAY_SPEC_VAR_CONST) \ - _(2527, ZEND_IN_ARRAY_SPEC_CV_CONST) \ - _(2528, ZEND_COUNT_SPEC_CONST_UNUSED) \ - _(2529, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \ + _(2521, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(2523, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(2524, ZEND_IN_ARRAY_SPEC_CONST_CONST) \ + _(2525, ZEND_IN_ARRAY_SPEC_TMP_CONST) \ + _(2526, ZEND_IN_ARRAY_SPEC_VAR_CONST) \ + _(2528, ZEND_IN_ARRAY_SPEC_CV_CONST) \ + _(2529, ZEND_COUNT_SPEC_CONST_UNUSED) \ _(2530, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \ - _(2532, ZEND_COUNT_SPEC_CV_UNUSED) \ - _(2533, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \ - _(2534, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \ + _(2531, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \ + _(2533, ZEND_COUNT_SPEC_CV_UNUSED) \ + _(2534, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \ _(2535, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \ - _(2536, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED) \ - _(2537, ZEND_GET_CLASS_SPEC_CV_UNUSED) \ - _(2538, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED) \ - _(2539, ZEND_GET_TYPE_SPEC_CONST_UNUSED) \ - _(2540, ZEND_GET_TYPE_SPEC_TMP_UNUSED) \ - _(2541, ZEND_GET_TYPE_SPEC_VAR_UNUSED) \ - _(2543, ZEND_GET_TYPE_SPEC_CV_UNUSED) \ - _(2544, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \ - _(2545, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ + _(2536, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \ + _(2537, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED) \ + _(2538, ZEND_GET_CLASS_SPEC_CV_UNUSED) \ + _(2539, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED) \ + _(2540, ZEND_GET_TYPE_SPEC_CONST_UNUSED) \ + _(2541, ZEND_GET_TYPE_SPEC_TMP_UNUSED) \ + _(2542, ZEND_GET_TYPE_SPEC_VAR_UNUSED) \ + _(2544, ZEND_GET_TYPE_SPEC_CV_UNUSED) \ + _(2545, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \ _(2546, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ - _(2548, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \ - _(2549, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ - _(2550, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(2547, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ + _(2549, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \ + _(2550, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ _(2551, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(2553, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ - _(2554, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ - _(2555, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(2552, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(2554, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ + _(2555, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ _(2556, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(2558, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ - _(2564, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \ - _(2565, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ + _(2557, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(2559, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ + _(2565, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \ _(2566, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ - _(2568, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \ - _(2569, ZEND_MATCH_SPEC_CONST_CONST) \ - _(2570, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ + _(2567, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ + _(2569, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \ + _(2570, ZEND_MATCH_SPEC_CONST_CONST) \ _(2571, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ - _(2573, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ - _(2579, ZEND_CASE_STRICT_SPEC_TMP_CONST) \ - _(2580, ZEND_CASE_STRICT_SPEC_TMP_TMP) \ - _(2581, ZEND_CASE_STRICT_SPEC_TMP_VAR) \ - _(2583, ZEND_CASE_STRICT_SPEC_TMP_CV) \ - _(2584, ZEND_CASE_STRICT_SPEC_VAR_CONST) \ - _(2585, ZEND_CASE_STRICT_SPEC_VAR_TMP) \ - _(2586, ZEND_CASE_STRICT_SPEC_VAR_VAR) \ - _(2588, ZEND_CASE_STRICT_SPEC_VAR_CV) \ - _(2599, ZEND_MATCH_ERROR_SPEC_CONST_UNUSED) \ - _(2600, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ + _(2572, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ + _(2574, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ + _(2580, ZEND_CASE_STRICT_SPEC_TMP_CONST) \ + _(2581, ZEND_CASE_STRICT_SPEC_TMP_TMP) \ + _(2582, ZEND_CASE_STRICT_SPEC_TMP_VAR) \ + _(2584, ZEND_CASE_STRICT_SPEC_TMP_CV) \ + _(2585, ZEND_CASE_STRICT_SPEC_VAR_CONST) \ + _(2586, ZEND_CASE_STRICT_SPEC_VAR_TMP) \ + _(2587, ZEND_CASE_STRICT_SPEC_VAR_VAR) \ + _(2589, ZEND_CASE_STRICT_SPEC_VAR_CV) \ + _(2600, ZEND_MATCH_ERROR_SPEC_CONST_UNUSED) \ _(2601, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ - _(2603, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ - _(2604, ZEND_JMP_NULL_SPEC_CONST) \ - _(2605, ZEND_JMP_NULL_SPEC_TMPVARCV) \ + _(2602, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ + _(2604, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ + _(2605, ZEND_JMP_NULL_SPEC_CONST) \ _(2606, ZEND_JMP_NULL_SPEC_TMPVARCV) \ - _(2608, ZEND_JMP_NULL_SPEC_TMPVARCV) \ - _(2609, ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED) \ - _(2610, ZEND_RECV_NOTYPE_SPEC) \ - _(2611, ZEND_JMP_FORWARD_SPEC) \ - _(2617, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2618, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2607, ZEND_JMP_NULL_SPEC_TMPVARCV) \ + _(2609, ZEND_JMP_NULL_SPEC_TMPVARCV) \ + _(2610, ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED) \ + _(2611, ZEND_RECV_NOTYPE_SPEC) \ + _(2612, ZEND_JMP_FORWARD_SPEC) \ + _(2618, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2619, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2621, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2622, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2623, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2620, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2622, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2623, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2624, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2626, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2632, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2633, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2625, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2627, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2633, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2634, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2636, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2642, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2643, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2635, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2637, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2643, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ _(2644, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2646, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2647, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2648, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2645, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2647, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2648, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ _(2649, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2651, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2657, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2658, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2650, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2652, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2658, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ _(2659, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2661, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2667, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2668, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2660, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2662, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2668, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2669, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2671, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2672, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2673, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2670, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2672, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2673, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2674, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2676, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2682, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2683, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2675, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2677, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2683, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2684, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2686, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2688, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2685, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2687, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2689, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2691, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2692, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2693, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2690, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2692, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2693, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2694, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2696, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2697, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2698, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2695, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2697, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2698, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2699, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2701, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2707, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2708, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2700, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2702, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2708, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2709, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2711, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2713, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2710, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2712, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2714, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2716, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2717, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2718, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2715, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2717, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2718, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ _(2719, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2721, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2722, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2723, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2720, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2722, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2723, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ _(2724, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2726, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2732, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2733, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2725, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2727, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2733, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ _(2734, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2736, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2738, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2735, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2737, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2739, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2741, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2742, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2743, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2740, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2742, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2743, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2744, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2746, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2747, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2748, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2745, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2747, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2748, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2749, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2751, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2757, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2758, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2750, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2752, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2758, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2759, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2761, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2767, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2768, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2760, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2762, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2768, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2769, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2771, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2772, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2773, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2770, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2772, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2773, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2774, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2776, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2782, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2783, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2775, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2777, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2783, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2784, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2786, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2792, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2793, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2785, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2787, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2793, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ _(2794, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2796, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2797, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2798, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2795, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2797, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2798, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ _(2799, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2801, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2807, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2808, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2800, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2802, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2808, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ _(2809, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2811, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2817, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2818, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2810, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2812, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2818, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2819, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2821, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2822, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2823, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2820, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2822, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2823, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2824, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2826, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2832, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2833, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2825, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2827, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2833, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2834, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2836, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2852, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2853, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2854, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2855, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2856, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2857, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2858, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2859, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2860, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2864, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2865, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2866, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2867, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2868, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2869, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2870, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2871, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2872, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2873, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2874, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2875, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2879, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2880, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2881, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2897, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2898, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2899, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2900, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2901, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2902, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2903, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2904, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2905, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2909, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2910, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2911, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2927, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2928, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2929, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2930, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2931, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2932, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2933, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2934, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2935, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2939, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2940, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2941, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2942, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2943, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2944, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2945, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2946, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2947, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2948, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2949, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2950, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2954, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2955, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2956, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2972, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2973, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2974, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2975, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2976, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2977, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2978, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2979, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2980, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2984, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2985, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2986, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3002, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3003, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3004, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3005, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3006, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3007, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3008, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3009, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3010, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3014, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3015, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3016, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3017, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3018, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3019, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3020, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3021, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3022, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3023, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3024, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3025, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3029, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3030, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3031, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3047, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3048, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3049, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3050, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3051, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3052, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3053, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3054, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3055, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3059, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3060, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3061, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3077, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3078, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3079, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3080, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3081, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3082, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3083, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3084, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3085, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3089, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3090, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3091, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3092, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3093, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3094, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3095, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3096, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3097, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3098, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3099, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3100, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3104, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3105, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3106, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3122, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3123, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3124, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3125, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3126, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3127, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3128, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3129, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3130, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3134, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3135, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3136, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3137, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(3141, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(3142, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(3146, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(3150, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3151, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3152, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3153, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3154, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3155, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3159, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3160, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3161, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3162, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3163, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3164, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3165, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3166, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3167, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3168, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3169, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3170, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3174, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3175, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3176, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3177, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3178, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3179, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3180, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3181, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3182, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3183, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3184, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3185, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3189, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3190, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3191, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3207, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3208, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3209, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3210, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3211, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3212, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3213, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3214, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3215, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3219, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3220, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3221, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3225, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3226, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3227, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3228, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3229, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3230, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3234, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3235, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3236, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3237, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3238, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3239, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3240, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3241, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3242, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3243, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3244, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3245, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3249, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3250, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3251, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3252, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3253, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3254, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3255, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3256, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3257, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3258, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3259, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3260, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3264, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3265, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3266, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3282, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3283, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3284, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3285, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3286, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3287, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3288, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3289, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3290, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3294, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3295, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3296, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3300, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3301, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3302, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3303, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3304, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3305, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3309, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3310, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3311, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3312, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3313, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3314, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3315, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3316, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3317, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3318, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3319, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3320, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3324, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3325, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3326, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3327, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3328, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3329, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3330, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3331, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3332, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3333, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3334, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3335, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3339, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3340, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3341, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3357, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3358, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3359, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3360, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3361, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3362, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3363, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3364, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3365, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3369, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3370, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3371, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3375, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3376, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3377, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3378, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3379, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3380, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3384, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3385, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3386, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3387, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3388, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3389, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3390, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3391, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3392, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3393, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3394, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3395, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3399, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3400, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3401, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3402, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3403, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3404, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3405, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3406, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3407, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3408, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3409, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3410, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3414, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3415, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3416, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3432, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3433, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3434, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3435, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3436, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3437, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3438, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3439, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3440, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3444, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3445, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3446, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3447, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3448, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3449, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3450, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ - _(3451, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3452, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3453, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3454, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ - _(3455, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3456, ZEND_POST_INC_LONG_SPEC_CV) \ - _(3457, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3458, ZEND_POST_DEC_LONG_SPEC_CV) \ - _(3459, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ - _(3460, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(2835, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2837, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2853, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2854, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2855, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2856, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2857, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2858, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2859, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2860, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2861, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2865, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2866, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2867, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2868, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2869, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2870, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2871, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2872, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2873, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2874, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2875, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2876, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2880, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2881, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2882, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2898, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2899, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2900, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2901, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2902, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2903, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2904, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2905, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2906, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2910, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2911, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2912, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2928, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2929, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2930, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2931, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2932, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2933, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2934, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2935, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2936, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2940, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2941, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2942, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2943, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2944, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2945, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2946, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2947, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2948, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2949, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2950, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2951, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2955, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2956, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2957, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2973, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2974, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2975, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2976, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2977, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2978, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2979, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2980, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2981, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2985, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2986, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2987, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3003, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3004, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3005, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3006, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3007, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3008, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3009, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3010, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3011, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3015, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3016, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3017, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3018, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3019, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3020, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3021, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3022, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3023, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3024, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3025, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3026, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3030, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3031, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3032, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3048, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3049, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3050, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3051, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3052, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3053, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3054, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3055, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3056, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3060, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3061, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3062, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3078, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3079, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3080, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3081, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3082, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3083, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3084, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3085, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3086, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3090, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3091, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3092, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3093, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3094, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3095, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3096, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3097, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3098, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3099, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3100, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3101, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3105, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3106, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3107, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3123, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3124, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3125, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3126, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3127, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3128, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3129, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3130, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3131, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3135, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3136, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3137, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3138, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3142, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3143, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3147, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3151, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3152, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3153, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3154, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3155, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3156, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3160, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3161, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3162, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3163, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3164, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3165, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3166, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3167, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3168, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3169, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3170, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3171, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3175, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3176, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3177, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3178, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3179, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3180, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3181, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3182, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3183, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3184, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3185, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3186, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3190, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3191, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3192, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3208, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3209, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3210, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3211, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3212, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3213, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3214, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3215, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3216, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3220, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3221, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3222, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3226, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3227, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3228, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3229, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3230, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3231, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3235, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3236, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3237, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3238, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3239, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3240, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3241, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3242, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3243, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3244, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3245, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3246, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3250, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3251, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3252, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3253, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3254, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3255, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3256, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3257, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3258, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3259, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3260, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3261, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3265, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3266, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3267, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3283, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3284, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3285, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3286, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3287, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3288, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3289, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3290, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3291, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3295, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3296, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3297, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3301, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3302, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3303, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3304, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3305, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3306, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3310, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3311, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3312, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3313, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3314, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3315, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3316, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3317, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3318, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3319, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3320, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3321, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3325, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3326, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3327, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3328, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3329, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3330, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3331, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3332, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3333, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3334, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3335, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3336, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3340, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3341, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3342, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3358, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3359, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3360, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3361, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3362, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3363, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3364, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3365, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3366, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3370, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3371, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3372, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3376, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3377, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3378, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3379, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3380, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3381, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3385, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3386, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3387, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3388, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3389, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3390, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3391, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3392, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3393, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3394, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3395, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3396, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3400, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3401, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3402, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3403, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3404, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3405, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3406, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3407, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3408, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3409, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3410, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3411, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3415, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3416, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3417, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3433, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3434, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3435, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3436, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3437, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3438, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3439, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3440, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3441, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3445, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3446, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3447, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3448, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3449, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3450, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3451, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ + _(3452, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3453, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3454, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3455, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ + _(3456, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3457, ZEND_POST_INC_LONG_SPEC_CV) \ + _(3458, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3459, ZEND_POST_DEC_LONG_SPEC_CV) \ + _(3460, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ _(3461, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3463, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3464, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ - _(3465, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3462, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3464, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3465, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ _(3466, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3468, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3469, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ - _(3470, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3467, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3469, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3470, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ _(3471, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3473, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3475, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3472, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3474, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ _(3476, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3478, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3479, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(3480, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3477, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3479, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3480, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ _(3481, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3483, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3484, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(3485, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3482, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3484, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3485, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ _(3486, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3488, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3494, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ - _(3495, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3487, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3489, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3495, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ _(3496, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3498, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3501, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ - _(3503, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ - _(3506, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ - _(3508, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ - _(3509, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ - _(3510, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ - _(3511, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ - _(3512, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ - _(3512+1, ZEND_NULL) + _(3497, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3499, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3502, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ + _(3504, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ + _(3507, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ + _(3509, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ + _(3510, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ + _(3511, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ + _(3512, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ + _(3513, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ + _(3513+1, ZEND_NULL) diff --git a/ext/zend_test/test.c b/ext/zend_test/test.c index 987dd76c57d68..a8c7ac67d56ee 100644 --- a/ext/zend_test/test.c +++ b/ext/zend_test/test.c @@ -440,6 +440,9 @@ static void get_retval_info(zval *retval, smart_str *buf) static void observer_end(zend_execute_data *execute_data, zval *retval) { + if (EG(exception)) { + php_printf("%*s\n", 2 * ZT_G(observer_nesting_depth), "", ZSTR_VAL(EG(exception)->ce->name)); + } ZT_G(observer_nesting_depth)--; if (execute_data->func && execute_data->func->common.function_name) { smart_str retval_info = {0}; diff --git a/ext/zend_test/tests/observer_exception_01.phpt b/ext/zend_test/tests/observer_exception_01.phpt new file mode 100644 index 0000000000000..b222274835264 --- /dev/null +++ b/ext/zend_test/tests/observer_exception_01.phpt @@ -0,0 +1,44 @@ +--TEST-- +Observer: Basic observability of userland functions with uncaught exceptions +--INI-- +zend_test.observer.enabled=1 +zend_test.observer.observe_all=1 +--FILE-- + +--EXPECTF-- + + + + +Call #0 + + +Call #1 + + +Call #2 + + + + + +Fatal error: Uncaught RuntimeException: Third time is a charm in %s/observer_exception_%d.php:%d +Stack trace: +#0 %s/observer_exception_%d.php(%d): foo() +#1 {main} + thrown in %s/observer_exception_%d.php on line %d From b8e1408d9ad42c848a100e4a19c332a34c595879 Mon Sep 17 00:00:00 2001 From: Sammy Powers Date: Wed, 26 Aug 2020 14:20:29 -0700 Subject: [PATCH 37/53] Do only one observer check in zend_generator_resume --- Zend/zend_generators.c | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/Zend/zend_generators.c b/Zend/zend_generators.c index 877ca071adcd9..4ce1faf13d8ce 100644 --- a/Zend/zend_generators.c +++ b/Zend/zend_generators.c @@ -772,17 +772,19 @@ ZEND_API void zend_generator_resume(zend_generator *orig_generator) /* {{{ */ /* Resume execution */ generator->flags |= ZEND_GENERATOR_CURRENTLY_RUNNING; - if (ZEND_OBSERVER_ENABLED) { + if (!ZEND_OBSERVER_ENABLED) { + zend_execute_ex(generator->execute_data); + } else { void *observer_handlers = ZEND_OBSERVER_HANDLERS(&generator->execute_data->func->op_array); ZEND_ASSERT(observer_handlers); if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { zend_observe_fcall_begin(observer_handlers, generator->execute_data); } - } - zend_execute_ex(generator->execute_data); - if (generator->execute_data) { - /* On the final return, this will be called from ZEND_GENERATOR_RETURN */ - zend_observer_maybe_fcall_call_end(generator->execute_data, &generator->value); + zend_execute_ex(generator->execute_data); + if (generator->execute_data) { + /* On the final return, this will be called from ZEND_GENERATOR_RETURN */ + zend_observer_maybe_fcall_call_end(generator->execute_data, &generator->value); + } } generator->flags &= ~ZEND_GENERATOR_CURRENTLY_RUNNING; From 7792c18dceb966e8e259fe1a3b9b820042062ddb Mon Sep 17 00:00:00 2001 From: Sammy Powers Date: Wed, 26 Aug 2020 14:28:33 -0700 Subject: [PATCH 38/53] Add test for observing closures --- ext/zend_test/tests/observer_closure_01.phpt | 47 ++++++++++++++++++++ 1 file changed, 47 insertions(+) create mode 100644 ext/zend_test/tests/observer_closure_01.phpt diff --git a/ext/zend_test/tests/observer_closure_01.phpt b/ext/zend_test/tests/observer_closure_01.phpt new file mode 100644 index 0000000000000..61caeb1eb5bd5 --- /dev/null +++ b/ext/zend_test/tests/observer_closure_01.phpt @@ -0,0 +1,47 @@ +--TEST-- +Observer: Basic observability of closures +--INI-- +zend_test.observer.enabled=1 +zend_test.observer.observe_all=1 +--FILE-- + +--EXPECTF-- + + + + + <{closure}> +Answer + <{closure}> +int(42) + + + <{closure}> +Answer + <{closure}> +int(42) + + + <{closure}> +Answer + <{closure}> +int(42) + + +DONE + From 3f93dc87b65b51babfe09582a56f45596a2dd877 Mon Sep 17 00:00:00 2001 From: Sammy Powers Date: Wed, 26 Aug 2020 14:43:20 -0700 Subject: [PATCH 39/53] Check for ZEND_OBSERVER_ENABLED before installing observers for closures --- Zend/zend_closures.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/Zend/zend_closures.c b/Zend/zend_closures.c index 15569c699fd41..e3a51333dece8 100644 --- a/Zend/zend_closures.c +++ b/Zend/zend_closures.c @@ -166,7 +166,9 @@ ZEND_METHOD(Closure, call) ptr = (char*)ptr + sizeof(void*); ZEND_MAP_PTR_SET(my_function.op_array.run_time_cache, ptr); memset(ptr, 0, my_function.op_array.cache_size); - zend_observer_fcall_install(&my_function); + if (ZEND_OBSERVER_ENABLED) { + zend_observer_fcall_install(&my_function); + } } } @@ -697,7 +699,9 @@ ZEND_API void zend_create_closure(zval *res, zend_function *func, zend_class_ent ZEND_MAP_PTR_SET(closure->func.op_array.run_time_cache, ptr); } memset(ptr, 0, func->op_array.cache_size); - zend_observer_fcall_install(&closure->func); + if (ZEND_OBSERVER_ENABLED) { + zend_observer_fcall_install(&closure->func); + } } zend_string_addref(closure->func.op_array.function_name); if (closure->func.op_array.refcount) { From 00a038bc3da94c8bb558ef0a6cf2d711cd21c895 Mon Sep 17 00:00:00 2001 From: Sammy Powers Date: Wed, 26 Aug 2020 14:49:16 -0700 Subject: [PATCH 40/53] Install observers only if enabled --- Zend/zend_compile.c | 4 +++- ext/opcache/jit/zend_jit_helpers.c | 8 ++++++-- 2 files changed, 9 insertions(+), 3 deletions(-) diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index db94265eaed30..1eb20c8011317 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -1329,7 +1329,9 @@ ZEND_API void zend_do_delayed_early_binding(zend_op_array *op_array, uint32_t fi ptr = (char*)ptr + sizeof(void*); ZEND_MAP_PTR_SET(op_array->run_time_cache, ptr); memset(ptr, 0, op_array->cache_size); - zend_observer_fcall_install((zend_function*)op_array); + if (ZEND_OBSERVER_ENABLED) { + zend_observer_fcall_install((zend_function*)op_array); + } } run_time_cache = RUN_TIME_CACHE(op_array); diff --git a/ext/opcache/jit/zend_jit_helpers.c b/ext/opcache/jit/zend_jit_helpers.c index c2ceb5a6d63f8..25cfee47a197f 100644 --- a/ext/opcache/jit/zend_jit_helpers.c +++ b/ext/opcache/jit/zend_jit_helpers.c @@ -41,7 +41,9 @@ static zend_never_inline zend_function* ZEND_FASTCALL _zend_jit_init_func_run_ti run_time_cache = zend_arena_alloc(&CG(arena), op_array->cache_size); memset(run_time_cache, 0, op_array->cache_size); ZEND_MAP_PTR_SET(op_array->run_time_cache, run_time_cache); - zend_observer_fcall_install((zend_function*) op_array); + if (ZEND_OBSERVER_ENABLED) { + zend_observer_fcall_install((zend_function*) op_array); + } return (zend_function*)op_array; } /* }}} */ @@ -54,7 +56,9 @@ static zend_never_inline zend_op_array* ZEND_FASTCALL zend_jit_init_func_run_tim run_time_cache = zend_arena_alloc(&CG(arena), op_array->cache_size); memset(run_time_cache, 0, op_array->cache_size); ZEND_MAP_PTR_SET(op_array->run_time_cache, run_time_cache); - zend_observer_fcall_install((zend_function*) op_array); + if (ZEND_OBSERVER_ENABLED) { + zend_observer_fcall_install((zend_function*) op_array); + } } return op_array; } From 1d2f9f6b3041bf366a71ad29fa5e436c92acd5df Mon Sep 17 00:00:00 2001 From: Sammy Powers Date: Thu, 27 Aug 2020 10:40:02 -0700 Subject: [PATCH 41/53] Disable JIT when observer extension present --- Zend/zend_observer.h | 2 +- ext/opcache/ZendAccelerator.c | 10 +++++++++ ext/opcache/jit/zend_jit_helpers.c | 7 ------ ext/zend_test/tests/observer_jit_01.phpt | 28 ++++++++++++++++++++++++ 4 files changed, 39 insertions(+), 8 deletions(-) create mode 100644 ext/zend_test/tests/observer_jit_01.phpt diff --git a/Zend/zend_observer.h b/Zend/zend_observer.h index fe7aa5b61607b..a3de52d5b18b2 100644 --- a/Zend/zend_observer.h +++ b/Zend/zend_observer.h @@ -25,7 +25,7 @@ BEGIN_EXTERN_C() -extern int zend_observer_fcall_op_array_extension; +extern ZEND_API int zend_observer_fcall_op_array_extension; #define ZEND_OBSERVER_ENABLED (zend_observer_fcall_op_array_extension != -1) diff --git a/ext/opcache/ZendAccelerator.c b/ext/opcache/ZendAccelerator.c index bde6e0eb7138a..3873fb831dd04 100644 --- a/ext/opcache/ZendAccelerator.c +++ b/ext/opcache/ZendAccelerator.c @@ -44,6 +44,7 @@ #include "zend_accelerator_util_funcs.h" #include "zend_accelerator_hash.h" #include "zend_file_cache.h" +#include "zend_observer.h" #include "ext/pcre/php_pcre.h" #include "ext/standard/md5.h" #include "ext/hash/php_hash.h" @@ -2977,6 +2978,15 @@ static int accel_post_startup(void) } } +#ifdef HAVE_JIT + /* TODO Observer support for JIT */ + if (ZEND_OBSERVER_ENABLED) { + JIT_G(enabled) = 0; + JIT_G(on) = 0; + zend_accel_error(ACCEL_LOG_INFO, "Observer extension present. Disabling JIT."); + } +#endif + /* Initialize zend_func_info_rid */ zend_optimizer_startup(); diff --git a/ext/opcache/jit/zend_jit_helpers.c b/ext/opcache/jit/zend_jit_helpers.c index 25cfee47a197f..d1beed9115b80 100644 --- a/ext/opcache/jit/zend_jit_helpers.c +++ b/ext/opcache/jit/zend_jit_helpers.c @@ -17,7 +17,6 @@ */ #include "Zend/zend_API.h" -#include "Zend/zend_observer.h" static ZEND_COLD void undef_result_after_exception() { const zend_op *opline = EG(opline_before_exception); @@ -41,9 +40,6 @@ static zend_never_inline zend_function* ZEND_FASTCALL _zend_jit_init_func_run_ti run_time_cache = zend_arena_alloc(&CG(arena), op_array->cache_size); memset(run_time_cache, 0, op_array->cache_size); ZEND_MAP_PTR_SET(op_array->run_time_cache, run_time_cache); - if (ZEND_OBSERVER_ENABLED) { - zend_observer_fcall_install((zend_function*) op_array); - } return (zend_function*)op_array; } /* }}} */ @@ -56,9 +52,6 @@ static zend_never_inline zend_op_array* ZEND_FASTCALL zend_jit_init_func_run_tim run_time_cache = zend_arena_alloc(&CG(arena), op_array->cache_size); memset(run_time_cache, 0, op_array->cache_size); ZEND_MAP_PTR_SET(op_array->run_time_cache, run_time_cache); - if (ZEND_OBSERVER_ENABLED) { - zend_observer_fcall_install((zend_function*) op_array); - } } return op_array; } diff --git a/ext/zend_test/tests/observer_jit_01.phpt b/ext/zend_test/tests/observer_jit_01.phpt new file mode 100644 index 0000000000000..e61ecef845d82 --- /dev/null +++ b/ext/zend_test/tests/observer_jit_01.phpt @@ -0,0 +1,28 @@ +--TEST-- +Observer: JIT is disabled when observer extension is present +--SKIPIF-- + + +--INI-- +zend_test.observer.enabled=1 +zend_test.observer.observe_all=1 +opcache.enable=1 +opcache.enable_cli=1 +opcache.jit=1 +opcache.jit_buffer_size=1M +--FILE-- + +--EXPECTF-- + + +JIT enabled: no +JIT on: no + From d22d421ffea1d9e4c60df7f39b13c25a8d27b08a Mon Sep 17 00:00:00 2001 From: Sammy Powers Date: Thu, 27 Aug 2020 10:42:09 -0700 Subject: [PATCH 42/53] Add SKIPIF's to the observer tests --- ext/zend_test/tests/observer_basic_01.phpt | 2 ++ ext/zend_test/tests/observer_basic_02.phpt | 2 ++ ext/zend_test/tests/observer_basic_03.phpt | 2 ++ ext/zend_test/tests/observer_basic_04.phpt | 2 ++ ext/zend_test/tests/observer_basic_05.phpt | 2 ++ ext/zend_test/tests/observer_closure_01.phpt | 2 ++ ext/zend_test/tests/observer_eval_01.phpt | 2 ++ ext/zend_test/tests/observer_exception_01.phpt | 2 ++ ext/zend_test/tests/observer_generator_01.phpt | 2 ++ ext/zend_test/tests/observer_generator_02.phpt | 2 ++ ext/zend_test/tests/observer_generator_03.phpt | 2 ++ ext/zend_test/tests/observer_generator_04.phpt | 2 ++ ext/zend_test/tests/observer_magic_01.phpt | 2 ++ 13 files changed, 26 insertions(+) diff --git a/ext/zend_test/tests/observer_basic_01.phpt b/ext/zend_test/tests/observer_basic_01.phpt index 4824885a4272f..9e31204dbe2d8 100644 --- a/ext/zend_test/tests/observer_basic_01.phpt +++ b/ext/zend_test/tests/observer_basic_01.phpt @@ -1,5 +1,7 @@ --TEST-- Observer: Basic observability of userland functions +--SKIPIF-- + --INI-- zend_test.observer.enabled=1 zend_test.observer.observe_all=1 diff --git a/ext/zend_test/tests/observer_basic_02.phpt b/ext/zend_test/tests/observer_basic_02.phpt index 8ea02fe6a5c7d..9d16b4fe1852f 100644 --- a/ext/zend_test/tests/observer_basic_02.phpt +++ b/ext/zend_test/tests/observer_basic_02.phpt @@ -1,5 +1,7 @@ --TEST-- Observer: Basic observability of userland methods +--SKIPIF-- + --INI-- zend_test.observer.enabled=1 zend_test.observer.observe_all=1 diff --git a/ext/zend_test/tests/observer_basic_03.phpt b/ext/zend_test/tests/observer_basic_03.phpt index 393057f082436..6a2d0b16eeab9 100644 --- a/ext/zend_test/tests/observer_basic_03.phpt +++ b/ext/zend_test/tests/observer_basic_03.phpt @@ -1,5 +1,7 @@ --TEST-- Observer: Basic observability of includes +--SKIPIF-- + --INI-- zend_test.observer.enabled=1 zend_test.observer.observe_all=1 diff --git a/ext/zend_test/tests/observer_basic_04.phpt b/ext/zend_test/tests/observer_basic_04.phpt index 5448da4912062..6c0a8df59da01 100644 --- a/ext/zend_test/tests/observer_basic_04.phpt +++ b/ext/zend_test/tests/observer_basic_04.phpt @@ -1,5 +1,7 @@ --TEST-- Observer: Basic observability of includes only (no functions) +--SKIPIF-- + --INI-- zend_test.observer.enabled=1 zend_test.observer.observe_includes=1 diff --git a/ext/zend_test/tests/observer_basic_05.phpt b/ext/zend_test/tests/observer_basic_05.phpt index 31a889ef53a4a..27462aadb3784 100644 --- a/ext/zend_test/tests/observer_basic_05.phpt +++ b/ext/zend_test/tests/observer_basic_05.phpt @@ -1,5 +1,7 @@ --TEST-- Observer: Basic observability of functions only (no includes) +--SKIPIF-- + --INI-- zend_test.observer.enabled=1 zend_test.observer.observe_functions=1 diff --git a/ext/zend_test/tests/observer_closure_01.phpt b/ext/zend_test/tests/observer_closure_01.phpt index 61caeb1eb5bd5..6e65d8e0d5eb7 100644 --- a/ext/zend_test/tests/observer_closure_01.phpt +++ b/ext/zend_test/tests/observer_closure_01.phpt @@ -1,5 +1,7 @@ --TEST-- Observer: Basic observability of closures +--SKIPIF-- + --INI-- zend_test.observer.enabled=1 zend_test.observer.observe_all=1 diff --git a/ext/zend_test/tests/observer_eval_01.phpt b/ext/zend_test/tests/observer_eval_01.phpt index a99976b837eba..1a230c7d96329 100644 --- a/ext/zend_test/tests/observer_eval_01.phpt +++ b/ext/zend_test/tests/observer_eval_01.phpt @@ -1,5 +1,7 @@ --TEST-- Observer: Basic eval observability +--SKIPIF-- + --INI-- zend_test.observer.enabled=1 zend_test.observer.observe_all=1 diff --git a/ext/zend_test/tests/observer_exception_01.phpt b/ext/zend_test/tests/observer_exception_01.phpt index b222274835264..fd49c0618b5bd 100644 --- a/ext/zend_test/tests/observer_exception_01.phpt +++ b/ext/zend_test/tests/observer_exception_01.phpt @@ -1,5 +1,7 @@ --TEST-- Observer: Basic observability of userland functions with uncaught exceptions +--SKIPIF-- + --INI-- zend_test.observer.enabled=1 zend_test.observer.observe_all=1 diff --git a/ext/zend_test/tests/observer_generator_01.phpt b/ext/zend_test/tests/observer_generator_01.phpt index f6dabf5b7a34f..a2d8b02a2b5bc 100644 --- a/ext/zend_test/tests/observer_generator_01.phpt +++ b/ext/zend_test/tests/observer_generator_01.phpt @@ -1,5 +1,7 @@ --TEST-- Observer: Basic generator observability +--SKIPIF-- + --INI-- zend_test.observer.enabled=1 zend_test.observer.observe_all=1 diff --git a/ext/zend_test/tests/observer_generator_02.phpt b/ext/zend_test/tests/observer_generator_02.phpt index 7c1c10fa71643..2e045f93f2f9f 100644 --- a/ext/zend_test/tests/observer_generator_02.phpt +++ b/ext/zend_test/tests/observer_generator_02.phpt @@ -1,5 +1,7 @@ --TEST-- Observer: Generator with explicit return +--SKIPIF-- + --INI-- zend_test.observer.enabled=1 zend_test.observer.observe_all=1 diff --git a/ext/zend_test/tests/observer_generator_03.phpt b/ext/zend_test/tests/observer_generator_03.phpt index 34e9381a18546..25b573919bab5 100644 --- a/ext/zend_test/tests/observer_generator_03.phpt +++ b/ext/zend_test/tests/observer_generator_03.phpt @@ -1,5 +1,7 @@ --TEST-- Observer: Generator with 'yield from' +--SKIPIF-- + --INI-- zend_test.observer.enabled=1 zend_test.observer.observe_all=1 diff --git a/ext/zend_test/tests/observer_generator_04.phpt b/ext/zend_test/tests/observer_generator_04.phpt index bbb689e7ba8a5..6c2f18207783d 100644 --- a/ext/zend_test/tests/observer_generator_04.phpt +++ b/ext/zend_test/tests/observer_generator_04.phpt @@ -1,5 +1,7 @@ --TEST-- Observer: Generator with manual traversal +--SKIPIF-- + --INI-- zend_test.observer.enabled=1 zend_test.observer.observe_all=1 diff --git a/ext/zend_test/tests/observer_magic_01.phpt b/ext/zend_test/tests/observer_magic_01.phpt index 2ecf3d8001df4..920f934b6c4c9 100644 --- a/ext/zend_test/tests/observer_magic_01.phpt +++ b/ext/zend_test/tests/observer_magic_01.phpt @@ -1,5 +1,7 @@ --TEST-- Observer: Basic magic method observability +--SKIPIF-- + --INI-- zend_test.observer.enabled=1 zend_test.observer.observe_all=1 From 96d1040510e2bc1ad58739c400094550683dda57 Mon Sep 17 00:00:00 2001 From: Sammy Powers Date: Thu, 27 Aug 2020 12:38:29 -0700 Subject: [PATCH 43/53] Add observer to zend_call_function --- Zend/zend_execute_API.c | 8 +++++ .../tests/observer_zend_call_function_01.phpt | 36 +++++++++++++++++++ 2 files changed, 44 insertions(+) create mode 100644 ext/zend_test/tests/observer_zend_call_function_01.phpt diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c index 0e721c451e9a6..c1c3d80187d84 100644 --- a/Zend/zend_execute_API.c +++ b/Zend/zend_execute_API.c @@ -35,6 +35,7 @@ #include "zend_float.h" #include "zend_weakrefs.h" #include "zend_inheritance.h" +#include "zend_observer.h" #ifdef HAVE_SYS_TIME_H #include #endif @@ -866,6 +867,13 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache) / uint32_t orig_jit_trace_num = EG(jit_trace_num); zend_init_func_execute_data(call, &func->op_array, fci->retval); + if (ZEND_OBSERVER_ENABLED) { + void *observer_handlers = ZEND_OBSERVER_HANDLERS(&func->op_array); + if (!observer_handlers) { + zend_observer_fcall_install((zend_function *)&func->op_array); + } + zend_observer_maybe_fcall_call_begin(call); + } zend_execute_ex(call); EG(jit_trace_num) = orig_jit_trace_num; EG(opline_before_exception) = current_opline_before_exception; diff --git a/ext/zend_test/tests/observer_zend_call_function_01.phpt b/ext/zend_test/tests/observer_zend_call_function_01.phpt new file mode 100644 index 0000000000000..03d7287470c83 --- /dev/null +++ b/ext/zend_test/tests/observer_zend_call_function_01.phpt @@ -0,0 +1,36 @@ +--TEST-- +Observer: Calls that go through zend_call_function are observed +--SKIPIF-- + +--INI-- +zend_test.observer.enabled=1 +zend_test.observer.observe_all=1 +--FILE-- + +--EXPECTF-- + + + + + + + + + + + + + +int(15) +Done + From 639a09ed234046392965ed0b484a0267f12ce175 Mon Sep 17 00:00:00 2001 From: Sammy Powers Date: Thu, 27 Aug 2020 13:40:12 -0700 Subject: [PATCH 44/53] Move observer install to first time fcall --- Zend/zend_closures.c | 7 - Zend/zend_compile.c | 4 - Zend/zend_execute_API.c | 4 - Zend/zend_generators.c | 7 +- Zend/zend_observer.c | 5 +- Zend/zend_observer.h | 4 + Zend/zend_vm_def.h | 24 +- Zend/zend_vm_execute.h | 4978 ++--------------- Zend/zend_vm_execute.skl | 1 - Zend/zend_vm_gen.php | 3 - Zend/zend_vm_handlers.h | 2471 ++++---- ext/zend_test/tests/observer_closure_01.phpt | 2 +- .../tests/observer_generator_03.phpt | 2 +- 13 files changed, 1582 insertions(+), 5930 deletions(-) diff --git a/Zend/zend_closures.c b/Zend/zend_closures.c index e3a51333dece8..6b36bede37cbe 100644 --- a/Zend/zend_closures.c +++ b/Zend/zend_closures.c @@ -25,7 +25,6 @@ #include "zend_interfaces.h" #include "zend_objects.h" #include "zend_objects_API.h" -#include "zend_observer.h" #include "zend_globals.h" #include "zend_closures_arginfo.h" @@ -166,9 +165,6 @@ ZEND_METHOD(Closure, call) ptr = (char*)ptr + sizeof(void*); ZEND_MAP_PTR_SET(my_function.op_array.run_time_cache, ptr); memset(ptr, 0, my_function.op_array.cache_size); - if (ZEND_OBSERVER_ENABLED) { - zend_observer_fcall_install(&my_function); - } } } @@ -699,9 +695,6 @@ ZEND_API void zend_create_closure(zval *res, zend_function *func, zend_class_ent ZEND_MAP_PTR_SET(closure->func.op_array.run_time_cache, ptr); } memset(ptr, 0, func->op_array.cache_size); - if (ZEND_OBSERVER_ENABLED) { - zend_observer_fcall_install(&closure->func); - } } zend_string_addref(closure->func.op_array.function_name); if (closure->func.op_array.refcount) { diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index 1eb20c8011317..a75c282d2d47e 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -32,7 +32,6 @@ #include "zend_language_scanner.h" #include "zend_inheritance.h" #include "zend_vm.h" -#include "zend_observer.h" #define SET_NODE(target, src) do { \ target ## _type = (src)->op_type; \ @@ -1329,9 +1328,6 @@ ZEND_API void zend_do_delayed_early_binding(zend_op_array *op_array, uint32_t fi ptr = (char*)ptr + sizeof(void*); ZEND_MAP_PTR_SET(op_array->run_time_cache, ptr); memset(ptr, 0, op_array->cache_size); - if (ZEND_OBSERVER_ENABLED) { - zend_observer_fcall_install((zend_function*)op_array); - } } run_time_cache = RUN_TIME_CACHE(op_array); diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c index c1c3d80187d84..8f339be53b3ef 100644 --- a/Zend/zend_execute_API.c +++ b/Zend/zend_execute_API.c @@ -868,10 +868,6 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache) / zend_init_func_execute_data(call, &func->op_array, fci->retval); if (ZEND_OBSERVER_ENABLED) { - void *observer_handlers = ZEND_OBSERVER_HANDLERS(&func->op_array); - if (!observer_handlers) { - zend_observer_fcall_install((zend_function *)&func->op_array); - } zend_observer_maybe_fcall_call_begin(call); } zend_execute_ex(call); diff --git a/Zend/zend_generators.c b/Zend/zend_generators.c index 4ce1faf13d8ce..dc95a0bedfc34 100644 --- a/Zend/zend_generators.c +++ b/Zend/zend_generators.c @@ -775,7 +775,12 @@ ZEND_API void zend_generator_resume(zend_generator *orig_generator) /* {{{ */ if (!ZEND_OBSERVER_ENABLED) { zend_execute_ex(generator->execute_data); } else { - void *observer_handlers = ZEND_OBSERVER_HANDLERS(&generator->execute_data->func->op_array); + zend_op_array *op_array = &generator->execute_data->func->op_array; + void *observer_handlers = ZEND_OBSERVER_HANDLERS(op_array); + if (!observer_handlers) { + zend_observer_fcall_install((zend_function *)op_array); + observer_handlers = ZEND_OBSERVER_HANDLERS(op_array); + } ZEND_ASSERT(observer_handlers); if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { zend_observe_fcall_begin(observer_handlers, generator->execute_data); diff --git a/Zend/zend_observer.c b/Zend/zend_observer.c index 19a61d311a89e..3cf349770c066 100644 --- a/Zend/zend_observer.c +++ b/Zend/zend_observer.c @@ -137,8 +137,9 @@ void zend_observer_fcall_call_end_helper( zend_function *func = execute_data->func; ZEND_ASSUME(ZEND_SHOULD_OBSERVE_FN(func->common.fn_flags)); void *observer_handlers = ZEND_OBSERVER_HANDLERS(&func->op_array); - ZEND_ASSERT(observer_handlers); - if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { + // TODO: Fix exceptions from generators + // ZEND_ASSERT(observer_handlers); + if (observer_handlers && observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { zend_observer_fcall_cache *cache = observer_handlers; zend_observe_fcall_end(cache, execute_data, return_value); } diff --git a/Zend/zend_observer.h b/Zend/zend_observer.h index a3de52d5b18b2..6a90c0df6edd6 100644 --- a/Zend/zend_observer.h +++ b/Zend/zend_observer.h @@ -85,6 +85,10 @@ ZEND_API zend_always_inline void zend_observer_maybe_fcall_call_begin( if (ZEND_SHOULD_OBSERVE_FN(op_array->fn_flags) && !(op_array->fn_flags & ZEND_ACC_GENERATOR)) { void *observer_handlers = ZEND_OBSERVER_HANDLERS(&EX(func)->op_array); + if (!observer_handlers) { + zend_observer_fcall_install((zend_function *)&EX(func)->op_array); + observer_handlers = ZEND_OBSERVER_HANDLERS(&EX(func)->op_array); + } ZEND_ASSERT(observer_handlers); if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { zend_observe_fcall_begin(observer_handlers, execute_data); diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 68272f76a0d28..7f8bf52347361 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -3383,7 +3383,7 @@ ZEND_VM_C_LABEL(try_class_name): ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -ZEND_VM_HOT_OBJ_HANDLER(112, ZEND_INIT_METHOD_CALL, CONST|TMPVAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, NUM|CACHE_SLOT, SPEC(OBSERVER)) +ZEND_VM_HOT_OBJ_HANDLER(112, ZEND_INIT_METHOD_CALL, CONST|TMPVAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, NUM|CACHE_SLOT) { USE_OPLINE zval *function_name; @@ -3504,7 +3504,6 @@ ZEND_VM_HOT_OBJ_HANDLER(112, ZEND_INIT_METHOD_CALL, CONST|TMPVAR|UNUSED|THIS|CV, } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - OBSERVER_FCALL_INSTALL((zend_function*)&fbc->op_array); } } @@ -3539,7 +3538,7 @@ ZEND_VM_HOT_OBJ_HANDLER(112, ZEND_INIT_METHOD_CALL, CONST|TMPVAR|UNUSED|THIS|CV, ZEND_VM_NEXT_OPCODE(); } -ZEND_VM_HANDLER(113, ZEND_INIT_STATIC_METHOD_CALL, UNUSED|CLASS_FETCH|CONST|VAR, CONST|TMPVAR|UNUSED|CONSTRUCTOR|CV, NUM|CACHE_SLOT, SPEC(OBSERVER)) +ZEND_VM_HANDLER(113, ZEND_INIT_STATIC_METHOD_CALL, UNUSED|CLASS_FETCH|CONST|VAR, CONST|TMPVAR|UNUSED|CONSTRUCTOR|CV, NUM|CACHE_SLOT) { USE_OPLINE zval *function_name; @@ -3622,7 +3621,6 @@ ZEND_VM_HANDLER(113, ZEND_INIT_STATIC_METHOD_CALL, UNUSED|CLASS_FETCH|CONST|VAR, } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - OBSERVER_FCALL_INSTALL((zend_function*)&fbc->op_array); } if (OP2_TYPE != IS_CONST) { FREE_OP2(); @@ -3639,7 +3637,6 @@ ZEND_VM_HANDLER(113, ZEND_INIT_STATIC_METHOD_CALL, UNUSED|CLASS_FETCH|CONST|VAR, fbc = ce->constructor; if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - OBSERVER_FCALL_INSTALL((zend_function*)&fbc->op_array); } } @@ -3673,7 +3670,7 @@ ZEND_VM_HANDLER(113, ZEND_INIT_STATIC_METHOD_CALL, UNUSED|CLASS_FETCH|CONST|VAR, ZEND_VM_NEXT_OPCODE(); } -ZEND_VM_HOT_HANDLER(59, ZEND_INIT_FCALL_BY_NAME, ANY, CONST, NUM|CACHE_SLOT, SPEC(OBSERVER)) +ZEND_VM_HOT_HANDLER(59, ZEND_INIT_FCALL_BY_NAME, ANY, CONST, NUM|CACHE_SLOT) { USE_OPLINE zend_function *fbc; @@ -3690,7 +3687,6 @@ ZEND_VM_HOT_HANDLER(59, ZEND_INIT_FCALL_BY_NAME, ANY, CONST, NUM|CACHE_SLOT, SPE fbc = Z_FUNC_P(func); if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - OBSERVER_FCALL_INSTALL((zend_function*)&fbc->op_array); } CACHE_PTR(opline->result.num, fbc); } @@ -3757,7 +3753,7 @@ ZEND_VM_C_LABEL(try_function_name): ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -ZEND_VM_HANDLER(118, ZEND_INIT_USER_CALL, CONST, CONST|TMPVAR|CV, NUM, SPEC(OBSERVER)) +ZEND_VM_HANDLER(118, ZEND_INIT_USER_CALL, CONST, CONST|TMPVAR|CV, NUM) { USE_OPLINE zval *function_name; @@ -3803,7 +3799,6 @@ ZEND_VM_HANDLER(118, ZEND_INIT_USER_CALL, CONST, CONST|TMPVAR|CV, NUM, SPEC(OBSE if (EXPECTED(func->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&func->op_array))) { init_func_run_time_cache(&func->op_array); - OBSERVER_FCALL_INSTALL((zend_function*)&func->op_array); } } else { zend_type_error("%s(): Argument #1 ($function) must be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error); @@ -3820,7 +3815,7 @@ ZEND_VM_HANDLER(118, ZEND_INIT_USER_CALL, CONST, CONST|TMPVAR|CV, NUM, SPEC(OBSE ZEND_VM_NEXT_OPCODE(); } -ZEND_VM_HOT_HANDLER(69, ZEND_INIT_NS_FCALL_BY_NAME, ANY, CONST, NUM|CACHE_SLOT, SPEC(OBSERVER)) +ZEND_VM_HOT_HANDLER(69, ZEND_INIT_NS_FCALL_BY_NAME, ANY, CONST, NUM|CACHE_SLOT) { USE_OPLINE zval *func_name; @@ -3841,7 +3836,6 @@ ZEND_VM_HOT_HANDLER(69, ZEND_INIT_NS_FCALL_BY_NAME, ANY, CONST, NUM|CACHE_SLOT, fbc = Z_FUNC_P(func); if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - OBSERVER_FCALL_INSTALL((zend_function*)&fbc->op_array); } CACHE_PTR(opline->result.num, fbc); } @@ -3854,7 +3848,7 @@ ZEND_VM_HOT_HANDLER(69, ZEND_INIT_NS_FCALL_BY_NAME, ANY, CONST, NUM|CACHE_SLOT, ZEND_VM_NEXT_OPCODE(); } -ZEND_VM_HOT_HANDLER(61, ZEND_INIT_FCALL, NUM, CONST, NUM|CACHE_SLOT, SPEC(OBSERVER)) +ZEND_VM_HOT_HANDLER(61, ZEND_INIT_FCALL, NUM, CONST, NUM|CACHE_SLOT) { USE_OPLINE zval *fname; @@ -3872,7 +3866,6 @@ ZEND_VM_HOT_HANDLER(61, ZEND_INIT_FCALL, NUM, CONST, NUM|CACHE_SLOT, SPEC(OBSERV fbc = Z_FUNC_P(func); if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - OBSERVER_FCALL_INSTALL((zend_function*)&fbc->op_array); } CACHE_PTR(opline->result.num, fbc); } @@ -5618,7 +5611,7 @@ ZEND_VM_C_LABEL(case_double): ZEND_VM_DISPATCH_TO_HELPER(zend_case_helper, op_1, op1, op_2, op2); } -ZEND_VM_HANDLER(68, ZEND_NEW, UNUSED|CLASS_FETCH|CONST|VAR, UNUSED|CACHE_SLOT, NUM, SPEC(OBSERVER)) +ZEND_VM_HANDLER(68, ZEND_NEW, UNUSED|CLASS_FETCH|CONST|VAR, UNUSED|CACHE_SLOT, NUM) { USE_OPLINE zval *result; @@ -5672,7 +5665,6 @@ ZEND_VM_HANDLER(68, ZEND_NEW, UNUSED|CLASS_FETCH|CONST|VAR, UNUSED|CACHE_SLOT, N } else { if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&constructor->op_array))) { init_func_run_time_cache(&constructor->op_array); - OBSERVER_FCALL_INSTALL((zend_function*)&constructor->op_array); } /* We are not handling overloaded classes right now */ call = zend_vm_stack_push_call_frame( @@ -6195,7 +6187,6 @@ ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMPVAR|CV, ANY, EVAL, SPEC(OBSER call->prev_execute_data = execute_data; i_init_code_execute_data(call, new_op_array, return_value); - OBSERVER_FCALL_INSTALL((zend_function*)new_op_array); OBSERVER_FCALL_BEGIN_HANDLERS(call); if (EXPECTED(zend_execute_ex == execute_ex)) { FREE_OP1(); @@ -8496,7 +8487,6 @@ ZEND_VM_HANDLER(158, ZEND_CALL_TRAMPOLINE, ANY, ANY, SPEC(OBSERVER)) if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) { if (UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - OBSERVER_FCALL_INSTALL((zend_function*)&fbc->op_array); } execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index e83b2416b2f17..6c055f382c410 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -3385,7 +3385,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CALL_TRAMPOLINE_SPEC_HANDLER(Z if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) { if (UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - } execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); @@ -3520,7 +3519,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER_ if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) { if (UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - zend_observer_fcall_install((zend_function*)&fbc->op_array); } execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); @@ -3637,36 +3635,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME fbc = Z_FUNC_P(func); if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - - } - CACHE_PTR(opline->result.num, fbc); - } - call = _zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION, - fbc, opline->extended_value, NULL); - call->prev_execute_data = EX(call); - EX(call) = call; - - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zend_function *fbc; - zval *function_name, *func; - zend_execute_data *call; - - fbc = CACHED_PTR(opline->result.num); - if (UNEXPECTED(fbc == NULL)) { - function_name = (zval*)RT_CONSTANT(opline, opline->op2); - func = zend_hash_find_ex(EG(function_table), Z_STR_P(function_name+1), 1); - if (UNEXPECTED(func == NULL)) { - ZEND_VM_TAIL_CALL(zend_undefined_function_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); - } - fbc = Z_FUNC_P(func); - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - zend_observer_fcall_install((zend_function*)&fbc->op_array); } CACHE_PTR(opline->result.num, fbc); } @@ -3753,41 +3721,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_NS_FCALL_BY_N fbc = Z_FUNC_P(func); if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - - } - CACHE_PTR(opline->result.num, fbc); - } - - call = _zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION, - fbc, opline->extended_value, NULL); - call->prev_execute_data = EX(call); - EX(call) = call; - - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *func_name; - zval *func; - zend_function *fbc; - zend_execute_data *call; - - fbc = CACHED_PTR(opline->result.num); - if (UNEXPECTED(fbc == NULL)) { - func_name = (zval *)RT_CONSTANT(opline, opline->op2); - func = zend_hash_find_ex(EG(function_table), Z_STR_P(func_name + 1), 1); - if (func == NULL) { - func = zend_hash_find_ex(EG(function_table), Z_STR_P(func_name + 2), 1); - if (UNEXPECTED(func == NULL)) { - ZEND_VM_TAIL_CALL(zend_undefined_function_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); - } - } - fbc = Z_FUNC_P(func); - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - zend_observer_fcall_install((zend_function*)&fbc->op_array); } CACHE_PTR(opline->result.num, fbc); } @@ -3818,39 +3751,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_FCALL_SPEC_CO fbc = Z_FUNC_P(func); if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - - } - CACHE_PTR(opline->result.num, fbc); - } - - call = _zend_vm_stack_push_call_frame_ex( - opline->op1.num, ZEND_CALL_NESTED_FUNCTION, - fbc, opline->extended_value, NULL); - call->prev_execute_data = EX(call); - EX(call) = call; - - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_FCALL_SPEC_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *fname; - zval *func; - zend_function *fbc; - zend_execute_data *call; - - fbc = CACHED_PTR(opline->result.num); - if (UNEXPECTED(fbc == NULL)) { - fname = (zval*)RT_CONSTANT(opline, opline->op2); - func = zend_hash_find_ex(EG(function_table), Z_STR_P(fname), 1); - if (UNEXPECTED(func == NULL)) { - ZEND_VM_TAIL_CALL(zend_undefined_function_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); - } - fbc = Z_FUNC_P(func); - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - zend_observer_fcall_install((zend_function*)&fbc->op_array); } CACHE_PTR(opline->result.num, fbc); } @@ -5034,7 +4934,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HAN call->prev_execute_data = execute_data; i_init_code_execute_data(call, new_op_array, return_value); - if (EXPECTED(zend_execute_ex == execute_ex)) { ZEND_VM_ENTER(); @@ -5103,7 +5002,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_OBS call->prev_execute_data = execute_data; i_init_code_execute_data(call, new_op_array, return_value); - zend_observer_fcall_install((zend_function*)new_op_array); zend_observer_maybe_fcall_call_begin(call); if (EXPECTED(zend_execute_ex == execute_ex)) { @@ -6819,163 +6717,6 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_ } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - - } - } - - if (IS_CONST != IS_CONST) { - - } - - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; - if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { - if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) { - zend_objects_store_del(obj); - if (UNEXPECTED(EG(exception))) { - HANDLE_EXCEPTION(); - } - } - /* call static method */ - obj = (zend_object*)called_scope; - call_info = ZEND_CALL_NESTED_FUNCTION; - } else if (IS_CONST & (IS_VAR|IS_TMP_VAR|IS_CV)) { - if (IS_CONST == IS_CV) { - GC_ADDREF(obj); /* For $this pointer */ - } - /* CV may be changed indirectly (e.g. when it's a reference) */ - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS; - } - - call = zend_vm_stack_push_call_frame(call_info, - fbc, opline->extended_value, obj); - call->prev_execute_data = EX(call); - EX(call) = call; - - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *function_name; - zval *object; - zend_function *fbc; - zend_class_entry *called_scope; - zend_object *obj; - zend_execute_data *call; - uint32_t call_info; - - SAVE_OPLINE(); - - object = RT_CONSTANT(opline, opline->op1); - - if (IS_CONST != IS_CONST) { - function_name = RT_CONSTANT(opline, opline->op2); - } - - if (IS_CONST != IS_CONST && - UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { - do { - if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { - function_name = Z_REFVAL_P(function_name); - if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { - break; - } - } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); - if (UNEXPECTED(EG(exception) != NULL)) { - - HANDLE_EXCEPTION(); - } - } - zend_throw_error(NULL, "Method name must be a string"); - - - HANDLE_EXCEPTION(); - } while (0); - } - - if (IS_CONST == IS_UNUSED) { - obj = Z_OBJ_P(object); - } else { - do { - if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { - obj = Z_OBJ_P(object); - } else { - if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) { - zend_reference *ref = Z_REF_P(object); - - object = &ref->val; - if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { - obj = Z_OBJ_P(object); - if (IS_CONST & IS_VAR) { - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else { - Z_ADDREF_P(object); - } - } - break; - } - } - if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { - object = ZVAL_UNDEFINED_OP1(); - if (UNEXPECTED(EG(exception) != NULL)) { - if (IS_CONST != IS_CONST) { - - } - HANDLE_EXCEPTION(); - } - } - if (IS_CONST == IS_CONST) { - function_name = RT_CONSTANT(opline, opline->op2); - } - zend_invalid_method_call(object, function_name); - - - HANDLE_EXCEPTION(); - } - } while (0); - } - - called_scope = obj->ce; - - if (IS_CONST == IS_CONST && - EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { - fbc = CACHED_PTR(opline->result.num + sizeof(void*)); - } else { - zend_object *orig_obj = obj; - - if (IS_CONST == IS_CONST) { - function_name = RT_CONSTANT(opline, opline->op2); - } - - /* First, locate the function. */ - fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); - if (UNEXPECTED(fbc == NULL)) { - if (EXPECTED(!EG(exception))) { - zend_undefined_method(obj->ce, Z_STR_P(function_name)); - } - - if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) { - zend_objects_store_del(orig_obj); - } - HANDLE_EXCEPTION(); - } - if (IS_CONST == IS_CONST && - EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && - EXPECTED(obj == orig_obj)) { - CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); - } - if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) { - GC_ADDREF(obj); /* For $this pointer */ - if (GC_DELREF(orig_obj) == 0) { - zend_objects_store_del(orig_obj); - } - } - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -7093,7 +6834,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_C } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - } if (IS_CONST != IS_CONST) { @@ -7110,141 +6850,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_C fbc = ce->constructor; if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - - } - } - - if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) { - if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) { - ce = (zend_class_entry*)Z_OBJ(EX(This)); - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; - } else { - zend_non_static_method_call(fbc); - HANDLE_EXCEPTION(); - } - } else { - /* previous opcode is ZEND_FETCH_CLASS */ - if (IS_CONST == IS_UNUSED - && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT || - (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) { - if (Z_TYPE(EX(This)) == IS_OBJECT) { - ce = Z_OBJCE(EX(This)); - } else { - ce = Z_CE(EX(This)); - } - } - call_info = ZEND_CALL_NESTED_FUNCTION; - } - - call = zend_vm_stack_push_call_frame(call_info, - fbc, opline->extended_value, ce); - call->prev_execute_data = EX(call); - EX(call) = call; - - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *function_name; - zend_class_entry *ce; - uint32_t call_info; - zend_function *fbc; - zend_execute_data *call; - - SAVE_OPLINE(); - - if (IS_CONST == IS_CONST) { - /* no function found. try a static method in class */ - ce = CACHED_PTR(opline->result.num); - if (UNEXPECTED(ce == NULL)) { - ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); - if (UNEXPECTED(ce == NULL)) { - - HANDLE_EXCEPTION(); - } - if (IS_CONST != IS_CONST) { - CACHE_PTR(opline->result.num, ce); - } - } - } else if (IS_CONST == IS_UNUSED) { - ce = zend_fetch_class(NULL, opline->op1.num); - if (UNEXPECTED(ce == NULL)) { - - HANDLE_EXCEPTION(); - } - } else { - ce = Z_CE_P(EX_VAR(opline->op1.var)); - } - - if (IS_CONST == IS_CONST && - IS_CONST == IS_CONST && - EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) { - /* nothing to do */ - } else if (IS_CONST != IS_CONST && - IS_CONST == IS_CONST && - EXPECTED(CACHED_PTR(opline->result.num) == ce)) { - fbc = CACHED_PTR(opline->result.num + sizeof(void*)); - } else if (IS_CONST != IS_UNUSED) { - function_name = RT_CONSTANT(opline, opline->op2); - if (IS_CONST != IS_CONST) { - if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { - do { - if (IS_CONST & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) { - function_name = Z_REFVAL_P(function_name); - if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { - break; - } - } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - } - zend_throw_error(NULL, "Method name must be a string"); - - HANDLE_EXCEPTION(); - } while (0); - } - } - - if (ce->get_static_method) { - fbc = ce->get_static_method(ce, Z_STR_P(function_name)); - } else { - fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); - } - if (UNEXPECTED(fbc == NULL)) { - if (EXPECTED(!EG(exception))) { - zend_undefined_method(ce, Z_STR_P(function_name)); - } - - HANDLE_EXCEPTION(); - } - if (IS_CONST == IS_CONST && - EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE)))) { - CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc); - } - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - zend_observer_fcall_install((zend_function*)&fbc->op_array); - } - if (IS_CONST != IS_CONST) { - - } - } else { - if (UNEXPECTED(ce->constructor == NULL)) { - zend_throw_error(NULL, "Cannot call constructor"); - HANDLE_EXCEPTION(); - } - if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { - zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name)); - HANDLE_EXCEPTION(); - } - fbc = ce->constructor; - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -7323,69 +6928,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CONS if (EXPECTED(func->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&func->op_array))) { init_func_run_time_cache(&func->op_array); - - } - } else { - zend_type_error("%s(): Argument #1 ($function) must be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error); - efree(error); - - HANDLE_EXCEPTION(); - } - - call = zend_vm_stack_push_call_frame(call_info, - func, opline->extended_value, object_or_called_scope); - call->prev_execute_data = EX(call); - EX(call) = call; - - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *function_name; - zend_fcall_info_cache fcc; - char *error = NULL; - zend_function *func; - void *object_or_called_scope; - zend_execute_data *call; - uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_DYNAMIC; - - SAVE_OPLINE(); - function_name = RT_CONSTANT(opline, opline->op2); - if (zend_is_callable_ex(function_name, NULL, 0, NULL, &fcc, &error)) { - ZEND_ASSERT(!error); - func = fcc.function_handler; - object_or_called_scope = fcc.called_scope; - if (func->common.fn_flags & ZEND_ACC_CLOSURE) { - /* Delay closure destruction until its invocation */ - GC_ADDREF(ZEND_CLOSURE_OBJECT(func)); - call_info |= ZEND_CALL_CLOSURE; - if (func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE) { - call_info |= ZEND_CALL_FAKE_CLOSURE; - } - if (fcc.object) { - object_or_called_scope = fcc.object; - call_info |= ZEND_CALL_HAS_THIS; - } - } else if (fcc.object) { - GC_ADDREF(fcc.object); /* For $this pointer */ - object_or_called_scope = fcc.object; - call_info |= ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS; - } - - if ((IS_CONST & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) { - if (call_info & ZEND_CALL_CLOSURE) { - zend_object_release(ZEND_CLOSURE_OBJECT(func)); - } else if (call_info & ZEND_CALL_RELEASE_THIS) { - zend_object_release(fcc.object); - } - HANDLE_EXCEPTION(); - } - - if (EXPECTED(func->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&func->op_array))) { - init_func_run_time_cache(&func->op_array); - zend_observer_fcall_install((zend_function*)&func->op_array); } } else { zend_type_error("%s(): Argument #1 ($function) must be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error); @@ -9465,163 +9007,6 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_ } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - - } - } - - if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - } - - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; - if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { - if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) { - zend_objects_store_del(obj); - if (UNEXPECTED(EG(exception))) { - HANDLE_EXCEPTION(); - } - } - /* call static method */ - obj = (zend_object*)called_scope; - call_info = ZEND_CALL_NESTED_FUNCTION; - } else if (IS_CONST & (IS_VAR|IS_TMP_VAR|IS_CV)) { - if (IS_CONST == IS_CV) { - GC_ADDREF(obj); /* For $this pointer */ - } - /* CV may be changed indirectly (e.g. when it's a reference) */ - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS; - } - - call = zend_vm_stack_push_call_frame(call_info, - fbc, opline->extended_value, obj); - call->prev_execute_data = EX(call); - EX(call) = call; - - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *function_name; - zval *object; - zend_function *fbc; - zend_class_entry *called_scope; - zend_object *obj; - zend_execute_data *call; - uint32_t call_info; - - SAVE_OPLINE(); - - object = RT_CONSTANT(opline, opline->op1); - - if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { - function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); - } - - if ((IS_TMP_VAR|IS_VAR) != IS_CONST && - UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { - do { - if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { - function_name = Z_REFVAL_P(function_name); - if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { - break; - } - } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); - if (UNEXPECTED(EG(exception) != NULL)) { - - HANDLE_EXCEPTION(); - } - } - zend_throw_error(NULL, "Method name must be a string"); - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - - HANDLE_EXCEPTION(); - } while (0); - } - - if (IS_CONST == IS_UNUSED) { - obj = Z_OBJ_P(object); - } else { - do { - if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { - obj = Z_OBJ_P(object); - } else { - if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) { - zend_reference *ref = Z_REF_P(object); - - object = &ref->val; - if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { - obj = Z_OBJ_P(object); - if (IS_CONST & IS_VAR) { - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else { - Z_ADDREF_P(object); - } - } - break; - } - } - if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { - object = ZVAL_UNDEFINED_OP1(); - if (UNEXPECTED(EG(exception) != NULL)) { - if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - } - HANDLE_EXCEPTION(); - } - } - if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { - function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); - } - zend_invalid_method_call(object, function_name); - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - - HANDLE_EXCEPTION(); - } - } while (0); - } - - called_scope = obj->ce; - - if ((IS_TMP_VAR|IS_VAR) == IS_CONST && - EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { - fbc = CACHED_PTR(opline->result.num + sizeof(void*)); - } else { - zend_object *orig_obj = obj; - - if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { - function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); - } - - /* First, locate the function. */ - fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); - if (UNEXPECTED(fbc == NULL)) { - if (EXPECTED(!EG(exception))) { - zend_undefined_method(obj->ce, Z_STR_P(function_name)); - } - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) { - zend_objects_store_del(orig_obj); - } - HANDLE_EXCEPTION(); - } - if ((IS_TMP_VAR|IS_VAR) == IS_CONST && - EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && - EXPECTED(obj == orig_obj)) { - CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); - } - if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) { - GC_ADDREF(obj); /* For $this pointer */ - if (GC_DELREF(orig_obj) == 0) { - zend_objects_store_del(orig_obj); - } - } - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -9739,141 +9124,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_C } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - - } - if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - } - } else { - if (UNEXPECTED(ce->constructor == NULL)) { - zend_throw_error(NULL, "Cannot call constructor"); - HANDLE_EXCEPTION(); - } - if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { - zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name)); - HANDLE_EXCEPTION(); - } - fbc = ce->constructor; - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - - } - } - - if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) { - if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) { - ce = (zend_class_entry*)Z_OBJ(EX(This)); - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; - } else { - zend_non_static_method_call(fbc); - HANDLE_EXCEPTION(); - } - } else { - /* previous opcode is ZEND_FETCH_CLASS */ - if (IS_CONST == IS_UNUSED - && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT || - (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) { - if (Z_TYPE(EX(This)) == IS_OBJECT) { - ce = Z_OBJCE(EX(This)); - } else { - ce = Z_CE(EX(This)); - } - } - call_info = ZEND_CALL_NESTED_FUNCTION; - } - - call = zend_vm_stack_push_call_frame(call_info, - fbc, opline->extended_value, ce); - call->prev_execute_data = EX(call); - EX(call) = call; - - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *function_name; - zend_class_entry *ce; - uint32_t call_info; - zend_function *fbc; - zend_execute_data *call; - - SAVE_OPLINE(); - - if (IS_CONST == IS_CONST) { - /* no function found. try a static method in class */ - ce = CACHED_PTR(opline->result.num); - if (UNEXPECTED(ce == NULL)) { - ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); - if (UNEXPECTED(ce == NULL)) { - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - HANDLE_EXCEPTION(); - } - if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { - CACHE_PTR(opline->result.num, ce); - } - } - } else if (IS_CONST == IS_UNUSED) { - ce = zend_fetch_class(NULL, opline->op1.num); - if (UNEXPECTED(ce == NULL)) { - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - HANDLE_EXCEPTION(); - } - } else { - ce = Z_CE_P(EX_VAR(opline->op1.var)); - } - - if (IS_CONST == IS_CONST && - (IS_TMP_VAR|IS_VAR) == IS_CONST && - EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) { - /* nothing to do */ - } else if (IS_CONST != IS_CONST && - (IS_TMP_VAR|IS_VAR) == IS_CONST && - EXPECTED(CACHED_PTR(opline->result.num) == ce)) { - fbc = CACHED_PTR(opline->result.num + sizeof(void*)); - } else if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { - function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); - if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { - if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { - do { - if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) { - function_name = Z_REFVAL_P(function_name); - if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { - break; - } - } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - } - zend_throw_error(NULL, "Method name must be a string"); - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - HANDLE_EXCEPTION(); - } while (0); - } - } - - if (ce->get_static_method) { - fbc = ce->get_static_method(ce, Z_STR_P(function_name)); - } else { - fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); - } - if (UNEXPECTED(fbc == NULL)) { - if (EXPECTED(!EG(exception))) { - zend_undefined_method(ce, Z_STR_P(function_name)); - } - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - HANDLE_EXCEPTION(); - } - if ((IS_TMP_VAR|IS_VAR) == IS_CONST && - EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE)))) { - CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc); - } - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - zend_observer_fcall_install((zend_function*)&fbc->op_array); } if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); @@ -9890,7 +9140,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_C fbc = ce->constructor; if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -9970,70 +9219,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_TMPV if (EXPECTED(func->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&func->op_array))) { init_func_run_time_cache(&func->op_array); - - } - } else { - zend_type_error("%s(): Argument #1 ($function) must be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error); - efree(error); - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - HANDLE_EXCEPTION(); - } - - call = zend_vm_stack_push_call_frame(call_info, - func, opline->extended_value, object_or_called_scope); - call->prev_execute_data = EX(call); - EX(call) = call; - - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *function_name; - zend_fcall_info_cache fcc; - char *error = NULL; - zend_function *func; - void *object_or_called_scope; - zend_execute_data *call; - uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_DYNAMIC; - - SAVE_OPLINE(); - function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); - if (zend_is_callable_ex(function_name, NULL, 0, NULL, &fcc, &error)) { - ZEND_ASSERT(!error); - func = fcc.function_handler; - object_or_called_scope = fcc.called_scope; - if (func->common.fn_flags & ZEND_ACC_CLOSURE) { - /* Delay closure destruction until its invocation */ - GC_ADDREF(ZEND_CLOSURE_OBJECT(func)); - call_info |= ZEND_CALL_CLOSURE; - if (func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE) { - call_info |= ZEND_CALL_FAKE_CLOSURE; - } - if (fcc.object) { - object_or_called_scope = fcc.object; - call_info |= ZEND_CALL_HAS_THIS; - } - } else if (fcc.object) { - GC_ADDREF(fcc.object); /* For $this pointer */ - object_or_called_scope = fcc.object; - call_info |= ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS; - } - - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - if (((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) { - if (call_info & ZEND_CALL_CLOSURE) { - zend_object_release(ZEND_CLOSURE_OBJECT(func)); - } else if (call_info & ZEND_CALL_RELEASE_THIS) { - zend_object_release(fcc.object); - } - HANDLE_EXCEPTION(); - } - - if (EXPECTED(func->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&func->op_array))) { - init_func_run_time_cache(&func->op_array); - zend_observer_fcall_install((zend_function*)&func->op_array); } } else { zend_type_error("%s(): Argument #1 ($function) must be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error); @@ -10680,7 +9865,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_C } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - } if (IS_UNUSED != IS_CONST) { @@ -10697,141 +9881,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_C fbc = ce->constructor; if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - - } - } - - if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) { - if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) { - ce = (zend_class_entry*)Z_OBJ(EX(This)); - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; - } else { - zend_non_static_method_call(fbc); - HANDLE_EXCEPTION(); - } - } else { - /* previous opcode is ZEND_FETCH_CLASS */ - if (IS_CONST == IS_UNUSED - && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT || - (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) { - if (Z_TYPE(EX(This)) == IS_OBJECT) { - ce = Z_OBJCE(EX(This)); - } else { - ce = Z_CE(EX(This)); - } - } - call_info = ZEND_CALL_NESTED_FUNCTION; - } - - call = zend_vm_stack_push_call_frame(call_info, - fbc, opline->extended_value, ce); - call->prev_execute_data = EX(call); - EX(call) = call; - - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *function_name; - zend_class_entry *ce; - uint32_t call_info; - zend_function *fbc; - zend_execute_data *call; - - SAVE_OPLINE(); - - if (IS_CONST == IS_CONST) { - /* no function found. try a static method in class */ - ce = CACHED_PTR(opline->result.num); - if (UNEXPECTED(ce == NULL)) { - ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); - if (UNEXPECTED(ce == NULL)) { - - HANDLE_EXCEPTION(); - } - if (IS_UNUSED != IS_CONST) { - CACHE_PTR(opline->result.num, ce); - } - } - } else if (IS_CONST == IS_UNUSED) { - ce = zend_fetch_class(NULL, opline->op1.num); - if (UNEXPECTED(ce == NULL)) { - - HANDLE_EXCEPTION(); - } - } else { - ce = Z_CE_P(EX_VAR(opline->op1.var)); - } - - if (IS_CONST == IS_CONST && - IS_UNUSED == IS_CONST && - EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) { - /* nothing to do */ - } else if (IS_CONST != IS_CONST && - IS_UNUSED == IS_CONST && - EXPECTED(CACHED_PTR(opline->result.num) == ce)) { - fbc = CACHED_PTR(opline->result.num + sizeof(void*)); - } else if (IS_UNUSED != IS_UNUSED) { - function_name = NULL; - if (IS_UNUSED != IS_CONST) { - if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { - do { - if (IS_UNUSED & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) { - function_name = Z_REFVAL_P(function_name); - if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { - break; - } - } else if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - } - zend_throw_error(NULL, "Method name must be a string"); - - HANDLE_EXCEPTION(); - } while (0); - } - } - - if (ce->get_static_method) { - fbc = ce->get_static_method(ce, Z_STR_P(function_name)); - } else { - fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_UNUSED == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); - } - if (UNEXPECTED(fbc == NULL)) { - if (EXPECTED(!EG(exception))) { - zend_undefined_method(ce, Z_STR_P(function_name)); - } - - HANDLE_EXCEPTION(); - } - if (IS_UNUSED == IS_CONST && - EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE)))) { - CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc); - } - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - zend_observer_fcall_install((zend_function*)&fbc->op_array); - } - if (IS_UNUSED != IS_CONST) { - - } - } else { - if (UNEXPECTED(ce->constructor == NULL)) { - zend_throw_error(NULL, "Cannot call constructor"); - HANDLE_EXCEPTION(); - } - if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { - zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name)); - HANDLE_EXCEPTION(); - } - fbc = ce->constructor; - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -11087,77 +10136,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_CONST_UNUSED_HANDLER( } else { if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&constructor->op_array))) { init_func_run_time_cache(&constructor->op_array); - - } - /* We are not handling overloaded classes right now */ - call = zend_vm_stack_push_call_frame( - ZEND_CALL_FUNCTION | ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS, - constructor, - opline->extended_value, - Z_OBJ_P(result)); - Z_ADDREF_P(result); - } - - call->prev_execute_data = EX(call); - EX(call) = call; - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_CONST_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *result; - zend_function *constructor; - zend_class_entry *ce; - zend_execute_data *call; - - SAVE_OPLINE(); - if (IS_CONST == IS_CONST) { - ce = CACHED_PTR(opline->op2.num); - if (UNEXPECTED(ce == NULL)) { - ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); - if (UNEXPECTED(ce == NULL)) { - ZVAL_UNDEF(EX_VAR(opline->result.var)); - HANDLE_EXCEPTION(); - } - CACHE_PTR(opline->op2.num, ce); - } - } else if (IS_CONST == IS_UNUSED) { - ce = zend_fetch_class(NULL, opline->op1.num); - if (UNEXPECTED(ce == NULL)) { - ZVAL_UNDEF(EX_VAR(opline->result.var)); - HANDLE_EXCEPTION(); - } - } else { - ce = Z_CE_P(EX_VAR(opline->op1.var)); - } - - result = EX_VAR(opline->result.var); - if (UNEXPECTED(object_init_ex(result, ce) != SUCCESS)) { - ZVAL_UNDEF(result); - HANDLE_EXCEPTION(); - } - - constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result)); - if (constructor == NULL) { - if (UNEXPECTED(EG(exception))) { - HANDLE_EXCEPTION(); - } - - /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next - * opcode is DO_FCALL in case EXT instructions are used. */ - if (EXPECTED(opline->extended_value == 0 && (opline+1)->opcode == ZEND_DO_FCALL)) { - ZEND_VM_NEXT_OPCODE_EX(1, 2); - } - - /* Perform a dummy function call */ - call = zend_vm_stack_push_call_frame( - ZEND_CALL_FUNCTION, (zend_function *) &zend_pass_function, - opline->extended_value, NULL); - } else { - if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&constructor->op_array))) { - init_func_run_time_cache(&constructor->op_array); - zend_observer_fcall_install((zend_function*)&constructor->op_array); } /* We are not handling overloaded classes right now */ call = zend_vm_stack_push_call_frame( @@ -12413,163 +11391,6 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_ } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - - } - } - - if (IS_CV != IS_CONST) { - - } - - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; - if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { - if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) { - zend_objects_store_del(obj); - if (UNEXPECTED(EG(exception))) { - HANDLE_EXCEPTION(); - } - } - /* call static method */ - obj = (zend_object*)called_scope; - call_info = ZEND_CALL_NESTED_FUNCTION; - } else if (IS_CONST & (IS_VAR|IS_TMP_VAR|IS_CV)) { - if (IS_CONST == IS_CV) { - GC_ADDREF(obj); /* For $this pointer */ - } - /* CV may be changed indirectly (e.g. when it's a reference) */ - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS; - } - - call = zend_vm_stack_push_call_frame(call_info, - fbc, opline->extended_value, obj); - call->prev_execute_data = EX(call); - EX(call) = call; - - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *function_name; - zval *object; - zend_function *fbc; - zend_class_entry *called_scope; - zend_object *obj; - zend_execute_data *call; - uint32_t call_info; - - SAVE_OPLINE(); - - object = RT_CONSTANT(opline, opline->op1); - - if (IS_CV != IS_CONST) { - function_name = EX_VAR(opline->op2.var); - } - - if (IS_CV != IS_CONST && - UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { - do { - if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { - function_name = Z_REFVAL_P(function_name); - if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { - break; - } - } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); - if (UNEXPECTED(EG(exception) != NULL)) { - - HANDLE_EXCEPTION(); - } - } - zend_throw_error(NULL, "Method name must be a string"); - - - HANDLE_EXCEPTION(); - } while (0); - } - - if (IS_CONST == IS_UNUSED) { - obj = Z_OBJ_P(object); - } else { - do { - if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { - obj = Z_OBJ_P(object); - } else { - if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) { - zend_reference *ref = Z_REF_P(object); - - object = &ref->val; - if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { - obj = Z_OBJ_P(object); - if (IS_CONST & IS_VAR) { - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else { - Z_ADDREF_P(object); - } - } - break; - } - } - if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { - object = ZVAL_UNDEFINED_OP1(); - if (UNEXPECTED(EG(exception) != NULL)) { - if (IS_CV != IS_CONST) { - - } - HANDLE_EXCEPTION(); - } - } - if (IS_CV == IS_CONST) { - function_name = EX_VAR(opline->op2.var); - } - zend_invalid_method_call(object, function_name); - - - HANDLE_EXCEPTION(); - } - } while (0); - } - - called_scope = obj->ce; - - if (IS_CV == IS_CONST && - EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { - fbc = CACHED_PTR(opline->result.num + sizeof(void*)); - } else { - zend_object *orig_obj = obj; - - if (IS_CV == IS_CONST) { - function_name = EX_VAR(opline->op2.var); - } - - /* First, locate the function. */ - fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); - if (UNEXPECTED(fbc == NULL)) { - if (EXPECTED(!EG(exception))) { - zend_undefined_method(obj->ce, Z_STR_P(function_name)); - } - - if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) { - zend_objects_store_del(orig_obj); - } - HANDLE_EXCEPTION(); - } - if (IS_CV == IS_CONST && - EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && - EXPECTED(obj == orig_obj)) { - CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); - } - if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) { - GC_ADDREF(obj); /* For $this pointer */ - if (GC_DELREF(orig_obj) == 0) { - zend_objects_store_del(orig_obj); - } - } - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -12687,7 +11508,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_C } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - } if (IS_CV != IS_CONST) { @@ -12704,141 +11524,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_C fbc = ce->constructor; if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - - } - } - - if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) { - if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) { - ce = (zend_class_entry*)Z_OBJ(EX(This)); - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; - } else { - zend_non_static_method_call(fbc); - HANDLE_EXCEPTION(); - } - } else { - /* previous opcode is ZEND_FETCH_CLASS */ - if (IS_CONST == IS_UNUSED - && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT || - (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) { - if (Z_TYPE(EX(This)) == IS_OBJECT) { - ce = Z_OBJCE(EX(This)); - } else { - ce = Z_CE(EX(This)); - } - } - call_info = ZEND_CALL_NESTED_FUNCTION; - } - - call = zend_vm_stack_push_call_frame(call_info, - fbc, opline->extended_value, ce); - call->prev_execute_data = EX(call); - EX(call) = call; - - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *function_name; - zend_class_entry *ce; - uint32_t call_info; - zend_function *fbc; - zend_execute_data *call; - - SAVE_OPLINE(); - - if (IS_CONST == IS_CONST) { - /* no function found. try a static method in class */ - ce = CACHED_PTR(opline->result.num); - if (UNEXPECTED(ce == NULL)) { - ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); - if (UNEXPECTED(ce == NULL)) { - - HANDLE_EXCEPTION(); - } - if (IS_CV != IS_CONST) { - CACHE_PTR(opline->result.num, ce); - } - } - } else if (IS_CONST == IS_UNUSED) { - ce = zend_fetch_class(NULL, opline->op1.num); - if (UNEXPECTED(ce == NULL)) { - - HANDLE_EXCEPTION(); - } - } else { - ce = Z_CE_P(EX_VAR(opline->op1.var)); - } - - if (IS_CONST == IS_CONST && - IS_CV == IS_CONST && - EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) { - /* nothing to do */ - } else if (IS_CONST != IS_CONST && - IS_CV == IS_CONST && - EXPECTED(CACHED_PTR(opline->result.num) == ce)) { - fbc = CACHED_PTR(opline->result.num + sizeof(void*)); - } else if (IS_CV != IS_UNUSED) { - function_name = EX_VAR(opline->op2.var); - if (IS_CV != IS_CONST) { - if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { - do { - if (IS_CV & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) { - function_name = Z_REFVAL_P(function_name); - if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { - break; - } - } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - } - zend_throw_error(NULL, "Method name must be a string"); - - HANDLE_EXCEPTION(); - } while (0); - } - } - - if (ce->get_static_method) { - fbc = ce->get_static_method(ce, Z_STR_P(function_name)); - } else { - fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); - } - if (UNEXPECTED(fbc == NULL)) { - if (EXPECTED(!EG(exception))) { - zend_undefined_method(ce, Z_STR_P(function_name)); - } - - HANDLE_EXCEPTION(); - } - if (IS_CV == IS_CONST && - EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE)))) { - CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc); - } - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - zend_observer_fcall_install((zend_function*)&fbc->op_array); - } - if (IS_CV != IS_CONST) { - - } - } else { - if (UNEXPECTED(ce->constructor == NULL)) { - zend_throw_error(NULL, "Cannot call constructor"); - HANDLE_EXCEPTION(); - } - if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { - zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name)); - HANDLE_EXCEPTION(); - } - fbc = ce->constructor; - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -12917,69 +11602,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CV_H if (EXPECTED(func->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&func->op_array))) { init_func_run_time_cache(&func->op_array); - - } - } else { - zend_type_error("%s(): Argument #1 ($function) must be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error); - efree(error); - - HANDLE_EXCEPTION(); - } - - call = zend_vm_stack_push_call_frame(call_info, - func, opline->extended_value, object_or_called_scope); - call->prev_execute_data = EX(call); - EX(call) = call; - - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *function_name; - zend_fcall_info_cache fcc; - char *error = NULL; - zend_function *func; - void *object_or_called_scope; - zend_execute_data *call; - uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_DYNAMIC; - - SAVE_OPLINE(); - function_name = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); - if (zend_is_callable_ex(function_name, NULL, 0, NULL, &fcc, &error)) { - ZEND_ASSERT(!error); - func = fcc.function_handler; - object_or_called_scope = fcc.called_scope; - if (func->common.fn_flags & ZEND_ACC_CLOSURE) { - /* Delay closure destruction until its invocation */ - GC_ADDREF(ZEND_CLOSURE_OBJECT(func)); - call_info |= ZEND_CALL_CLOSURE; - if (func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE) { - call_info |= ZEND_CALL_FAKE_CLOSURE; - } - if (fcc.object) { - object_or_called_scope = fcc.object; - call_info |= ZEND_CALL_HAS_THIS; - } - } else if (fcc.object) { - GC_ADDREF(fcc.object); /* For $this pointer */ - object_or_called_scope = fcc.object; - call_info |= ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS; - } - - if ((IS_CV & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) { - if (call_info & ZEND_CALL_CLOSURE) { - zend_object_release(ZEND_CLOSURE_OBJECT(func)); - } else if (call_info & ZEND_CALL_RELEASE_THIS) { - zend_object_release(fcc.object); - } - HANDLE_EXCEPTION(); - } - - if (EXPECTED(func->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&func->op_array))) { - init_func_run_time_cache(&func->op_array); - zend_observer_fcall_install((zend_function*)&func->op_array); } } else { zend_type_error("%s(): Argument #1 ($function) must be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error); @@ -15873,7 +14495,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HA call->prev_execute_data = execute_data; i_init_code_execute_data(call, new_op_array, return_value); - if (EXPECTED(zend_execute_ex == execute_ex)) { zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); ZEND_VM_ENTER(); @@ -15942,7 +14563,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_OB call->prev_execute_data = execute_data; i_init_code_execute_data(call, new_op_array, return_value); - zend_observer_fcall_install((zend_function*)new_op_array); zend_observer_maybe_fcall_call_begin(call); if (EXPECTED(zend_execute_ex == execute_ex)) { zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); @@ -17218,163 +15838,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_C } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - - } - } - - if (IS_CONST != IS_CONST) { - - } - - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; - if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { - if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) { - zend_objects_store_del(obj); - if (UNEXPECTED(EG(exception))) { - HANDLE_EXCEPTION(); - } - } - /* call static method */ - obj = (zend_object*)called_scope; - call_info = ZEND_CALL_NESTED_FUNCTION; - } else if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR|IS_CV)) { - if ((IS_TMP_VAR|IS_VAR) == IS_CV) { - GC_ADDREF(obj); /* For $this pointer */ - } - /* CV may be changed indirectly (e.g. when it's a reference) */ - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS; - } - - call = zend_vm_stack_push_call_frame(call_info, - fbc, opline->extended_value, obj); - call->prev_execute_data = EX(call); - EX(call) = call; - - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *function_name; - zval *object; - zend_function *fbc; - zend_class_entry *called_scope; - zend_object *obj; - zend_execute_data *call; - uint32_t call_info; - - SAVE_OPLINE(); - - object = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - - if (IS_CONST != IS_CONST) { - function_name = RT_CONSTANT(opline, opline->op2); - } - - if (IS_CONST != IS_CONST && - UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { - do { - if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { - function_name = Z_REFVAL_P(function_name); - if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { - break; - } - } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); - if (UNEXPECTED(EG(exception) != NULL)) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); - } - } - zend_throw_error(NULL, "Method name must be a string"); - - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); - } while (0); - } - - if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { - obj = Z_OBJ_P(object); - } else { - do { - if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { - obj = Z_OBJ_P(object); - } else { - if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) { - zend_reference *ref = Z_REF_P(object); - - object = &ref->val; - if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { - obj = Z_OBJ_P(object); - if ((IS_TMP_VAR|IS_VAR) & IS_VAR) { - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else { - Z_ADDREF_P(object); - } - } - break; - } - } - if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { - object = ZVAL_UNDEFINED_OP1(); - if (UNEXPECTED(EG(exception) != NULL)) { - if (IS_CONST != IS_CONST) { - - } - HANDLE_EXCEPTION(); - } - } - if (IS_CONST == IS_CONST) { - function_name = RT_CONSTANT(opline, opline->op2); - } - zend_invalid_method_call(object, function_name); - - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); - } - } while (0); - } - - called_scope = obj->ce; - - if (IS_CONST == IS_CONST && - EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { - fbc = CACHED_PTR(opline->result.num + sizeof(void*)); - } else { - zend_object *orig_obj = obj; - - if (IS_CONST == IS_CONST) { - function_name = RT_CONSTANT(opline, opline->op2); - } - - /* First, locate the function. */ - fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); - if (UNEXPECTED(fbc == NULL)) { - if (EXPECTED(!EG(exception))) { - zend_undefined_method(obj->ce, Z_STR_P(function_name)); - } - - if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) { - zend_objects_store_del(orig_obj); - } - HANDLE_EXCEPTION(); - } - if (IS_CONST == IS_CONST && - EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && - EXPECTED(obj == orig_obj)) { - CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); - } - if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) { - GC_ADDREF(obj); /* For $this pointer */ - if (GC_DELREF(orig_obj) == 0) { - zend_objects_store_del(orig_obj); - } - } - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -18795,163 +17258,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_T } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - - } - } - - if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - } - - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; - if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { - if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) { - zend_objects_store_del(obj); - if (UNEXPECTED(EG(exception))) { - HANDLE_EXCEPTION(); - } - } - /* call static method */ - obj = (zend_object*)called_scope; - call_info = ZEND_CALL_NESTED_FUNCTION; - } else if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR|IS_CV)) { - if ((IS_TMP_VAR|IS_VAR) == IS_CV) { - GC_ADDREF(obj); /* For $this pointer */ - } - /* CV may be changed indirectly (e.g. when it's a reference) */ - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS; - } - - call = zend_vm_stack_push_call_frame(call_info, - fbc, opline->extended_value, obj); - call->prev_execute_data = EX(call); - EX(call) = call; - - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *function_name; - zval *object; - zend_function *fbc; - zend_class_entry *called_scope; - zend_object *obj; - zend_execute_data *call; - uint32_t call_info; - - SAVE_OPLINE(); - - object = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - - if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { - function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); - } - - if ((IS_TMP_VAR|IS_VAR) != IS_CONST && - UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { - do { - if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { - function_name = Z_REFVAL_P(function_name); - if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { - break; - } - } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); - if (UNEXPECTED(EG(exception) != NULL)) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); - } - } - zend_throw_error(NULL, "Method name must be a string"); - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); - } while (0); - } - - if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { - obj = Z_OBJ_P(object); - } else { - do { - if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { - obj = Z_OBJ_P(object); - } else { - if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) { - zend_reference *ref = Z_REF_P(object); - - object = &ref->val; - if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { - obj = Z_OBJ_P(object); - if ((IS_TMP_VAR|IS_VAR) & IS_VAR) { - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else { - Z_ADDREF_P(object); - } - } - break; - } - } - if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { - object = ZVAL_UNDEFINED_OP1(); - if (UNEXPECTED(EG(exception) != NULL)) { - if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - } - HANDLE_EXCEPTION(); - } - } - if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { - function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); - } - zend_invalid_method_call(object, function_name); - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); - } - } while (0); - } - - called_scope = obj->ce; - - if ((IS_TMP_VAR|IS_VAR) == IS_CONST && - EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { - fbc = CACHED_PTR(opline->result.num + sizeof(void*)); - } else { - zend_object *orig_obj = obj; - - if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { - function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); - } - - /* First, locate the function. */ - fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); - if (UNEXPECTED(fbc == NULL)) { - if (EXPECTED(!EG(exception))) { - zend_undefined_method(obj->ce, Z_STR_P(function_name)); - } - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) { - zend_objects_store_del(orig_obj); - } - HANDLE_EXCEPTION(); - } - if ((IS_TMP_VAR|IS_VAR) == IS_CONST && - EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && - EXPECTED(obj == orig_obj)) { - CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); - } - if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) { - GC_ADDREF(obj); /* For $this pointer */ - if (GC_DELREF(orig_obj) == 0) { - zend_objects_store_del(orig_obj); - } - } - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -20265,163 +18571,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_C } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - - } - } - - if (IS_CV != IS_CONST) { - - } - - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; - if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { - if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) { - zend_objects_store_del(obj); - if (UNEXPECTED(EG(exception))) { - HANDLE_EXCEPTION(); - } - } - /* call static method */ - obj = (zend_object*)called_scope; - call_info = ZEND_CALL_NESTED_FUNCTION; - } else if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR|IS_CV)) { - if ((IS_TMP_VAR|IS_VAR) == IS_CV) { - GC_ADDREF(obj); /* For $this pointer */ - } - /* CV may be changed indirectly (e.g. when it's a reference) */ - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS; - } - - call = zend_vm_stack_push_call_frame(call_info, - fbc, opline->extended_value, obj); - call->prev_execute_data = EX(call); - EX(call) = call; - - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *function_name; - zval *object; - zend_function *fbc; - zend_class_entry *called_scope; - zend_object *obj; - zend_execute_data *call; - uint32_t call_info; - - SAVE_OPLINE(); - - object = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - - if (IS_CV != IS_CONST) { - function_name = EX_VAR(opline->op2.var); - } - - if (IS_CV != IS_CONST && - UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { - do { - if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { - function_name = Z_REFVAL_P(function_name); - if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { - break; - } - } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); - if (UNEXPECTED(EG(exception) != NULL)) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); - } - } - zend_throw_error(NULL, "Method name must be a string"); - - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); - } while (0); - } - - if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { - obj = Z_OBJ_P(object); - } else { - do { - if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { - obj = Z_OBJ_P(object); - } else { - if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) { - zend_reference *ref = Z_REF_P(object); - - object = &ref->val; - if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { - obj = Z_OBJ_P(object); - if ((IS_TMP_VAR|IS_VAR) & IS_VAR) { - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else { - Z_ADDREF_P(object); - } - } - break; - } - } - if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { - object = ZVAL_UNDEFINED_OP1(); - if (UNEXPECTED(EG(exception) != NULL)) { - if (IS_CV != IS_CONST) { - - } - HANDLE_EXCEPTION(); - } - } - if (IS_CV == IS_CONST) { - function_name = EX_VAR(opline->op2.var); - } - zend_invalid_method_call(object, function_name); - - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); - } - } while (0); - } - - called_scope = obj->ce; - - if (IS_CV == IS_CONST && - EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { - fbc = CACHED_PTR(opline->result.num + sizeof(void*)); - } else { - zend_object *orig_obj = obj; - - if (IS_CV == IS_CONST) { - function_name = EX_VAR(opline->op2.var); - } - - /* First, locate the function. */ - fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); - if (UNEXPECTED(fbc == NULL)) { - if (EXPECTED(!EG(exception))) { - zend_undefined_method(obj->ce, Z_STR_P(function_name)); - } - - if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) { - zend_objects_store_del(orig_obj); - } - HANDLE_EXCEPTION(); - } - if (IS_CV == IS_CONST && - EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && - EXPECTED(obj == orig_obj)) { - CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); - } - if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) { - GC_ADDREF(obj); /* For $this pointer */ - if (GC_DELREF(orig_obj) == 0) { - zend_objects_store_del(orig_obj); - } - } - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -26263,141 +24412,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_V } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - - } - if (IS_CONST != IS_CONST) { - - } - } else { - if (UNEXPECTED(ce->constructor == NULL)) { - zend_throw_error(NULL, "Cannot call constructor"); - HANDLE_EXCEPTION(); - } - if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { - zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name)); - HANDLE_EXCEPTION(); - } - fbc = ce->constructor; - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - - } - } - - if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) { - if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) { - ce = (zend_class_entry*)Z_OBJ(EX(This)); - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; - } else { - zend_non_static_method_call(fbc); - HANDLE_EXCEPTION(); - } - } else { - /* previous opcode is ZEND_FETCH_CLASS */ - if (IS_VAR == IS_UNUSED - && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT || - (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) { - if (Z_TYPE(EX(This)) == IS_OBJECT) { - ce = Z_OBJCE(EX(This)); - } else { - ce = Z_CE(EX(This)); - } - } - call_info = ZEND_CALL_NESTED_FUNCTION; - } - - call = zend_vm_stack_push_call_frame(call_info, - fbc, opline->extended_value, ce); - call->prev_execute_data = EX(call); - EX(call) = call; - - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *function_name; - zend_class_entry *ce; - uint32_t call_info; - zend_function *fbc; - zend_execute_data *call; - - SAVE_OPLINE(); - - if (IS_VAR == IS_CONST) { - /* no function found. try a static method in class */ - ce = CACHED_PTR(opline->result.num); - if (UNEXPECTED(ce == NULL)) { - ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); - if (UNEXPECTED(ce == NULL)) { - - HANDLE_EXCEPTION(); - } - if (IS_CONST != IS_CONST) { - CACHE_PTR(opline->result.num, ce); - } - } - } else if (IS_VAR == IS_UNUSED) { - ce = zend_fetch_class(NULL, opline->op1.num); - if (UNEXPECTED(ce == NULL)) { - - HANDLE_EXCEPTION(); - } - } else { - ce = Z_CE_P(EX_VAR(opline->op1.var)); - } - - if (IS_VAR == IS_CONST && - IS_CONST == IS_CONST && - EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) { - /* nothing to do */ - } else if (IS_VAR != IS_CONST && - IS_CONST == IS_CONST && - EXPECTED(CACHED_PTR(opline->result.num) == ce)) { - fbc = CACHED_PTR(opline->result.num + sizeof(void*)); - } else if (IS_CONST != IS_UNUSED) { - function_name = RT_CONSTANT(opline, opline->op2); - if (IS_CONST != IS_CONST) { - if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { - do { - if (IS_CONST & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) { - function_name = Z_REFVAL_P(function_name); - if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { - break; - } - } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - } - zend_throw_error(NULL, "Method name must be a string"); - - HANDLE_EXCEPTION(); - } while (0); - } - } - - if (ce->get_static_method) { - fbc = ce->get_static_method(ce, Z_STR_P(function_name)); - } else { - fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); - } - if (UNEXPECTED(fbc == NULL)) { - if (EXPECTED(!EG(exception))) { - zend_undefined_method(ce, Z_STR_P(function_name)); - } - - HANDLE_EXCEPTION(); - } - if (IS_CONST == IS_CONST && - EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE)))) { - CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc); - } - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - zend_observer_fcall_install((zend_function*)&fbc->op_array); } if (IS_CONST != IS_CONST) { @@ -26414,7 +24428,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_V fbc = ce->constructor; if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -28915,7 +26928,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_V } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - } if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); @@ -28932,141 +26944,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_V fbc = ce->constructor; if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - - } - } - - if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) { - if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) { - ce = (zend_class_entry*)Z_OBJ(EX(This)); - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; - } else { - zend_non_static_method_call(fbc); - HANDLE_EXCEPTION(); - } - } else { - /* previous opcode is ZEND_FETCH_CLASS */ - if (IS_VAR == IS_UNUSED - && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT || - (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) { - if (Z_TYPE(EX(This)) == IS_OBJECT) { - ce = Z_OBJCE(EX(This)); - } else { - ce = Z_CE(EX(This)); - } - } - call_info = ZEND_CALL_NESTED_FUNCTION; - } - - call = zend_vm_stack_push_call_frame(call_info, - fbc, opline->extended_value, ce); - call->prev_execute_data = EX(call); - EX(call) = call; - - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *function_name; - zend_class_entry *ce; - uint32_t call_info; - zend_function *fbc; - zend_execute_data *call; - - SAVE_OPLINE(); - - if (IS_VAR == IS_CONST) { - /* no function found. try a static method in class */ - ce = CACHED_PTR(opline->result.num); - if (UNEXPECTED(ce == NULL)) { - ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); - if (UNEXPECTED(ce == NULL)) { - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - HANDLE_EXCEPTION(); - } - if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { - CACHE_PTR(opline->result.num, ce); - } - } - } else if (IS_VAR == IS_UNUSED) { - ce = zend_fetch_class(NULL, opline->op1.num); - if (UNEXPECTED(ce == NULL)) { - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - HANDLE_EXCEPTION(); - } - } else { - ce = Z_CE_P(EX_VAR(opline->op1.var)); - } - - if (IS_VAR == IS_CONST && - (IS_TMP_VAR|IS_VAR) == IS_CONST && - EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) { - /* nothing to do */ - } else if (IS_VAR != IS_CONST && - (IS_TMP_VAR|IS_VAR) == IS_CONST && - EXPECTED(CACHED_PTR(opline->result.num) == ce)) { - fbc = CACHED_PTR(opline->result.num + sizeof(void*)); - } else if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { - function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); - if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { - if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { - do { - if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) { - function_name = Z_REFVAL_P(function_name); - if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { - break; - } - } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - } - zend_throw_error(NULL, "Method name must be a string"); - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - HANDLE_EXCEPTION(); - } while (0); - } - } - - if (ce->get_static_method) { - fbc = ce->get_static_method(ce, Z_STR_P(function_name)); - } else { - fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); - } - if (UNEXPECTED(fbc == NULL)) { - if (EXPECTED(!EG(exception))) { - zend_undefined_method(ce, Z_STR_P(function_name)); - } - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - HANDLE_EXCEPTION(); - } - if ((IS_TMP_VAR|IS_VAR) == IS_CONST && - EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE)))) { - CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc); - } - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - zend_observer_fcall_install((zend_function*)&fbc->op_array); - } - if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - } - } else { - if (UNEXPECTED(ce->constructor == NULL)) { - zend_throw_error(NULL, "Cannot call constructor"); - HANDLE_EXCEPTION(); - } - if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { - zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name)); - HANDLE_EXCEPTION(); - } - fbc = ce->constructor; - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -30038,120 +27915,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_ ZEND_VM_NEXT_OPCODE_EX(1, 2); } -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *object_ptr, *orig_object_ptr; - zval *value; - zval *variable_ptr; - zval *dim; - - SAVE_OPLINE(); - orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - - if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { -try_assign_dim_array: - SEPARATE_ARRAY(object_ptr); - if (IS_UNUSED == IS_UNUSED) { - value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); - if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { - ZVAL_DEREF(value); - } - variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value); - if (UNEXPECTED(variable_ptr == NULL)) { - zend_cannot_add_element(); - goto assign_dim_error; - } else if (IS_VAR == IS_CV) { - if (Z_REFCOUNTED_P(value)) { - Z_ADDREF_P(value); - } - } else if (IS_VAR == IS_VAR) { - zval *free_op_data = EX_VAR((opline+1)->op1.var); - if (value != free_op_data) { - if (Z_REFCOUNTED_P(value)) { - Z_ADDREF_P(value); - } - zval_ptr_dtor_nogc(free_op_data); - } - } else if (IS_VAR == IS_CONST) { - if (UNEXPECTED(Z_REFCOUNTED_P(value))) { - Z_ADDREF_P(value); - } - } - } else { - dim = NULL; - if (IS_UNUSED == IS_CONST) { - variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); - } else { - variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); - } - if (UNEXPECTED(variable_ptr == NULL)) { - goto assign_dim_error; - } - value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); - value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES()); - } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); - } - } else { - if (EXPECTED(Z_ISREF_P(object_ptr))) { - object_ptr = Z_REFVAL_P(object_ptr); - if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { - goto try_assign_dim_array; - } - } - if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { - dim = NULL; - value = _get_zval_ptr_var_deref((opline+1)->op1.var EXECUTE_DATA_CC); - - if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { - dim++; - } - zend_assign_to_object_dim(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); - - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { - if (IS_UNUSED == IS_UNUSED) { - zend_use_new_element_for_string(); - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - UNDEF_RESULT(); - } else { - dim = NULL; - value = _get_zval_ptr_var_deref((opline+1)->op1.var EXECUTE_DATA_CC); - zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - } - } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { - if (Z_ISREF_P(orig_object_ptr) - && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr)) - && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) { - dim = NULL; - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - UNDEF_RESULT(); - } else { - ZVAL_ARR(object_ptr, zend_new_array(8)); - goto try_assign_dim_array; - } - } else { - zend_use_scalar_as_array(); - dim = NULL; -assign_dim_error: - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); - } - } - } - if (IS_UNUSED != IS_UNUSED) { - - } - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - /* assign_dim has two opcodes! */ - ZEND_VM_NEXT_OPCODE_EX(1, 2); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object_ptr, *orig_object_ptr; @@ -30166,19 +27930,19 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_ try_assign_dim_array: SEPARATE_ARRAY(object_ptr); if (IS_UNUSED == IS_UNUSED) { - value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC); - if (IS_CV == IS_CV || IS_CV == IS_VAR) { + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { ZVAL_DEREF(value); } variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value); if (UNEXPECTED(variable_ptr == NULL)) { zend_cannot_add_element(); goto assign_dim_error; - } else if (IS_CV == IS_CV) { + } else if (IS_VAR == IS_CV) { if (Z_REFCOUNTED_P(value)) { Z_ADDREF_P(value); } - } else if (IS_CV == IS_VAR) { + } else if (IS_VAR == IS_VAR) { zval *free_op_data = EX_VAR((opline+1)->op1.var); if (value != free_op_data) { if (Z_REFCOUNTED_P(value)) { @@ -30186,7 +27950,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_ } zval_ptr_dtor_nogc(free_op_data); } - } else if (IS_CV == IS_CONST) { + } else if (IS_VAR == IS_CONST) { if (UNEXPECTED(Z_REFCOUNTED_P(value))) { Z_ADDREF_P(value); } @@ -30201,8 +27965,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_ if (UNEXPECTED(variable_ptr == NULL)) { goto assign_dim_error; } - value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC); - value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES()); + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES()); } if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(EX_VAR(opline->result.var), value); @@ -30216,30 +27980,31 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_ } if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { dim = NULL; - value = _get_zval_ptr_cv_deref_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC); + value = _get_zval_ptr_var_deref((opline+1)->op1.var EXECUTE_DATA_CC); if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { dim++; } zend_assign_to_object_dim(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { if (IS_UNUSED == IS_UNUSED) { zend_use_new_element_for_string(); - + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); UNDEF_RESULT(); } else { dim = NULL; - value = _get_zval_ptr_cv_deref_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC); + value = _get_zval_ptr_var_deref((opline+1)->op1.var EXECUTE_DATA_CC); zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); - + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { if (Z_ISREF_P(orig_object_ptr) && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr)) && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) { dim = NULL; - + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); UNDEF_RESULT(); } else { ZVAL_ARR(object_ptr, zend_new_array(8)); @@ -30249,7 +28014,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_ zend_use_scalar_as_array(); dim = NULL; assign_dim_error: - + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_NULL(EX_VAR(opline->result.var)); } @@ -30263,141 +28028,119 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_ ZEND_VM_NEXT_OPCODE_EX(1, 2); } -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *function_name; - zend_class_entry *ce; - uint32_t call_info; - zend_function *fbc; - zend_execute_data *call; + zval *object_ptr, *orig_object_ptr; + zval *value; + zval *variable_ptr; + zval *dim; SAVE_OPLINE(); + orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - if (IS_VAR == IS_CONST) { - /* no function found. try a static method in class */ - ce = CACHED_PTR(opline->result.num); - if (UNEXPECTED(ce == NULL)) { - ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); - if (UNEXPECTED(ce == NULL)) { - - HANDLE_EXCEPTION(); + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { +try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); + if (IS_UNUSED == IS_UNUSED) { + value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_CV == IS_CV || IS_CV == IS_VAR) { + ZVAL_DEREF(value); } - if (IS_UNUSED != IS_CONST) { - CACHE_PTR(opline->result.num, ce); + variable_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value); + if (UNEXPECTED(variable_ptr == NULL)) { + zend_cannot_add_element(); + goto assign_dim_error; + } else if (IS_CV == IS_CV) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + } else if (IS_CV == IS_VAR) { + zval *free_op_data = EX_VAR((opline+1)->op1.var); + if (value != free_op_data) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + zval_ptr_dtor_nogc(free_op_data); + } + } else if (IS_CV == IS_CONST) { + if (UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } } + } else { + dim = NULL; + if (IS_UNUSED == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; + } + value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC); + value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES()); } - } else if (IS_VAR == IS_UNUSED) { - ce = zend_fetch_class(NULL, opline->op1.num); - if (UNEXPECTED(ce == NULL)) { - - HANDLE_EXCEPTION(); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); } } else { - ce = Z_CE_P(EX_VAR(opline->op1.var)); - } - - if (IS_VAR == IS_CONST && - IS_UNUSED == IS_CONST && - EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) { - /* nothing to do */ - } else if (IS_VAR != IS_CONST && - IS_UNUSED == IS_CONST && - EXPECTED(CACHED_PTR(opline->result.num) == ce)) { - fbc = CACHED_PTR(opline->result.num + sizeof(void*)); - } else if (IS_UNUSED != IS_UNUSED) { - function_name = NULL; - if (IS_UNUSED != IS_CONST) { - if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { - do { - if (IS_UNUSED & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) { - function_name = Z_REFVAL_P(function_name); - if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { - break; - } - } else if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - } - zend_throw_error(NULL, "Method name must be a string"); - - HANDLE_EXCEPTION(); - } while (0); + if (EXPECTED(Z_ISREF_P(object_ptr))) { + object_ptr = Z_REFVAL_P(object_ptr); + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { + goto try_assign_dim_array; } } + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + dim = NULL; + value = _get_zval_ptr_cv_deref_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC); - if (ce->get_static_method) { - fbc = ce->get_static_method(ce, Z_STR_P(function_name)); - } else { - fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_UNUSED == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); - } - if (UNEXPECTED(fbc == NULL)) { - if (EXPECTED(!EG(exception))) { - zend_undefined_method(ce, Z_STR_P(function_name)); + if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + dim++; } + zend_assign_to_object_dim(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); - HANDLE_EXCEPTION(); - } - if (IS_UNUSED == IS_CONST && - EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE)))) { - CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc); - } - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - - } - if (IS_UNUSED != IS_CONST) { + } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { + if (IS_UNUSED == IS_UNUSED) { + zend_use_new_element_for_string(); - } - } else { - if (UNEXPECTED(ce->constructor == NULL)) { - zend_throw_error(NULL, "Cannot call constructor"); - HANDLE_EXCEPTION(); - } - if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { - zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name)); - HANDLE_EXCEPTION(); - } - fbc = ce->constructor; - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); + UNDEF_RESULT(); + } else { + dim = NULL; + value = _get_zval_ptr_cv_deref_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC); + zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); - } - } + } + } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { + if (Z_ISREF_P(orig_object_ptr) + && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr)) + && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) { + dim = NULL; - if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) { - if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) { - ce = (zend_class_entry*)Z_OBJ(EX(This)); - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; - } else { - zend_non_static_method_call(fbc); - HANDLE_EXCEPTION(); - } - } else { - /* previous opcode is ZEND_FETCH_CLASS */ - if (IS_VAR == IS_UNUSED - && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT || - (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) { - if (Z_TYPE(EX(This)) == IS_OBJECT) { - ce = Z_OBJCE(EX(This)); + UNDEF_RESULT(); } else { - ce = Z_CE(EX(This)); + ZVAL_ARR(object_ptr, zend_new_array(8)); + goto try_assign_dim_array; + } + } else { + zend_use_scalar_as_array(); + dim = NULL; +assign_dim_error: + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); } } - call_info = ZEND_CALL_NESTED_FUNCTION; } + if (IS_UNUSED != IS_UNUSED) { - call = zend_vm_stack_push_call_frame(call_info, - fbc, opline->extended_value, ce); - call->prev_execute_data = EX(call); - EX(call) = call; - - ZEND_VM_NEXT_OPCODE(); + } + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + /* assign_dim has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); } -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *function_name; @@ -30480,7 +28223,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_V } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - zend_observer_fcall_install((zend_function*)&fbc->op_array); } if (IS_UNUSED != IS_CONST) { @@ -30497,7 +28239,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_V fbc = ce->constructor; if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -30907,82 +28648,15 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_HA ZEND_VM_NEXT_OPCODE(); } -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *varptr, *arg; - uint32_t arg_num; - - if (IS_UNUSED == IS_CONST) { - SAVE_OPLINE(); - zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); - arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); - if (UNEXPECTED(!arg)) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); - } - } else { - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - arg_num = opline->op2.num; - } - - if (EXPECTED(1)) { - if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { - goto send_var_by_ref; - } - } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { -send_var_by_ref: - varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - if (Z_ISREF_P(varptr)) { - Z_ADDREF_P(varptr); - } else { - ZVAL_MAKE_REF_EX(varptr, 2); - } - ZVAL_REF(arg, Z_REF_P(varptr)); - - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE(); - } - - varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) { - SAVE_OPLINE(); - ZVAL_UNDEFINED_OP1(); - ZVAL_NULL(arg); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } - - if (IS_VAR == IS_CV) { - ZVAL_COPY_DEREF(arg, varptr); - } else /* if (IS_VAR == IS_VAR) */ { - if (UNEXPECTED(Z_ISREF_P(varptr))) { - zend_refcounted *ref = Z_COUNTED_P(varptr); - - varptr = Z_REFVAL_P(varptr); - ZVAL_COPY_VALUE(arg, varptr); - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else if (Z_OPT_REFCOUNTED_P(arg)) { - Z_ADDREF_P(arg); - } - } else { - ZVAL_COPY_VALUE(arg, varptr); - } - } - - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *varptr, *arg; + uint32_t arg_num; if (IS_UNUSED == IS_CONST) { - // TODO: Would it make sense to share the cache slot with CHECK_FUNC_ARG? SAVE_OPLINE(); zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); - uint32_t arg_num; arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); if (UNEXPECTED(!arg)) { zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); @@ -30990,9 +28664,15 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_FUNC_ARG_SPEC } } else { arg = ZEND_CALL_VAR(EX(call), opline->result.var); + arg_num = opline->op2.num; } - if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) { + if (EXPECTED(1)) { + if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { + goto send_var_by_ref; + } + } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) { +send_var_by_ref: varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); if (Z_ISREF_P(varptr)) { Z_ADDREF_P(varptr); @@ -31006,95 +28686,86 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_FUNC_ARG_SPEC } varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + ZVAL_NULL(arg); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } - if (UNEXPECTED(Z_ISREF_P(varptr))) { - zend_refcounted *ref = Z_COUNTED_P(varptr); + if (IS_VAR == IS_CV) { + ZVAL_COPY_DEREF(arg, varptr); + } else /* if (IS_VAR == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(varptr))) { + zend_refcounted *ref = Z_COUNTED_P(varptr); - varptr = Z_REFVAL_P(varptr); - ZVAL_COPY_VALUE(arg, varptr); - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else if (Z_OPT_REFCOUNTED_P(arg)) { - Z_ADDREF_P(arg); + varptr = Z_REFVAL_P(varptr); + ZVAL_COPY_VALUE(arg, varptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(arg)) { + Z_ADDREF_P(arg); + } + } else { + ZVAL_COPY_VALUE(arg, varptr); } - } else { - ZVAL_COPY_VALUE(arg, varptr); } ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *result; - zend_function *constructor; - zend_class_entry *ce; - zend_execute_data *call; + zval *varptr, *arg; - SAVE_OPLINE(); - if (IS_VAR == IS_CONST) { - ce = CACHED_PTR(opline->op2.num); - if (UNEXPECTED(ce == NULL)) { - ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); - if (UNEXPECTED(ce == NULL)) { - ZVAL_UNDEF(EX_VAR(opline->result.var)); - HANDLE_EXCEPTION(); - } - CACHE_PTR(opline->op2.num, ce); - } - } else if (IS_VAR == IS_UNUSED) { - ce = zend_fetch_class(NULL, opline->op1.num); - if (UNEXPECTED(ce == NULL)) { - ZVAL_UNDEF(EX_VAR(opline->result.var)); + if (IS_UNUSED == IS_CONST) { + // TODO: Would it make sense to share the cache slot with CHECK_FUNC_ARG? + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + uint32_t arg_num; + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); HANDLE_EXCEPTION(); } } else { - ce = Z_CE_P(EX_VAR(opline->op1.var)); - } - - result = EX_VAR(opline->result.var); - if (UNEXPECTED(object_init_ex(result, ce) != SUCCESS)) { - ZVAL_UNDEF(result); - HANDLE_EXCEPTION(); + arg = ZEND_CALL_VAR(EX(call), opline->result.var); } - constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result)); - if (constructor == NULL) { - if (UNEXPECTED(EG(exception))) { - HANDLE_EXCEPTION(); + if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) { + varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + if (Z_ISREF_P(varptr)) { + Z_ADDREF_P(varptr); + } else { + ZVAL_MAKE_REF_EX(varptr, 2); } + ZVAL_REF(arg, Z_REF_P(varptr)); - /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next - * opcode is DO_FCALL in case EXT instructions are used. */ - if (EXPECTED(opline->extended_value == 0 && (opline+1)->opcode == ZEND_DO_FCALL)) { - ZEND_VM_NEXT_OPCODE_EX(1, 2); - } + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE(); + } - /* Perform a dummy function call */ - call = zend_vm_stack_push_call_frame( - ZEND_CALL_FUNCTION, (zend_function *) &zend_pass_function, - opline->extended_value, NULL); - } else { - if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&constructor->op_array))) { - init_func_run_time_cache(&constructor->op_array); + varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if (UNEXPECTED(Z_ISREF_P(varptr))) { + zend_refcounted *ref = Z_COUNTED_P(varptr); + varptr = Z_REFVAL_P(varptr); + ZVAL_COPY_VALUE(arg, varptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(arg)) { + Z_ADDREF_P(arg); } - /* We are not handling overloaded classes right now */ - call = zend_vm_stack_push_call_frame( - ZEND_CALL_FUNCTION | ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS, - constructor, - opline->extended_value, - Z_OBJ_P(result)); - Z_ADDREF_P(result); + } else { + ZVAL_COPY_VALUE(arg, varptr); } - call->prev_execute_data = EX(call); - EX(call) = call; ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_VAR_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *result; @@ -31148,7 +28819,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_VAR_UNUSED_OBSERVER_H } else { if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&constructor->op_array))) { init_func_run_time_cache(&constructor->op_array); - zend_observer_fcall_install((zend_function*)&constructor->op_array); } /* We are not handling overloaded classes right now */ call = zend_vm_stack_push_call_frame( @@ -33270,141 +30940,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_V } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - - } - if (IS_CV != IS_CONST) { - - } - } else { - if (UNEXPECTED(ce->constructor == NULL)) { - zend_throw_error(NULL, "Cannot call constructor"); - HANDLE_EXCEPTION(); - } - if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { - zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name)); - HANDLE_EXCEPTION(); - } - fbc = ce->constructor; - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - - } - } - - if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) { - if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) { - ce = (zend_class_entry*)Z_OBJ(EX(This)); - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; - } else { - zend_non_static_method_call(fbc); - HANDLE_EXCEPTION(); - } - } else { - /* previous opcode is ZEND_FETCH_CLASS */ - if (IS_VAR == IS_UNUSED - && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT || - (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) { - if (Z_TYPE(EX(This)) == IS_OBJECT) { - ce = Z_OBJCE(EX(This)); - } else { - ce = Z_CE(EX(This)); - } - } - call_info = ZEND_CALL_NESTED_FUNCTION; - } - - call = zend_vm_stack_push_call_frame(call_info, - fbc, opline->extended_value, ce); - call->prev_execute_data = EX(call); - EX(call) = call; - - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *function_name; - zend_class_entry *ce; - uint32_t call_info; - zend_function *fbc; - zend_execute_data *call; - - SAVE_OPLINE(); - - if (IS_VAR == IS_CONST) { - /* no function found. try a static method in class */ - ce = CACHED_PTR(opline->result.num); - if (UNEXPECTED(ce == NULL)) { - ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); - if (UNEXPECTED(ce == NULL)) { - - HANDLE_EXCEPTION(); - } - if (IS_CV != IS_CONST) { - CACHE_PTR(opline->result.num, ce); - } - } - } else if (IS_VAR == IS_UNUSED) { - ce = zend_fetch_class(NULL, opline->op1.num); - if (UNEXPECTED(ce == NULL)) { - - HANDLE_EXCEPTION(); - } - } else { - ce = Z_CE_P(EX_VAR(opline->op1.var)); - } - - if (IS_VAR == IS_CONST && - IS_CV == IS_CONST && - EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) { - /* nothing to do */ - } else if (IS_VAR != IS_CONST && - IS_CV == IS_CONST && - EXPECTED(CACHED_PTR(opline->result.num) == ce)) { - fbc = CACHED_PTR(opline->result.num + sizeof(void*)); - } else if (IS_CV != IS_UNUSED) { - function_name = EX_VAR(opline->op2.var); - if (IS_CV != IS_CONST) { - if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { - do { - if (IS_CV & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) { - function_name = Z_REFVAL_P(function_name); - if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { - break; - } - } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - } - zend_throw_error(NULL, "Method name must be a string"); - - HANDLE_EXCEPTION(); - } while (0); - } - } - - if (ce->get_static_method) { - fbc = ce->get_static_method(ce, Z_STR_P(function_name)); - } else { - fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); - } - if (UNEXPECTED(fbc == NULL)) { - if (EXPECTED(!EG(exception))) { - zend_undefined_method(ce, Z_STR_P(function_name)); - } - - HANDLE_EXCEPTION(); - } - if (IS_CV == IS_CONST && - EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE)))) { - CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc); - } - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - zend_observer_fcall_install((zend_function*)&fbc->op_array); } if (IS_CV != IS_CONST) { @@ -33421,7 +30956,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_V fbc = ce->constructor; if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -35447,163 +32981,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_S } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - - } - } - - if (IS_CONST != IS_CONST) { - - } - - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; - if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { - if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) { - zend_objects_store_del(obj); - if (UNEXPECTED(EG(exception))) { - HANDLE_EXCEPTION(); - } - } - /* call static method */ - obj = (zend_object*)called_scope; - call_info = ZEND_CALL_NESTED_FUNCTION; - } else if (IS_UNUSED & (IS_VAR|IS_TMP_VAR|IS_CV)) { - if (IS_UNUSED == IS_CV) { - GC_ADDREF(obj); /* For $this pointer */ - } - /* CV may be changed indirectly (e.g. when it's a reference) */ - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS; - } - - call = zend_vm_stack_push_call_frame(call_info, - fbc, opline->extended_value, obj); - call->prev_execute_data = EX(call); - EX(call) = call; - - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *function_name; - zval *object; - zend_function *fbc; - zend_class_entry *called_scope; - zend_object *obj; - zend_execute_data *call; - uint32_t call_info; - - SAVE_OPLINE(); - - object = &EX(This); - - if (IS_CONST != IS_CONST) { - function_name = RT_CONSTANT(opline, opline->op2); - } - - if (IS_CONST != IS_CONST && - UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { - do { - if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { - function_name = Z_REFVAL_P(function_name); - if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { - break; - } - } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); - if (UNEXPECTED(EG(exception) != NULL)) { - - HANDLE_EXCEPTION(); - } - } - zend_throw_error(NULL, "Method name must be a string"); - - - HANDLE_EXCEPTION(); - } while (0); - } - - if (IS_UNUSED == IS_UNUSED) { - obj = Z_OBJ_P(object); - } else { - do { - if (IS_UNUSED != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { - obj = Z_OBJ_P(object); - } else { - if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) { - zend_reference *ref = Z_REF_P(object); - - object = &ref->val; - if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { - obj = Z_OBJ_P(object); - if (IS_UNUSED & IS_VAR) { - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else { - Z_ADDREF_P(object); - } - } - break; - } - } - if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { - object = ZVAL_UNDEFINED_OP1(); - if (UNEXPECTED(EG(exception) != NULL)) { - if (IS_CONST != IS_CONST) { - - } - HANDLE_EXCEPTION(); - } - } - if (IS_CONST == IS_CONST) { - function_name = RT_CONSTANT(opline, opline->op2); - } - zend_invalid_method_call(object, function_name); - - - HANDLE_EXCEPTION(); - } - } while (0); - } - - called_scope = obj->ce; - - if (IS_CONST == IS_CONST && - EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { - fbc = CACHED_PTR(opline->result.num + sizeof(void*)); - } else { - zend_object *orig_obj = obj; - - if (IS_CONST == IS_CONST) { - function_name = RT_CONSTANT(opline, opline->op2); - } - - /* First, locate the function. */ - fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); - if (UNEXPECTED(fbc == NULL)) { - if (EXPECTED(!EG(exception))) { - zend_undefined_method(obj->ce, Z_STR_P(function_name)); - } - - if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) { - zend_objects_store_del(orig_obj); - } - HANDLE_EXCEPTION(); - } - if (IS_CONST == IS_CONST && - EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && - EXPECTED(obj == orig_obj)) { - CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); - } - if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) { - GC_ADDREF(obj); /* For $this pointer */ - if (GC_DELREF(orig_obj) == 0) { - zend_objects_store_del(orig_obj); - } - } - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -35721,141 +33098,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_U } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - - } - if (IS_CONST != IS_CONST) { - - } - } else { - if (UNEXPECTED(ce->constructor == NULL)) { - zend_throw_error(NULL, "Cannot call constructor"); - HANDLE_EXCEPTION(); - } - if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { - zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name)); - HANDLE_EXCEPTION(); - } - fbc = ce->constructor; - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - - } - } - - if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) { - if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) { - ce = (zend_class_entry*)Z_OBJ(EX(This)); - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; - } else { - zend_non_static_method_call(fbc); - HANDLE_EXCEPTION(); - } - } else { - /* previous opcode is ZEND_FETCH_CLASS */ - if (IS_UNUSED == IS_UNUSED - && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT || - (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) { - if (Z_TYPE(EX(This)) == IS_OBJECT) { - ce = Z_OBJCE(EX(This)); - } else { - ce = Z_CE(EX(This)); - } - } - call_info = ZEND_CALL_NESTED_FUNCTION; - } - - call = zend_vm_stack_push_call_frame(call_info, - fbc, opline->extended_value, ce); - call->prev_execute_data = EX(call); - EX(call) = call; - - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *function_name; - zend_class_entry *ce; - uint32_t call_info; - zend_function *fbc; - zend_execute_data *call; - - SAVE_OPLINE(); - - if (IS_UNUSED == IS_CONST) { - /* no function found. try a static method in class */ - ce = CACHED_PTR(opline->result.num); - if (UNEXPECTED(ce == NULL)) { - ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); - if (UNEXPECTED(ce == NULL)) { - - HANDLE_EXCEPTION(); - } - if (IS_CONST != IS_CONST) { - CACHE_PTR(opline->result.num, ce); - } - } - } else if (IS_UNUSED == IS_UNUSED) { - ce = zend_fetch_class(NULL, opline->op1.num); - if (UNEXPECTED(ce == NULL)) { - - HANDLE_EXCEPTION(); - } - } else { - ce = Z_CE_P(EX_VAR(opline->op1.var)); - } - - if (IS_UNUSED == IS_CONST && - IS_CONST == IS_CONST && - EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) { - /* nothing to do */ - } else if (IS_UNUSED != IS_CONST && - IS_CONST == IS_CONST && - EXPECTED(CACHED_PTR(opline->result.num) == ce)) { - fbc = CACHED_PTR(opline->result.num + sizeof(void*)); - } else if (IS_CONST != IS_UNUSED) { - function_name = RT_CONSTANT(opline, opline->op2); - if (IS_CONST != IS_CONST) { - if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { - do { - if (IS_CONST & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) { - function_name = Z_REFVAL_P(function_name); - if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { - break; - } - } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - } - zend_throw_error(NULL, "Method name must be a string"); - - HANDLE_EXCEPTION(); - } while (0); - } - } - - if (ce->get_static_method) { - fbc = ce->get_static_method(ce, Z_STR_P(function_name)); - } else { - fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); - } - if (UNEXPECTED(fbc == NULL)) { - if (EXPECTED(!EG(exception))) { - zend_undefined_method(ce, Z_STR_P(function_name)); - } - - HANDLE_EXCEPTION(); - } - if (IS_CONST == IS_CONST && - EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE)))) { - CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc); - } - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - zend_observer_fcall_install((zend_function*)&fbc->op_array); } if (IS_CONST != IS_CONST) { @@ -35872,7 +33114,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_U fbc = ce->constructor; if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -37649,163 +34890,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_T } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - - } - } - - if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - } - - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; - if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { - if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) { - zend_objects_store_del(obj); - if (UNEXPECTED(EG(exception))) { - HANDLE_EXCEPTION(); - } - } - /* call static method */ - obj = (zend_object*)called_scope; - call_info = ZEND_CALL_NESTED_FUNCTION; - } else if (IS_UNUSED & (IS_VAR|IS_TMP_VAR|IS_CV)) { - if (IS_UNUSED == IS_CV) { - GC_ADDREF(obj); /* For $this pointer */ - } - /* CV may be changed indirectly (e.g. when it's a reference) */ - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS; - } - - call = zend_vm_stack_push_call_frame(call_info, - fbc, opline->extended_value, obj); - call->prev_execute_data = EX(call); - EX(call) = call; - - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *function_name; - zval *object; - zend_function *fbc; - zend_class_entry *called_scope; - zend_object *obj; - zend_execute_data *call; - uint32_t call_info; - - SAVE_OPLINE(); - - object = &EX(This); - - if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { - function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); - } - - if ((IS_TMP_VAR|IS_VAR) != IS_CONST && - UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { - do { - if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { - function_name = Z_REFVAL_P(function_name); - if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { - break; - } - } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); - if (UNEXPECTED(EG(exception) != NULL)) { - - HANDLE_EXCEPTION(); - } - } - zend_throw_error(NULL, "Method name must be a string"); - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - - HANDLE_EXCEPTION(); - } while (0); - } - - if (IS_UNUSED == IS_UNUSED) { - obj = Z_OBJ_P(object); - } else { - do { - if (IS_UNUSED != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { - obj = Z_OBJ_P(object); - } else { - if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) { - zend_reference *ref = Z_REF_P(object); - - object = &ref->val; - if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { - obj = Z_OBJ_P(object); - if (IS_UNUSED & IS_VAR) { - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else { - Z_ADDREF_P(object); - } - } - break; - } - } - if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { - object = ZVAL_UNDEFINED_OP1(); - if (UNEXPECTED(EG(exception) != NULL)) { - if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - } - HANDLE_EXCEPTION(); - } - } - if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { - function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); - } - zend_invalid_method_call(object, function_name); - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - - HANDLE_EXCEPTION(); - } - } while (0); - } - - called_scope = obj->ce; - - if ((IS_TMP_VAR|IS_VAR) == IS_CONST && - EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { - fbc = CACHED_PTR(opline->result.num + sizeof(void*)); - } else { - zend_object *orig_obj = obj; - - if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { - function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); - } - - /* First, locate the function. */ - fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); - if (UNEXPECTED(fbc == NULL)) { - if (EXPECTED(!EG(exception))) { - zend_undefined_method(obj->ce, Z_STR_P(function_name)); - } - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) { - zend_objects_store_del(orig_obj); - } - HANDLE_EXCEPTION(); - } - if ((IS_TMP_VAR|IS_VAR) == IS_CONST && - EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && - EXPECTED(obj == orig_obj)) { - CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); - } - if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) { - GC_ADDREF(obj); /* For $this pointer */ - if (GC_DELREF(orig_obj) == 0) { - zend_objects_store_del(orig_obj); - } - } - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -37923,141 +35007,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_U } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - - } - if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - } - } else { - if (UNEXPECTED(ce->constructor == NULL)) { - zend_throw_error(NULL, "Cannot call constructor"); - HANDLE_EXCEPTION(); - } - if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { - zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name)); - HANDLE_EXCEPTION(); - } - fbc = ce->constructor; - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - - } - } - - if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) { - if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) { - ce = (zend_class_entry*)Z_OBJ(EX(This)); - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; - } else { - zend_non_static_method_call(fbc); - HANDLE_EXCEPTION(); - } - } else { - /* previous opcode is ZEND_FETCH_CLASS */ - if (IS_UNUSED == IS_UNUSED - && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT || - (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) { - if (Z_TYPE(EX(This)) == IS_OBJECT) { - ce = Z_OBJCE(EX(This)); - } else { - ce = Z_CE(EX(This)); - } - } - call_info = ZEND_CALL_NESTED_FUNCTION; - } - - call = zend_vm_stack_push_call_frame(call_info, - fbc, opline->extended_value, ce); - call->prev_execute_data = EX(call); - EX(call) = call; - - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *function_name; - zend_class_entry *ce; - uint32_t call_info; - zend_function *fbc; - zend_execute_data *call; - - SAVE_OPLINE(); - - if (IS_UNUSED == IS_CONST) { - /* no function found. try a static method in class */ - ce = CACHED_PTR(opline->result.num); - if (UNEXPECTED(ce == NULL)) { - ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); - if (UNEXPECTED(ce == NULL)) { - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - HANDLE_EXCEPTION(); - } - if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { - CACHE_PTR(opline->result.num, ce); - } - } - } else if (IS_UNUSED == IS_UNUSED) { - ce = zend_fetch_class(NULL, opline->op1.num); - if (UNEXPECTED(ce == NULL)) { - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - HANDLE_EXCEPTION(); - } - } else { - ce = Z_CE_P(EX_VAR(opline->op1.var)); - } - - if (IS_UNUSED == IS_CONST && - (IS_TMP_VAR|IS_VAR) == IS_CONST && - EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) { - /* nothing to do */ - } else if (IS_UNUSED != IS_CONST && - (IS_TMP_VAR|IS_VAR) == IS_CONST && - EXPECTED(CACHED_PTR(opline->result.num) == ce)) { - fbc = CACHED_PTR(opline->result.num + sizeof(void*)); - } else if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { - function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); - if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { - if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { - do { - if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) { - function_name = Z_REFVAL_P(function_name); - if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { - break; - } - } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - } - zend_throw_error(NULL, "Method name must be a string"); - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - HANDLE_EXCEPTION(); - } while (0); - } - } - - if (ce->get_static_method) { - fbc = ce->get_static_method(ce, Z_STR_P(function_name)); - } else { - fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); - } - if (UNEXPECTED(fbc == NULL)) { - if (EXPECTED(!EG(exception))) { - zend_undefined_method(ce, Z_STR_P(function_name)); - } - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - HANDLE_EXCEPTION(); - } - if ((IS_TMP_VAR|IS_VAR) == IS_CONST && - EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE)))) { - CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc); - } - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - zend_observer_fcall_install((zend_function*)&fbc->op_array); } if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); @@ -38074,7 +35023,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_U fbc = ce->constructor; if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -38473,7 +35421,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_U } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - } if (IS_UNUSED != IS_CONST) { @@ -38490,141 +35437,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_U fbc = ce->constructor; if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - - } - } - - if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) { - if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) { - ce = (zend_class_entry*)Z_OBJ(EX(This)); - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; - } else { - zend_non_static_method_call(fbc); - HANDLE_EXCEPTION(); - } - } else { - /* previous opcode is ZEND_FETCH_CLASS */ - if (IS_UNUSED == IS_UNUSED - && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT || - (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) { - if (Z_TYPE(EX(This)) == IS_OBJECT) { - ce = Z_OBJCE(EX(This)); - } else { - ce = Z_CE(EX(This)); - } - } - call_info = ZEND_CALL_NESTED_FUNCTION; - } - - call = zend_vm_stack_push_call_frame(call_info, - fbc, opline->extended_value, ce); - call->prev_execute_data = EX(call); - EX(call) = call; - - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *function_name; - zend_class_entry *ce; - uint32_t call_info; - zend_function *fbc; - zend_execute_data *call; - - SAVE_OPLINE(); - - if (IS_UNUSED == IS_CONST) { - /* no function found. try a static method in class */ - ce = CACHED_PTR(opline->result.num); - if (UNEXPECTED(ce == NULL)) { - ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); - if (UNEXPECTED(ce == NULL)) { - - HANDLE_EXCEPTION(); - } - if (IS_UNUSED != IS_CONST) { - CACHE_PTR(opline->result.num, ce); - } - } - } else if (IS_UNUSED == IS_UNUSED) { - ce = zend_fetch_class(NULL, opline->op1.num); - if (UNEXPECTED(ce == NULL)) { - - HANDLE_EXCEPTION(); - } - } else { - ce = Z_CE_P(EX_VAR(opline->op1.var)); - } - - if (IS_UNUSED == IS_CONST && - IS_UNUSED == IS_CONST && - EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) { - /* nothing to do */ - } else if (IS_UNUSED != IS_CONST && - IS_UNUSED == IS_CONST && - EXPECTED(CACHED_PTR(opline->result.num) == ce)) { - fbc = CACHED_PTR(opline->result.num + sizeof(void*)); - } else if (IS_UNUSED != IS_UNUSED) { - function_name = NULL; - if (IS_UNUSED != IS_CONST) { - if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { - do { - if (IS_UNUSED & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) { - function_name = Z_REFVAL_P(function_name); - if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { - break; - } - } else if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - } - zend_throw_error(NULL, "Method name must be a string"); - - HANDLE_EXCEPTION(); - } while (0); - } - } - - if (ce->get_static_method) { - fbc = ce->get_static_method(ce, Z_STR_P(function_name)); - } else { - fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_UNUSED == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); - } - if (UNEXPECTED(fbc == NULL)) { - if (EXPECTED(!EG(exception))) { - zend_undefined_method(ce, Z_STR_P(function_name)); - } - - HANDLE_EXCEPTION(); - } - if (IS_UNUSED == IS_CONST && - EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE)))) { - CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc); - } - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - zend_observer_fcall_install((zend_function*)&fbc->op_array); - } - if (IS_UNUSED != IS_CONST) { - - } - } else { - if (UNEXPECTED(ce->constructor == NULL)) { - zend_throw_error(NULL, "Cannot call constructor"); - HANDLE_EXCEPTION(); - } - if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { - zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name)); - HANDLE_EXCEPTION(); - } - fbc = ce->constructor; - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -38856,77 +35668,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_UNUSED_UNUSED_HANDLER } else { if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&constructor->op_array))) { init_func_run_time_cache(&constructor->op_array); - - } - /* We are not handling overloaded classes right now */ - call = zend_vm_stack_push_call_frame( - ZEND_CALL_FUNCTION | ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS, - constructor, - opline->extended_value, - Z_OBJ_P(result)); - Z_ADDREF_P(result); - } - - call->prev_execute_data = EX(call); - EX(call) = call; - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_UNUSED_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *result; - zend_function *constructor; - zend_class_entry *ce; - zend_execute_data *call; - - SAVE_OPLINE(); - if (IS_UNUSED == IS_CONST) { - ce = CACHED_PTR(opline->op2.num); - if (UNEXPECTED(ce == NULL)) { - ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); - if (UNEXPECTED(ce == NULL)) { - ZVAL_UNDEF(EX_VAR(opline->result.var)); - HANDLE_EXCEPTION(); - } - CACHE_PTR(opline->op2.num, ce); - } - } else if (IS_UNUSED == IS_UNUSED) { - ce = zend_fetch_class(NULL, opline->op1.num); - if (UNEXPECTED(ce == NULL)) { - ZVAL_UNDEF(EX_VAR(opline->result.var)); - HANDLE_EXCEPTION(); - } - } else { - ce = Z_CE_P(EX_VAR(opline->op1.var)); - } - - result = EX_VAR(opline->result.var); - if (UNEXPECTED(object_init_ex(result, ce) != SUCCESS)) { - ZVAL_UNDEF(result); - HANDLE_EXCEPTION(); - } - - constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result)); - if (constructor == NULL) { - if (UNEXPECTED(EG(exception))) { - HANDLE_EXCEPTION(); - } - - /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next - * opcode is DO_FCALL in case EXT instructions are used. */ - if (EXPECTED(opline->extended_value == 0 && (opline+1)->opcode == ZEND_DO_FCALL)) { - ZEND_VM_NEXT_OPCODE_EX(1, 2); - } - - /* Perform a dummy function call */ - call = zend_vm_stack_push_call_frame( - ZEND_CALL_FUNCTION, (zend_function *) &zend_pass_function, - opline->extended_value, NULL); - } else { - if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&constructor->op_array))) { - init_func_run_time_cache(&constructor->op_array); - zend_observer_fcall_install((zend_function*)&constructor->op_array); } /* We are not handling overloaded classes right now */ call = zend_vm_stack_push_call_frame( @@ -40636,163 +37377,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_C } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - - } - } - - if (IS_CV != IS_CONST) { - - } - - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; - if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { - if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) { - zend_objects_store_del(obj); - if (UNEXPECTED(EG(exception))) { - HANDLE_EXCEPTION(); - } - } - /* call static method */ - obj = (zend_object*)called_scope; - call_info = ZEND_CALL_NESTED_FUNCTION; - } else if (IS_UNUSED & (IS_VAR|IS_TMP_VAR|IS_CV)) { - if (IS_UNUSED == IS_CV) { - GC_ADDREF(obj); /* For $this pointer */ - } - /* CV may be changed indirectly (e.g. when it's a reference) */ - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS; - } - - call = zend_vm_stack_push_call_frame(call_info, - fbc, opline->extended_value, obj); - call->prev_execute_data = EX(call); - EX(call) = call; - - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *function_name; - zval *object; - zend_function *fbc; - zend_class_entry *called_scope; - zend_object *obj; - zend_execute_data *call; - uint32_t call_info; - - SAVE_OPLINE(); - - object = &EX(This); - - if (IS_CV != IS_CONST) { - function_name = EX_VAR(opline->op2.var); - } - - if (IS_CV != IS_CONST && - UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { - do { - if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { - function_name = Z_REFVAL_P(function_name); - if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { - break; - } - } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); - if (UNEXPECTED(EG(exception) != NULL)) { - - HANDLE_EXCEPTION(); - } - } - zend_throw_error(NULL, "Method name must be a string"); - - - HANDLE_EXCEPTION(); - } while (0); - } - - if (IS_UNUSED == IS_UNUSED) { - obj = Z_OBJ_P(object); - } else { - do { - if (IS_UNUSED != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { - obj = Z_OBJ_P(object); - } else { - if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) { - zend_reference *ref = Z_REF_P(object); - - object = &ref->val; - if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { - obj = Z_OBJ_P(object); - if (IS_UNUSED & IS_VAR) { - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else { - Z_ADDREF_P(object); - } - } - break; - } - } - if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { - object = ZVAL_UNDEFINED_OP1(); - if (UNEXPECTED(EG(exception) != NULL)) { - if (IS_CV != IS_CONST) { - - } - HANDLE_EXCEPTION(); - } - } - if (IS_CV == IS_CONST) { - function_name = EX_VAR(opline->op2.var); - } - zend_invalid_method_call(object, function_name); - - - HANDLE_EXCEPTION(); - } - } while (0); - } - - called_scope = obj->ce; - - if (IS_CV == IS_CONST && - EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { - fbc = CACHED_PTR(opline->result.num + sizeof(void*)); - } else { - zend_object *orig_obj = obj; - - if (IS_CV == IS_CONST) { - function_name = EX_VAR(opline->op2.var); - } - - /* First, locate the function. */ - fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); - if (UNEXPECTED(fbc == NULL)) { - if (EXPECTED(!EG(exception))) { - zend_undefined_method(obj->ce, Z_STR_P(function_name)); - } - - if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) { - zend_objects_store_del(orig_obj); - } - HANDLE_EXCEPTION(); - } - if (IS_CV == IS_CONST && - EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && - EXPECTED(obj == orig_obj)) { - CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); - } - if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) { - GC_ADDREF(obj); /* For $this pointer */ - if (GC_DELREF(orig_obj) == 0) { - zend_objects_store_del(orig_obj); - } - } - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -40910,7 +37494,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_U } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - } if (IS_CV != IS_CONST) { @@ -40927,141 +37510,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_U fbc = ce->constructor; if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - - } - } - - if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) { - if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) { - ce = (zend_class_entry*)Z_OBJ(EX(This)); - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; - } else { - zend_non_static_method_call(fbc); - HANDLE_EXCEPTION(); - } - } else { - /* previous opcode is ZEND_FETCH_CLASS */ - if (IS_UNUSED == IS_UNUSED - && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT || - (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) { - if (Z_TYPE(EX(This)) == IS_OBJECT) { - ce = Z_OBJCE(EX(This)); - } else { - ce = Z_CE(EX(This)); - } - } - call_info = ZEND_CALL_NESTED_FUNCTION; - } - - call = zend_vm_stack_push_call_frame(call_info, - fbc, opline->extended_value, ce); - call->prev_execute_data = EX(call); - EX(call) = call; - - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *function_name; - zend_class_entry *ce; - uint32_t call_info; - zend_function *fbc; - zend_execute_data *call; - - SAVE_OPLINE(); - - if (IS_UNUSED == IS_CONST) { - /* no function found. try a static method in class */ - ce = CACHED_PTR(opline->result.num); - if (UNEXPECTED(ce == NULL)) { - ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); - if (UNEXPECTED(ce == NULL)) { - - HANDLE_EXCEPTION(); - } - if (IS_CV != IS_CONST) { - CACHE_PTR(opline->result.num, ce); - } - } - } else if (IS_UNUSED == IS_UNUSED) { - ce = zend_fetch_class(NULL, opline->op1.num); - if (UNEXPECTED(ce == NULL)) { - - HANDLE_EXCEPTION(); - } - } else { - ce = Z_CE_P(EX_VAR(opline->op1.var)); - } - - if (IS_UNUSED == IS_CONST && - IS_CV == IS_CONST && - EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) { - /* nothing to do */ - } else if (IS_UNUSED != IS_CONST && - IS_CV == IS_CONST && - EXPECTED(CACHED_PTR(opline->result.num) == ce)) { - fbc = CACHED_PTR(opline->result.num + sizeof(void*)); - } else if (IS_CV != IS_UNUSED) { - function_name = EX_VAR(opline->op2.var); - if (IS_CV != IS_CONST) { - if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { - do { - if (IS_CV & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) { - function_name = Z_REFVAL_P(function_name); - if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { - break; - } - } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - } - zend_throw_error(NULL, "Method name must be a string"); - - HANDLE_EXCEPTION(); - } while (0); - } - } - - if (ce->get_static_method) { - fbc = ce->get_static_method(ce, Z_STR_P(function_name)); - } else { - fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); - } - if (UNEXPECTED(fbc == NULL)) { - if (EXPECTED(!EG(exception))) { - zend_undefined_method(ce, Z_STR_P(function_name)); - } - - HANDLE_EXCEPTION(); - } - if (IS_CV == IS_CONST && - EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE)))) { - CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc); - } - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - zend_observer_fcall_install((zend_function*)&fbc->op_array); - } - if (IS_CV != IS_CONST) { - - } - } else { - if (UNEXPECTED(ce->constructor == NULL)) { - zend_throw_error(NULL, "Cannot call constructor"); - HANDLE_EXCEPTION(); - } - if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) { - zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name)); - HANDLE_EXCEPTION(); - } - fbc = ce->constructor; - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -42421,7 +38869,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLE call->prev_execute_data = execute_data; i_init_code_execute_data(call, new_op_array, return_value); - if (EXPECTED(zend_execute_ex == execute_ex)) { ZEND_VM_ENTER(); @@ -42490,7 +38937,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_OBSERV call->prev_execute_data = execute_data; i_init_code_execute_data(call, new_op_array, return_value); - zend_observer_fcall_install((zend_function*)new_op_array); zend_observer_maybe_fcall_call_begin(call); if (EXPECTED(zend_execute_ex == execute_ex)) { @@ -45863,163 +42309,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_S } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - - } - } - - if (IS_CONST != IS_CONST) { - - } - - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; - if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { - if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) { - zend_objects_store_del(obj); - if (UNEXPECTED(EG(exception))) { - HANDLE_EXCEPTION(); - } - } - /* call static method */ - obj = (zend_object*)called_scope; - call_info = ZEND_CALL_NESTED_FUNCTION; - } else if (IS_CV & (IS_VAR|IS_TMP_VAR|IS_CV)) { - if (IS_CV == IS_CV) { - GC_ADDREF(obj); /* For $this pointer */ - } - /* CV may be changed indirectly (e.g. when it's a reference) */ - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS; - } - - call = zend_vm_stack_push_call_frame(call_info, - fbc, opline->extended_value, obj); - call->prev_execute_data = EX(call); - EX(call) = call; - - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *function_name; - zval *object; - zend_function *fbc; - zend_class_entry *called_scope; - zend_object *obj; - zend_execute_data *call; - uint32_t call_info; - - SAVE_OPLINE(); - - object = EX_VAR(opline->op1.var); - - if (IS_CONST != IS_CONST) { - function_name = RT_CONSTANT(opline, opline->op2); - } - - if (IS_CONST != IS_CONST && - UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { - do { - if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { - function_name = Z_REFVAL_P(function_name); - if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { - break; - } - } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); - if (UNEXPECTED(EG(exception) != NULL)) { - - HANDLE_EXCEPTION(); - } - } - zend_throw_error(NULL, "Method name must be a string"); - - - HANDLE_EXCEPTION(); - } while (0); - } - - if (IS_CV == IS_UNUSED) { - obj = Z_OBJ_P(object); - } else { - do { - if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { - obj = Z_OBJ_P(object); - } else { - if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) { - zend_reference *ref = Z_REF_P(object); - - object = &ref->val; - if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { - obj = Z_OBJ_P(object); - if (IS_CV & IS_VAR) { - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else { - Z_ADDREF_P(object); - } - } - break; - } - } - if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { - object = ZVAL_UNDEFINED_OP1(); - if (UNEXPECTED(EG(exception) != NULL)) { - if (IS_CONST != IS_CONST) { - - } - HANDLE_EXCEPTION(); - } - } - if (IS_CONST == IS_CONST) { - function_name = RT_CONSTANT(opline, opline->op2); - } - zend_invalid_method_call(object, function_name); - - - HANDLE_EXCEPTION(); - } - } while (0); - } - - called_scope = obj->ce; - - if (IS_CONST == IS_CONST && - EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { - fbc = CACHED_PTR(opline->result.num + sizeof(void*)); - } else { - zend_object *orig_obj = obj; - - if (IS_CONST == IS_CONST) { - function_name = RT_CONSTANT(opline, opline->op2); - } - - /* First, locate the function. */ - fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); - if (UNEXPECTED(fbc == NULL)) { - if (EXPECTED(!EG(exception))) { - zend_undefined_method(obj->ce, Z_STR_P(function_name)); - } - - if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) { - zend_objects_store_del(orig_obj); - } - HANDLE_EXCEPTION(); - } - if (IS_CONST == IS_CONST && - EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && - EXPECTED(obj == orig_obj)) { - CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); - } - if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) { - GC_ADDREF(obj); /* For $this pointer */ - if (GC_DELREF(orig_obj) == 0) { - zend_objects_store_del(orig_obj); - } - } - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -49607,163 +45896,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVA } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - - } - } - - if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - } - - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; - if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { - if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) { - zend_objects_store_del(obj); - if (UNEXPECTED(EG(exception))) { - HANDLE_EXCEPTION(); - } - } - /* call static method */ - obj = (zend_object*)called_scope; - call_info = ZEND_CALL_NESTED_FUNCTION; - } else if (IS_CV & (IS_VAR|IS_TMP_VAR|IS_CV)) { - if (IS_CV == IS_CV) { - GC_ADDREF(obj); /* For $this pointer */ - } - /* CV may be changed indirectly (e.g. when it's a reference) */ - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS; - } - - call = zend_vm_stack_push_call_frame(call_info, - fbc, opline->extended_value, obj); - call->prev_execute_data = EX(call); - EX(call) = call; - - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *function_name; - zval *object; - zend_function *fbc; - zend_class_entry *called_scope; - zend_object *obj; - zend_execute_data *call; - uint32_t call_info; - - SAVE_OPLINE(); - - object = EX_VAR(opline->op1.var); - - if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { - function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); - } - - if ((IS_TMP_VAR|IS_VAR) != IS_CONST && - UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { - do { - if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { - function_name = Z_REFVAL_P(function_name); - if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { - break; - } - } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); - if (UNEXPECTED(EG(exception) != NULL)) { - - HANDLE_EXCEPTION(); - } - } - zend_throw_error(NULL, "Method name must be a string"); - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - - HANDLE_EXCEPTION(); - } while (0); - } - - if (IS_CV == IS_UNUSED) { - obj = Z_OBJ_P(object); - } else { - do { - if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { - obj = Z_OBJ_P(object); - } else { - if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) { - zend_reference *ref = Z_REF_P(object); - - object = &ref->val; - if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { - obj = Z_OBJ_P(object); - if (IS_CV & IS_VAR) { - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else { - Z_ADDREF_P(object); - } - } - break; - } - } - if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { - object = ZVAL_UNDEFINED_OP1(); - if (UNEXPECTED(EG(exception) != NULL)) { - if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - } - HANDLE_EXCEPTION(); - } - } - if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { - function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); - } - zend_invalid_method_call(object, function_name); - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - - HANDLE_EXCEPTION(); - } - } while (0); - } - - called_scope = obj->ce; - - if ((IS_TMP_VAR|IS_VAR) == IS_CONST && - EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { - fbc = CACHED_PTR(opline->result.num + sizeof(void*)); - } else { - zend_object *orig_obj = obj; - - if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { - function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); - } - - /* First, locate the function. */ - fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); - if (UNEXPECTED(fbc == NULL)) { - if (EXPECTED(!EG(exception))) { - zend_undefined_method(obj->ce, Z_STR_P(function_name)); - } - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) { - zend_objects_store_del(orig_obj); - } - HANDLE_EXCEPTION(); - } - if ((IS_TMP_VAR|IS_VAR) == IS_CONST && - EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && - EXPECTED(obj == orig_obj)) { - CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); - } - if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) { - GC_ADDREF(obj); /* For $this pointer */ - if (GC_DELREF(orig_obj) == 0) { - zend_objects_store_del(orig_obj); - } - } - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -54888,163 +51020,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HA } if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); - - } - } - - if (IS_CV != IS_CONST) { - - } - - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; - if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { - if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) { - zend_objects_store_del(obj); - if (UNEXPECTED(EG(exception))) { - HANDLE_EXCEPTION(); - } - } - /* call static method */ - obj = (zend_object*)called_scope; - call_info = ZEND_CALL_NESTED_FUNCTION; - } else if (IS_CV & (IS_VAR|IS_TMP_VAR|IS_CV)) { - if (IS_CV == IS_CV) { - GC_ADDREF(obj); /* For $this pointer */ - } - /* CV may be changed indirectly (e.g. when it's a reference) */ - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS; - } - - call = zend_vm_stack_push_call_frame(call_info, - fbc, opline->extended_value, obj); - call->prev_execute_data = EX(call); - EX(call) = call; - - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *function_name; - zval *object; - zend_function *fbc; - zend_class_entry *called_scope; - zend_object *obj; - zend_execute_data *call; - uint32_t call_info; - - SAVE_OPLINE(); - - object = EX_VAR(opline->op1.var); - - if (IS_CV != IS_CONST) { - function_name = EX_VAR(opline->op2.var); - } - - if (IS_CV != IS_CONST && - UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { - do { - if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { - function_name = Z_REFVAL_P(function_name); - if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { - break; - } - } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); - if (UNEXPECTED(EG(exception) != NULL)) { - - HANDLE_EXCEPTION(); - } - } - zend_throw_error(NULL, "Method name must be a string"); - - - HANDLE_EXCEPTION(); - } while (0); - } - - if (IS_CV == IS_UNUSED) { - obj = Z_OBJ_P(object); - } else { - do { - if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { - obj = Z_OBJ_P(object); - } else { - if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) { - zend_reference *ref = Z_REF_P(object); - - object = &ref->val; - if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { - obj = Z_OBJ_P(object); - if (IS_CV & IS_VAR) { - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else { - Z_ADDREF_P(object); - } - } - break; - } - } - if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { - object = ZVAL_UNDEFINED_OP1(); - if (UNEXPECTED(EG(exception) != NULL)) { - if (IS_CV != IS_CONST) { - - } - HANDLE_EXCEPTION(); - } - } - if (IS_CV == IS_CONST) { - function_name = EX_VAR(opline->op2.var); - } - zend_invalid_method_call(object, function_name); - - - HANDLE_EXCEPTION(); - } - } while (0); - } - - called_scope = obj->ce; - - if (IS_CV == IS_CONST && - EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { - fbc = CACHED_PTR(opline->result.num + sizeof(void*)); - } else { - zend_object *orig_obj = obj; - - if (IS_CV == IS_CONST) { - function_name = EX_VAR(opline->op2.var); - } - - /* First, locate the function. */ - fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); - if (UNEXPECTED(fbc == NULL)) { - if (EXPECTED(!EG(exception))) { - zend_undefined_method(obj->ce, Z_STR_P(function_name)); - } - - if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) { - zend_objects_store_del(orig_obj); - } - HANDLE_EXCEPTION(); - } - if (IS_CV == IS_CONST && - EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && - EXPECTED(obj == orig_obj)) { - CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); - } - if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) { - GC_ADDREF(obj); /* For $this pointer */ - if (GC_DELREF(orig_obj) == 0) { - zend_objects_store_del(orig_obj); - } - } - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - zend_observer_fcall_install((zend_function*)&fbc->op_array); } } @@ -57036,13 +53011,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_BEGIN_SILENCE_SPEC_LABEL, (void*)&&ZEND_END_SILENCE_SPEC_TMP_LABEL, (void*)&&ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_LABEL, - (void*)&&ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_OBSERVER_LABEL, (void*)&&ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_LABEL, (void*)&&ZEND_DO_FCALL_SPEC_RETVAL_USED_LABEL, (void*)&&ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_OBSERVER_LABEL, (void*)&&ZEND_DO_FCALL_SPEC_RETVAL_USED_OBSERVER_LABEL, (void*)&&ZEND_INIT_FCALL_SPEC_CONST_LABEL, - (void*)&&ZEND_INIT_FCALL_SPEC_CONST_OBSERVER_LABEL, (void*)&&ZEND_RETURN_SPEC_CONST_LABEL, (void*)&&ZEND_RETURN_SPEC_CONST_OBSERVER_LABEL, (void*)&&ZEND_RETURN_SPEC_TMP_LABEL, @@ -57156,17 +53129,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_SEND_REF_SPEC_CV_UNUSED_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NEW_SPEC_CONST_UNUSED_LABEL, - (void*)&&ZEND_NEW_SPEC_CONST_UNUSED_OBSERVER_LABEL, - (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NEW_SPEC_VAR_UNUSED_LABEL, - (void*)&&ZEND_NEW_SPEC_VAR_UNUSED_OBSERVER_LABEL, (void*)&&ZEND_NEW_SPEC_UNUSED_UNUSED_LABEL, - (void*)&&ZEND_NEW_SPEC_UNUSED_UNUSED_OBSERVER_LABEL, - (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_LABEL, - (void*)&&ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_OBSERVER_LABEL, (void*)&&ZEND_FREE_SPEC_TMPVAR_LABEL, (void*)&&ZEND_INIT_ARRAY_SPEC_CONST_CONST_LABEL, (void*)&&ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_LABEL, @@ -57693,100 +53660,50 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_RETURN_BY_REF_SPEC_CV_LABEL, (void*)&&ZEND_RETURN_BY_REF_SPEC_CV_OBSERVER_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_LABEL, - (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_OBSERVER_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_LABEL, - (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_OBSERVER_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_LABEL, - (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_OBSERVER_LABEL, - (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_LABEL, - (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_OBSERVER_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_LABEL, - (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_OBSERVER_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_LABEL, - (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_OBSERVER_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_LABEL, - (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_OBSERVER_LABEL, - (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_LABEL, - (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_OBSERVER_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_LABEL, - (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_OBSERVER_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_LABEL, - (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_OBSERVER_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_LABEL, - (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_OBSERVER_LABEL, - (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_LABEL, - (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_OBSERVER_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_LABEL, - (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_OBSERVER_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_LABEL, - (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_OBSERVER_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_LABEL, - (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_OBSERVER_LABEL, - (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_LABEL, - (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_OBSERVER_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_LABEL, - (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_OBSERVER_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_LABEL, - (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_OBSERVER_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_LABEL, - (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_OBSERVER_LABEL, - (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_CV_LABEL, - (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_CV_OBSERVER_LABEL, (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_LABEL, - (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_OBSERVER_LABEL, (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_LABEL, - (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_OBSERVER_LABEL, (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_LABEL, - (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_OBSERVER_LABEL, (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_LABEL, - (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_OBSERVER_LABEL, (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_LABEL, - (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_OBSERVER_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_LABEL, - (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_OBSERVER_LABEL, (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_LABEL, - (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_OBSERVER_LABEL, (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_LABEL, - (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_OBSERVER_LABEL, (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_LABEL, - (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_OBSERVER_LABEL, (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_LABEL, - (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_OBSERVER_LABEL, (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_LABEL, - (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_OBSERVER_LABEL, (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_LABEL, - (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_OBSERVER_LABEL, (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_LABEL, - (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_OBSERVER_LABEL, (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_LABEL, - (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_OBSERVER_LABEL, (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_LABEL, - (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_OBSERVER_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -57898,15 +53815,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_SEND_VAR_SPEC_CV_UNUSED_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_CONST_LABEL, - (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_CONST_OBSERVER_LABEL, (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_LABEL, - (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_OBSERVER_LABEL, (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_LABEL, - (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_OBSERVER_LABEL, - (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_CV_LABEL, - (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_CV_OBSERVER_LABEL, (void*)&&ZEND_SEND_ARRAY_SPEC_LABEL, (void*)&&ZEND_SEND_USER_SPEC_CONST_LABEL, (void*)&&ZEND_SEND_USER_SPEC_TMP_LABEL, @@ -59579,10 +55491,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INIT_FCALL_BY_NAME_SPEC_CONST) ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_OBSERVER): - VM_TRACE(ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_OBSERVER) - ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_INIT_DYNAMIC_CALL_SPEC_CONST): VM_TRACE(ZEND_INIT_DYNAMIC_CALL_SPEC_CONST) ZEND_INIT_DYNAMIC_CALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -59591,18 +55499,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST) ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_OBSERVER): - VM_TRACE(ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_OBSERVER) - ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_INIT_FCALL_SPEC_CONST): VM_TRACE(ZEND_INIT_FCALL_SPEC_CONST) ZEND_INIT_FCALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_FCALL_SPEC_CONST_OBSERVER): - VM_TRACE(ZEND_INIT_FCALL_SPEC_CONST_OBSERVER) - ZEND_INIT_FCALL_SPEC_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_RECV_INIT_SPEC_CONST): VM_TRACE(ZEND_RECV_INIT_SPEC_CONST) ZEND_RECV_INIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -60027,26 +55927,14 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST) ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_OBSERVER): - VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_OBSERVER) - ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST): VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST) ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_OBSERVER): - VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_OBSERVER) - ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_INIT_USER_CALL_SPEC_CONST_CONST): VM_TRACE(ZEND_INIT_USER_CALL_SPEC_CONST_CONST) ZEND_INIT_USER_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_USER_CALL_SPEC_CONST_CONST_OBSERVER): - VM_TRACE(ZEND_INIT_USER_CALL_SPEC_CONST_CONST_OBSERVER) - ZEND_INIT_USER_CALL_SPEC_CONST_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_SEND_VAL_SPEC_CONST_CONST): VM_TRACE(ZEND_SEND_VAL_SPEC_CONST_CONST) ZEND_SEND_VAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -60267,26 +56155,14 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_OBSERVER): - VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_OBSERVER) - ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR): VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_OBSERVER): - VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_OBSERVER) - ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR): VM_TRACE(ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_OBSERVER): - VM_TRACE(ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_OBSERVER) - ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR): VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR) ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -60343,10 +56219,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED) ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_OBSERVER): - VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_OBSERVER) - ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED): VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED) ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -60367,10 +56239,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_NEW_SPEC_CONST_UNUSED) ZEND_NEW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_NEW_SPEC_CONST_UNUSED_OBSERVER): - VM_TRACE(ZEND_NEW_SPEC_CONST_UNUSED_OBSERVER) - ZEND_NEW_SPEC_CONST_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED): VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED) ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -60467,26 +56335,14 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CONST_CV) ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_OBSERVER): - VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_OBSERVER) - ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV): VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV) ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_OBSERVER): - VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_OBSERVER) - ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_INIT_USER_CALL_SPEC_CONST_CV): VM_TRACE(ZEND_INIT_USER_CALL_SPEC_CONST_CV) ZEND_INIT_USER_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_USER_CALL_SPEC_CONST_CV_OBSERVER): - VM_TRACE(ZEND_INIT_USER_CALL_SPEC_CONST_CV_OBSERVER) - ZEND_INIT_USER_CALL_SPEC_CONST_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV): VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV) ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -61083,10 +56939,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_OBSERVER): - VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_OBSERVER) - ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_SEND_VAL_SPEC_TMPVAR_CONST): VM_TRACE(ZEND_SEND_VAL_SPEC_TMPVAR_CONST) ZEND_SEND_VAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -61187,10 +57039,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_OBSERVER): - VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_OBSERVER) - ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_CASE_SPEC_TMPVAR_TMPVAR): VM_TRACE(ZEND_CASE_SPEC_TMPVAR_TMPVAR) ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -61303,10 +57151,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_OBSERVER): - VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_OBSERVER) - ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_CASE_SPEC_TMPVAR_CV): VM_TRACE(ZEND_CASE_SPEC_TMPVAR_CV) ZEND_CASE_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -62027,10 +57871,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST) ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_OBSERVER): - VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_OBSERVER) - ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_SEND_VAR_SPEC_VAR_CONST): VM_TRACE(ZEND_SEND_VAR_SPEC_VAR_CONST) ZEND_SEND_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -62183,10 +58023,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_OBSERVER): - VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_OBSERVER) - ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR): VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR) ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -62287,10 +58123,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED) ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_OBSERVER): - VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_OBSERVER) - ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED): VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED) ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -62331,10 +58163,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_NEW_SPEC_VAR_UNUSED) ZEND_NEW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_NEW_SPEC_VAR_UNUSED_OBSERVER): - VM_TRACE(ZEND_NEW_SPEC_VAR_UNUSED_OBSERVER) - ZEND_NEW_SPEC_VAR_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED): VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED) ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -62479,10 +58307,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV) ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_OBSERVER): - VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_OBSERVER) - ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV): VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV) ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -62591,18 +58415,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST) ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_OBSERVER): - VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_OBSERVER) - ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST): VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST) ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_OBSERVER): - VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_OBSERVER) - ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST): VM_TRACE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST) ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -62703,18 +58519,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_OBSERVER): - VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_OBSERVER) - ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR): VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_OBSERVER): - VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_OBSERVER) - ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR): VM_TRACE(ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR) ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -62739,10 +58547,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED) ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_OBSERVER): - VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_OBSERVER) - ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED): VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED) ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -62763,10 +58567,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_NEW_SPEC_UNUSED_UNUSED) ZEND_NEW_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_NEW_SPEC_UNUSED_UNUSED_OBSERVER): - VM_TRACE(ZEND_NEW_SPEC_UNUSED_UNUSED_OBSERVER) - ZEND_NEW_SPEC_UNUSED_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED): VM_TRACE(ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED) ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -62871,18 +58671,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV) ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_OBSERVER): - VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_OBSERVER) - ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV): VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV) ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_OBSERVER): - VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_OBSERVER) - ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_UNUSED_CV): VM_TRACE(ZEND_INIT_ARRAY_SPEC_UNUSED_CV) ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -63407,10 +59199,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CV_CONST) ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_OBSERVER): - VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_OBSERVER) - ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_SEND_VAR_SPEC_CV_CONST): VM_TRACE(ZEND_SEND_VAR_SPEC_CV_CONST) ZEND_SEND_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -63643,10 +59431,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_OBSERVER): - VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_OBSERVER) - ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR): VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR) ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -64039,10 +59823,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CV_CV) ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CV_CV_OBSERVER): - VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CV_CV_OBSERVER) - ZEND_INIT_METHOD_CALL_SPEC_CV_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - HYBRID_BREAK(); HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV): VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV) ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -64150,7 +59930,6 @@ ZEND_API void zend_execute(zend_op_array *op_array, zval *return_value) EX(prev_execute_data) = EG(current_execute_data); i_init_code_execute_data(execute_data, op_array, return_value); if (ZEND_OBSERVER_ENABLED) { - zend_observer_fcall_install((zend_function*)op_array); zend_observer_maybe_fcall_call_begin(execute_data); } zend_execute_ex(execute_data); @@ -65512,13 +61291,11 @@ void zend_vm_init(void) ZEND_BEGIN_SILENCE_SPEC_HANDLER, ZEND_END_SILENCE_SPEC_TMP_HANDLER, ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER, - ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_OBSERVER_HANDLER, ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_HANDLER, ZEND_DO_FCALL_SPEC_RETVAL_USED_HANDLER, ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_OBSERVER_HANDLER, ZEND_DO_FCALL_SPEC_RETVAL_USED_OBSERVER_HANDLER, ZEND_INIT_FCALL_SPEC_CONST_HANDLER, - ZEND_INIT_FCALL_SPEC_CONST_OBSERVER_HANDLER, ZEND_RETURN_SPEC_CONST_HANDLER, ZEND_RETURN_SPEC_CONST_OBSERVER_HANDLER, ZEND_RETURN_SPEC_TMP_HANDLER, @@ -65632,17 +61409,11 @@ void zend_vm_init(void) ZEND_SEND_REF_SPEC_CV_UNUSED_HANDLER, ZEND_NULL_HANDLER, ZEND_NEW_SPEC_CONST_UNUSED_HANDLER, - ZEND_NEW_SPEC_CONST_UNUSED_OBSERVER_HANDLER, - ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NEW_SPEC_VAR_UNUSED_HANDLER, - ZEND_NEW_SPEC_VAR_UNUSED_OBSERVER_HANDLER, ZEND_NEW_SPEC_UNUSED_UNUSED_HANDLER, - ZEND_NEW_SPEC_UNUSED_UNUSED_OBSERVER_HANDLER, - ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER, - ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_OBSERVER_HANDLER, ZEND_FREE_SPEC_TMPVAR_HANDLER, ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER, ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_HANDLER, @@ -66169,100 +61940,50 @@ void zend_vm_init(void) ZEND_RETURN_BY_REF_SPEC_CV_HANDLER, ZEND_RETURN_BY_REF_SPEC_CV_OBSERVER_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_HANDLER, - ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_OBSERVER_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER, - ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_OBSERVER_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER, - ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_OBSERVER_HANDLER, - ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_HANDLER, - ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_OBSERVER_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_HANDLER, - ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_OBSERVER_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER, - ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_OBSERVER_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER, - ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_OBSERVER_HANDLER, - ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_HANDLER, - ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_OBSERVER_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_HANDLER, - ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_OBSERVER_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER, - ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_OBSERVER_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER, - ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_OBSERVER_HANDLER, - ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_HANDLER, - ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_OBSERVER_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER, - ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_OBSERVER_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER, - ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_OBSERVER_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER, - ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_OBSERVER_HANDLER, - ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER, - ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_OBSERVER_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER, - ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_OBSERVER_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_HANDLER, - ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_OBSERVER_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_HANDLER, - ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_OBSERVER_HANDLER, - ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER, - ZEND_INIT_METHOD_CALL_SPEC_CV_CV_OBSERVER_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER, - ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_OBSERVER_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER, - ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_OBSERVER_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER, - ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_OBSERVER_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER, - ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_OBSERVER_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER, - ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_OBSERVER_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER, - ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_OBSERVER_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER, - ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_OBSERVER_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER, - ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_OBSERVER_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER, - ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_OBSERVER_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER, - ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_OBSERVER_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER, - ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_OBSERVER_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER, - ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_OBSERVER_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER, - ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_OBSERVER_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_HANDLER, - ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_OBSERVER_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_HANDLER, - ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_OBSERVER_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, @@ -66374,15 +62095,10 @@ void zend_vm_init(void) ZEND_SEND_VAR_SPEC_CV_UNUSED_HANDLER, ZEND_NULL_HANDLER, ZEND_INIT_USER_CALL_SPEC_CONST_CONST_HANDLER, - ZEND_INIT_USER_CALL_SPEC_CONST_CONST_OBSERVER_HANDLER, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER, - ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_OBSERVER_HANDLER, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER, - ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_OBSERVER_HANDLER, - ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_INIT_USER_CALL_SPEC_CONST_CV_HANDLER, - ZEND_INIT_USER_CALL_SPEC_CONST_CV_OBSERVER_HANDLER, ZEND_SEND_ARRAY_SPEC_HANDLER, ZEND_SEND_USER_SPEC_CONST_HANDLER, ZEND_SEND_USER_SPEC_TMP_HANDLER, @@ -67738,148 +63454,148 @@ void zend_vm_init(void) 1342 | SPEC_RULE_OP2, 1347, 1348, - 1349 | SPEC_RULE_OBSERVER, - 1351 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, - 1355 | SPEC_RULE_OBSERVER, - 1357 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, - 1367, - 1368, - 1369 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1394 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, - 1444 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1469 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, - 1479 | SPEC_RULE_OBSERVER, - 1481, - 1482 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1507 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1532 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, - 1542 | SPEC_RULE_OP1, - 1547 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1572 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1597 | SPEC_RULE_OP1, - 1602, - 1603, - 1604 | SPEC_RULE_OP1, - 1609 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1634 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1659 | SPEC_RULE_OP1, - 1664 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1689 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1714 | SPEC_RULE_OP1, - 1719 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1744 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1769 | SPEC_RULE_OP1, - 1774 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1799 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1824 | SPEC_RULE_OP1, - 1829 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1854 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1879 | SPEC_RULE_OP1, - 1884 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1909 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1934 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1959, - 1960 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, - 1970, - 1971, + 1349, + 1350 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, + 1354, + 1355 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, + 1365, + 1366, + 1367 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1392 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, + 1442 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1467 | SPEC_RULE_OP1, + 1472, + 1473, + 1474 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1499 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1524 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, + 1534 | SPEC_RULE_OP1, + 1539 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1564 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1589 | SPEC_RULE_OP1, + 1594, + 1595, + 1596 | SPEC_RULE_OP1, + 1601 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1626 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1651 | SPEC_RULE_OP1, + 1656 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1681 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1706 | SPEC_RULE_OP1, + 1711 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1736 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1761 | SPEC_RULE_OP1, + 1766 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1791 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1816 | SPEC_RULE_OP1, + 1821 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1846 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1871 | SPEC_RULE_OP1, + 1876 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1901 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1926 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1951, + 1952 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, + 1962, + 1963, + 1964, + 1965, + 1966, + 1967 | SPEC_RULE_OP2, 1972, - 1973, - 1974, - 1975 | SPEC_RULE_OP2, - 1980, - 1981 | SPEC_RULE_OP1, - 1986 | SPEC_RULE_OP2, - 1991 | SPEC_RULE_OP1, - 1996 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, - 2006 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OBSERVER, - 2056 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OBSERVER, - 2106 | SPEC_RULE_OP1, - 2111 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2136 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, - 2186 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2211 | SPEC_RULE_OP2 | SPEC_RULE_OBSERVER, - 2221, - 2222 | SPEC_RULE_OP1, - 2227 | SPEC_RULE_OP1, - 2232, - 2233 | SPEC_RULE_OP1, - 2238 | SPEC_RULE_OP1, - 2243 | SPEC_RULE_OP1, - 2248, - 2249, - 2250 | SPEC_RULE_OP2, - 2255 | SPEC_RULE_RETVAL, - 2257 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, - 2261 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, - 2265 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2265 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2290 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2290 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2315 | SPEC_RULE_OP1, - 2320, - 2321 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1973 | SPEC_RULE_OP1, + 1978 | SPEC_RULE_OP2, + 1983 | SPEC_RULE_OP1, + 1988 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, + 1998 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2023 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2048 | SPEC_RULE_OP1, + 2053 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2078 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, + 2128 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2153 | SPEC_RULE_OP2, + 2158, + 2159 | SPEC_RULE_OP1, + 2164 | SPEC_RULE_OP1, + 2169, + 2170 | SPEC_RULE_OP1, + 2175 | SPEC_RULE_OP1, + 2180 | SPEC_RULE_OP1, + 2185, + 2186, + 2187 | SPEC_RULE_OP2, + 2192 | SPEC_RULE_RETVAL, + 2194 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, + 2198 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, + 2202 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2202 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2227 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2227 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2252 | SPEC_RULE_OP1, + 2257, + 2258 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2283, + 2284 | SPEC_RULE_OP1, + 2289, + 2290, + 2291, + 2292, + 2293, + 2294, + 2295, + 2296 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2321 | SPEC_RULE_OBSERVER, + 2323, + 2324, + 2325 | SPEC_RULE_OP1, + 2330, + 2331 | SPEC_RULE_ISSET, + 2333 | SPEC_RULE_OP2, + 2338, + 2339 | SPEC_RULE_OP1, + 2344 | SPEC_RULE_OBSERVER, 2346, - 2347 | SPEC_RULE_OP1, - 2352, - 2353, - 2354, - 2355, - 2356, - 2357, - 2358, - 2359 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2384 | SPEC_RULE_OBSERVER, - 2386, - 2387, - 2388 | SPEC_RULE_OP1, - 2393, - 2394 | SPEC_RULE_ISSET, - 2396 | SPEC_RULE_OP2, - 2401, - 2402 | SPEC_RULE_OP1, - 2407 | SPEC_RULE_OBSERVER, - 2409, - 2410 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2435 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, - 2445, - 2446, - 2447, - 2448, - 2449 | SPEC_RULE_OP1, - 2454, - 2455, + 2347 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2372 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, + 2382, + 2383, + 2384, + 2385, + 2386 | SPEC_RULE_OP1, + 2391, + 2392, + 2393 | SPEC_RULE_OP1, + 2398 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2423, + 2424 | SPEC_RULE_OP1, + 2429, + 2430, + 2431, + 2432, + 2433, + 2434, + 2435, + 2436, + 2437 | SPEC_RULE_OP1, + 2442, + 2443, + 2444, + 2445 | SPEC_RULE_OP2, + 2450, + 2451 | SPEC_RULE_OP1, 2456 | SPEC_RULE_OP1, - 2461 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2486, - 2487 | SPEC_RULE_OP1, - 2492, - 2493, - 2494, - 2495, - 2496, - 2497, - 2498, - 2499, - 2500 | SPEC_RULE_OP1, - 2505, - 2506, - 2507, - 2508 | SPEC_RULE_OP2, - 2513, - 2514 | SPEC_RULE_OP1, - 2519 | SPEC_RULE_OP1, - 2524 | SPEC_RULE_OP1, - 2529 | SPEC_RULE_OP1, - 2534 | SPEC_RULE_OP1, - 2539, - 2540 | SPEC_RULE_OP1, - 2545 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2570 | SPEC_RULE_OP1, - 2575 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2600 | SPEC_RULE_OP1, - 2605 | SPEC_RULE_OP1, - 2610, - 3514 + 2461 | SPEC_RULE_OP1, + 2466 | SPEC_RULE_OP1, + 2471 | SPEC_RULE_OP1, + 2476, + 2477 | SPEC_RULE_OP1, + 2482 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2507 | SPEC_RULE_OP1, + 2512 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2537 | SPEC_RULE_OP1, + 2542 | SPEC_RULE_OP1, + 2547, + 3451 }; #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID) zend_opcode_handler_funcs = labels; @@ -68052,7 +63768,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 = 2613 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2550 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -68060,7 +63776,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 = 2638 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2575 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -68068,7 +63784,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 = 2663 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2600 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -68079,17 +63795,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 = 2688 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2625 | 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 = 2713 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2650 | 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 = 2738 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2675 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_MUL: @@ -68100,17 +63816,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 = 2763 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2700 | 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 = 2788 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2725 | 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 = 2813 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2750 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_IDENTICAL: @@ -68121,14 +63837,14 @@ 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 = 2838 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2775 | 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 = 2913 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2850 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF))) { - spec = 3138 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3075 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_IDENTICAL: @@ -68139,14 +63855,14 @@ 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 = 2988 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2925 | 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 = 3063 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3000 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF))) { - spec = 3143 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3080 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_EQUAL: @@ -68157,12 +63873,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 = 2838 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2775 | 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 = 2913 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2850 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_EQUAL: @@ -68173,12 +63889,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 = 2988 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2925 | 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 = 3063 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3000 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_SMALLER: @@ -68186,12 +63902,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 = 3148 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3085 | 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 = 3223 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3160 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_IS_SMALLER_OR_EQUAL: @@ -68199,74 +63915,74 @@ 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 = 3298 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3235 | 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 = 3373 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3310 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_QM_ASSIGN: if (op1_info == MAY_BE_LONG) { - spec = 3460 | SPEC_RULE_OP1; + spec = 3397 | SPEC_RULE_OP1; } else if (op1_info == MAY_BE_DOUBLE) { - spec = 3465 | SPEC_RULE_OP1; + spec = 3402 | 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 = 3470 | SPEC_RULE_OP1; + spec = 3407 | SPEC_RULE_OP1; } break; case ZEND_PRE_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3448 | SPEC_RULE_RETVAL; + spec = 3385 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3450 | SPEC_RULE_RETVAL; + spec = 3387 | SPEC_RULE_RETVAL; } break; case ZEND_PRE_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3452 | SPEC_RULE_RETVAL; + spec = 3389 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3454 | SPEC_RULE_RETVAL; + spec = 3391 | SPEC_RULE_RETVAL; } break; case ZEND_POST_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3456; + spec = 3393; } else if (op1_info == MAY_BE_LONG) { - spec = 3457; + spec = 3394; } break; case ZEND_POST_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3458; + spec = 3395; } else if (op1_info == MAY_BE_LONG) { - spec = 3459; + spec = 3396; } break; case ZEND_JMP: if (OP_JMP_ADDR(op, op->op1) > op) { - spec = 2612; + spec = 2549; } break; case ZEND_RECV: if (op->op2.num == MAY_BE_ANY) { - spec = 2611; + spec = 2548; } break; case ZEND_SEND_VAL: if (op->op1_type == IS_CONST && op->op2_type == IS_UNUSED && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3510; + spec = 3447; } break; case ZEND_SEND_VAR_EX: if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3505 | SPEC_RULE_OP1; + spec = 3442 | 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 = 3512 | SPEC_RULE_RETVAL; + spec = 3449 | SPEC_RULE_RETVAL; } break; case ZEND_FETCH_DIM_R: @@ -68274,17 +63990,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 = 3475 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 3412 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_SEND_VAL_EX: if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3511; + spec = 3448; } break; case ZEND_SEND_VAR: if (op->op2_type == IS_UNUSED && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3500 | SPEC_RULE_OP1; + spec = 3437 | SPEC_RULE_OP1; } break; case ZEND_BW_OR: diff --git a/Zend/zend_vm_execute.skl b/Zend/zend_vm_execute.skl index c5651ccc732c6..22911760e43e1 100644 --- a/Zend/zend_vm_execute.skl +++ b/Zend/zend_vm_execute.skl @@ -56,7 +56,6 @@ ZEND_API void zend_{%EXECUTOR_NAME%}(zend_op_array *op_array, zval *return_value EX(prev_execute_data) = EG(current_execute_data); i_init_code_execute_data(execute_data, op_array, return_value); if (ZEND_OBSERVER_ENABLED) { - zend_observer_fcall_install((zend_function*)op_array); zend_observer_maybe_fcall_call_begin(execute_data); } zend_{%EXECUTOR_NAME%}_ex(execute_data); diff --git a/Zend/zend_vm_gen.php b/Zend/zend_vm_gen.php index c3e3494f9b211..0c79812805891 100755 --- a/Zend/zend_vm_gen.php +++ b/Zend/zend_vm_gen.php @@ -793,9 +793,6 @@ function gen_code($f, $spec, $kind, $code, $op1, $op2, $name, $extra_spec=null) "/opline->extended_value\s*&\s*~\s*ZEND_ISEMPTY/" => isset($extra_spec['ISSET']) ? ($extra_spec['ISSET'] == 0 ? "\\0" : "opline->extended_value") : "\\0", - "/OBSERVER_FCALL_INSTALL\(\s*(.*)\s*\)/" => isset($extra_spec['OBSERVER']) ? - ($extra_spec['OBSERVER'] == 0 ? "" : "zend_observer_fcall_install(\\1)") - : "", "/OBSERVER_FCALL_BEGIN_HANDLERS\(\s*(.*)\s*\)/" => isset($extra_spec['OBSERVER']) ? ($extra_spec['OBSERVER'] == 0 ? "" : "zend_observer_maybe_fcall_call_begin(\\1)") : "", diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h index 3cf762bc825da..8410c70e15ceb 100644 --- a/Zend/zend_vm_handlers.h +++ b/Zend/zend_vm_handlers.h @@ -635,1261 +635,1216 @@ _(1347, ZEND_BEGIN_SILENCE_SPEC) \ _(1348, ZEND_END_SILENCE_SPEC_TMP) \ _(1349, ZEND_INIT_FCALL_BY_NAME_SPEC_CONST) \ - _(1350, ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_OBSERVER) \ - _(1351, ZEND_DO_FCALL_SPEC_RETVAL_UNUSED) \ - _(1352, ZEND_DO_FCALL_SPEC_RETVAL_USED) \ - _(1353, ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_OBSERVER) \ - _(1354, ZEND_DO_FCALL_SPEC_RETVAL_USED_OBSERVER) \ - _(1355, ZEND_INIT_FCALL_SPEC_CONST) \ - _(1356, ZEND_INIT_FCALL_SPEC_CONST_OBSERVER) \ - _(1357, ZEND_RETURN_SPEC_CONST) \ - _(1358, ZEND_RETURN_SPEC_CONST_OBSERVER) \ - _(1359, ZEND_RETURN_SPEC_TMP) \ - _(1360, ZEND_RETURN_SPEC_TMP_OBSERVER) \ - _(1361, ZEND_RETURN_SPEC_VAR) \ - _(1362, ZEND_RETURN_SPEC_VAR_OBSERVER) \ - _(1365, ZEND_RETURN_SPEC_CV) \ - _(1366, ZEND_RETURN_SPEC_CV_OBSERVER) \ - _(1367, ZEND_RECV_SPEC_UNUSED) \ - _(1368, ZEND_RECV_INIT_SPEC_CONST) \ - _(1369, ZEND_SEND_VAL_SPEC_CONST_CONST) \ - _(1372, ZEND_SEND_VAL_SPEC_CONST_UNUSED) \ - _(1374, ZEND_SEND_VAL_SPEC_TMPVAR_CONST) \ - _(1377, ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED) \ - _(1379, ZEND_SEND_VAL_SPEC_TMPVAR_CONST) \ - _(1382, ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED) \ - _(1414, ZEND_SEND_VAR_EX_SPEC_VAR_CONST) \ - _(1415, ZEND_SEND_VAR_EX_SPEC_VAR_CONST) \ - _(1420, ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED) \ - _(1421, ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK) \ - _(1434, ZEND_SEND_VAR_EX_SPEC_CV_CONST) \ - _(1435, ZEND_SEND_VAR_EX_SPEC_CV_CONST) \ - _(1440, ZEND_SEND_VAR_EX_SPEC_CV_UNUSED) \ - _(1441, ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK) \ - _(1454, ZEND_SEND_REF_SPEC_VAR_CONST) \ - _(1457, ZEND_SEND_REF_SPEC_VAR_UNUSED) \ - _(1464, ZEND_SEND_REF_SPEC_CV_CONST) \ - _(1467, ZEND_SEND_REF_SPEC_CV_UNUSED) \ - _(1469, ZEND_NEW_SPEC_CONST_UNUSED) \ - _(1470, ZEND_NEW_SPEC_CONST_UNUSED_OBSERVER) \ - _(1473, ZEND_NEW_SPEC_VAR_UNUSED) \ - _(1474, ZEND_NEW_SPEC_VAR_UNUSED_OBSERVER) \ - _(1475, ZEND_NEW_SPEC_UNUSED_UNUSED) \ - _(1476, ZEND_NEW_SPEC_UNUSED_UNUSED_OBSERVER) \ - _(1479, ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST) \ - _(1480, ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_OBSERVER) \ - _(1481, ZEND_FREE_SPEC_TMPVAR) \ - _(1482, ZEND_INIT_ARRAY_SPEC_CONST_CONST) \ - _(1483, ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR) \ - _(1484, ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR) \ - _(1485, ZEND_INIT_ARRAY_SPEC_CONST_UNUSED) \ - _(1486, ZEND_INIT_ARRAY_SPEC_CONST_CV) \ - _(1487, ZEND_INIT_ARRAY_SPEC_TMP_CONST) \ - _(1488, ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR) \ - _(1489, ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR) \ - _(1490, ZEND_INIT_ARRAY_SPEC_TMP_UNUSED) \ - _(1491, ZEND_INIT_ARRAY_SPEC_TMP_CV) \ - _(1492, ZEND_INIT_ARRAY_SPEC_VAR_CONST) \ - _(1493, ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR) \ - _(1494, ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR) \ - _(1495, ZEND_INIT_ARRAY_SPEC_VAR_UNUSED) \ - _(1496, ZEND_INIT_ARRAY_SPEC_VAR_CV) \ - _(1497, ZEND_INIT_ARRAY_SPEC_UNUSED_CONST) \ - _(1498, ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR) \ - _(1499, ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR) \ - _(1500, ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED) \ - _(1501, ZEND_INIT_ARRAY_SPEC_UNUSED_CV) \ - _(1502, ZEND_INIT_ARRAY_SPEC_CV_CONST) \ - _(1503, ZEND_INIT_ARRAY_SPEC_CV_TMPVAR) \ - _(1504, ZEND_INIT_ARRAY_SPEC_CV_TMPVAR) \ - _(1505, ZEND_INIT_ARRAY_SPEC_CV_UNUSED) \ - _(1506, ZEND_INIT_ARRAY_SPEC_CV_CV) \ - _(1507, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST) \ - _(1508, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR) \ - _(1509, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR) \ - _(1510, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED) \ - _(1511, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV) \ - _(1512, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST) \ - _(1513, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR) \ - _(1514, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR) \ - _(1515, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED) \ - _(1516, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV) \ - _(1517, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST) \ - _(1518, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR) \ - _(1519, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR) \ - _(1520, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED) \ - _(1521, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV) \ - _(1527, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST) \ - _(1528, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR) \ - _(1529, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR) \ - _(1530, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED) \ - _(1531, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV) \ - _(1532, ZEND_INCLUDE_OR_EVAL_SPEC_CONST) \ - _(1533, ZEND_INCLUDE_OR_EVAL_SPEC_CONST_OBSERVER) \ - _(1534, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR) \ - _(1535, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_OBSERVER) \ - _(1536, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR) \ - _(1537, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_OBSERVER) \ - _(1540, ZEND_INCLUDE_OR_EVAL_SPEC_CV) \ - _(1541, ZEND_INCLUDE_OR_EVAL_SPEC_CV_OBSERVER) \ - _(1542, ZEND_UNSET_VAR_SPEC_CONST_UNUSED) \ - _(1543, ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED) \ - _(1544, ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED) \ - _(1546, ZEND_UNSET_VAR_SPEC_CV_UNUSED) \ - _(1557, ZEND_UNSET_DIM_SPEC_VAR_CONST) \ - _(1558, ZEND_UNSET_DIM_SPEC_VAR_TMPVAR) \ - _(1559, ZEND_UNSET_DIM_SPEC_VAR_TMPVAR) \ - _(1561, ZEND_UNSET_DIM_SPEC_VAR_CV) \ - _(1567, ZEND_UNSET_DIM_SPEC_CV_CONST) \ - _(1568, ZEND_UNSET_DIM_SPEC_CV_TMPVAR) \ - _(1569, ZEND_UNSET_DIM_SPEC_CV_TMPVAR) \ - _(1571, ZEND_UNSET_DIM_SPEC_CV_CV) \ - _(1582, ZEND_UNSET_OBJ_SPEC_VAR_CONST) \ - _(1583, ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR) \ - _(1584, ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR) \ - _(1586, ZEND_UNSET_OBJ_SPEC_VAR_CV) \ - _(1587, ZEND_UNSET_OBJ_SPEC_UNUSED_CONST) \ - _(1588, ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR) \ - _(1589, ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR) \ - _(1591, ZEND_UNSET_OBJ_SPEC_UNUSED_CV) \ - _(1592, ZEND_UNSET_OBJ_SPEC_CV_CONST) \ - _(1593, ZEND_UNSET_OBJ_SPEC_CV_TMPVAR) \ - _(1594, ZEND_UNSET_OBJ_SPEC_CV_TMPVAR) \ - _(1596, ZEND_UNSET_OBJ_SPEC_CV_CV) \ - _(1597, ZEND_FE_RESET_R_SPEC_CONST) \ - _(1598, ZEND_FE_RESET_R_SPEC_TMP) \ - _(1599, ZEND_FE_RESET_R_SPEC_VAR) \ - _(1601, ZEND_FE_RESET_R_SPEC_CV) \ - _(1602, ZEND_FE_FETCH_R_SPEC_VAR) \ - _(1603, ZEND_EXIT_SPEC) \ - _(1604, ZEND_FETCH_R_SPEC_CONST_UNUSED) \ - _(1605, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \ - _(1606, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \ - _(1608, ZEND_FETCH_R_SPEC_CV_UNUSED) \ - _(1609, ZEND_FETCH_DIM_R_SPEC_CONST_CONST) \ - _(1610, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \ - _(1611, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \ - _(1613, ZEND_FETCH_DIM_R_SPEC_CONST_CV) \ - _(1614, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \ - _(1615, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ - _(1616, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ - _(1618, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \ - _(1619, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \ - _(1620, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ - _(1621, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ - _(1623, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \ - _(1629, ZEND_FETCH_DIM_R_SPEC_CV_CONST) \ - _(1630, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \ - _(1631, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \ - _(1633, ZEND_FETCH_DIM_R_SPEC_CV_CV) \ - _(1634, ZEND_FETCH_OBJ_R_SPEC_CONST_CONST) \ - _(1635, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \ - _(1636, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \ - _(1638, ZEND_FETCH_OBJ_R_SPEC_CONST_CV) \ - _(1639, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \ - _(1640, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ - _(1641, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ - _(1643, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \ - _(1644, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \ - _(1645, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ - _(1646, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ - _(1648, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \ - _(1649, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST) \ - _(1650, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \ - _(1651, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \ - _(1653, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV) \ - _(1654, ZEND_FETCH_OBJ_R_SPEC_CV_CONST) \ - _(1655, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \ - _(1656, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \ - _(1658, ZEND_FETCH_OBJ_R_SPEC_CV_CV) \ - _(1659, ZEND_FETCH_W_SPEC_CONST_UNUSED) \ - _(1660, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \ - _(1661, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \ - _(1663, ZEND_FETCH_W_SPEC_CV_UNUSED) \ - _(1674, ZEND_FETCH_DIM_W_SPEC_VAR_CONST) \ - _(1675, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \ - _(1676, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \ - _(1677, ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED) \ - _(1678, ZEND_FETCH_DIM_W_SPEC_VAR_CV) \ - _(1684, ZEND_FETCH_DIM_W_SPEC_CV_CONST) \ - _(1685, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \ - _(1686, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \ - _(1687, ZEND_FETCH_DIM_W_SPEC_CV_UNUSED) \ - _(1688, ZEND_FETCH_DIM_W_SPEC_CV_CV) \ - _(1699, ZEND_FETCH_OBJ_W_SPEC_VAR_CONST) \ - _(1700, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \ - _(1701, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \ - _(1703, ZEND_FETCH_OBJ_W_SPEC_VAR_CV) \ - _(1704, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST) \ - _(1705, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \ - _(1706, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \ - _(1708, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV) \ - _(1709, ZEND_FETCH_OBJ_W_SPEC_CV_CONST) \ - _(1710, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \ - _(1711, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \ - _(1713, ZEND_FETCH_OBJ_W_SPEC_CV_CV) \ - _(1714, ZEND_FETCH_RW_SPEC_CONST_UNUSED) \ - _(1715, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \ - _(1716, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \ - _(1718, ZEND_FETCH_RW_SPEC_CV_UNUSED) \ - _(1729, ZEND_FETCH_DIM_RW_SPEC_VAR_CONST) \ - _(1730, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \ - _(1731, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \ - _(1732, ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED) \ - _(1733, ZEND_FETCH_DIM_RW_SPEC_VAR_CV) \ - _(1739, ZEND_FETCH_DIM_RW_SPEC_CV_CONST) \ - _(1740, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \ - _(1741, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \ - _(1742, ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED) \ - _(1743, ZEND_FETCH_DIM_RW_SPEC_CV_CV) \ - _(1754, ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST) \ - _(1755, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \ - _(1756, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \ - _(1758, ZEND_FETCH_OBJ_RW_SPEC_VAR_CV) \ - _(1759, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST) \ - _(1760, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \ - _(1761, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \ - _(1763, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV) \ - _(1764, ZEND_FETCH_OBJ_RW_SPEC_CV_CONST) \ - _(1765, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \ - _(1766, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \ - _(1768, ZEND_FETCH_OBJ_RW_SPEC_CV_CV) \ - _(1769, ZEND_FETCH_IS_SPEC_CONST_UNUSED) \ - _(1770, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \ - _(1771, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \ - _(1773, ZEND_FETCH_IS_SPEC_CV_UNUSED) \ - _(1774, ZEND_FETCH_DIM_IS_SPEC_CONST_CONST) \ - _(1775, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \ - _(1776, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \ - _(1778, ZEND_FETCH_DIM_IS_SPEC_CONST_CV) \ - _(1779, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \ - _(1780, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ - _(1781, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ - _(1783, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \ - _(1784, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \ - _(1785, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ - _(1786, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ - _(1788, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \ - _(1794, ZEND_FETCH_DIM_IS_SPEC_CV_CONST) \ - _(1795, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \ - _(1796, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \ - _(1798, ZEND_FETCH_DIM_IS_SPEC_CV_CV) \ - _(1799, ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST) \ - _(1800, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \ - _(1801, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \ - _(1803, ZEND_FETCH_OBJ_IS_SPEC_CONST_CV) \ - _(1804, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \ - _(1805, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ - _(1806, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ - _(1808, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \ - _(1809, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \ - _(1810, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ - _(1811, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ - _(1813, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \ - _(1814, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST) \ - _(1815, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \ - _(1816, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \ - _(1818, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV) \ - _(1819, ZEND_FETCH_OBJ_IS_SPEC_CV_CONST) \ - _(1820, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \ - _(1821, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \ - _(1823, ZEND_FETCH_OBJ_IS_SPEC_CV_CV) \ - _(1824, ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED) \ - _(1825, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \ - _(1826, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \ - _(1828, ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED) \ - _(1829, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST) \ - _(1830, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \ - _(1831, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \ - _(1832, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED) \ - _(1833, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV) \ - _(1834, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST) \ - _(1835, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \ - _(1836, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \ - _(1837, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED) \ - _(1838, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV) \ - _(1839, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST) \ - _(1840, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \ - _(1841, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \ - _(1842, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED) \ - _(1843, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV) \ - _(1849, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST) \ - _(1850, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \ - _(1851, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \ - _(1852, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED) \ - _(1853, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV) \ - _(1854, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST) \ - _(1855, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \ - _(1856, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \ - _(1858, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV) \ - _(1859, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST) \ - _(1860, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \ - _(1861, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \ - _(1863, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV) \ - _(1864, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST) \ - _(1865, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \ - _(1866, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \ - _(1868, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV) \ - _(1869, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST) \ - _(1870, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \ - _(1871, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \ - _(1873, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV) \ - _(1874, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST) \ - _(1875, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \ - _(1876, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \ - _(1878, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV) \ - _(1879, ZEND_FETCH_UNSET_SPEC_CONST_UNUSED) \ - _(1880, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \ - _(1881, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \ - _(1883, ZEND_FETCH_UNSET_SPEC_CV_UNUSED) \ - _(1894, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST) \ - _(1895, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \ - _(1896, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \ - _(1898, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV) \ - _(1904, ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST) \ - _(1905, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \ - _(1906, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \ - _(1908, ZEND_FETCH_DIM_UNSET_SPEC_CV_CV) \ - _(1919, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST) \ - _(1920, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \ - _(1921, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \ - _(1923, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV) \ - _(1924, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST) \ - _(1925, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \ - _(1926, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \ - _(1928, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV) \ - _(1929, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST) \ - _(1930, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \ - _(1931, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \ - _(1933, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV) \ - _(1934, ZEND_FETCH_LIST_R_SPEC_CONST_CONST) \ - _(1935, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \ - _(1936, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \ - _(1938, ZEND_FETCH_LIST_R_SPEC_CONST_CV) \ - _(1939, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ - _(1940, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1941, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1943, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ - _(1944, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ - _(1945, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1946, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1948, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ - _(1954, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ - _(1955, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1956, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1958, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ - _(1959, ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST) \ - _(1960, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST) \ - _(1961, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST) \ - _(1966, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED) \ - _(1967, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK) \ - _(1970, ZEND_EXT_STMT_SPEC) \ - _(1971, ZEND_EXT_FCALL_BEGIN_SPEC) \ - _(1972, ZEND_EXT_FCALL_END_SPEC) \ - _(1973, ZEND_EXT_NOP_SPEC) \ - _(1974, ZEND_TICKS_SPEC) \ - _(1975, ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST) \ - _(1978, ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED) \ - _(1980, ZEND_CATCH_SPEC_CONST) \ - _(1981, ZEND_THROW_SPEC_CONST) \ - _(1982, ZEND_THROW_SPEC_TMPVAR) \ - _(1983, ZEND_THROW_SPEC_TMPVAR) \ - _(1985, ZEND_THROW_SPEC_CV) \ - _(1986, ZEND_FETCH_CLASS_SPEC_UNUSED_CONST) \ - _(1987, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \ - _(1988, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \ - _(1989, ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED) \ - _(1990, ZEND_FETCH_CLASS_SPEC_UNUSED_CV) \ - _(1991, ZEND_CLONE_SPEC_CONST) \ - _(1992, ZEND_CLONE_SPEC_TMPVAR) \ - _(1993, ZEND_CLONE_SPEC_TMPVAR) \ - _(1994, ZEND_CLONE_SPEC_UNUSED) \ - _(1995, ZEND_CLONE_SPEC_CV) \ - _(1996, ZEND_RETURN_BY_REF_SPEC_CONST) \ - _(1997, ZEND_RETURN_BY_REF_SPEC_CONST_OBSERVER) \ - _(1998, ZEND_RETURN_BY_REF_SPEC_TMP) \ - _(1999, ZEND_RETURN_BY_REF_SPEC_TMP_OBSERVER) \ - _(2000, ZEND_RETURN_BY_REF_SPEC_VAR) \ - _(2001, ZEND_RETURN_BY_REF_SPEC_VAR_OBSERVER) \ - _(2004, ZEND_RETURN_BY_REF_SPEC_CV) \ - _(2005, ZEND_RETURN_BY_REF_SPEC_CV_OBSERVER) \ - _(2006, ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST) \ - _(2007, ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_OBSERVER) \ - _(2008, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \ - _(2009, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_OBSERVER) \ - _(2010, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \ - _(2011, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_OBSERVER) \ - _(2014, ZEND_INIT_METHOD_CALL_SPEC_CONST_CV) \ - _(2015, ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_OBSERVER) \ - _(2016, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \ - _(2017, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_OBSERVER) \ - _(2018, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ - _(2019, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_OBSERVER) \ - _(2020, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ - _(2021, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_OBSERVER) \ - _(2024, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \ - _(2025, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_OBSERVER) \ - _(2026, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \ - _(2027, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_OBSERVER) \ - _(2028, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ - _(2029, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_OBSERVER) \ - _(2030, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ - _(2031, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_OBSERVER) \ - _(2034, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \ - _(2035, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_OBSERVER) \ - _(2036, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST) \ - _(2037, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_OBSERVER) \ - _(2038, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ - _(2039, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_OBSERVER) \ - _(2040, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ - _(2041, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_OBSERVER) \ - _(2044, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV) \ - _(2045, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_OBSERVER) \ - _(2046, ZEND_INIT_METHOD_CALL_SPEC_CV_CONST) \ - _(2047, ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_OBSERVER) \ - _(2048, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \ - _(2049, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_OBSERVER) \ - _(2050, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \ - _(2051, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_OBSERVER) \ - _(2054, ZEND_INIT_METHOD_CALL_SPEC_CV_CV) \ - _(2055, ZEND_INIT_METHOD_CALL_SPEC_CV_CV_OBSERVER) \ - _(2056, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST) \ - _(2057, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_OBSERVER) \ - _(2058, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \ - _(2059, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_OBSERVER) \ - _(2060, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \ - _(2061, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_OBSERVER) \ - _(2062, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED) \ - _(2063, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_OBSERVER) \ - _(2064, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV) \ - _(2065, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_OBSERVER) \ - _(2076, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST) \ - _(2077, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_OBSERVER) \ - _(2078, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \ - _(2079, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_OBSERVER) \ - _(2080, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \ - _(2081, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_OBSERVER) \ - _(2082, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED) \ - _(2083, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_OBSERVER) \ - _(2084, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV) \ - _(2085, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_OBSERVER) \ - _(2086, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST) \ - _(2087, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_OBSERVER) \ - _(2088, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ - _(2089, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_OBSERVER) \ - _(2090, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ - _(2091, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_OBSERVER) \ - _(2092, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED) \ - _(2093, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_OBSERVER) \ - _(2094, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV) \ - _(2095, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_OBSERVER) \ - _(2106, ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED) \ - _(2107, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \ - _(2108, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \ - _(2110, ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED) \ - _(2111, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST) \ - _(2112, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \ - _(2113, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \ - _(2115, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV) \ - _(2116, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \ - _(2117, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2118, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2120, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \ - _(2121, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \ - _(2122, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2123, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2125, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \ - _(2131, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST) \ - _(2132, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \ - _(2133, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \ - _(2135, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV) \ - _(2136, ZEND_SEND_VAL_EX_SPEC_CONST_CONST) \ - _(2137, ZEND_SEND_VAL_EX_SPEC_CONST_CONST) \ - _(2142, ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED) \ - _(2143, ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK) \ - _(2146, ZEND_SEND_VAL_EX_SPEC_TMP_CONST) \ - _(2147, ZEND_SEND_VAL_EX_SPEC_TMP_CONST) \ - _(2152, ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED) \ - _(2153, ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK) \ - _(2196, ZEND_SEND_VAR_SPEC_VAR_CONST) \ - _(2199, ZEND_SEND_VAR_SPEC_VAR_UNUSED) \ - _(2206, ZEND_SEND_VAR_SPEC_CV_CONST) \ - _(2209, ZEND_SEND_VAR_SPEC_CV_UNUSED) \ - _(2211, ZEND_INIT_USER_CALL_SPEC_CONST_CONST) \ - _(2212, ZEND_INIT_USER_CALL_SPEC_CONST_CONST_OBSERVER) \ - _(2213, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \ - _(2214, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_OBSERVER) \ - _(2215, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \ - _(2216, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_OBSERVER) \ - _(2219, ZEND_INIT_USER_CALL_SPEC_CONST_CV) \ - _(2220, ZEND_INIT_USER_CALL_SPEC_CONST_CV_OBSERVER) \ - _(2221, ZEND_SEND_ARRAY_SPEC) \ - _(2222, ZEND_SEND_USER_SPEC_CONST) \ - _(2223, ZEND_SEND_USER_SPEC_TMP) \ - _(2224, ZEND_SEND_USER_SPEC_VAR) \ - _(2226, ZEND_SEND_USER_SPEC_CV) \ - _(2227, ZEND_STRLEN_SPEC_CONST) \ - _(2228, ZEND_STRLEN_SPEC_TMPVAR) \ - _(2229, ZEND_STRLEN_SPEC_TMPVAR) \ - _(2231, ZEND_STRLEN_SPEC_CV) \ - _(2232, ZEND_DEFINED_SPEC_CONST) \ - _(2233, ZEND_TYPE_CHECK_SPEC_CONST) \ - _(2234, ZEND_TYPE_CHECK_SPEC_TMPVAR) \ - _(2235, ZEND_TYPE_CHECK_SPEC_TMPVAR) \ - _(2237, ZEND_TYPE_CHECK_SPEC_CV) \ - _(2238, ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED) \ - _(2239, ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED) \ - _(2240, ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED) \ - _(2241, ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED) \ - _(2242, ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED) \ - _(2243, ZEND_FE_RESET_RW_SPEC_CONST) \ - _(2244, ZEND_FE_RESET_RW_SPEC_TMP) \ - _(2245, ZEND_FE_RESET_RW_SPEC_VAR) \ - _(2247, ZEND_FE_RESET_RW_SPEC_CV) \ - _(2248, ZEND_FE_FETCH_RW_SPEC_VAR) \ - _(2249, ZEND_FE_FREE_SPEC_TMPVAR) \ - _(2250, ZEND_INIT_DYNAMIC_CALL_SPEC_CONST) \ - _(2251, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \ - _(2252, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \ - _(2254, ZEND_INIT_DYNAMIC_CALL_SPEC_CV) \ - _(2255, ZEND_DO_ICALL_SPEC_RETVAL_UNUSED) \ - _(2256, ZEND_DO_ICALL_SPEC_RETVAL_USED) \ - _(2257, ZEND_DO_UCALL_SPEC_RETVAL_UNUSED) \ - _(2258, ZEND_DO_UCALL_SPEC_RETVAL_USED) \ - _(2259, ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_OBSERVER) \ - _(2260, ZEND_DO_UCALL_SPEC_RETVAL_USED_OBSERVER) \ - _(2261, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED) \ - _(2262, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED) \ - _(2263, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_OBSERVER) \ - _(2264, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_OBSERVER) \ - _(2275, ZEND_PRE_INC_OBJ_SPEC_VAR_CONST) \ - _(2276, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \ - _(2277, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \ - _(2279, ZEND_PRE_INC_OBJ_SPEC_VAR_CV) \ - _(2280, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST) \ - _(2281, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2282, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2284, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV) \ - _(2285, ZEND_PRE_INC_OBJ_SPEC_CV_CONST) \ - _(2286, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \ - _(2287, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \ - _(2289, ZEND_PRE_INC_OBJ_SPEC_CV_CV) \ - _(2300, ZEND_POST_INC_OBJ_SPEC_VAR_CONST) \ - _(2301, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \ - _(2302, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \ - _(2304, ZEND_POST_INC_OBJ_SPEC_VAR_CV) \ - _(2305, ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST) \ - _(2306, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2307, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2309, ZEND_POST_INC_OBJ_SPEC_UNUSED_CV) \ - _(2310, ZEND_POST_INC_OBJ_SPEC_CV_CONST) \ - _(2311, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \ - _(2312, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \ - _(2314, ZEND_POST_INC_OBJ_SPEC_CV_CV) \ - _(2315, ZEND_ECHO_SPEC_CONST) \ - _(2316, ZEND_ECHO_SPEC_TMPVAR) \ - _(2317, ZEND_ECHO_SPEC_TMPVAR) \ - _(2319, ZEND_ECHO_SPEC_CV) \ - _(2326, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \ - _(2328, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \ - _(2329, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \ - _(2331, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \ - _(2333, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \ - _(2334, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \ - _(2341, ZEND_INSTANCEOF_SPEC_CV_CONST) \ - _(2343, ZEND_INSTANCEOF_SPEC_CV_VAR) \ - _(2344, ZEND_INSTANCEOF_SPEC_CV_UNUSED) \ - _(2346, ZEND_GENERATOR_CREATE_SPEC) \ - _(2349, ZEND_MAKE_REF_SPEC_VAR_UNUSED) \ - _(2351, ZEND_MAKE_REF_SPEC_CV_UNUSED) \ - _(2352, ZEND_DECLARE_FUNCTION_SPEC) \ - _(2353, ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED) \ - _(2354, ZEND_DECLARE_CONST_SPEC_CONST_CONST) \ - _(2355, ZEND_DECLARE_CLASS_SPEC_CONST) \ - _(2356, ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST) \ - _(2357, ZEND_DECLARE_ANON_CLASS_SPEC) \ - _(2358, ZEND_ADD_ARRAY_UNPACK_SPEC) \ - _(2359, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST) \ - _(2360, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \ - _(2361, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \ - _(2363, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV) \ - _(2364, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ - _(2365, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2366, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2368, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ - _(2369, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ - _(2370, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2371, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2373, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ - _(2374, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST) \ - _(2375, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2376, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2378, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV) \ - _(2379, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST) \ - _(2380, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ - _(2381, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ - _(2383, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV) \ - _(2384, ZEND_HANDLE_EXCEPTION_SPEC) \ - _(2385, ZEND_HANDLE_EXCEPTION_SPEC_OBSERVER) \ - _(2386, ZEND_USER_OPCODE_SPEC) \ - _(2387, ZEND_ASSERT_CHECK_SPEC) \ - _(2388, ZEND_JMP_SET_SPEC_CONST) \ - _(2389, ZEND_JMP_SET_SPEC_TMP) \ - _(2390, ZEND_JMP_SET_SPEC_VAR) \ - _(2392, ZEND_JMP_SET_SPEC_CV) \ - _(2393, ZEND_UNSET_CV_SPEC_CV_UNUSED) \ - _(2394, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET) \ - _(2395, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY) \ - _(2396, ZEND_FETCH_LIST_W_SPEC_VAR_CONST) \ - _(2397, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ - _(2398, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ - _(2400, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \ - _(2401, ZEND_SEPARATE_SPEC_VAR_UNUSED) \ - _(2403, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \ - _(2404, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \ - _(2405, ZEND_FETCH_CLASS_NAME_SPEC_UNUSED) \ - _(2406, ZEND_FETCH_CLASS_NAME_SPEC_CV) \ - _(2407, ZEND_CALL_TRAMPOLINE_SPEC) \ - _(2408, ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER) \ - _(2409, ZEND_DISCARD_EXCEPTION_SPEC) \ - _(2410, ZEND_YIELD_SPEC_CONST_CONST) \ - _(2411, ZEND_YIELD_SPEC_CONST_TMPVAR) \ - _(2412, ZEND_YIELD_SPEC_CONST_TMPVAR) \ - _(2413, ZEND_YIELD_SPEC_CONST_UNUSED) \ - _(2414, ZEND_YIELD_SPEC_CONST_CV) \ - _(2415, ZEND_YIELD_SPEC_TMP_CONST) \ - _(2416, ZEND_YIELD_SPEC_TMP_TMPVAR) \ - _(2417, ZEND_YIELD_SPEC_TMP_TMPVAR) \ - _(2418, ZEND_YIELD_SPEC_TMP_UNUSED) \ - _(2419, ZEND_YIELD_SPEC_TMP_CV) \ - _(2420, ZEND_YIELD_SPEC_VAR_CONST) \ - _(2421, ZEND_YIELD_SPEC_VAR_TMPVAR) \ - _(2422, ZEND_YIELD_SPEC_VAR_TMPVAR) \ - _(2423, ZEND_YIELD_SPEC_VAR_UNUSED) \ - _(2424, ZEND_YIELD_SPEC_VAR_CV) \ - _(2425, ZEND_YIELD_SPEC_UNUSED_CONST) \ - _(2426, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \ - _(2427, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \ - _(2428, ZEND_YIELD_SPEC_UNUSED_UNUSED) \ - _(2429, ZEND_YIELD_SPEC_UNUSED_CV) \ - _(2430, ZEND_YIELD_SPEC_CV_CONST) \ - _(2431, ZEND_YIELD_SPEC_CV_TMPVAR) \ - _(2432, ZEND_YIELD_SPEC_CV_TMPVAR) \ - _(2433, ZEND_YIELD_SPEC_CV_UNUSED) \ - _(2434, ZEND_YIELD_SPEC_CV_CV) \ - _(2435, ZEND_GENERATOR_RETURN_SPEC_CONST) \ - _(2436, ZEND_GENERATOR_RETURN_SPEC_CONST_OBSERVER) \ - _(2437, ZEND_GENERATOR_RETURN_SPEC_TMP) \ - _(2438, ZEND_GENERATOR_RETURN_SPEC_TMP_OBSERVER) \ - _(2439, ZEND_GENERATOR_RETURN_SPEC_VAR) \ - _(2440, ZEND_GENERATOR_RETURN_SPEC_VAR_OBSERVER) \ - _(2443, ZEND_GENERATOR_RETURN_SPEC_CV) \ - _(2444, ZEND_GENERATOR_RETURN_SPEC_CV_OBSERVER) \ - _(2445, ZEND_FAST_CALL_SPEC) \ - _(2446, ZEND_FAST_RET_SPEC) \ - _(2447, ZEND_RECV_VARIADIC_SPEC_UNUSED) \ - _(2448, ZEND_SEND_UNPACK_SPEC) \ - _(2449, ZEND_YIELD_FROM_SPEC_CONST) \ - _(2450, ZEND_YIELD_FROM_SPEC_TMPVAR) \ - _(2451, ZEND_YIELD_FROM_SPEC_TMPVAR) \ - _(2453, ZEND_YIELD_FROM_SPEC_CV) \ - _(2454, ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED) \ - _(2455, ZEND_BIND_GLOBAL_SPEC_CV_CONST) \ - _(2456, ZEND_COALESCE_SPEC_CONST) \ - _(2457, ZEND_COALESCE_SPEC_TMP) \ - _(2458, ZEND_COALESCE_SPEC_VAR) \ - _(2460, ZEND_COALESCE_SPEC_CV) \ - _(2461, ZEND_SPACESHIP_SPEC_CONST_CONST) \ - _(2462, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ - _(2463, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ - _(2465, ZEND_SPACESHIP_SPEC_CONST_CV) \ - _(2466, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ - _(2467, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(2468, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(2470, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ - _(2471, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ - _(2472, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(2473, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(2475, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ - _(2481, ZEND_SPACESHIP_SPEC_CV_CONST) \ - _(2482, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ - _(2483, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ - _(2485, ZEND_SPACESHIP_SPEC_CV_CV) \ - _(2486, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED) \ - _(2487, ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED) \ - _(2490, ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED) \ - _(2492, ZEND_FETCH_STATIC_PROP_R_SPEC) \ - _(2493, ZEND_FETCH_STATIC_PROP_W_SPEC) \ - _(2494, ZEND_FETCH_STATIC_PROP_RW_SPEC) \ - _(2495, ZEND_FETCH_STATIC_PROP_IS_SPEC) \ - _(2496, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC) \ - _(2497, ZEND_FETCH_STATIC_PROP_UNSET_SPEC) \ - _(2498, ZEND_UNSET_STATIC_PROP_SPEC) \ - _(2499, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC) \ - _(2500, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) \ - _(2502, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) \ - _(2503, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST) \ - _(2505, ZEND_BIND_LEXICAL_SPEC_TMP_CV) \ - _(2506, ZEND_BIND_STATIC_SPEC_CV_UNUSED) \ - _(2507, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED) \ - _(2508, ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST) \ - _(2511, ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED) \ - _(2513, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED) \ - _(2514, ZEND_SWITCH_LONG_SPEC_CONST_CONST) \ - _(2515, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(2516, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(2518, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(2519, ZEND_SWITCH_STRING_SPEC_CONST_CONST) \ - _(2520, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(2521, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(2523, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(2524, ZEND_IN_ARRAY_SPEC_CONST_CONST) \ - _(2525, ZEND_IN_ARRAY_SPEC_TMP_CONST) \ - _(2526, ZEND_IN_ARRAY_SPEC_VAR_CONST) \ - _(2528, ZEND_IN_ARRAY_SPEC_CV_CONST) \ - _(2529, ZEND_COUNT_SPEC_CONST_UNUSED) \ - _(2530, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \ - _(2531, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \ - _(2533, ZEND_COUNT_SPEC_CV_UNUSED) \ - _(2534, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \ - _(2535, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \ - _(2536, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \ - _(2537, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED) \ - _(2538, ZEND_GET_CLASS_SPEC_CV_UNUSED) \ - _(2539, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED) \ - _(2540, ZEND_GET_TYPE_SPEC_CONST_UNUSED) \ - _(2541, ZEND_GET_TYPE_SPEC_TMP_UNUSED) \ - _(2542, ZEND_GET_TYPE_SPEC_VAR_UNUSED) \ - _(2544, ZEND_GET_TYPE_SPEC_CV_UNUSED) \ - _(2545, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \ - _(2546, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ - _(2547, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ - _(2549, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \ - _(2550, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ - _(2551, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(2552, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(2554, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ - _(2555, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ - _(2556, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(2557, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(2559, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ - _(2565, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \ - _(2566, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ - _(2567, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ - _(2569, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \ - _(2570, ZEND_MATCH_SPEC_CONST_CONST) \ - _(2571, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ - _(2572, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ - _(2574, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ - _(2580, ZEND_CASE_STRICT_SPEC_TMP_CONST) \ - _(2581, ZEND_CASE_STRICT_SPEC_TMP_TMP) \ - _(2582, ZEND_CASE_STRICT_SPEC_TMP_VAR) \ - _(2584, ZEND_CASE_STRICT_SPEC_TMP_CV) \ - _(2585, ZEND_CASE_STRICT_SPEC_VAR_CONST) \ - _(2586, ZEND_CASE_STRICT_SPEC_VAR_TMP) \ - _(2587, ZEND_CASE_STRICT_SPEC_VAR_VAR) \ - _(2589, ZEND_CASE_STRICT_SPEC_VAR_CV) \ - _(2600, ZEND_MATCH_ERROR_SPEC_CONST_UNUSED) \ - _(2601, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ - _(2602, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ - _(2604, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ - _(2605, ZEND_JMP_NULL_SPEC_CONST) \ - _(2606, ZEND_JMP_NULL_SPEC_TMPVARCV) \ - _(2607, ZEND_JMP_NULL_SPEC_TMPVARCV) \ - _(2609, ZEND_JMP_NULL_SPEC_TMPVARCV) \ - _(2610, ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED) \ - _(2611, ZEND_RECV_NOTYPE_SPEC) \ - _(2612, ZEND_JMP_FORWARD_SPEC) \ - _(2618, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2619, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2620, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2622, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2623, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2624, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2625, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2627, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2633, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2634, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2635, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2637, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2643, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2644, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2645, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2647, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2648, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2649, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2650, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2652, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2658, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2659, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2660, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2662, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2668, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2669, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2670, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2672, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2673, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2674, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2675, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2677, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2683, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2684, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2685, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2687, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2689, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2690, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2692, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2693, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2694, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2695, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2697, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2698, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2699, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2700, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2702, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2708, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2709, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2710, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2712, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2714, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2715, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2717, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2718, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2719, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2720, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2722, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2723, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2724, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2725, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2727, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2733, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2734, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2735, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2737, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2739, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2740, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2742, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2743, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2744, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2745, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2747, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2748, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2749, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2750, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2752, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2758, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2759, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2760, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2762, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2768, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2769, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2770, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2772, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2773, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2774, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2775, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2777, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2783, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2784, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2785, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2787, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2793, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2794, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2795, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2797, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2798, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2799, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2800, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2802, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2808, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2809, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2810, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2812, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2818, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2819, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2820, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2822, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2823, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2824, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2825, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2827, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2833, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2834, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2835, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2837, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2853, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2854, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2855, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2856, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2857, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2858, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2859, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2860, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2861, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2865, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2866, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2867, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2868, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2869, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2870, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2871, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2872, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2873, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2874, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2875, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2876, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2880, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2881, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2882, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2898, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2899, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2900, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2901, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2902, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2903, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2904, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2905, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2906, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2910, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2911, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2912, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2928, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2929, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2930, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2931, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2932, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2933, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2934, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2935, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2936, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2940, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2941, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2942, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2943, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2944, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2945, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2946, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2947, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2948, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2949, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2950, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2951, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2955, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2956, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2957, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2973, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2974, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2975, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2976, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2977, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2978, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2979, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2980, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2981, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2985, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2986, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2987, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3003, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3004, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3005, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3006, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3007, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3008, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3009, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3010, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3011, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3015, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3016, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3017, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3018, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3019, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3020, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3021, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3022, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3023, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3024, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3025, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3026, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3030, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3031, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3032, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3048, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3049, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3050, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3051, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3052, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3053, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3054, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3055, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3056, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3060, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3061, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3062, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3078, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3079, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3080, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3081, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3082, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3083, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3084, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3085, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3086, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3090, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3091, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3092, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3093, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3094, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3095, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3096, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3097, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3098, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3099, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3100, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3101, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3105, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3106, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3107, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3123, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3124, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3125, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3126, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3127, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3128, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3129, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3130, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3131, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3135, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3136, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3137, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3138, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(3142, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(3143, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(3147, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(3151, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3152, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3153, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3154, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3155, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3156, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3160, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3161, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3162, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3163, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3164, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3165, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3166, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3167, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3168, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3169, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3170, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3171, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3175, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3176, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3177, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3178, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3179, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3180, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3181, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3182, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3183, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3184, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3185, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3186, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3190, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3191, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3192, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3208, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3209, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3210, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3211, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3212, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3213, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3214, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3215, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3216, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3220, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3221, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3222, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3226, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3227, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3228, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3229, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3230, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3231, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3235, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3236, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3237, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3238, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3239, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3240, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3241, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3242, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3243, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3244, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3245, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3246, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3250, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3251, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3252, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3253, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3254, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3255, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3256, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3257, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3258, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3259, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3260, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3261, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3265, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3266, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3267, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3283, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3284, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3285, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3286, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3287, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3288, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3289, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3290, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3291, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3295, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3296, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3297, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3301, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3302, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3303, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3304, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3305, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3306, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3310, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3311, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3312, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3313, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3314, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3315, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3316, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3317, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3318, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3319, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3320, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3321, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3325, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3326, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3327, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3328, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3329, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3330, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3331, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3332, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3333, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3334, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3335, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3336, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3340, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3341, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3342, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3358, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3359, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3360, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3361, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3362, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3363, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3364, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3365, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3366, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3370, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3371, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3372, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3376, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3377, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3378, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3379, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3380, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3381, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3385, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3386, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3387, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3388, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3389, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3390, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3391, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3392, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3393, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3394, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3395, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3396, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3400, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3401, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3402, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3403, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3404, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3405, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3406, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3407, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3408, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3409, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3410, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3411, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3415, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3416, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3417, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3433, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3434, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3435, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3436, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3437, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3438, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3439, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3440, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3441, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3445, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3446, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3447, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3448, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3449, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3450, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3451, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ - _(3452, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3453, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3454, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3455, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ - _(3456, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3457, ZEND_POST_INC_LONG_SPEC_CV) \ - _(3458, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3459, ZEND_POST_DEC_LONG_SPEC_CV) \ - _(3460, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ - _(3461, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3462, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3464, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3465, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ - _(3466, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3467, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3469, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3470, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ - _(3471, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3472, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3474, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3476, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3477, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3479, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3480, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(3481, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3482, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3484, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3485, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(3486, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3487, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3489, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3495, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ - _(3496, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3497, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3499, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3502, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ - _(3504, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ - _(3507, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ - _(3509, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ - _(3510, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ - _(3511, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ - _(3512, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ - _(3513, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ - _(3513+1, ZEND_NULL) + _(1350, ZEND_DO_FCALL_SPEC_RETVAL_UNUSED) \ + _(1351, ZEND_DO_FCALL_SPEC_RETVAL_USED) \ + _(1352, ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_OBSERVER) \ + _(1353, ZEND_DO_FCALL_SPEC_RETVAL_USED_OBSERVER) \ + _(1354, ZEND_INIT_FCALL_SPEC_CONST) \ + _(1355, ZEND_RETURN_SPEC_CONST) \ + _(1356, ZEND_RETURN_SPEC_CONST_OBSERVER) \ + _(1357, ZEND_RETURN_SPEC_TMP) \ + _(1358, ZEND_RETURN_SPEC_TMP_OBSERVER) \ + _(1359, ZEND_RETURN_SPEC_VAR) \ + _(1360, ZEND_RETURN_SPEC_VAR_OBSERVER) \ + _(1363, ZEND_RETURN_SPEC_CV) \ + _(1364, ZEND_RETURN_SPEC_CV_OBSERVER) \ + _(1365, ZEND_RECV_SPEC_UNUSED) \ + _(1366, ZEND_RECV_INIT_SPEC_CONST) \ + _(1367, ZEND_SEND_VAL_SPEC_CONST_CONST) \ + _(1370, ZEND_SEND_VAL_SPEC_CONST_UNUSED) \ + _(1372, ZEND_SEND_VAL_SPEC_TMPVAR_CONST) \ + _(1375, ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED) \ + _(1377, ZEND_SEND_VAL_SPEC_TMPVAR_CONST) \ + _(1380, ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED) \ + _(1412, ZEND_SEND_VAR_EX_SPEC_VAR_CONST) \ + _(1413, ZEND_SEND_VAR_EX_SPEC_VAR_CONST) \ + _(1418, ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED) \ + _(1419, ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK) \ + _(1432, ZEND_SEND_VAR_EX_SPEC_CV_CONST) \ + _(1433, ZEND_SEND_VAR_EX_SPEC_CV_CONST) \ + _(1438, ZEND_SEND_VAR_EX_SPEC_CV_UNUSED) \ + _(1439, ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK) \ + _(1452, ZEND_SEND_REF_SPEC_VAR_CONST) \ + _(1455, ZEND_SEND_REF_SPEC_VAR_UNUSED) \ + _(1462, ZEND_SEND_REF_SPEC_CV_CONST) \ + _(1465, ZEND_SEND_REF_SPEC_CV_UNUSED) \ + _(1467, ZEND_NEW_SPEC_CONST_UNUSED) \ + _(1469, ZEND_NEW_SPEC_VAR_UNUSED) \ + _(1470, ZEND_NEW_SPEC_UNUSED_UNUSED) \ + _(1472, ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST) \ + _(1473, ZEND_FREE_SPEC_TMPVAR) \ + _(1474, ZEND_INIT_ARRAY_SPEC_CONST_CONST) \ + _(1475, ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR) \ + _(1476, ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR) \ + _(1477, ZEND_INIT_ARRAY_SPEC_CONST_UNUSED) \ + _(1478, ZEND_INIT_ARRAY_SPEC_CONST_CV) \ + _(1479, ZEND_INIT_ARRAY_SPEC_TMP_CONST) \ + _(1480, ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR) \ + _(1481, ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR) \ + _(1482, ZEND_INIT_ARRAY_SPEC_TMP_UNUSED) \ + _(1483, ZEND_INIT_ARRAY_SPEC_TMP_CV) \ + _(1484, ZEND_INIT_ARRAY_SPEC_VAR_CONST) \ + _(1485, ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR) \ + _(1486, ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR) \ + _(1487, ZEND_INIT_ARRAY_SPEC_VAR_UNUSED) \ + _(1488, ZEND_INIT_ARRAY_SPEC_VAR_CV) \ + _(1489, ZEND_INIT_ARRAY_SPEC_UNUSED_CONST) \ + _(1490, ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR) \ + _(1491, ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR) \ + _(1492, ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED) \ + _(1493, ZEND_INIT_ARRAY_SPEC_UNUSED_CV) \ + _(1494, ZEND_INIT_ARRAY_SPEC_CV_CONST) \ + _(1495, ZEND_INIT_ARRAY_SPEC_CV_TMPVAR) \ + _(1496, ZEND_INIT_ARRAY_SPEC_CV_TMPVAR) \ + _(1497, ZEND_INIT_ARRAY_SPEC_CV_UNUSED) \ + _(1498, ZEND_INIT_ARRAY_SPEC_CV_CV) \ + _(1499, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST) \ + _(1500, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR) \ + _(1501, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR) \ + _(1502, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED) \ + _(1503, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV) \ + _(1504, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST) \ + _(1505, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR) \ + _(1506, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR) \ + _(1507, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED) \ + _(1508, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV) \ + _(1509, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST) \ + _(1510, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR) \ + _(1511, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR) \ + _(1512, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED) \ + _(1513, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV) \ + _(1519, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST) \ + _(1520, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR) \ + _(1521, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR) \ + _(1522, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED) \ + _(1523, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV) \ + _(1524, ZEND_INCLUDE_OR_EVAL_SPEC_CONST) \ + _(1525, ZEND_INCLUDE_OR_EVAL_SPEC_CONST_OBSERVER) \ + _(1526, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR) \ + _(1527, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_OBSERVER) \ + _(1528, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR) \ + _(1529, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_OBSERVER) \ + _(1532, ZEND_INCLUDE_OR_EVAL_SPEC_CV) \ + _(1533, ZEND_INCLUDE_OR_EVAL_SPEC_CV_OBSERVER) \ + _(1534, ZEND_UNSET_VAR_SPEC_CONST_UNUSED) \ + _(1535, ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED) \ + _(1536, ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED) \ + _(1538, ZEND_UNSET_VAR_SPEC_CV_UNUSED) \ + _(1549, ZEND_UNSET_DIM_SPEC_VAR_CONST) \ + _(1550, ZEND_UNSET_DIM_SPEC_VAR_TMPVAR) \ + _(1551, ZEND_UNSET_DIM_SPEC_VAR_TMPVAR) \ + _(1553, ZEND_UNSET_DIM_SPEC_VAR_CV) \ + _(1559, ZEND_UNSET_DIM_SPEC_CV_CONST) \ + _(1560, ZEND_UNSET_DIM_SPEC_CV_TMPVAR) \ + _(1561, ZEND_UNSET_DIM_SPEC_CV_TMPVAR) \ + _(1563, ZEND_UNSET_DIM_SPEC_CV_CV) \ + _(1574, ZEND_UNSET_OBJ_SPEC_VAR_CONST) \ + _(1575, ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR) \ + _(1576, ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR) \ + _(1578, ZEND_UNSET_OBJ_SPEC_VAR_CV) \ + _(1579, ZEND_UNSET_OBJ_SPEC_UNUSED_CONST) \ + _(1580, ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR) \ + _(1581, ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR) \ + _(1583, ZEND_UNSET_OBJ_SPEC_UNUSED_CV) \ + _(1584, ZEND_UNSET_OBJ_SPEC_CV_CONST) \ + _(1585, ZEND_UNSET_OBJ_SPEC_CV_TMPVAR) \ + _(1586, ZEND_UNSET_OBJ_SPEC_CV_TMPVAR) \ + _(1588, ZEND_UNSET_OBJ_SPEC_CV_CV) \ + _(1589, ZEND_FE_RESET_R_SPEC_CONST) \ + _(1590, ZEND_FE_RESET_R_SPEC_TMP) \ + _(1591, ZEND_FE_RESET_R_SPEC_VAR) \ + _(1593, ZEND_FE_RESET_R_SPEC_CV) \ + _(1594, ZEND_FE_FETCH_R_SPEC_VAR) \ + _(1595, ZEND_EXIT_SPEC) \ + _(1596, ZEND_FETCH_R_SPEC_CONST_UNUSED) \ + _(1597, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \ + _(1598, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \ + _(1600, ZEND_FETCH_R_SPEC_CV_UNUSED) \ + _(1601, ZEND_FETCH_DIM_R_SPEC_CONST_CONST) \ + _(1602, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \ + _(1603, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \ + _(1605, ZEND_FETCH_DIM_R_SPEC_CONST_CV) \ + _(1606, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \ + _(1607, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ + _(1608, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ + _(1610, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \ + _(1611, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \ + _(1612, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ + _(1613, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ + _(1615, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \ + _(1621, ZEND_FETCH_DIM_R_SPEC_CV_CONST) \ + _(1622, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \ + _(1623, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \ + _(1625, ZEND_FETCH_DIM_R_SPEC_CV_CV) \ + _(1626, ZEND_FETCH_OBJ_R_SPEC_CONST_CONST) \ + _(1627, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \ + _(1628, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \ + _(1630, ZEND_FETCH_OBJ_R_SPEC_CONST_CV) \ + _(1631, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \ + _(1632, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ + _(1633, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ + _(1635, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \ + _(1636, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \ + _(1637, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ + _(1638, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ + _(1640, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \ + _(1641, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST) \ + _(1642, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \ + _(1643, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \ + _(1645, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV) \ + _(1646, ZEND_FETCH_OBJ_R_SPEC_CV_CONST) \ + _(1647, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \ + _(1648, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \ + _(1650, ZEND_FETCH_OBJ_R_SPEC_CV_CV) \ + _(1651, ZEND_FETCH_W_SPEC_CONST_UNUSED) \ + _(1652, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \ + _(1653, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \ + _(1655, ZEND_FETCH_W_SPEC_CV_UNUSED) \ + _(1666, ZEND_FETCH_DIM_W_SPEC_VAR_CONST) \ + _(1667, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \ + _(1668, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \ + _(1669, ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED) \ + _(1670, ZEND_FETCH_DIM_W_SPEC_VAR_CV) \ + _(1676, ZEND_FETCH_DIM_W_SPEC_CV_CONST) \ + _(1677, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \ + _(1678, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \ + _(1679, ZEND_FETCH_DIM_W_SPEC_CV_UNUSED) \ + _(1680, ZEND_FETCH_DIM_W_SPEC_CV_CV) \ + _(1691, ZEND_FETCH_OBJ_W_SPEC_VAR_CONST) \ + _(1692, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \ + _(1693, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \ + _(1695, ZEND_FETCH_OBJ_W_SPEC_VAR_CV) \ + _(1696, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST) \ + _(1697, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \ + _(1698, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \ + _(1700, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV) \ + _(1701, ZEND_FETCH_OBJ_W_SPEC_CV_CONST) \ + _(1702, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \ + _(1703, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \ + _(1705, ZEND_FETCH_OBJ_W_SPEC_CV_CV) \ + _(1706, ZEND_FETCH_RW_SPEC_CONST_UNUSED) \ + _(1707, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \ + _(1708, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \ + _(1710, ZEND_FETCH_RW_SPEC_CV_UNUSED) \ + _(1721, ZEND_FETCH_DIM_RW_SPEC_VAR_CONST) \ + _(1722, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \ + _(1723, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \ + _(1724, ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED) \ + _(1725, ZEND_FETCH_DIM_RW_SPEC_VAR_CV) \ + _(1731, ZEND_FETCH_DIM_RW_SPEC_CV_CONST) \ + _(1732, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \ + _(1733, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \ + _(1734, ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED) \ + _(1735, ZEND_FETCH_DIM_RW_SPEC_CV_CV) \ + _(1746, ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST) \ + _(1747, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \ + _(1748, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \ + _(1750, ZEND_FETCH_OBJ_RW_SPEC_VAR_CV) \ + _(1751, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST) \ + _(1752, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \ + _(1753, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \ + _(1755, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV) \ + _(1756, ZEND_FETCH_OBJ_RW_SPEC_CV_CONST) \ + _(1757, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \ + _(1758, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \ + _(1760, ZEND_FETCH_OBJ_RW_SPEC_CV_CV) \ + _(1761, ZEND_FETCH_IS_SPEC_CONST_UNUSED) \ + _(1762, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \ + _(1763, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \ + _(1765, ZEND_FETCH_IS_SPEC_CV_UNUSED) \ + _(1766, ZEND_FETCH_DIM_IS_SPEC_CONST_CONST) \ + _(1767, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \ + _(1768, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \ + _(1770, ZEND_FETCH_DIM_IS_SPEC_CONST_CV) \ + _(1771, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \ + _(1772, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ + _(1773, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ + _(1775, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \ + _(1776, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \ + _(1777, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ + _(1778, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ + _(1780, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \ + _(1786, ZEND_FETCH_DIM_IS_SPEC_CV_CONST) \ + _(1787, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \ + _(1788, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \ + _(1790, ZEND_FETCH_DIM_IS_SPEC_CV_CV) \ + _(1791, ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST) \ + _(1792, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \ + _(1793, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \ + _(1795, ZEND_FETCH_OBJ_IS_SPEC_CONST_CV) \ + _(1796, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \ + _(1797, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ + _(1798, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ + _(1800, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \ + _(1801, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \ + _(1802, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ + _(1803, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ + _(1805, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \ + _(1806, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST) \ + _(1807, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \ + _(1808, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \ + _(1810, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV) \ + _(1811, ZEND_FETCH_OBJ_IS_SPEC_CV_CONST) \ + _(1812, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \ + _(1813, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \ + _(1815, ZEND_FETCH_OBJ_IS_SPEC_CV_CV) \ + _(1816, ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED) \ + _(1817, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \ + _(1818, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \ + _(1820, ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED) \ + _(1821, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST) \ + _(1822, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \ + _(1823, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \ + _(1824, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED) \ + _(1825, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV) \ + _(1826, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST) \ + _(1827, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \ + _(1828, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \ + _(1829, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED) \ + _(1830, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV) \ + _(1831, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST) \ + _(1832, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \ + _(1833, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \ + _(1834, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED) \ + _(1835, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV) \ + _(1841, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST) \ + _(1842, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \ + _(1843, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \ + _(1844, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED) \ + _(1845, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV) \ + _(1846, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST) \ + _(1847, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \ + _(1848, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \ + _(1850, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV) \ + _(1851, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST) \ + _(1852, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \ + _(1853, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \ + _(1855, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV) \ + _(1856, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST) \ + _(1857, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \ + _(1858, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \ + _(1860, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV) \ + _(1861, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST) \ + _(1862, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \ + _(1863, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \ + _(1865, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV) \ + _(1866, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST) \ + _(1867, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \ + _(1868, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \ + _(1870, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV) \ + _(1871, ZEND_FETCH_UNSET_SPEC_CONST_UNUSED) \ + _(1872, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \ + _(1873, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \ + _(1875, ZEND_FETCH_UNSET_SPEC_CV_UNUSED) \ + _(1886, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST) \ + _(1887, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \ + _(1888, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \ + _(1890, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV) \ + _(1896, ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST) \ + _(1897, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \ + _(1898, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \ + _(1900, ZEND_FETCH_DIM_UNSET_SPEC_CV_CV) \ + _(1911, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST) \ + _(1912, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \ + _(1913, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \ + _(1915, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV) \ + _(1916, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST) \ + _(1917, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \ + _(1918, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \ + _(1920, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV) \ + _(1921, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST) \ + _(1922, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \ + _(1923, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \ + _(1925, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV) \ + _(1926, ZEND_FETCH_LIST_R_SPEC_CONST_CONST) \ + _(1927, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \ + _(1928, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \ + _(1930, ZEND_FETCH_LIST_R_SPEC_CONST_CV) \ + _(1931, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ + _(1932, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ + _(1933, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ + _(1935, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ + _(1936, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ + _(1937, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ + _(1938, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ + _(1940, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ + _(1946, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ + _(1947, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ + _(1948, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ + _(1950, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ + _(1951, ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST) \ + _(1952, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST) \ + _(1953, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST) \ + _(1958, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED) \ + _(1959, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK) \ + _(1962, ZEND_EXT_STMT_SPEC) \ + _(1963, ZEND_EXT_FCALL_BEGIN_SPEC) \ + _(1964, ZEND_EXT_FCALL_END_SPEC) \ + _(1965, ZEND_EXT_NOP_SPEC) \ + _(1966, ZEND_TICKS_SPEC) \ + _(1967, ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST) \ + _(1970, ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED) \ + _(1972, ZEND_CATCH_SPEC_CONST) \ + _(1973, ZEND_THROW_SPEC_CONST) \ + _(1974, ZEND_THROW_SPEC_TMPVAR) \ + _(1975, ZEND_THROW_SPEC_TMPVAR) \ + _(1977, ZEND_THROW_SPEC_CV) \ + _(1978, ZEND_FETCH_CLASS_SPEC_UNUSED_CONST) \ + _(1979, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \ + _(1980, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \ + _(1981, ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED) \ + _(1982, ZEND_FETCH_CLASS_SPEC_UNUSED_CV) \ + _(1983, ZEND_CLONE_SPEC_CONST) \ + _(1984, ZEND_CLONE_SPEC_TMPVAR) \ + _(1985, ZEND_CLONE_SPEC_TMPVAR) \ + _(1986, ZEND_CLONE_SPEC_UNUSED) \ + _(1987, ZEND_CLONE_SPEC_CV) \ + _(1988, ZEND_RETURN_BY_REF_SPEC_CONST) \ + _(1989, ZEND_RETURN_BY_REF_SPEC_CONST_OBSERVER) \ + _(1990, ZEND_RETURN_BY_REF_SPEC_TMP) \ + _(1991, ZEND_RETURN_BY_REF_SPEC_TMP_OBSERVER) \ + _(1992, ZEND_RETURN_BY_REF_SPEC_VAR) \ + _(1993, ZEND_RETURN_BY_REF_SPEC_VAR_OBSERVER) \ + _(1996, ZEND_RETURN_BY_REF_SPEC_CV) \ + _(1997, ZEND_RETURN_BY_REF_SPEC_CV_OBSERVER) \ + _(1998, ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST) \ + _(1999, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \ + _(2000, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \ + _(2002, ZEND_INIT_METHOD_CALL_SPEC_CONST_CV) \ + _(2003, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \ + _(2004, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ + _(2005, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ + _(2007, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \ + _(2008, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \ + _(2009, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ + _(2010, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ + _(2012, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \ + _(2013, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST) \ + _(2014, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ + _(2015, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ + _(2017, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV) \ + _(2018, ZEND_INIT_METHOD_CALL_SPEC_CV_CONST) \ + _(2019, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \ + _(2020, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \ + _(2022, ZEND_INIT_METHOD_CALL_SPEC_CV_CV) \ + _(2023, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST) \ + _(2024, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \ + _(2025, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \ + _(2026, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED) \ + _(2027, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV) \ + _(2033, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST) \ + _(2034, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \ + _(2035, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \ + _(2036, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED) \ + _(2037, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV) \ + _(2038, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST) \ + _(2039, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ + _(2040, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ + _(2041, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED) \ + _(2042, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV) \ + _(2048, ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED) \ + _(2049, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \ + _(2050, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \ + _(2052, ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED) \ + _(2053, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST) \ + _(2054, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \ + _(2055, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \ + _(2057, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV) \ + _(2058, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \ + _(2059, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2060, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2062, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \ + _(2063, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \ + _(2064, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2065, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2067, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \ + _(2073, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST) \ + _(2074, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \ + _(2075, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \ + _(2077, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV) \ + _(2078, ZEND_SEND_VAL_EX_SPEC_CONST_CONST) \ + _(2079, ZEND_SEND_VAL_EX_SPEC_CONST_CONST) \ + _(2084, ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED) \ + _(2085, ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK) \ + _(2088, ZEND_SEND_VAL_EX_SPEC_TMP_CONST) \ + _(2089, ZEND_SEND_VAL_EX_SPEC_TMP_CONST) \ + _(2094, ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED) \ + _(2095, ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK) \ + _(2138, ZEND_SEND_VAR_SPEC_VAR_CONST) \ + _(2141, ZEND_SEND_VAR_SPEC_VAR_UNUSED) \ + _(2148, ZEND_SEND_VAR_SPEC_CV_CONST) \ + _(2151, ZEND_SEND_VAR_SPEC_CV_UNUSED) \ + _(2153, ZEND_INIT_USER_CALL_SPEC_CONST_CONST) \ + _(2154, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \ + _(2155, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \ + _(2157, ZEND_INIT_USER_CALL_SPEC_CONST_CV) \ + _(2158, ZEND_SEND_ARRAY_SPEC) \ + _(2159, ZEND_SEND_USER_SPEC_CONST) \ + _(2160, ZEND_SEND_USER_SPEC_TMP) \ + _(2161, ZEND_SEND_USER_SPEC_VAR) \ + _(2163, ZEND_SEND_USER_SPEC_CV) \ + _(2164, ZEND_STRLEN_SPEC_CONST) \ + _(2165, ZEND_STRLEN_SPEC_TMPVAR) \ + _(2166, ZEND_STRLEN_SPEC_TMPVAR) \ + _(2168, ZEND_STRLEN_SPEC_CV) \ + _(2169, ZEND_DEFINED_SPEC_CONST) \ + _(2170, ZEND_TYPE_CHECK_SPEC_CONST) \ + _(2171, ZEND_TYPE_CHECK_SPEC_TMPVAR) \ + _(2172, ZEND_TYPE_CHECK_SPEC_TMPVAR) \ + _(2174, ZEND_TYPE_CHECK_SPEC_CV) \ + _(2175, ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED) \ + _(2176, ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED) \ + _(2177, ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED) \ + _(2178, ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED) \ + _(2179, ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED) \ + _(2180, ZEND_FE_RESET_RW_SPEC_CONST) \ + _(2181, ZEND_FE_RESET_RW_SPEC_TMP) \ + _(2182, ZEND_FE_RESET_RW_SPEC_VAR) \ + _(2184, ZEND_FE_RESET_RW_SPEC_CV) \ + _(2185, ZEND_FE_FETCH_RW_SPEC_VAR) \ + _(2186, ZEND_FE_FREE_SPEC_TMPVAR) \ + _(2187, ZEND_INIT_DYNAMIC_CALL_SPEC_CONST) \ + _(2188, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \ + _(2189, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \ + _(2191, ZEND_INIT_DYNAMIC_CALL_SPEC_CV) \ + _(2192, ZEND_DO_ICALL_SPEC_RETVAL_UNUSED) \ + _(2193, ZEND_DO_ICALL_SPEC_RETVAL_USED) \ + _(2194, ZEND_DO_UCALL_SPEC_RETVAL_UNUSED) \ + _(2195, ZEND_DO_UCALL_SPEC_RETVAL_USED) \ + _(2196, ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_OBSERVER) \ + _(2197, ZEND_DO_UCALL_SPEC_RETVAL_USED_OBSERVER) \ + _(2198, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED) \ + _(2199, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED) \ + _(2200, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_OBSERVER) \ + _(2201, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_OBSERVER) \ + _(2212, ZEND_PRE_INC_OBJ_SPEC_VAR_CONST) \ + _(2213, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \ + _(2214, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \ + _(2216, ZEND_PRE_INC_OBJ_SPEC_VAR_CV) \ + _(2217, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST) \ + _(2218, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2219, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2221, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV) \ + _(2222, ZEND_PRE_INC_OBJ_SPEC_CV_CONST) \ + _(2223, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \ + _(2224, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \ + _(2226, ZEND_PRE_INC_OBJ_SPEC_CV_CV) \ + _(2237, ZEND_POST_INC_OBJ_SPEC_VAR_CONST) \ + _(2238, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \ + _(2239, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \ + _(2241, ZEND_POST_INC_OBJ_SPEC_VAR_CV) \ + _(2242, ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST) \ + _(2243, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2244, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2246, ZEND_POST_INC_OBJ_SPEC_UNUSED_CV) \ + _(2247, ZEND_POST_INC_OBJ_SPEC_CV_CONST) \ + _(2248, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \ + _(2249, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \ + _(2251, ZEND_POST_INC_OBJ_SPEC_CV_CV) \ + _(2252, ZEND_ECHO_SPEC_CONST) \ + _(2253, ZEND_ECHO_SPEC_TMPVAR) \ + _(2254, ZEND_ECHO_SPEC_TMPVAR) \ + _(2256, ZEND_ECHO_SPEC_CV) \ + _(2263, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \ + _(2265, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \ + _(2266, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \ + _(2268, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \ + _(2270, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \ + _(2271, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \ + _(2278, ZEND_INSTANCEOF_SPEC_CV_CONST) \ + _(2280, ZEND_INSTANCEOF_SPEC_CV_VAR) \ + _(2281, ZEND_INSTANCEOF_SPEC_CV_UNUSED) \ + _(2283, ZEND_GENERATOR_CREATE_SPEC) \ + _(2286, ZEND_MAKE_REF_SPEC_VAR_UNUSED) \ + _(2288, ZEND_MAKE_REF_SPEC_CV_UNUSED) \ + _(2289, ZEND_DECLARE_FUNCTION_SPEC) \ + _(2290, ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED) \ + _(2291, ZEND_DECLARE_CONST_SPEC_CONST_CONST) \ + _(2292, ZEND_DECLARE_CLASS_SPEC_CONST) \ + _(2293, ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST) \ + _(2294, ZEND_DECLARE_ANON_CLASS_SPEC) \ + _(2295, ZEND_ADD_ARRAY_UNPACK_SPEC) \ + _(2296, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST) \ + _(2297, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \ + _(2298, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \ + _(2300, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV) \ + _(2301, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ + _(2302, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2303, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2305, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ + _(2306, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ + _(2307, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2308, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2310, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ + _(2311, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST) \ + _(2312, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2313, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2315, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV) \ + _(2316, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST) \ + _(2317, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ + _(2318, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ + _(2320, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV) \ + _(2321, ZEND_HANDLE_EXCEPTION_SPEC) \ + _(2322, ZEND_HANDLE_EXCEPTION_SPEC_OBSERVER) \ + _(2323, ZEND_USER_OPCODE_SPEC) \ + _(2324, ZEND_ASSERT_CHECK_SPEC) \ + _(2325, ZEND_JMP_SET_SPEC_CONST) \ + _(2326, ZEND_JMP_SET_SPEC_TMP) \ + _(2327, ZEND_JMP_SET_SPEC_VAR) \ + _(2329, ZEND_JMP_SET_SPEC_CV) \ + _(2330, ZEND_UNSET_CV_SPEC_CV_UNUSED) \ + _(2331, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET) \ + _(2332, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY) \ + _(2333, ZEND_FETCH_LIST_W_SPEC_VAR_CONST) \ + _(2334, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ + _(2335, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ + _(2337, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \ + _(2338, ZEND_SEPARATE_SPEC_VAR_UNUSED) \ + _(2340, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \ + _(2341, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \ + _(2342, ZEND_FETCH_CLASS_NAME_SPEC_UNUSED) \ + _(2343, ZEND_FETCH_CLASS_NAME_SPEC_CV) \ + _(2344, ZEND_CALL_TRAMPOLINE_SPEC) \ + _(2345, ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER) \ + _(2346, ZEND_DISCARD_EXCEPTION_SPEC) \ + _(2347, ZEND_YIELD_SPEC_CONST_CONST) \ + _(2348, ZEND_YIELD_SPEC_CONST_TMPVAR) \ + _(2349, ZEND_YIELD_SPEC_CONST_TMPVAR) \ + _(2350, ZEND_YIELD_SPEC_CONST_UNUSED) \ + _(2351, ZEND_YIELD_SPEC_CONST_CV) \ + _(2352, ZEND_YIELD_SPEC_TMP_CONST) \ + _(2353, ZEND_YIELD_SPEC_TMP_TMPVAR) \ + _(2354, ZEND_YIELD_SPEC_TMP_TMPVAR) \ + _(2355, ZEND_YIELD_SPEC_TMP_UNUSED) \ + _(2356, ZEND_YIELD_SPEC_TMP_CV) \ + _(2357, ZEND_YIELD_SPEC_VAR_CONST) \ + _(2358, ZEND_YIELD_SPEC_VAR_TMPVAR) \ + _(2359, ZEND_YIELD_SPEC_VAR_TMPVAR) \ + _(2360, ZEND_YIELD_SPEC_VAR_UNUSED) \ + _(2361, ZEND_YIELD_SPEC_VAR_CV) \ + _(2362, ZEND_YIELD_SPEC_UNUSED_CONST) \ + _(2363, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \ + _(2364, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \ + _(2365, ZEND_YIELD_SPEC_UNUSED_UNUSED) \ + _(2366, ZEND_YIELD_SPEC_UNUSED_CV) \ + _(2367, ZEND_YIELD_SPEC_CV_CONST) \ + _(2368, ZEND_YIELD_SPEC_CV_TMPVAR) \ + _(2369, ZEND_YIELD_SPEC_CV_TMPVAR) \ + _(2370, ZEND_YIELD_SPEC_CV_UNUSED) \ + _(2371, ZEND_YIELD_SPEC_CV_CV) \ + _(2372, ZEND_GENERATOR_RETURN_SPEC_CONST) \ + _(2373, ZEND_GENERATOR_RETURN_SPEC_CONST_OBSERVER) \ + _(2374, ZEND_GENERATOR_RETURN_SPEC_TMP) \ + _(2375, ZEND_GENERATOR_RETURN_SPEC_TMP_OBSERVER) \ + _(2376, ZEND_GENERATOR_RETURN_SPEC_VAR) \ + _(2377, ZEND_GENERATOR_RETURN_SPEC_VAR_OBSERVER) \ + _(2380, ZEND_GENERATOR_RETURN_SPEC_CV) \ + _(2381, ZEND_GENERATOR_RETURN_SPEC_CV_OBSERVER) \ + _(2382, ZEND_FAST_CALL_SPEC) \ + _(2383, ZEND_FAST_RET_SPEC) \ + _(2384, ZEND_RECV_VARIADIC_SPEC_UNUSED) \ + _(2385, ZEND_SEND_UNPACK_SPEC) \ + _(2386, ZEND_YIELD_FROM_SPEC_CONST) \ + _(2387, ZEND_YIELD_FROM_SPEC_TMPVAR) \ + _(2388, ZEND_YIELD_FROM_SPEC_TMPVAR) \ + _(2390, ZEND_YIELD_FROM_SPEC_CV) \ + _(2391, ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED) \ + _(2392, ZEND_BIND_GLOBAL_SPEC_CV_CONST) \ + _(2393, ZEND_COALESCE_SPEC_CONST) \ + _(2394, ZEND_COALESCE_SPEC_TMP) \ + _(2395, ZEND_COALESCE_SPEC_VAR) \ + _(2397, ZEND_COALESCE_SPEC_CV) \ + _(2398, ZEND_SPACESHIP_SPEC_CONST_CONST) \ + _(2399, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ + _(2400, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ + _(2402, ZEND_SPACESHIP_SPEC_CONST_CV) \ + _(2403, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ + _(2404, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ + _(2405, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ + _(2407, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ + _(2408, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ + _(2409, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ + _(2410, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ + _(2412, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ + _(2418, ZEND_SPACESHIP_SPEC_CV_CONST) \ + _(2419, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ + _(2420, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ + _(2422, ZEND_SPACESHIP_SPEC_CV_CV) \ + _(2423, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED) \ + _(2424, ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED) \ + _(2427, ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED) \ + _(2429, ZEND_FETCH_STATIC_PROP_R_SPEC) \ + _(2430, ZEND_FETCH_STATIC_PROP_W_SPEC) \ + _(2431, ZEND_FETCH_STATIC_PROP_RW_SPEC) \ + _(2432, ZEND_FETCH_STATIC_PROP_IS_SPEC) \ + _(2433, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC) \ + _(2434, ZEND_FETCH_STATIC_PROP_UNSET_SPEC) \ + _(2435, ZEND_UNSET_STATIC_PROP_SPEC) \ + _(2436, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC) \ + _(2437, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) \ + _(2439, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) \ + _(2440, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST) \ + _(2442, ZEND_BIND_LEXICAL_SPEC_TMP_CV) \ + _(2443, ZEND_BIND_STATIC_SPEC_CV_UNUSED) \ + _(2444, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED) \ + _(2445, ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST) \ + _(2448, ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED) \ + _(2450, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED) \ + _(2451, ZEND_SWITCH_LONG_SPEC_CONST_CONST) \ + _(2452, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(2453, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(2455, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(2456, ZEND_SWITCH_STRING_SPEC_CONST_CONST) \ + _(2457, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(2458, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(2460, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(2461, ZEND_IN_ARRAY_SPEC_CONST_CONST) \ + _(2462, ZEND_IN_ARRAY_SPEC_TMP_CONST) \ + _(2463, ZEND_IN_ARRAY_SPEC_VAR_CONST) \ + _(2465, ZEND_IN_ARRAY_SPEC_CV_CONST) \ + _(2466, ZEND_COUNT_SPEC_CONST_UNUSED) \ + _(2467, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \ + _(2468, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \ + _(2470, ZEND_COUNT_SPEC_CV_UNUSED) \ + _(2471, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \ + _(2472, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \ + _(2473, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \ + _(2474, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED) \ + _(2475, ZEND_GET_CLASS_SPEC_CV_UNUSED) \ + _(2476, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED) \ + _(2477, ZEND_GET_TYPE_SPEC_CONST_UNUSED) \ + _(2478, ZEND_GET_TYPE_SPEC_TMP_UNUSED) \ + _(2479, ZEND_GET_TYPE_SPEC_VAR_UNUSED) \ + _(2481, ZEND_GET_TYPE_SPEC_CV_UNUSED) \ + _(2482, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \ + _(2483, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ + _(2484, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ + _(2486, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \ + _(2487, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ + _(2488, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(2489, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(2491, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ + _(2492, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ + _(2493, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(2494, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(2496, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ + _(2502, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \ + _(2503, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ + _(2504, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ + _(2506, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \ + _(2507, ZEND_MATCH_SPEC_CONST_CONST) \ + _(2508, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ + _(2509, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ + _(2511, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ + _(2517, ZEND_CASE_STRICT_SPEC_TMP_CONST) \ + _(2518, ZEND_CASE_STRICT_SPEC_TMP_TMP) \ + _(2519, ZEND_CASE_STRICT_SPEC_TMP_VAR) \ + _(2521, ZEND_CASE_STRICT_SPEC_TMP_CV) \ + _(2522, ZEND_CASE_STRICT_SPEC_VAR_CONST) \ + _(2523, ZEND_CASE_STRICT_SPEC_VAR_TMP) \ + _(2524, ZEND_CASE_STRICT_SPEC_VAR_VAR) \ + _(2526, ZEND_CASE_STRICT_SPEC_VAR_CV) \ + _(2537, ZEND_MATCH_ERROR_SPEC_CONST_UNUSED) \ + _(2538, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ + _(2539, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ + _(2541, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ + _(2542, ZEND_JMP_NULL_SPEC_CONST) \ + _(2543, ZEND_JMP_NULL_SPEC_TMPVARCV) \ + _(2544, ZEND_JMP_NULL_SPEC_TMPVARCV) \ + _(2546, ZEND_JMP_NULL_SPEC_TMPVARCV) \ + _(2547, ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED) \ + _(2548, ZEND_RECV_NOTYPE_SPEC) \ + _(2549, ZEND_JMP_FORWARD_SPEC) \ + _(2555, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2556, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2557, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2559, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2560, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2561, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2562, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2564, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2570, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2571, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2572, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2574, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2580, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2581, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2582, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2584, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2585, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2586, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2587, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2589, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2595, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2596, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2597, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2599, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2605, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2606, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2607, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2609, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2610, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2611, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2612, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2614, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2620, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2621, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2622, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2624, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2626, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2627, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2629, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2630, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2631, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2632, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2634, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2635, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2636, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2637, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2639, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2645, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2646, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2647, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2649, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2651, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2652, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2654, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2655, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2656, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2657, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2659, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2660, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2661, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2662, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2664, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2670, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2671, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2672, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2674, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2676, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2677, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2679, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2680, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2681, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2682, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2684, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2685, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2686, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2687, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2689, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2695, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2696, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2697, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2699, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2705, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2706, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2707, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2709, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2710, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2711, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2712, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2714, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2720, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2721, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2722, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2724, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2730, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2731, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2732, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2734, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2735, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2736, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2737, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2739, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2745, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2746, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2747, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2749, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2755, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2756, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2757, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2759, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2760, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2761, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2762, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2764, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2770, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2771, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2772, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2774, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2790, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2791, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2792, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2793, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2794, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2795, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2796, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2797, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2798, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2802, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2803, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2804, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2805, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2806, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2807, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2808, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2809, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2810, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2811, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2812, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2813, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2817, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2818, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2819, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2835, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2836, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2837, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2838, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2839, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2840, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2841, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2842, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2843, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2847, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2848, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2849, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2865, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2866, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2867, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2868, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2869, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2870, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2871, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2872, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2873, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2877, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2878, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2879, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2880, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2881, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2882, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2883, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2884, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2885, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2886, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2887, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2888, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2892, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2893, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2894, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2910, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2911, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2912, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2913, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2914, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2915, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2916, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2917, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2918, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2922, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2923, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2924, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2940, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2941, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2942, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2943, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2944, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2945, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2946, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2947, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2948, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2952, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2953, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2954, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2955, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2956, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2957, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2958, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2959, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2960, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2961, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2962, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2963, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2967, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2968, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2969, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2985, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2986, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2987, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2988, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2989, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2990, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2991, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2992, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2993, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2997, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2998, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2999, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3015, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3016, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3017, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3018, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3019, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3020, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3021, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3022, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3023, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3027, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3028, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3029, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3030, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3031, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3032, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3033, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3034, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3035, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3036, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3037, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3038, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3042, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3043, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3044, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3060, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3061, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3062, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3063, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3064, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3065, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3066, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3067, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3068, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3072, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3073, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3074, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3075, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3079, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3080, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3084, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3088, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3089, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3090, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3091, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3092, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3093, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3097, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3098, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3099, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3100, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3101, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3102, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3103, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3104, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3105, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3106, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3107, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3108, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3112, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3113, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3114, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3115, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3116, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3117, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3118, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3119, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3120, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3121, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3122, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3123, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3127, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3128, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3129, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3145, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3146, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3147, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3148, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3149, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3150, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3151, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3152, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3153, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3157, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3158, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3159, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3163, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3164, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3165, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3166, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3167, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3168, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3172, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3173, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3174, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3175, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3176, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3177, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3178, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3179, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3180, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3181, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3182, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3183, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3187, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3188, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3189, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3190, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3191, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3192, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3193, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3194, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3195, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3196, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3197, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3198, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3202, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3203, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3204, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3220, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3221, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3222, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3223, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3224, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3225, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3226, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3227, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3228, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3232, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3233, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3234, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3238, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3239, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3240, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3241, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3242, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3243, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3247, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3248, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3249, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3250, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3251, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3252, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3253, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3254, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3255, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3256, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3257, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3258, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3262, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3263, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3264, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3265, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3266, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3267, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3268, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3269, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3270, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3271, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3272, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3273, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3277, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3278, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3279, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3295, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3296, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3297, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3298, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3299, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3300, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3301, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3302, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3303, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3307, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3308, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3309, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3313, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3314, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3315, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3316, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3317, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3318, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3322, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3323, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3324, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3325, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3326, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3327, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3328, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3329, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3330, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3331, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3332, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3333, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3337, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3338, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3339, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3340, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3341, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3342, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3343, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3344, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3345, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3346, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3347, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3348, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3352, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3353, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3354, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3370, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3371, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3372, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3373, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3374, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3375, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3376, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3377, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3378, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3382, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3383, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3384, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3385, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3386, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3387, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3388, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ + _(3389, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3390, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3391, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3392, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ + _(3393, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3394, ZEND_POST_INC_LONG_SPEC_CV) \ + _(3395, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3396, ZEND_POST_DEC_LONG_SPEC_CV) \ + _(3397, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ + _(3398, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3399, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3401, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3402, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ + _(3403, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3404, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3406, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3407, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ + _(3408, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3409, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3411, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3413, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3414, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3416, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3417, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3418, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3419, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3421, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3422, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3423, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3424, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3426, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3432, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ + _(3433, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3434, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3436, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3439, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ + _(3441, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ + _(3444, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ + _(3446, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ + _(3447, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ + _(3448, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ + _(3449, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ + _(3450, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ + _(3450+1, ZEND_NULL) diff --git a/ext/zend_test/tests/observer_closure_01.phpt b/ext/zend_test/tests/observer_closure_01.phpt index 6e65d8e0d5eb7..3e120493bc1a9 100644 --- a/ext/zend_test/tests/observer_closure_01.phpt +++ b/ext/zend_test/tests/observer_closure_01.phpt @@ -25,10 +25,10 @@ echo 'DONE' . PHP_EOL; --EXPECTF-- - <{closure}> Answer + <{closure}> int(42) diff --git a/ext/zend_test/tests/observer_generator_03.phpt b/ext/zend_test/tests/observer_generator_03.phpt index 25b573919bab5..459bdfb424510 100644 --- a/ext/zend_test/tests/observer_generator_03.phpt +++ b/ext/zend_test/tests/observer_generator_03.phpt @@ -45,8 +45,8 @@ echo doSomething() . PHP_EOL; 1 - + 10 From 971824bb1ef8c533d7344868a7796d66703c1292 Mon Sep 17 00:00:00 2001 From: Sammy Powers Date: Thu, 27 Aug 2020 13:48:23 -0700 Subject: [PATCH 45/53] Move LOAD_OPLINE_EX() back to the end of DO_UCALL handler --- Zend/zend_vm_def.h | 3 +-- Zend/zend_vm_execute.h | 14 ++++++-------- 2 files changed, 7 insertions(+), 10 deletions(-) diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 7f8bf52347361..70c916fd622d8 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -3955,12 +3955,11 @@ ZEND_VM_HOT_HANDLER(130, ZEND_DO_UCALL, ANY, ANY, SPEC(RETVAL,OBSERVER)) ret = EX_VAR(opline->result.var); } - LOAD_OPLINE_EX(); - call->prev_execute_data = execute_data; execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); OBSERVER_FCALL_BEGIN_HANDLERS(execute_data); + LOAD_OPLINE_EX(); ZEND_VM_ENTER_EX(); } diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 6c055f382c410..0ed45de6b82d1 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -1347,12 +1347,12 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_RETV ret = EX_VAR(opline->result.var); } - LOAD_OPLINE_EX(); - call->prev_execute_data = execute_data; execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); + LOAD_OPLINE_EX(); + ZEND_VM_ENTER_EX(); } @@ -1371,12 +1371,12 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_RETV ret = EX_VAR(opline->result.var); } - LOAD_OPLINE_EX(); - call->prev_execute_data = execute_data; execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); + LOAD_OPLINE_EX(); + ZEND_VM_ENTER_EX(); } @@ -1395,12 +1395,11 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_RETV ret = EX_VAR(opline->result.var); } - LOAD_OPLINE_EX(); - call->prev_execute_data = execute_data; execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); zend_observer_maybe_fcall_call_begin(execute_data); + LOAD_OPLINE_EX(); ZEND_VM_ENTER_EX(); } @@ -1420,12 +1419,11 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_RETV ret = EX_VAR(opline->result.var); } - LOAD_OPLINE_EX(); - call->prev_execute_data = execute_data; execute_data = call; i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); zend_observer_maybe_fcall_call_begin(execute_data); + LOAD_OPLINE_EX(); ZEND_VM_ENTER_EX(); } From f9e10a0d045c2092257e809b3bdde5c715c2edca Mon Sep 17 00:00:00 2001 From: Sammy Powers Date: Thu, 27 Aug 2020 13:51:48 -0700 Subject: [PATCH 46/53] Rename ZEND_SHOULD_OBSERVE_FN to ZEND_OBSERVABLE_FN --- Zend/zend_observer.c | 2 +- Zend/zend_observer.h | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/Zend/zend_observer.c b/Zend/zend_observer.c index 3cf349770c066..1b675ca459e7c 100644 --- a/Zend/zend_observer.c +++ b/Zend/zend_observer.c @@ -135,7 +135,7 @@ void zend_observer_fcall_call_end_helper( zval *return_value) { zend_function *func = execute_data->func; - ZEND_ASSUME(ZEND_SHOULD_OBSERVE_FN(func->common.fn_flags)); + ZEND_ASSUME(ZEND_OBSERVABLE_FN(func->common.fn_flags)); void *observer_handlers = ZEND_OBSERVER_HANDLERS(&func->op_array); // TODO: Fix exceptions from generators // ZEND_ASSERT(observer_handlers); diff --git a/Zend/zend_observer.h b/Zend/zend_observer.h index 6a90c0df6edd6..c65d77013dfd3 100644 --- a/Zend/zend_observer.h +++ b/Zend/zend_observer.h @@ -34,7 +34,7 @@ extern ZEND_API int zend_observer_fcall_op_array_extension; #define ZEND_OBSERVER_NOT_OBSERVED ((void *) 2) -#define ZEND_SHOULD_OBSERVE_FN(fn_flags) \ +#define ZEND_OBSERVABLE_FN(fn_flags) \ (ZEND_OBSERVER_ENABLED && \ !(fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE))) @@ -82,7 +82,7 @@ ZEND_API zend_always_inline void zend_observer_maybe_fcall_call_begin( zend_execute_data *execute_data) { zend_op_array *op_array = (zend_op_array *)execute_data->func; - if (ZEND_SHOULD_OBSERVE_FN(op_array->fn_flags) && + if (ZEND_OBSERVABLE_FN(op_array->fn_flags) && !(op_array->fn_flags & ZEND_ACC_GENERATOR)) { void *observer_handlers = ZEND_OBSERVER_HANDLERS(&EX(func)->op_array); if (!observer_handlers) { @@ -101,7 +101,7 @@ ZEND_API zend_always_inline void zend_observer_maybe_fcall_call_end( zval *return_value) { zend_function *func = execute_data->func; - if (ZEND_SHOULD_OBSERVE_FN(func->common.fn_flags)) { + if (ZEND_OBSERVABLE_FN(func->common.fn_flags)) { zend_observer_fcall_call_end_helper(execute_data, return_value); } } From e4a6c45354374c6de5630e9c1a25055b3f5fa708 Mon Sep 17 00:00:00 2001 From: Sammy Powers Date: Thu, 27 Aug 2020 13:59:08 -0700 Subject: [PATCH 47/53] Mark SPEC(OBSERVER) handlers as ZEND_VM_COLD --- Zend/zend_vm_execute.h | 26 +++++++++++++------------- Zend/zend_vm_gen.php | 5 +++++ 2 files changed, 18 insertions(+), 13 deletions(-) diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 0ed45de6b82d1..7033416d78576 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -1380,7 +1380,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_RETV ZEND_VM_ENTER_EX(); } -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_execute_data *call = EX(call); @@ -1404,7 +1404,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_RETV ZEND_VM_ENTER_EX(); } -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_RETVAL_USED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_RETVAL_USED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_execute_data *call = EX(call); @@ -1610,7 +1610,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_S ZEND_VM_CONTINUE(); } -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_execute_data *call = EX(call); @@ -1701,7 +1701,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_S ZEND_VM_CONTINUE(); } -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_execute_data *call = EX(call); @@ -1996,7 +1996,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETV ZEND_VM_CONTINUE(); } -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_execute_data *call = EX(call); @@ -2099,7 +2099,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETV ZEND_VM_CONTINUE(); } -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETVAL_USED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETVAL_USED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_execute_data *call = EX(call); @@ -4325,7 +4325,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_CONST_ ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *retval_ptr; @@ -18889,7 +18889,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_TMP_HA ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_TMP_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_TMP_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *retval_ptr; @@ -19021,7 +19021,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_TMP_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_TMP_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *retval_ptr; @@ -21615,7 +21615,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_VAR_HA ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_VAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_VAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *retval_ptr; @@ -21748,7 +21748,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_VAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_VAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *retval_ptr; @@ -38311,7 +38311,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_CV_HAN ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *retval_ptr; @@ -38443,7 +38443,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CV_HANDLER( ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *retval_ptr; diff --git a/Zend/zend_vm_gen.php b/Zend/zend_vm_gen.php index 0c79812805891..2c2a64b294ccb 100755 --- a/Zend/zend_vm_gen.php +++ b/Zend/zend_vm_gen.php @@ -958,6 +958,9 @@ function is_hot_handler($hot, $op1, $op2, $extra_spec) { if (isset($extra_spec["SMART_BRANCH"]) && $extra_spec["SMART_BRANCH"] == 0) { return false; } + if (isset($extra_spec["OBSERVER"]) && $extra_spec["OBSERVER"] == 1) { + return false; + } if ($hot === 'HOT_' || $hot === 'INLINE_') { return true; } else if ($hot === 'HOT_NOCONST_') { @@ -976,6 +979,8 @@ function is_hot_handler($hot, $op1, $op2, $extra_spec) { function is_cold_handler($hot, $op1, $op2, $extra_spec) { if ($hot === 'COLD_') { return true; + } else if (isset($extra_spec["OBSERVER"]) && $extra_spec["OBSERVER"] == 1) { + return true; } else if ($hot === 'COLD_CONST_') { return ($op1 === 'CONST'); } else if ($hot === 'COLD_CONSTCONST_') { From 58a075fbf21a07d1bec60e16ec6ed83cb44425c7 Mon Sep 17 00:00:00 2001 From: Sammy Powers Date: Thu, 27 Aug 2020 14:14:59 -0700 Subject: [PATCH 48/53] Only register zend_test as observer when enabled --- ext/zend_test/test.c | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/ext/zend_test/test.c b/ext/zend_test/test.c index a8c7ac67d56ee..f4910c655077f 100644 --- a/ext/zend_test/test.c +++ b/ext/zend_test/test.c @@ -393,7 +393,7 @@ PHP_MINIT_FUNCTION(zend_test) REGISTER_INI_ENTRIES(); // Loading via dl() not supported with the observer API - if (type != MODULE_TEMPORARY) { + if (ZT_G(observer_enabled) && type != MODULE_TEMPORARY) { zend_observer_fcall_register(observer_fcall_init); } @@ -460,10 +460,6 @@ static void observer_end(zend_execute_data *execute_data, zval *retval) static zend_observer_fcall observer_fcall_init(zend_function *fbc) { - if (!ZT_G(observer_enabled)) { - return (zend_observer_fcall){NULL, NULL}; - } - if (fbc->common.function_name) { if (fbc->common.scope) { php_printf("%*s\n", 2 * ZT_G(observer_nesting_depth), "", ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name)); From 1698665c8f3b7c4f77a61c610cd8b58da66e04ef Mon Sep 17 00:00:00 2001 From: Sammy Powers Date: Thu, 27 Aug 2020 17:42:05 -0700 Subject: [PATCH 49/53] Add zend_test.observer.show_output INI setting --- ext/zend_test/test.c | 34 ++++++++++++++++++++++++++++------ 1 file changed, 28 insertions(+), 6 deletions(-) diff --git a/ext/zend_test/test.c b/ext/zend_test/test.c index f4910c655077f..64fd421292e76 100644 --- a/ext/zend_test/test.c +++ b/ext/zend_test/test.c @@ -30,6 +30,7 @@ ZEND_BEGIN_MODULE_GLOBALS(zend_test) int observer_enabled; + int observer_show_output; int observer_observe_all; int observer_observe_includes; int observer_observe_functions; @@ -296,6 +297,7 @@ ZEND_METHOD(_ZendTestTrait, testMethod) /* {{{ */ { PHP_INI_BEGIN() STD_PHP_INI_BOOLEAN("zend_test.observer.enabled", "0", PHP_INI_SYSTEM, OnUpdateBool, observer_enabled, zend_zend_test_globals, zend_test_globals) + STD_PHP_INI_BOOLEAN("zend_test.observer.show_output", "1", PHP_INI_SYSTEM, OnUpdateBool, observer_show_output, zend_zend_test_globals, zend_test_globals) STD_PHP_INI_BOOLEAN("zend_test.observer.observe_all", "0", PHP_INI_SYSTEM, OnUpdateBool, observer_observe_all, zend_zend_test_globals, zend_test_globals) STD_PHP_INI_BOOLEAN("zend_test.observer.observe_includes", "0", PHP_INI_SYSTEM, OnUpdateBool, observer_observe_includes, zend_zend_test_globals, zend_test_globals) STD_PHP_INI_BOOLEAN("zend_test.observer.observe_functions", "0", PHP_INI_SYSTEM, OnUpdateBool, observer_observe_functions, zend_zend_test_globals, zend_test_globals) @@ -390,11 +392,14 @@ PHP_MINIT_FUNCTION(zend_test) attr->validator = zend_attribute_validate_zendtestattribute; } - REGISTER_INI_ENTRIES(); - // Loading via dl() not supported with the observer API - if (ZT_G(observer_enabled) && type != MODULE_TEMPORARY) { - zend_observer_fcall_register(observer_fcall_init); + if (type != MODULE_TEMPORARY) { + REGISTER_INI_ENTRIES(); + if (ZT_G(observer_enabled)) { + zend_observer_fcall_register(observer_fcall_init); + } + } else { + (void)ini_entries; } return SUCCESS; @@ -402,13 +407,19 @@ PHP_MINIT_FUNCTION(zend_test) PHP_MSHUTDOWN_FUNCTION(zend_test) { - UNREGISTER_INI_ENTRIES(); + if (type != MODULE_TEMPORARY) { + UNREGISTER_INI_ENTRIES(); + } return SUCCESS; } static void observer_begin(zend_execute_data *execute_data) { + if (!ZT_G(observer_show_output)) { + return; + } + if (execute_data->func && execute_data->func->common.function_name) { if (execute_data->func->common.scope) { php_printf("%*s<%s::%s>\n", 2 * ZT_G(observer_nesting_depth), "", ZSTR_VAL(execute_data->func->common.scope->name), ZSTR_VAL(execute_data->func->common.function_name)); @@ -440,6 +451,10 @@ static void get_retval_info(zval *retval, smart_str *buf) static void observer_end(zend_execute_data *execute_data, zval *retval) { + if (!ZT_G(observer_show_output)) { + return; + } + if (EG(exception)) { php_printf("%*s\n", 2 * ZT_G(observer_nesting_depth), "", ZSTR_VAL(EG(exception)->ce->name)); } @@ -458,7 +473,7 @@ static void observer_end(zend_execute_data *execute_data, zval *retval) } } -static zend_observer_fcall observer_fcall_init(zend_function *fbc) +static void observer_show_init(zend_function *fbc) { if (fbc->common.function_name) { if (fbc->common.scope) { @@ -469,6 +484,13 @@ static zend_observer_fcall observer_fcall_init(zend_function *fbc) } else { php_printf("%*s\n", 2 * ZT_G(observer_nesting_depth), "", ZSTR_VAL(fbc->op_array.filename)); } +} + +static zend_observer_fcall observer_fcall_init(zend_function *fbc) +{ + if (ZT_G(observer_show_output)) { + observer_show_init(fbc); + } if (ZT_G(observer_observe_all)) { return (zend_observer_fcall){observer_begin, observer_end}; From 6181716ace2b192903c92d060c83bbe7393ac34d Mon Sep 17 00:00:00 2001 From: Sammy Powers Date: Thu, 27 Aug 2020 18:00:00 -0700 Subject: [PATCH 50/53] Skip JIT tests on non-JIT builds --- ext/zend_test/tests/observer_jit_01.phpt | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/ext/zend_test/tests/observer_jit_01.phpt b/ext/zend_test/tests/observer_jit_01.phpt index e61ecef845d82..f489986b6e79b 100644 --- a/ext/zend_test/tests/observer_jit_01.phpt +++ b/ext/zend_test/tests/observer_jit_01.phpt @@ -3,6 +3,7 @@ Observer: JIT is disabled when observer extension is present --SKIPIF-- + --INI-- zend_test.observer.enabled=1 zend_test.observer.observe_all=1 @@ -13,10 +14,6 @@ opcache.jit_buffer_size=1M --FILE-- From 63dba3df6bffb93f6daa94a61a001fd3998b988e Mon Sep 17 00:00:00 2001 From: Levi Morrison Date: Mon, 31 Aug 2020 15:27:27 -0600 Subject: [PATCH 51/53] Update observer arena size --- Zend/zend_observer.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/Zend/zend_observer.c b/Zend/zend_observer.c index 1b675ca459e7c..0f89e58ed2dec 100644 --- a/Zend/zend_observer.c +++ b/Zend/zend_observer.c @@ -61,9 +61,8 @@ ZEND_API void zend_observer_startup(void) { } ZEND_API void zend_observer_activate(void) { - /* todo: how to size the arena? */ if (ZEND_OBSERVER_ENABLED) { - fcall_handlers_arena = zend_arena_create(1024); + fcall_handlers_arena = zend_arena_create(4096); } } From 1ca066b9e652e3899490553d863f2851b8a6a6cc Mon Sep 17 00:00:00 2001 From: Levi Morrison Date: Mon, 31 Aug 2020 15:39:22 -0600 Subject: [PATCH 52/53] Add ZEND_API to some observer functions --- Zend/zend_observer.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Zend/zend_observer.c b/Zend/zend_observer.c index 0f89e58ed2dec..033551c6e91bd 100644 --- a/Zend/zend_observer.c +++ b/Zend/zend_observer.c @@ -117,7 +117,7 @@ ZEND_API void zend_observer_fcall_install(zend_function *function) { zend_llist_destroy(&handlers_list); } -void zend_observe_fcall_begin( +ZEND_API void zend_observe_fcall_begin( zend_observer_fcall_cache *cache, zend_execute_data *execute_data) { @@ -129,7 +129,7 @@ void zend_observe_fcall_begin( } } -void zend_observer_fcall_call_end_helper( +ZEND_API void zend_observer_fcall_call_end_helper( zend_execute_data *execute_data, zval *return_value) { @@ -144,7 +144,7 @@ void zend_observer_fcall_call_end_helper( } } -void zend_observe_fcall_end( +ZEND_API void zend_observe_fcall_end( zend_observer_fcall_cache *cache, zend_execute_data *execute_data, zval *return_value) From 85083ff6f360f39b3d2901850456d95b36c554ae Mon Sep 17 00:00:00 2001 From: Levi Morrison Date: Mon, 31 Aug 2020 16:50:17 -0600 Subject: [PATCH 53/53] Fix C++ compat for zend_observer.h Also cleanup zend_observer_maybe_fcall_call_begin --- Zend/zend_observer.h | 18 +++++++++++------- 1 file changed, 11 insertions(+), 7 deletions(-) diff --git a/Zend/zend_observer.h b/Zend/zend_observer.h index c65d77013dfd3..9fb538ce3da0e 100644 --- a/Zend/zend_observer.h +++ b/Zend/zend_observer.h @@ -81,17 +81,21 @@ ZEND_API void zend_observer_fcall_call_end_helper( ZEND_API zend_always_inline void zend_observer_maybe_fcall_call_begin( zend_execute_data *execute_data) { - zend_op_array *op_array = (zend_op_array *)execute_data->func; - if (ZEND_OBSERVABLE_FN(op_array->fn_flags) && - !(op_array->fn_flags & ZEND_ACC_GENERATOR)) { - void *observer_handlers = ZEND_OBSERVER_HANDLERS(&EX(func)->op_array); + ZEND_ASSUME(execute_data->func); + zend_op_array *op_array = &execute_data->func->op_array; + uint32_t fn_flags = op_array->fn_flags; + if (ZEND_OBSERVABLE_FN(fn_flags) && !(fn_flags & ZEND_ACC_GENERATOR)) { + void *observer_handlers = ZEND_OBSERVER_HANDLERS(op_array); if (!observer_handlers) { - zend_observer_fcall_install((zend_function *)&EX(func)->op_array); - observer_handlers = ZEND_OBSERVER_HANDLERS(&EX(func)->op_array); + zend_observer_fcall_install((zend_function *)op_array); + observer_handlers = ZEND_OBSERVER_HANDLERS(op_array); } + ZEND_ASSERT(observer_handlers); if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) { - zend_observe_fcall_begin(observer_handlers, execute_data); + zend_observe_fcall_begin( + (zend_observer_fcall_cache *)observer_handlers, + execute_data); } } }