#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;
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();
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();
+}
+
+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);
+ 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);
+ }
+
+ 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();
+}
+
+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);
+ 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);
+ }
+
+ 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();
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();
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_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);
+ 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_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);
+ 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();
ZEND_VM_CONTINUE();
}
+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);
+ 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_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);
+ 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);
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
}
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();
}
}
}
+
+ 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_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));
}
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
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 */
+ zend_generator_close(generator, 1);
+
+ /* Pass execution back to handling code */
+ ZEND_VM_RETURN();
+}
+
static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_THROW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
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);
+
+ 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));
call->prev_execute_data = execute_data;
i_init_code_execute_data(call, new_op_array, return_value);
+ zend_observer_maybe_fcall_call_begin(call);
if (EXPECTED(zend_execute_ex == execute_ex)) {
+
ZEND_VM_ENTER();
} else {
ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
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();
}
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);
+
+ 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));
call->prev_execute_data = execute_data;
i_init_code_execute_data(call, new_op_array, return_value);
+ 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();
} else {
ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
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();
}
}
}
}
+
+ 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_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));
}
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_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
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 */
+ zend_generator_close(generator, 1);
+
+ /* Pass execution back to handling code */
+ ZEND_VM_RETURN();
+}
+
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
}
}
}
+
+ 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_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));
}
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_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
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 */
+ zend_generator_close(generator, 1);
+
+ /* Pass execution back to handling code */
+ ZEND_VM_RETURN();
+}
+
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
}
}
}
+
+ 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_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));
}
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_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
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 */
+ zend_generator_close(generator, 1);
+
+ /* Pass execution back to handling code */
+ ZEND_VM_RETURN();
+}
+
static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_THROW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
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);
+
+ 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));
call->prev_execute_data = execute_data;
i_init_code_execute_data(call, new_op_array, return_value);
+ zend_observer_maybe_fcall_call_begin(call);
if (EXPECTED(zend_execute_ex == execute_ex)) {
+
ZEND_VM_ENTER();
} else {
ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
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();
}
(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,
(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,
(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,
(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,
(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,
(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,
(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,
(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,
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);
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);
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);
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);
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);
}
}
}
+
+ 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;
}
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);
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);
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);
}
}
}
+
+ 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;
}
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);
}
}
}
+
+ 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;
}
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);
}
}
}
+
+ 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;
}
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);
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);
}
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_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);
}
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,
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,
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,
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,
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,
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,
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,
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,
1347,
1348,
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,
- 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,
+ 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,
- 1953,
- 1954,
- 1955 | SPEC_RULE_OP2,
- 1960,
- 1961 | SPEC_RULE_OP1,
- 1966 | SPEC_RULE_OP2,
- 1971 | SPEC_RULE_OP1,
- 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,
- 2163 | SPEC_RULE_OP1,
- 2168,
+ 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 | SPEC_RULE_OP1,
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,
- 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,
+ 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 | 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,
- 2416,
- 2417 | SPEC_RULE_OP2,
- 2422,
- 2423 | SPEC_RULE_OP1,
- 2428 | SPEC_RULE_OP1,
- 2433 | SPEC_RULE_OP1,
- 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
+ 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 | 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,
+ 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;
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) {
} 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;
if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
break;
}
- spec = 2522 | 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);
}
if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
break;
}
- spec = 2547 | 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);
}
if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
break;
}
- spec = 2572 | 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);
}
if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
break;
}
- spec = 2597 | 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 = 2622 | 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 = 2647 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+ spec = 2675 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
}
break;
case ZEND_MUL:
if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
break;
}
- spec = 2672 | 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 = 2697 | 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 = 2722 | 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:
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 = 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 = 2822 | 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 = 3047 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+ spec = 3075 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
}
break;
case ZEND_IS_NOT_IDENTICAL:
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 = 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 = 2972 | 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 = 3052 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+ spec = 3080 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
}
break;
case ZEND_IS_EQUAL:
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 = 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 = 2822 | 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:
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 = 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 = 2972 | 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:
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 = 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 = 3132 | 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:
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 = 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 = 3282 | 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 = 3369 | SPEC_RULE_OP1;
+ spec = 3397 | SPEC_RULE_OP1;
} else if (op1_info == MAY_BE_DOUBLE) {
- spec = 3374 | 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 = 3379 | 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 = 3357 | SPEC_RULE_RETVAL;
+ spec = 3385 | SPEC_RULE_RETVAL;
} else if (op1_info == MAY_BE_LONG) {
- spec = 3359 | 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 = 3361 | SPEC_RULE_RETVAL;
+ spec = 3389 | SPEC_RULE_RETVAL;
} else if (op1_info == MAY_BE_LONG) {
- spec = 3363 | 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 = 3365;
+ spec = 3393;
} else if (op1_info == MAY_BE_LONG) {
- spec = 3366;
+ spec = 3394;
}
break;
case ZEND_POST_DEC:
if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
- spec = 3367;
+ spec = 3395;
} else if (op1_info == MAY_BE_LONG) {
- spec = 3368;
+ spec = 3396;
}
break;
case ZEND_JMP:
if (OP_JMP_ADDR(op, op->op1) > op) {
- spec = 2521;
+ spec = 2549;
}
break;
case ZEND_RECV:
if (op->op2.num == MAY_BE_ANY) {
- spec = 2520;
+ 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 = 3419;
+ 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 = 3414 | SPEC_RULE_OP1;
+ spec = 3442 | SPEC_RULE_OP1;
}
break;
case ZEND_FE_FETCH_R:
if (op->op2_type == IS_CV && (op1_info & (MAY_BE_ANY|MAY_BE_REF)) == MAY_BE_ARRAY) {
- spec = 3421 | SPEC_RULE_RETVAL;
+ spec = 3449 | SPEC_RULE_RETVAL;
}
break;
case ZEND_FETCH_DIM_R:
if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
break;
}
- spec = 3384 | 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 = 3420;
+ spec = 3448;
}
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 = 3437 | SPEC_RULE_OP1;
}
break;
case ZEND_BW_OR:
_(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_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) \
- _(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) \
- _(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) \
- _(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) \
- _(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) \
- _(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) \
- _(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) \
- _(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) \
- _(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) \
- _(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) \
- _(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) \
- _(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) \
- _(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) \
- _(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) \
- _(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) \
- _(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) \
- _(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)
+ _(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)
projects / php / commitdiff