diff --git a/Zend/Optimizer/dfa_pass.c b/Zend/Optimizer/dfa_pass.c index 77dc322fbdec..e748e0d5a459 100644 --- a/Zend/Optimizer/dfa_pass.c +++ b/Zend/Optimizer/dfa_pass.c @@ -316,6 +316,54 @@ static inline bool can_elide_return_type_check( return false; } +static inline bool can_return_value_safely_be_coerced( + const zend_op_array *op_array, const zend_ssa *ssa, const zend_ssa_op *ssa_op, zend_op *opline +) { + const uint32_t return_type_mask = ZEND_TYPE_FULL_MASK(op_array->arg_info[-1].type); + const zend_ssa_var_info *use_info = &ssa->var_info[ssa_op->op1_use]; + + /* Type preference order: int -> float -> string -> bool */ + /* Can always safely cast booleans to inter */ + if (return_type_mask & MAY_BE_LONG) { + if (use_info->type & MAY_BE_BOOL) { + opline->opcode = ZEND_CAST_VALUE_FOR_RETURN_TYPE; + opline->extended_value = IS_LONG; + return true; + } + return false; + } + if (return_type_mask & MAY_BE_DOUBLE) { + /* Can always safely cast booleans, and integers to float */ + if (use_info->type & (MAY_BE_LONG|MAY_BE_BOOL)) { + opline->opcode = ZEND_CAST_VALUE_FOR_RETURN_TYPE; + opline->extended_value = IS_DOUBLE; + return true; + } + return false; + } + /* Can always safely cast booleans, and integers to string, + * float value must not be NAN */ + if (return_type_mask & MAY_BE_STRING) { + if (use_info->type & (MAY_BE_LONG|MAY_BE_BOOL)) { + opline->opcode = ZEND_CAST_VALUE_FOR_RETURN_TYPE; + opline->extended_value = IS_STRING; + return true; + } + return false; + } + return false; + if ((return_type_mask & MAY_BE_BOOL) == MAY_BE_BOOL) { + /* Can always safely cast integers and strings to bool, + * float value must not be NAN */ + if (use_info->type & (MAY_BE_LONG|MAY_BE_STRING)) { + opline->opcode = ZEND_CAST_VALUE_FOR_RETURN_TYPE; + opline->extended_value = IS_FALSE; + return true; + } + return false; + } +} + static bool opline_supports_assign_contraction( zend_op_array *op_array, zend_ssa *ssa, zend_op *opline, int src_var, uint32_t cv_var) { if (opline->opcode == ZEND_NEW) { @@ -1287,6 +1335,8 @@ void zend_dfa_optimize_op_array(zend_op_array *op_array, zend_optimizer_ctx *ctx MAKE_NOP(opline); remove_nops = 1; + } else if (can_return_value_safely_be_coerced(op_array, ssa, &ssa->ops[op_1], opline)) { + continue; } } } diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 05923bbc2b61..d225f1da7486 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -22,6 +22,8 @@ * php zend_vm_gen.php */ +#include "zend_variables.h" + ZEND_VM_HELPER(zend_add_helper, ANY, ANY, zval *op_1, zval *op_2) { USE_OPLINE @@ -4532,6 +4534,40 @@ ZEND_VM_COLD_CONST_HANDLER(124, ZEND_VERIFY_RETURN_TYPE, CONST|TMP|VAR|UNUSED|CV } } +ZEND_VM_COLD_CONST_HANDLER(45, ZEND_CAST_VALUE_FOR_RETURN_TYPE, TMP|VAR|CV, UNUSED) +{ + USE_OPLINE + zval *retval_ptr = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R); + ZEND_ASSERT(!Z_ISREF_P(retval_ptr)); + + switch (opline->extended_value) { + case IS_LONG: { + zend_long lval = zval_get_long(retval_ptr); + zval_ptr_dtor(retval_ptr); + ZVAL_LONG(retval_ptr, lval); + break; + } + case IS_DOUBLE: { + double dval = zval_get_double(retval_ptr); + zval_ptr_dtor(retval_ptr); + ZVAL_DOUBLE(retval_ptr, dval); + break; + } + case IS_STRING: + /* retval_ptr cannot be a refcounted value */ + ZVAL_STR(retval_ptr, zval_get_string(retval_ptr)); + break; + case IS_FALSE: { /* Used for booleans */ + bool bval = i_zend_is_true(retval_ptr); + zval_ptr_dtor(retval_ptr); + ZVAL_BOOL(retval_ptr, bval); + break; + } + /* Default case assert? */ + } + ZEND_VM_NEXT_OPCODE(); +} + ZEND_VM_COLD_HANDLER(201, ZEND_VERIFY_NEVER_TYPE, UNUSED, UNUSED) { SAVE_OPLINE(); diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 2b5b9e5fcd47..5e79853fb064 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -11250,6 +11250,40 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ } } +static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CAST_VALUE_FOR_RETURN_TYPE_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *retval_ptr = RT_CONSTANT(opline, opline->op1); + ZEND_ASSERT(!Z_ISREF_P(retval_ptr)); + + switch (opline->extended_value) { + case IS_LONG: { + zend_long lval = zval_get_long(retval_ptr); + zval_ptr_dtor(retval_ptr); + ZVAL_LONG(retval_ptr, lval); + break; + } + case IS_DOUBLE: { + double dval = zval_get_double(retval_ptr); + zval_ptr_dtor(retval_ptr); + ZVAL_DOUBLE(retval_ptr, dval); + break; + } + case IS_STRING: + /* retval_ptr cannot be a refcounted value */ + ZVAL_STR(retval_ptr, zval_get_string(retval_ptr)); + break; + case IS_FALSE: { /* Used for booleans */ + bool bval = i_zend_is_true(retval_ptr); + zval_ptr_dtor(retval_ptr); + ZVAL_BOOL(retval_ptr, bval); + break; + } + /* Default case assert? */ + } + ZEND_VM_NEXT_OPCODE(); +} + static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_VAL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -21559,6 +21593,40 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_VERIFY_RETURN } } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CAST_VALUE_FOR_RETURN_TYPE_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + ZEND_ASSERT(!Z_ISREF_P(retval_ptr)); + + switch (opline->extended_value) { + case IS_LONG: { + zend_long lval = zval_get_long(retval_ptr); + zval_ptr_dtor(retval_ptr); + ZVAL_LONG(retval_ptr, lval); + break; + } + case IS_DOUBLE: { + double dval = zval_get_double(retval_ptr); + zval_ptr_dtor(retval_ptr); + ZVAL_DOUBLE(retval_ptr, dval); + break; + } + case IS_STRING: + /* retval_ptr cannot be a refcounted value */ + ZVAL_STR(retval_ptr, zval_get_string(retval_ptr)); + break; + case IS_FALSE: { /* Used for booleans */ + bool bval = i_zend_is_true(retval_ptr); + zval_ptr_dtor(retval_ptr); + ZVAL_BOOL(retval_ptr, bval); + break; + } + /* Default case assert? */ + } + ZEND_VM_NEXT_OPCODE(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -29604,6 +29672,40 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_VERIFY_RETURN } } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CAST_VALUE_FOR_RETURN_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *retval_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + ZEND_ASSERT(!Z_ISREF_P(retval_ptr)); + + switch (opline->extended_value) { + case IS_LONG: { + zend_long lval = zval_get_long(retval_ptr); + zval_ptr_dtor(retval_ptr); + ZVAL_LONG(retval_ptr, lval); + break; + } + case IS_DOUBLE: { + double dval = zval_get_double(retval_ptr); + zval_ptr_dtor(retval_ptr); + ZVAL_DOUBLE(retval_ptr, dval); + break; + } + case IS_STRING: + /* retval_ptr cannot be a refcounted value */ + ZVAL_STR(retval_ptr, zval_get_string(retval_ptr)); + break; + case IS_FALSE: { /* Used for booleans */ + bool bval = i_zend_is_true(retval_ptr); + zval_ptr_dtor(retval_ptr); + ZVAL_BOOL(retval_ptr, bval); + break; + } + /* Default case assert? */ + } + ZEND_VM_NEXT_OPCODE(); +} + static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -49200,6 +49302,40 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_VERIFY_RETURN } } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CAST_VALUE_FOR_RETURN_TYPE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *retval_ptr = EX_VAR(opline->op1.var); + ZEND_ASSERT(!Z_ISREF_P(retval_ptr)); + + switch (opline->extended_value) { + case IS_LONG: { + zend_long lval = zval_get_long(retval_ptr); + zval_ptr_dtor(retval_ptr); + ZVAL_LONG(retval_ptr, lval); + break; + } + case IS_DOUBLE: { + double dval = zval_get_double(retval_ptr); + zval_ptr_dtor(retval_ptr); + ZVAL_DOUBLE(retval_ptr, dval); + break; + } + case IS_STRING: + /* retval_ptr cannot be a refcounted value */ + ZVAL_STR(retval_ptr, zval_get_string(retval_ptr)); + break; + case IS_FALSE: { /* Used for booleans */ + bool bval = i_zend_is_true(retval_ptr); + zval_ptr_dtor(retval_ptr); + ZVAL_BOOL(retval_ptr, bval); + break; + } + /* Default case assert? */ + } + ZEND_VM_NEXT_OPCODE(); +} + static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -63806,6 +63942,40 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_VERIF } } +static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CAST_VALUE_FOR_RETURN_TYPE_SPEC_CONST_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *retval_ptr = RT_CONSTANT(opline, opline->op1); + ZEND_ASSERT(!Z_ISREF_P(retval_ptr)); + + switch (opline->extended_value) { + case IS_LONG: { + zend_long lval = zval_get_long(retval_ptr); + zval_ptr_dtor(retval_ptr); + ZVAL_LONG(retval_ptr, lval); + break; + } + case IS_DOUBLE: { + double dval = zval_get_double(retval_ptr); + zval_ptr_dtor(retval_ptr); + ZVAL_DOUBLE(retval_ptr, dval); + break; + } + case IS_STRING: + /* retval_ptr cannot be a refcounted value */ + ZVAL_STR(retval_ptr, zval_get_string(retval_ptr)); + break; + case IS_FALSE: { /* Used for booleans */ + bool bval = i_zend_is_true(retval_ptr); + zval_ptr_dtor(retval_ptr); + ZVAL_BOOL(retval_ptr, bval); + break; + } + /* Default case assert? */ + } + ZEND_VM_NEXT_OPCODE(); +} + static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_VAL_SPEC_CONST_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -74015,6 +74185,40 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_VERIFY_RETURN_TYPE } } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CAST_VALUE_FOR_RETURN_TYPE_SPEC_TMP_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + ZEND_ASSERT(!Z_ISREF_P(retval_ptr)); + + switch (opline->extended_value) { + case IS_LONG: { + zend_long lval = zval_get_long(retval_ptr); + zval_ptr_dtor(retval_ptr); + ZVAL_LONG(retval_ptr, lval); + break; + } + case IS_DOUBLE: { + double dval = zval_get_double(retval_ptr); + zval_ptr_dtor(retval_ptr); + ZVAL_DOUBLE(retval_ptr, dval); + break; + } + case IS_STRING: + /* retval_ptr cannot be a refcounted value */ + ZVAL_STR(retval_ptr, zval_get_string(retval_ptr)); + break; + case IS_FALSE: { /* Used for booleans */ + bool bval = i_zend_is_true(retval_ptr); + zval_ptr_dtor(retval_ptr); + ZVAL_BOOL(retval_ptr, bval); + break; + } + /* Default case assert? */ + } + ZEND_VM_NEXT_OPCODE(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -82060,6 +82264,40 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_VERIFY_RETURN_TYPE } } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CAST_VALUE_FOR_RETURN_TYPE_SPEC_VAR_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *retval_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + ZEND_ASSERT(!Z_ISREF_P(retval_ptr)); + + switch (opline->extended_value) { + case IS_LONG: { + zend_long lval = zval_get_long(retval_ptr); + zval_ptr_dtor(retval_ptr); + ZVAL_LONG(retval_ptr, lval); + break; + } + case IS_DOUBLE: { + double dval = zval_get_double(retval_ptr); + zval_ptr_dtor(retval_ptr); + ZVAL_DOUBLE(retval_ptr, dval); + break; + } + case IS_STRING: + /* retval_ptr cannot be a refcounted value */ + ZVAL_STR(retval_ptr, zval_get_string(retval_ptr)); + break; + case IS_FALSE: { /* Used for booleans */ + bool bval = i_zend_is_true(retval_ptr); + zval_ptr_dtor(retval_ptr); + ZVAL_BOOL(retval_ptr, bval); + break; + } + /* Default case assert? */ + } + ZEND_VM_NEXT_OPCODE(); +} + static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_VAR_SPEC_VAR_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -101554,6 +101792,40 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_VERIFY_RETURN_TYPE } } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CAST_VALUE_FOR_RETURN_TYPE_SPEC_CV_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *retval_ptr = EX_VAR(opline->op1.var); + ZEND_ASSERT(!Z_ISREF_P(retval_ptr)); + + switch (opline->extended_value) { + case IS_LONG: { + zend_long lval = zval_get_long(retval_ptr); + zval_ptr_dtor(retval_ptr); + ZVAL_LONG(retval_ptr, lval); + break; + } + case IS_DOUBLE: { + double dval = zval_get_double(retval_ptr); + zval_ptr_dtor(retval_ptr); + ZVAL_DOUBLE(retval_ptr, dval); + break; + } + case IS_STRING: + /* retval_ptr cannot be a refcounted value */ + ZVAL_STR(retval_ptr, zval_get_string(retval_ptr)); + break; + case IS_FALSE: { /* Used for booleans */ + bool bval = i_zend_is_true(retval_ptr); + zval_ptr_dtor(retval_ptr); + ZVAL_BOOL(retval_ptr, bval); + break; + } + /* Default case assert? */ + } + ZEND_VM_NEXT_OPCODE(); +} + static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_VAR_SPEC_CV_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -107920,6 +108192,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_JMPNZ_SPEC_CV_LABEL, + (void*)&&ZEND_CAST_VALUE_FOR_RETURN_TYPE_SPEC_CONST_UNUSED_LABEL, + (void*)&&ZEND_CAST_VALUE_FOR_RETURN_TYPE_SPEC_TMP_UNUSED_LABEL, + (void*)&&ZEND_CAST_VALUE_FOR_RETURN_TYPE_SPEC_VAR_UNUSED_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_CAST_VALUE_FOR_RETURN_TYPE_SPEC_CV_UNUSED_LABEL, (void*)&&ZEND_JMPZ_EX_SPEC_CONST_LABEL, (void*)&&ZEND_JMPZ_EX_SPEC_TMP_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -111521,6 +111798,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED) HYBRID_BREAK(); + HYBRID_CASE(ZEND_CAST_VALUE_FOR_RETURN_TYPE_SPEC_CONST_UNUSED): + VM_TRACE(ZEND_CAST_VALUE_FOR_RETURN_TYPE_SPEC_CONST_UNUSED) + ZEND_CAST_VALUE_FOR_RETURN_TYPE_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_CAST_VALUE_FOR_RETURN_TYPE_SPEC_CONST_UNUSED) + HYBRID_BREAK(); HYBRID_CASE(ZEND_SEND_VAL_SPEC_CONST_UNUSED): VM_TRACE(ZEND_SEND_VAL_SPEC_CONST_UNUSED) ZEND_SEND_VAL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -112910,6 +113192,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED) HYBRID_BREAK(); + HYBRID_CASE(ZEND_CAST_VALUE_FOR_RETURN_TYPE_SPEC_TMP_UNUSED): + VM_TRACE(ZEND_CAST_VALUE_FOR_RETURN_TYPE_SPEC_TMP_UNUSED) + ZEND_CAST_VALUE_FOR_RETURN_TYPE_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_CAST_VALUE_FOR_RETURN_TYPE_SPEC_TMP_UNUSED) + HYBRID_BREAK(); HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED): VM_TRACE(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED) ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -113510,6 +113797,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED) HYBRID_BREAK(); + HYBRID_CASE(ZEND_CAST_VALUE_FOR_RETURN_TYPE_SPEC_VAR_UNUSED): + VM_TRACE(ZEND_CAST_VALUE_FOR_RETURN_TYPE_SPEC_VAR_UNUSED) + ZEND_CAST_VALUE_FOR_RETURN_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_CAST_VALUE_FOR_RETURN_TYPE_SPEC_VAR_UNUSED) + HYBRID_BREAK(); HYBRID_CASE(ZEND_SEND_VAR_SPEC_VAR_UNUSED): VM_TRACE(ZEND_SEND_VAR_SPEC_VAR_UNUSED) ZEND_SEND_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -115149,6 +115441,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED) HYBRID_BREAK(); + HYBRID_CASE(ZEND_CAST_VALUE_FOR_RETURN_TYPE_SPEC_CV_UNUSED): + VM_TRACE(ZEND_CAST_VALUE_FOR_RETURN_TYPE_SPEC_CV_UNUSED) + ZEND_CAST_VALUE_FOR_RETURN_TYPE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_CAST_VALUE_FOR_RETURN_TYPE_SPEC_CV_UNUSED) + HYBRID_BREAK(); HYBRID_CASE(ZEND_SEND_VAR_SPEC_CV_UNUSED): VM_TRACE(ZEND_SEND_VAR_SPEC_CV_UNUSED) ZEND_SEND_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -116858,6 +117155,11 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_JMPNZ_SPEC_CV_HANDLER, + ZEND_CAST_VALUE_FOR_RETURN_TYPE_SPEC_CONST_UNUSED_HANDLER, + ZEND_CAST_VALUE_FOR_RETURN_TYPE_SPEC_TMP_UNUSED_HANDLER, + ZEND_CAST_VALUE_FOR_RETURN_TYPE_SPEC_VAR_UNUSED_HANDLER, + ZEND_NULL_HANDLER, + ZEND_CAST_VALUE_FOR_RETURN_TYPE_SPEC_CV_UNUSED_HANDLER, ZEND_JMPZ_EX_SPEC_CONST_HANDLER, ZEND_JMPZ_EX_SPEC_TMP_HANDLER, ZEND_NULL_HANDLER, @@ -120336,6 +120638,11 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_JMPNZ_SPEC_CV_TAILCALL_HANDLER, + ZEND_CAST_VALUE_FOR_RETURN_TYPE_SPEC_CONST_UNUSED_TAILCALL_HANDLER, + ZEND_CAST_VALUE_FOR_RETURN_TYPE_SPEC_TMP_UNUSED_TAILCALL_HANDLER, + ZEND_CAST_VALUE_FOR_RETURN_TYPE_SPEC_VAR_UNUSED_TAILCALL_HANDLER, + ZEND_NULL_TAILCALL_HANDLER, + ZEND_CAST_VALUE_FOR_RETURN_TYPE_SPEC_CV_UNUSED_TAILCALL_HANDLER, ZEND_JMPZ_EX_SPEC_CONST_TAILCALL_HANDLER, ZEND_JMPZ_EX_SPEC_TMP_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -122597,217 +122904,217 @@ void zend_vm_init(void) 1255, 1256 | SPEC_RULE_OP1, 1261 | SPEC_RULE_OP1, - 3474, 1266 | SPEC_RULE_OP1, 1271 | SPEC_RULE_OP1, - 1276 | SPEC_RULE_OP2, - 1281, - 1282 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, - 1292 | SPEC_RULE_OP1, + 1276 | SPEC_RULE_OP1, + 1281 | SPEC_RULE_OP2, + 1286, + 1287 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, 1297 | SPEC_RULE_OP1, - 1302 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1327 | SPEC_RULE_OP2, + 1302 | SPEC_RULE_OP1, + 1307 | SPEC_RULE_OP1 | SPEC_RULE_OP2, 1332 | SPEC_RULE_OP2, 1337 | SPEC_RULE_OP2, - 1342, - 1343, - 1344, - 1345 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, + 1342 | SPEC_RULE_OP2, + 1347, + 1348, 1349, - 1350 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, - 1360, - 1361, - 1362 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1387 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, - 1437 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1462 | SPEC_RULE_OP1, - 1467, - 1468, - 1469 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1494 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1519 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, - 1529 | SPEC_RULE_OP1, - 1534 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1559 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1584 | SPEC_RULE_OP1, - 1589, - 3474, - 1590 | SPEC_RULE_OP1, - 1595 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1620 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1645 | SPEC_RULE_OP1, - 1650 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1675 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1700 | SPEC_RULE_OP1, - 1705 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1730 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1755 | SPEC_RULE_OP1, - 1760 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1785 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1810 | SPEC_RULE_OP1, - 1815 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1840 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1865 | SPEC_RULE_OP1, - 1870 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1895 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1920 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1945, - 1946 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, - 1956, - 1957, - 1958, - 1959, - 1960, - 1961 | SPEC_RULE_OP2, - 1966, - 1967 | SPEC_RULE_OP1, - 1972 | SPEC_RULE_OP2, - 1977 | SPEC_RULE_OP1, - 1982 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, - 1992 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2017 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2042 | SPEC_RULE_OP1, - 2047 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2072 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, - 2122 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2147 | SPEC_RULE_OP2, - 2152, - 2153 | SPEC_RULE_OP1, + 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, + 3479, + 1595 | SPEC_RULE_OP1, + 1600 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1625 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1650 | SPEC_RULE_OP1, + 1655 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1680 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1705 | SPEC_RULE_OP1, + 1710 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1735 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1760 | SPEC_RULE_OP1, + 1765 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1790 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1815 | SPEC_RULE_OP1, + 1820 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1845 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1870 | SPEC_RULE_OP1, + 1875 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1900 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1925 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1950, + 1951 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, + 1961, + 1962, + 1963, + 1964, + 1965, + 1966 | SPEC_RULE_OP2, + 1971, + 1972 | SPEC_RULE_OP1, + 1977 | SPEC_RULE_OP2, + 1982 | SPEC_RULE_OP1, + 1987 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, + 1997 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2022 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2047 | SPEC_RULE_OP1, + 2052 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2077 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, + 2127 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2152 | SPEC_RULE_OP2, + 2157, 2158 | SPEC_RULE_OP1, - 2163, - 2164 | SPEC_RULE_OP1, + 2163 | SPEC_RULE_OP1, + 2168, 2169 | SPEC_RULE_OP1, 2174 | SPEC_RULE_OP1, - 2179, - 2180, - 2181 | SPEC_RULE_OP2, - 2186 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, - 2190 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, - 2194 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, - 2198 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2198 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2223 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2223 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2248 | SPEC_RULE_OP1, - 2253, - 2254 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2279, - 2280 | SPEC_RULE_OP1, - 2285, - 2286, - 2287, - 2288, - 2289, + 2179 | SPEC_RULE_OP1, + 2184, + 2185, + 2186 | SPEC_RULE_OP2, + 2191 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, + 2195 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, + 2199 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, + 2203 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2203 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2228 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2228 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2253 | SPEC_RULE_OP1, + 2258, + 2259 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2284, + 2285 | SPEC_RULE_OP1, 2290, 2291, - 2292 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2317, - 2318, - 2319, - 2320 | SPEC_RULE_OP1, - 2325, - 2326 | SPEC_RULE_ISSET, - 2328 | SPEC_RULE_OP2, - 2333, - 2334 | SPEC_RULE_OP1, - 2339 | SPEC_RULE_OBSERVER, - 2341, - 2342 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2367 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, - 2377, - 2378, - 2379, - 2380, - 2381 | SPEC_RULE_OP1, - 2386, - 2387, - 2388 | SPEC_RULE_OP1, - 2393 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2418, - 2419 | SPEC_RULE_OP1, - 2424, - 2425, - 2426, - 2427, - 2428, + 2292, + 2293, + 2294, + 2295, + 2296, + 2297 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2322, + 2323, + 2324, + 2325 | SPEC_RULE_OP1, + 2330, + 2331 | SPEC_RULE_ISSET, + 2333 | SPEC_RULE_OP2, + 2338, + 2339 | SPEC_RULE_OP1, + 2344 | SPEC_RULE_OBSERVER, + 2346, + 2347 | SPEC_RULE_OP1 | 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 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2457, - 2458, - 2459, - 2460 | SPEC_RULE_OP2, - 2465, - 2466 | SPEC_RULE_OP1, + 2432, + 2433, + 2434, + 2435, + 2436, + 2437 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2462, + 2463, + 2464, + 2465 | SPEC_RULE_OP2, + 2470, 2471 | SPEC_RULE_OP1, 2476 | SPEC_RULE_OP1, 2481 | SPEC_RULE_OP1, 2486 | SPEC_RULE_OP1, - 2491, - 2492 | SPEC_RULE_OP1, - 2497 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2522 | SPEC_RULE_OP1, - 2527 | SPEC_RULE_OP2, - 2532 | SPEC_RULE_OP1, + 2491 | SPEC_RULE_OP1, + 2496, + 2497 | SPEC_RULE_OP1, + 2502 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2527 | SPEC_RULE_OP1, + 2532 | SPEC_RULE_OP2, 2537 | SPEC_RULE_OP1, - 2542, - 2543, - 2544, - 2545, - 2546, - 2547 | SPEC_RULE_OBSERVER, - 2549 | SPEC_RULE_OBSERVER, - 2551 | SPEC_RULE_OBSERVER, - 2553 | SPEC_RULE_OBSERVER, - 2555, - 2556, - 2557, - 2558, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, + 2542 | SPEC_RULE_OP1, + 2547, + 2548, + 2549, + 2550, + 2551, + 2552 | SPEC_RULE_OBSERVER, + 2554 | SPEC_RULE_OBSERVER, + 2556 | SPEC_RULE_OBSERVER, + 2558 | SPEC_RULE_OBSERVER, + 2560, + 2561, + 2562, + 2563, + 3479, + 3479, + 3479, + 3479, + 3479, + 3479, + 3479, + 3479, + 3479, + 3479, + 3479, + 3479, + 3479, + 3479, + 3479, + 3479, + 3479, + 3479, + 3479, + 3479, + 3479, + 3479, + 3479, + 3479, + 3479, + 3479, + 3479, + 3479, + 3479, + 3479, + 3479, + 3479, + 3479, + 3479, + 3479, + 3479, + 3479, + 3479, + 3479, + 3479, + 3479, + 3479, + 3479, + 3479, }; #if 0 #elif (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID) @@ -122984,7 +123291,7 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2567 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2572 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -122992,7 +123299,7 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2592 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2597 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -123000,7 +123307,7 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2617 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2622 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -123011,17 +123318,17 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2642 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2647 | 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 = 2667 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2672 | 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 = 2692 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2697 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_MUL: @@ -123032,17 +123339,17 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2717 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2722 | 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 = 2742 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2747 | 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 = 2767 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2772 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_IDENTICAL: @@ -123053,16 +123360,16 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2792 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2797 | 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 = 2867 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2872 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op2_type == IS_CONST && (Z_TYPE_P(RT_CONSTANT(op, op->op2)) == IS_ARRAY && zend_hash_num_elements(Z_ARR_P(RT_CONSTANT(op, op->op2))) == 0)) { - spec = 3092 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3097 | 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 = 3098 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3103 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_IDENTICAL: @@ -123073,16 +123380,16 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2942 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2947 | 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 = 3017 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3022 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op2_type == IS_CONST && (Z_TYPE_P(RT_CONSTANT(op, op->op2)) == IS_ARRAY && zend_hash_num_elements(Z_ARR_P(RT_CONSTANT(op, op->op2))) == 0)) { - spec = 3095 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3100 | 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 = 3103 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3108 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_EQUAL: @@ -123093,12 +123400,12 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2792 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2797 | 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 = 2867 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2872 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_EQUAL: @@ -123109,12 +123416,12 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2942 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2947 | 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 = 3017 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3022 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_SMALLER: @@ -123122,12 +123429,12 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3108 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3113 | 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 = 3183 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3188 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_IS_SMALLER_OR_EQUAL: @@ -123135,79 +123442,79 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3258 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3263 | 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 = 3333 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3338 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_QM_ASSIGN: if (op1_info == MAY_BE_LONG) { - spec = 3420 | SPEC_RULE_OP1; - } else if (op1_info == MAY_BE_DOUBLE) { spec = 3425 | SPEC_RULE_OP1; - } else if ((op->op1_type == IS_CONST) ? !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1)) : (!(op1_info & ((MAY_BE_ANY|MAY_BE_UNDEF)-(MAY_BE_NULL|MAY_BE_FALSE|MAY_BE_TRUE|MAY_BE_LONG|MAY_BE_DOUBLE))))) { + } else if (op1_info == MAY_BE_DOUBLE) { spec = 3430 | 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 = 3435 | SPEC_RULE_OP1; } break; case ZEND_PRE_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3408 | SPEC_RULE_RETVAL; + spec = 3413 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3410 | SPEC_RULE_RETVAL; + spec = 3415 | SPEC_RULE_RETVAL; } break; case ZEND_PRE_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3412 | SPEC_RULE_RETVAL; + spec = 3417 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3414 | SPEC_RULE_RETVAL; + spec = 3419 | SPEC_RULE_RETVAL; } break; case ZEND_POST_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3416; + spec = 3421; } else if (op1_info == MAY_BE_LONG) { - spec = 3417; + spec = 3422; } break; case ZEND_POST_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3418; + spec = 3423; } else if (op1_info == MAY_BE_LONG) { - spec = 3419; + spec = 3424; } break; case ZEND_JMP: if (OP_JMP_ADDR(op, op->op1) > op) { - spec = 2566; + spec = 2571; } break; case ZEND_INIT_FCALL: if (Z_EXTRA_P(RT_CONSTANT(op, op->op2)) != 0) { - spec = 2559; + spec = 2564; } break; case ZEND_RECV: if (op->op2.num == MAY_BE_ANY) { - spec = 2560; + spec = 2565; } 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 = 3470; + spec = 3475; } 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 = 3465 | SPEC_RULE_OP1; + spec = 3470 | 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 = 3472 | SPEC_RULE_RETVAL; + spec = 3477 | SPEC_RULE_RETVAL; } break; case ZEND_FETCH_DIM_R: @@ -123215,22 +123522,22 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3435 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 3440 | 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 = 3471; + spec = 3476; } break; case ZEND_SEND_VAR: if (op->op2_type == IS_UNUSED && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3460 | SPEC_RULE_OP1; + spec = 3465 | SPEC_RULE_OP1; } break; case ZEND_COUNT: if ((op1_info & (MAY_BE_ANY|MAY_BE_UNDEF|MAY_BE_REF)) == MAY_BE_ARRAY) { - spec = 2561 | SPEC_RULE_OP1; + spec = 2566 | SPEC_RULE_OP1; } break; case ZEND_BW_OR: diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h index 6f1595195450..a08113e541f8 100644 --- a/Zend/zend_vm_handlers.h +++ b/Zend/zend_vm_handlers.h @@ -453,1141 +453,1145 @@ _(1261, ZEND_JMPNZ_SPEC_CONST) \ _(1262, ZEND_JMPNZ_SPEC_TMP) \ _(1265, ZEND_JMPNZ_SPEC_CV) \ - _(1266, ZEND_JMPZ_EX_SPEC_CONST) \ - _(1267, ZEND_JMPZ_EX_SPEC_TMP) \ - _(1270, ZEND_JMPZ_EX_SPEC_CV) \ - _(1271, ZEND_JMPNZ_EX_SPEC_CONST) \ - _(1272, ZEND_JMPNZ_EX_SPEC_TMP) \ - _(1275, ZEND_JMPNZ_EX_SPEC_CV) \ - _(1276, ZEND_CASE_SPEC_TMP_CONST) \ - _(1277, ZEND_CASE_SPEC_TMP_TMP) \ - _(1280, ZEND_CASE_SPEC_TMP_CV) \ - _(1281, ZEND_CHECK_VAR_SPEC_CV_UNUSED) \ - _(1282, ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST) \ - _(1283, ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST) \ - _(1288, ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED) \ - _(1289, ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK) \ - _(1292, ZEND_CAST_SPEC_CONST) \ - _(1293, ZEND_CAST_SPEC_TMP) \ - _(1296, ZEND_CAST_SPEC_CV) \ - _(1297, ZEND_BOOL_SPEC_CONST) \ - _(1298, ZEND_BOOL_SPEC_TMP) \ - _(1301, ZEND_BOOL_SPEC_CV) \ - _(1302, ZEND_FAST_CONCAT_SPEC_CONST_CONST) \ - _(1303, ZEND_FAST_CONCAT_SPEC_CONST_TMP) \ - _(1306, ZEND_FAST_CONCAT_SPEC_CONST_CV) \ - _(1307, ZEND_FAST_CONCAT_SPEC_TMP_CONST) \ - _(1308, ZEND_FAST_CONCAT_SPEC_TMP_TMP) \ - _(1311, ZEND_FAST_CONCAT_SPEC_TMP_CV) \ - _(1322, ZEND_FAST_CONCAT_SPEC_CV_CONST) \ - _(1323, ZEND_FAST_CONCAT_SPEC_CV_TMP) \ - _(1326, ZEND_FAST_CONCAT_SPEC_CV_CV) \ - _(1327, ZEND_ROPE_INIT_SPEC_UNUSED_CONST) \ - _(1328, ZEND_ROPE_INIT_SPEC_UNUSED_TMP) \ - _(1331, ZEND_ROPE_INIT_SPEC_UNUSED_CV) \ - _(1332, ZEND_ROPE_ADD_SPEC_TMP_CONST) \ - _(1333, ZEND_ROPE_ADD_SPEC_TMP_TMP) \ - _(1336, ZEND_ROPE_ADD_SPEC_TMP_CV) \ - _(1337, ZEND_ROPE_END_SPEC_TMP_CONST) \ - _(1338, ZEND_ROPE_END_SPEC_TMP_TMP) \ - _(1341, ZEND_ROPE_END_SPEC_TMP_CV) \ - _(1342, ZEND_BEGIN_SILENCE_SPEC) \ - _(1343, ZEND_END_SILENCE_SPEC_TMP) \ - _(1344, ZEND_INIT_FCALL_BY_NAME_SPEC_CONST) \ - _(1345, ZEND_DO_FCALL_SPEC_RETVAL_UNUSED) \ - _(1346, ZEND_DO_FCALL_SPEC_RETVAL_USED) \ - _(1347, ZEND_DO_FCALL_SPEC_OBSERVER) \ - _(1348, ZEND_DO_FCALL_SPEC_OBSERVER) \ - _(1349, ZEND_INIT_FCALL_SPEC_CONST) \ - _(1350, ZEND_RETURN_SPEC_CONST) \ - _(1351, ZEND_RETURN_SPEC_OBSERVER) \ - _(1352, ZEND_RETURN_SPEC_TMP) \ - _(1353, ZEND_RETURN_SPEC_OBSERVER) \ - _(1358, ZEND_RETURN_SPEC_CV) \ - _(1359, ZEND_RETURN_SPEC_OBSERVER) \ - _(1360, ZEND_RECV_SPEC_UNUSED) \ - _(1361, ZEND_RECV_INIT_SPEC_CONST) \ - _(1362, ZEND_SEND_VAL_SPEC_CONST_CONST) \ - _(1365, ZEND_SEND_VAL_SPEC_CONST_UNUSED) \ - _(1367, ZEND_SEND_VAL_SPEC_TMPVAR_CONST) \ - _(1370, ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED) \ + _(1266, ZEND_CAST_VALUE_FOR_RETURN_TYPE_SPEC_CONST_UNUSED) \ + _(1267, ZEND_CAST_VALUE_FOR_RETURN_TYPE_SPEC_TMP_UNUSED) \ + _(1268, ZEND_CAST_VALUE_FOR_RETURN_TYPE_SPEC_VAR_UNUSED) \ + _(1270, ZEND_CAST_VALUE_FOR_RETURN_TYPE_SPEC_CV_UNUSED) \ + _(1271, ZEND_JMPZ_EX_SPEC_CONST) \ + _(1272, ZEND_JMPZ_EX_SPEC_TMP) \ + _(1275, ZEND_JMPZ_EX_SPEC_CV) \ + _(1276, ZEND_JMPNZ_EX_SPEC_CONST) \ + _(1277, ZEND_JMPNZ_EX_SPEC_TMP) \ + _(1280, ZEND_JMPNZ_EX_SPEC_CV) \ + _(1281, ZEND_CASE_SPEC_TMP_CONST) \ + _(1282, ZEND_CASE_SPEC_TMP_TMP) \ + _(1285, ZEND_CASE_SPEC_TMP_CV) \ + _(1286, ZEND_CHECK_VAR_SPEC_CV_UNUSED) \ + _(1287, ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST) \ + _(1288, ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST) \ + _(1293, ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED) \ + _(1294, ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK) \ + _(1297, ZEND_CAST_SPEC_CONST) \ + _(1298, ZEND_CAST_SPEC_TMP) \ + _(1301, ZEND_CAST_SPEC_CV) \ + _(1302, ZEND_BOOL_SPEC_CONST) \ + _(1303, ZEND_BOOL_SPEC_TMP) \ + _(1306, ZEND_BOOL_SPEC_CV) \ + _(1307, ZEND_FAST_CONCAT_SPEC_CONST_CONST) \ + _(1308, ZEND_FAST_CONCAT_SPEC_CONST_TMP) \ + _(1311, ZEND_FAST_CONCAT_SPEC_CONST_CV) \ + _(1312, ZEND_FAST_CONCAT_SPEC_TMP_CONST) \ + _(1313, ZEND_FAST_CONCAT_SPEC_TMP_TMP) \ + _(1316, ZEND_FAST_CONCAT_SPEC_TMP_CV) \ + _(1327, ZEND_FAST_CONCAT_SPEC_CV_CONST) \ + _(1328, ZEND_FAST_CONCAT_SPEC_CV_TMP) \ + _(1331, ZEND_FAST_CONCAT_SPEC_CV_CV) \ + _(1332, ZEND_ROPE_INIT_SPEC_UNUSED_CONST) \ + _(1333, ZEND_ROPE_INIT_SPEC_UNUSED_TMP) \ + _(1336, ZEND_ROPE_INIT_SPEC_UNUSED_CV) \ + _(1337, ZEND_ROPE_ADD_SPEC_TMP_CONST) \ + _(1338, ZEND_ROPE_ADD_SPEC_TMP_TMP) \ + _(1341, ZEND_ROPE_ADD_SPEC_TMP_CV) \ + _(1342, ZEND_ROPE_END_SPEC_TMP_CONST) \ + _(1343, ZEND_ROPE_END_SPEC_TMP_TMP) \ + _(1346, ZEND_ROPE_END_SPEC_TMP_CV) \ + _(1347, ZEND_BEGIN_SILENCE_SPEC) \ + _(1348, ZEND_END_SILENCE_SPEC_TMP) \ + _(1349, ZEND_INIT_FCALL_BY_NAME_SPEC_CONST) \ + _(1350, ZEND_DO_FCALL_SPEC_RETVAL_UNUSED) \ + _(1351, ZEND_DO_FCALL_SPEC_RETVAL_USED) \ + _(1352, ZEND_DO_FCALL_SPEC_OBSERVER) \ + _(1353, ZEND_DO_FCALL_SPEC_OBSERVER) \ + _(1354, ZEND_INIT_FCALL_SPEC_CONST) \ + _(1355, ZEND_RETURN_SPEC_CONST) \ + _(1356, ZEND_RETURN_SPEC_OBSERVER) \ + _(1357, ZEND_RETURN_SPEC_TMP) \ + _(1358, ZEND_RETURN_SPEC_OBSERVER) \ + _(1363, ZEND_RETURN_SPEC_CV) \ + _(1364, ZEND_RETURN_SPEC_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) \ - _(1407, ZEND_SEND_VAR_EX_SPEC_VAR_CONST) \ - _(1408, ZEND_SEND_VAR_EX_SPEC_VAR_CONST) \ - _(1413, ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED) \ - _(1414, ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK) \ - _(1427, ZEND_SEND_VAR_EX_SPEC_CV_CONST) \ - _(1428, ZEND_SEND_VAR_EX_SPEC_CV_CONST) \ - _(1433, ZEND_SEND_VAR_EX_SPEC_CV_UNUSED) \ - _(1434, ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK) \ - _(1447, ZEND_SEND_REF_SPEC_VAR_CONST) \ - _(1450, ZEND_SEND_REF_SPEC_VAR_UNUSED) \ - _(1457, ZEND_SEND_REF_SPEC_CV_CONST) \ - _(1460, ZEND_SEND_REF_SPEC_CV_UNUSED) \ - _(1462, ZEND_NEW_SPEC_CONST_UNUSED) \ - _(1464, ZEND_NEW_SPEC_VAR_UNUSED) \ - _(1465, ZEND_NEW_SPEC_UNUSED_UNUSED) \ - _(1467, ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST) \ - _(1468, ZEND_FREE_SPEC_TMPVAR) \ - _(1469, ZEND_INIT_ARRAY_SPEC_CONST_CONST) \ - _(1470, ZEND_INIT_ARRAY_SPEC_CONST_TMP) \ - _(1472, ZEND_INIT_ARRAY_SPEC_CONST_UNUSED) \ - _(1473, ZEND_INIT_ARRAY_SPEC_CONST_CV) \ - _(1474, ZEND_INIT_ARRAY_SPEC_TMP_CONST) \ - _(1475, ZEND_INIT_ARRAY_SPEC_TMP_TMP) \ - _(1477, ZEND_INIT_ARRAY_SPEC_TMP_UNUSED) \ - _(1478, ZEND_INIT_ARRAY_SPEC_TMP_CV) \ - _(1479, ZEND_INIT_ARRAY_SPEC_VAR_CONST) \ - _(1480, ZEND_INIT_ARRAY_SPEC_VAR_TMP) \ - _(1482, ZEND_INIT_ARRAY_SPEC_VAR_UNUSED) \ - _(1483, ZEND_INIT_ARRAY_SPEC_VAR_CV) \ - _(1484, ZEND_INIT_ARRAY_SPEC_UNUSED_CONST) \ - _(1485, ZEND_INIT_ARRAY_SPEC_UNUSED_TMP) \ - _(1487, ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED) \ - _(1488, ZEND_INIT_ARRAY_SPEC_UNUSED_CV) \ - _(1489, ZEND_INIT_ARRAY_SPEC_CV_CONST) \ - _(1490, ZEND_INIT_ARRAY_SPEC_CV_TMP) \ - _(1492, ZEND_INIT_ARRAY_SPEC_CV_UNUSED) \ - _(1493, ZEND_INIT_ARRAY_SPEC_CV_CV) \ - _(1494, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST) \ - _(1495, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP) \ - _(1497, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED) \ - _(1498, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV) \ - _(1499, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST) \ - _(1500, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP) \ - _(1502, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED) \ - _(1503, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV) \ - _(1504, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST) \ - _(1505, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP) \ - _(1507, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED) \ - _(1508, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV) \ - _(1514, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST) \ - _(1515, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP) \ - _(1517, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED) \ - _(1518, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV) \ - _(1519, ZEND_INCLUDE_OR_EVAL_SPEC_CONST) \ - _(1520, ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER) \ - _(1521, ZEND_INCLUDE_OR_EVAL_SPEC_TMP) \ - _(1522, ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER) \ - _(1527, ZEND_INCLUDE_OR_EVAL_SPEC_CV) \ - _(1528, ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER) \ - _(1529, ZEND_UNSET_VAR_SPEC_CONST_UNUSED) \ - _(1530, ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED) \ - _(1531, ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED) \ - _(1533, ZEND_UNSET_VAR_SPEC_CV_UNUSED) \ - _(1544, ZEND_UNSET_DIM_SPEC_VAR_CONST) \ - _(1545, ZEND_UNSET_DIM_SPEC_VAR_TMP) \ - _(1548, ZEND_UNSET_DIM_SPEC_VAR_CV) \ - _(1554, ZEND_UNSET_DIM_SPEC_CV_CONST) \ - _(1555, ZEND_UNSET_DIM_SPEC_CV_TMP) \ - _(1558, ZEND_UNSET_DIM_SPEC_CV_CV) \ - _(1569, ZEND_UNSET_OBJ_SPEC_VAR_CONST) \ - _(1570, ZEND_UNSET_OBJ_SPEC_VAR_TMP) \ - _(1573, ZEND_UNSET_OBJ_SPEC_VAR_CV) \ - _(1574, ZEND_UNSET_OBJ_SPEC_UNUSED_CONST) \ - _(1575, ZEND_UNSET_OBJ_SPEC_UNUSED_TMP) \ - _(1578, ZEND_UNSET_OBJ_SPEC_UNUSED_CV) \ - _(1579, ZEND_UNSET_OBJ_SPEC_CV_CONST) \ - _(1580, ZEND_UNSET_OBJ_SPEC_CV_TMP) \ - _(1583, ZEND_UNSET_OBJ_SPEC_CV_CV) \ - _(1584, ZEND_FE_RESET_R_SPEC_CONST) \ - _(1585, ZEND_FE_RESET_R_SPEC_TMP) \ - _(1588, ZEND_FE_RESET_R_SPEC_CV) \ - _(1589, ZEND_FE_FETCH_R_SPEC_TMP) \ - _(1590, ZEND_FETCH_R_SPEC_CONST_UNUSED) \ - _(1591, ZEND_FETCH_R_SPEC_TMP_UNUSED) \ - _(1594, ZEND_FETCH_R_SPEC_CV_UNUSED) \ - _(1595, ZEND_FETCH_DIM_R_SPEC_CONST_CONST) \ - _(1596, ZEND_FETCH_DIM_R_SPEC_CONST_TMP) \ - _(1599, ZEND_FETCH_DIM_R_SPEC_CONST_CV) \ - _(1600, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \ - _(1601, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMP) \ - _(1604, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \ + _(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_TMP) \ + _(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_TMP) \ + _(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_TMP) \ + _(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_TMP) \ + _(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_TMP) \ + _(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_TMP) \ + _(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_TMP) \ + _(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_TMP) \ + _(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_TMP) \ + _(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_OBSERVER) \ + _(1526, ZEND_INCLUDE_OR_EVAL_SPEC_TMP) \ + _(1527, ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER) \ + _(1532, ZEND_INCLUDE_OR_EVAL_SPEC_CV) \ + _(1533, ZEND_INCLUDE_OR_EVAL_SPEC_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_TMP) \ + _(1553, ZEND_UNSET_DIM_SPEC_VAR_CV) \ + _(1559, ZEND_UNSET_DIM_SPEC_CV_CONST) \ + _(1560, ZEND_UNSET_DIM_SPEC_CV_TMP) \ + _(1563, ZEND_UNSET_DIM_SPEC_CV_CV) \ + _(1574, ZEND_UNSET_OBJ_SPEC_VAR_CONST) \ + _(1575, ZEND_UNSET_OBJ_SPEC_VAR_TMP) \ + _(1578, ZEND_UNSET_OBJ_SPEC_VAR_CV) \ + _(1579, ZEND_UNSET_OBJ_SPEC_UNUSED_CONST) \ + _(1580, ZEND_UNSET_OBJ_SPEC_UNUSED_TMP) \ + _(1583, ZEND_UNSET_OBJ_SPEC_UNUSED_CV) \ + _(1584, ZEND_UNSET_OBJ_SPEC_CV_CONST) \ + _(1585, ZEND_UNSET_OBJ_SPEC_CV_TMP) \ + _(1588, ZEND_UNSET_OBJ_SPEC_CV_CV) \ + _(1589, ZEND_FE_RESET_R_SPEC_CONST) \ + _(1590, ZEND_FE_RESET_R_SPEC_TMP) \ + _(1593, ZEND_FE_RESET_R_SPEC_CV) \ + _(1594, ZEND_FE_FETCH_R_SPEC_TMP) \ + _(1595, ZEND_FETCH_R_SPEC_CONST_UNUSED) \ + _(1596, ZEND_FETCH_R_SPEC_TMP_UNUSED) \ + _(1599, ZEND_FETCH_R_SPEC_CV_UNUSED) \ + _(1600, ZEND_FETCH_DIM_R_SPEC_CONST_CONST) \ + _(1601, ZEND_FETCH_DIM_R_SPEC_CONST_TMP) \ + _(1604, ZEND_FETCH_DIM_R_SPEC_CONST_CV) \ _(1605, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \ _(1606, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMP) \ _(1609, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \ - _(1615, ZEND_FETCH_DIM_R_SPEC_CV_CONST) \ - _(1616, ZEND_FETCH_DIM_R_SPEC_CV_TMP) \ - _(1619, ZEND_FETCH_DIM_R_SPEC_CV_CV) \ - _(1620, ZEND_FETCH_OBJ_R_SPEC_CONST_CONST) \ - _(1621, ZEND_FETCH_OBJ_R_SPEC_CONST_TMP) \ - _(1624, ZEND_FETCH_OBJ_R_SPEC_CONST_CV) \ - _(1625, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \ - _(1626, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMP) \ - _(1629, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \ + _(1610, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \ + _(1611, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMP) \ + _(1614, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \ + _(1620, ZEND_FETCH_DIM_R_SPEC_CV_CONST) \ + _(1621, ZEND_FETCH_DIM_R_SPEC_CV_TMP) \ + _(1624, ZEND_FETCH_DIM_R_SPEC_CV_CV) \ + _(1625, ZEND_FETCH_OBJ_R_SPEC_CONST_CONST) \ + _(1626, ZEND_FETCH_OBJ_R_SPEC_CONST_TMP) \ + _(1629, ZEND_FETCH_OBJ_R_SPEC_CONST_CV) \ _(1630, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \ _(1631, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMP) \ _(1634, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \ - _(1635, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST) \ - _(1636, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMP) \ - _(1639, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV) \ - _(1640, ZEND_FETCH_OBJ_R_SPEC_CV_CONST) \ - _(1641, ZEND_FETCH_OBJ_R_SPEC_CV_TMP) \ - _(1644, ZEND_FETCH_OBJ_R_SPEC_CV_CV) \ - _(1645, ZEND_FETCH_W_SPEC_CONST_UNUSED) \ - _(1646, ZEND_FETCH_W_SPEC_TMP_UNUSED) \ - _(1649, ZEND_FETCH_W_SPEC_CV_UNUSED) \ - _(1660, ZEND_FETCH_DIM_W_SPEC_VAR_CONST) \ - _(1661, ZEND_FETCH_DIM_W_SPEC_VAR_TMP) \ - _(1663, ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED) \ - _(1664, ZEND_FETCH_DIM_W_SPEC_VAR_CV) \ - _(1670, ZEND_FETCH_DIM_W_SPEC_CV_CONST) \ - _(1671, ZEND_FETCH_DIM_W_SPEC_CV_TMP) \ - _(1673, ZEND_FETCH_DIM_W_SPEC_CV_UNUSED) \ - _(1674, ZEND_FETCH_DIM_W_SPEC_CV_CV) \ - _(1685, ZEND_FETCH_OBJ_W_SPEC_VAR_CONST) \ - _(1686, ZEND_FETCH_OBJ_W_SPEC_VAR_TMP) \ - _(1689, ZEND_FETCH_OBJ_W_SPEC_VAR_CV) \ - _(1690, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST) \ - _(1691, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMP) \ - _(1694, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV) \ - _(1695, ZEND_FETCH_OBJ_W_SPEC_CV_CONST) \ - _(1696, ZEND_FETCH_OBJ_W_SPEC_CV_TMP) \ - _(1699, ZEND_FETCH_OBJ_W_SPEC_CV_CV) \ - _(1700, ZEND_FETCH_RW_SPEC_CONST_UNUSED) \ - _(1701, ZEND_FETCH_RW_SPEC_TMP_UNUSED) \ - _(1704, ZEND_FETCH_RW_SPEC_CV_UNUSED) \ - _(1715, ZEND_FETCH_DIM_RW_SPEC_VAR_CONST) \ - _(1716, ZEND_FETCH_DIM_RW_SPEC_VAR_TMP) \ - _(1718, ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED) \ - _(1719, ZEND_FETCH_DIM_RW_SPEC_VAR_CV) \ - _(1725, ZEND_FETCH_DIM_RW_SPEC_CV_CONST) \ - _(1726, ZEND_FETCH_DIM_RW_SPEC_CV_TMP) \ - _(1728, ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED) \ - _(1729, ZEND_FETCH_DIM_RW_SPEC_CV_CV) \ - _(1740, ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST) \ - _(1741, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMP) \ - _(1744, ZEND_FETCH_OBJ_RW_SPEC_VAR_CV) \ - _(1745, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST) \ - _(1746, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMP) \ - _(1749, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV) \ - _(1750, ZEND_FETCH_OBJ_RW_SPEC_CV_CONST) \ - _(1751, ZEND_FETCH_OBJ_RW_SPEC_CV_TMP) \ - _(1754, ZEND_FETCH_OBJ_RW_SPEC_CV_CV) \ - _(1755, ZEND_FETCH_IS_SPEC_CONST_UNUSED) \ - _(1756, ZEND_FETCH_IS_SPEC_TMP_UNUSED) \ - _(1759, ZEND_FETCH_IS_SPEC_CV_UNUSED) \ - _(1760, ZEND_FETCH_DIM_IS_SPEC_CONST_CONST) \ - _(1761, ZEND_FETCH_DIM_IS_SPEC_CONST_TMP) \ - _(1764, ZEND_FETCH_DIM_IS_SPEC_CONST_CV) \ - _(1765, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \ - _(1766, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMP) \ - _(1769, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \ + _(1635, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \ + _(1636, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMP) \ + _(1639, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \ + _(1640, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST) \ + _(1641, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMP) \ + _(1644, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV) \ + _(1645, ZEND_FETCH_OBJ_R_SPEC_CV_CONST) \ + _(1646, ZEND_FETCH_OBJ_R_SPEC_CV_TMP) \ + _(1649, ZEND_FETCH_OBJ_R_SPEC_CV_CV) \ + _(1650, ZEND_FETCH_W_SPEC_CONST_UNUSED) \ + _(1651, ZEND_FETCH_W_SPEC_TMP_UNUSED) \ + _(1654, ZEND_FETCH_W_SPEC_CV_UNUSED) \ + _(1665, ZEND_FETCH_DIM_W_SPEC_VAR_CONST) \ + _(1666, ZEND_FETCH_DIM_W_SPEC_VAR_TMP) \ + _(1668, ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED) \ + _(1669, ZEND_FETCH_DIM_W_SPEC_VAR_CV) \ + _(1675, ZEND_FETCH_DIM_W_SPEC_CV_CONST) \ + _(1676, ZEND_FETCH_DIM_W_SPEC_CV_TMP) \ + _(1678, ZEND_FETCH_DIM_W_SPEC_CV_UNUSED) \ + _(1679, ZEND_FETCH_DIM_W_SPEC_CV_CV) \ + _(1690, ZEND_FETCH_OBJ_W_SPEC_VAR_CONST) \ + _(1691, ZEND_FETCH_OBJ_W_SPEC_VAR_TMP) \ + _(1694, ZEND_FETCH_OBJ_W_SPEC_VAR_CV) \ + _(1695, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST) \ + _(1696, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMP) \ + _(1699, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV) \ + _(1700, ZEND_FETCH_OBJ_W_SPEC_CV_CONST) \ + _(1701, ZEND_FETCH_OBJ_W_SPEC_CV_TMP) \ + _(1704, ZEND_FETCH_OBJ_W_SPEC_CV_CV) \ + _(1705, ZEND_FETCH_RW_SPEC_CONST_UNUSED) \ + _(1706, ZEND_FETCH_RW_SPEC_TMP_UNUSED) \ + _(1709, ZEND_FETCH_RW_SPEC_CV_UNUSED) \ + _(1720, ZEND_FETCH_DIM_RW_SPEC_VAR_CONST) \ + _(1721, ZEND_FETCH_DIM_RW_SPEC_VAR_TMP) \ + _(1723, ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED) \ + _(1724, ZEND_FETCH_DIM_RW_SPEC_VAR_CV) \ + _(1730, ZEND_FETCH_DIM_RW_SPEC_CV_CONST) \ + _(1731, ZEND_FETCH_DIM_RW_SPEC_CV_TMP) \ + _(1733, ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED) \ + _(1734, ZEND_FETCH_DIM_RW_SPEC_CV_CV) \ + _(1745, ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST) \ + _(1746, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMP) \ + _(1749, ZEND_FETCH_OBJ_RW_SPEC_VAR_CV) \ + _(1750, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST) \ + _(1751, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMP) \ + _(1754, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV) \ + _(1755, ZEND_FETCH_OBJ_RW_SPEC_CV_CONST) \ + _(1756, ZEND_FETCH_OBJ_RW_SPEC_CV_TMP) \ + _(1759, ZEND_FETCH_OBJ_RW_SPEC_CV_CV) \ + _(1760, ZEND_FETCH_IS_SPEC_CONST_UNUSED) \ + _(1761, ZEND_FETCH_IS_SPEC_TMP_UNUSED) \ + _(1764, ZEND_FETCH_IS_SPEC_CV_UNUSED) \ + _(1765, ZEND_FETCH_DIM_IS_SPEC_CONST_CONST) \ + _(1766, ZEND_FETCH_DIM_IS_SPEC_CONST_TMP) \ + _(1769, ZEND_FETCH_DIM_IS_SPEC_CONST_CV) \ _(1770, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \ _(1771, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMP) \ _(1774, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \ - _(1780, ZEND_FETCH_DIM_IS_SPEC_CV_CONST) \ - _(1781, ZEND_FETCH_DIM_IS_SPEC_CV_TMP) \ - _(1784, ZEND_FETCH_DIM_IS_SPEC_CV_CV) \ - _(1785, ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST) \ - _(1786, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMP) \ - _(1789, ZEND_FETCH_OBJ_IS_SPEC_CONST_CV) \ - _(1790, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \ - _(1791, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMP) \ - _(1794, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \ + _(1775, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \ + _(1776, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMP) \ + _(1779, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \ + _(1785, ZEND_FETCH_DIM_IS_SPEC_CV_CONST) \ + _(1786, ZEND_FETCH_DIM_IS_SPEC_CV_TMP) \ + _(1789, ZEND_FETCH_DIM_IS_SPEC_CV_CV) \ + _(1790, ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST) \ + _(1791, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMP) \ + _(1794, ZEND_FETCH_OBJ_IS_SPEC_CONST_CV) \ _(1795, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \ _(1796, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMP) \ _(1799, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \ - _(1800, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST) \ - _(1801, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMP) \ - _(1804, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV) \ - _(1805, ZEND_FETCH_OBJ_IS_SPEC_CV_CONST) \ - _(1806, ZEND_FETCH_OBJ_IS_SPEC_CV_TMP) \ - _(1809, ZEND_FETCH_OBJ_IS_SPEC_CV_CV) \ - _(1810, ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED) \ - _(1811, ZEND_FETCH_FUNC_ARG_SPEC_TMP_UNUSED) \ - _(1814, ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED) \ - _(1815, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST) \ - _(1816, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMP) \ - _(1818, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED) \ - _(1819, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV) \ - _(1820, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST) \ - _(1821, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMP) \ - _(1823, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED) \ - _(1824, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV) \ - _(1825, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST) \ - _(1826, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMP) \ - _(1828, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED) \ - _(1829, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV) \ - _(1835, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST) \ - _(1836, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMP) \ - _(1838, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED) \ - _(1839, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV) \ - _(1840, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST) \ - _(1841, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMP) \ - _(1844, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV) \ - _(1845, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST) \ - _(1846, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMP) \ - _(1849, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV) \ - _(1850, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST) \ - _(1851, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMP) \ - _(1854, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV) \ - _(1855, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST) \ - _(1856, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMP) \ - _(1859, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV) \ - _(1860, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST) \ - _(1861, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMP) \ - _(1864, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV) \ - _(1865, ZEND_FETCH_UNSET_SPEC_CONST_UNUSED) \ - _(1866, ZEND_FETCH_UNSET_SPEC_TMP_UNUSED) \ - _(1869, ZEND_FETCH_UNSET_SPEC_CV_UNUSED) \ - _(1880, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST) \ - _(1881, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMP) \ - _(1884, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV) \ - _(1890, ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST) \ - _(1891, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMP) \ - _(1894, ZEND_FETCH_DIM_UNSET_SPEC_CV_CV) \ - _(1905, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST) \ - _(1906, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMP) \ - _(1909, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV) \ - _(1910, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST) \ - _(1911, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMP) \ - _(1914, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV) \ - _(1915, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST) \ - _(1916, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMP) \ - _(1919, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV) \ - _(1920, ZEND_FETCH_LIST_R_SPEC_CONST_CONST) \ - _(1921, ZEND_FETCH_LIST_R_SPEC_CONST_TMP) \ - _(1924, ZEND_FETCH_LIST_R_SPEC_CONST_CV) \ - _(1925, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ - _(1926, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMP) \ - _(1929, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ + _(1800, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \ + _(1801, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMP) \ + _(1804, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \ + _(1805, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST) \ + _(1806, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMP) \ + _(1809, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV) \ + _(1810, ZEND_FETCH_OBJ_IS_SPEC_CV_CONST) \ + _(1811, ZEND_FETCH_OBJ_IS_SPEC_CV_TMP) \ + _(1814, ZEND_FETCH_OBJ_IS_SPEC_CV_CV) \ + _(1815, ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED) \ + _(1816, ZEND_FETCH_FUNC_ARG_SPEC_TMP_UNUSED) \ + _(1819, ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED) \ + _(1820, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST) \ + _(1821, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMP) \ + _(1823, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED) \ + _(1824, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV) \ + _(1825, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST) \ + _(1826, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMP) \ + _(1828, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED) \ + _(1829, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV) \ + _(1830, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST) \ + _(1831, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMP) \ + _(1833, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED) \ + _(1834, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV) \ + _(1840, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST) \ + _(1841, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMP) \ + _(1843, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED) \ + _(1844, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV) \ + _(1845, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST) \ + _(1846, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMP) \ + _(1849, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV) \ + _(1850, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST) \ + _(1851, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMP) \ + _(1854, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV) \ + _(1855, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST) \ + _(1856, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMP) \ + _(1859, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV) \ + _(1860, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST) \ + _(1861, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMP) \ + _(1864, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV) \ + _(1865, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST) \ + _(1866, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMP) \ + _(1869, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV) \ + _(1870, ZEND_FETCH_UNSET_SPEC_CONST_UNUSED) \ + _(1871, ZEND_FETCH_UNSET_SPEC_TMP_UNUSED) \ + _(1874, ZEND_FETCH_UNSET_SPEC_CV_UNUSED) \ + _(1885, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST) \ + _(1886, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMP) \ + _(1889, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV) \ + _(1895, ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST) \ + _(1896, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMP) \ + _(1899, ZEND_FETCH_DIM_UNSET_SPEC_CV_CV) \ + _(1910, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST) \ + _(1911, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMP) \ + _(1914, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV) \ + _(1915, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST) \ + _(1916, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMP) \ + _(1919, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV) \ + _(1920, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST) \ + _(1921, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMP) \ + _(1924, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV) \ + _(1925, ZEND_FETCH_LIST_R_SPEC_CONST_CONST) \ + _(1926, ZEND_FETCH_LIST_R_SPEC_CONST_TMP) \ + _(1929, ZEND_FETCH_LIST_R_SPEC_CONST_CV) \ _(1930, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ _(1931, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMP) \ _(1934, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ - _(1940, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ - _(1941, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMP) \ - _(1944, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ - _(1945, ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST) \ - _(1946, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST) \ - _(1947, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST) \ - _(1952, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED) \ - _(1953, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK) \ - _(1956, ZEND_EXT_STMT_SPEC) \ - _(1957, ZEND_EXT_FCALL_BEGIN_SPEC) \ - _(1958, ZEND_EXT_FCALL_END_SPEC) \ - _(1959, ZEND_EXT_NOP_SPEC) \ - _(1960, ZEND_TICKS_SPEC) \ - _(1961, ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST) \ - _(1964, ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED) \ - _(1966, ZEND_CATCH_SPEC_CONST) \ - _(1967, ZEND_THROW_SPEC_CONST) \ - _(1968, ZEND_THROW_SPEC_TMP) \ - _(1971, ZEND_THROW_SPEC_CV) \ - _(1972, ZEND_FETCH_CLASS_SPEC_UNUSED_CONST) \ - _(1973, ZEND_FETCH_CLASS_SPEC_UNUSED_TMP) \ - _(1975, ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED) \ - _(1976, ZEND_FETCH_CLASS_SPEC_UNUSED_CV) \ - _(1977, ZEND_CLONE_SPEC_CONST) \ - _(1978, ZEND_CLONE_SPEC_TMP) \ - _(1980, ZEND_CLONE_SPEC_UNUSED) \ - _(1981, ZEND_CLONE_SPEC_CV) \ - _(1982, ZEND_RETURN_BY_REF_SPEC_CONST) \ - _(1983, ZEND_RETURN_BY_REF_SPEC_OBSERVER) \ - _(1984, ZEND_RETURN_BY_REF_SPEC_TMP) \ - _(1985, ZEND_RETURN_BY_REF_SPEC_OBSERVER) \ - _(1986, ZEND_RETURN_BY_REF_SPEC_VAR) \ - _(1987, ZEND_RETURN_BY_REF_SPEC_OBSERVER) \ - _(1990, ZEND_RETURN_BY_REF_SPEC_CV) \ - _(1991, ZEND_RETURN_BY_REF_SPEC_OBSERVER) \ - _(1992, ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST) \ - _(1993, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMP) \ - _(1996, ZEND_INIT_METHOD_CALL_SPEC_CONST_CV) \ - _(1997, ZEND_INIT_METHOD_CALL_SPEC_TMP_CONST) \ - _(1998, ZEND_INIT_METHOD_CALL_SPEC_TMP_TMP) \ - _(2001, ZEND_INIT_METHOD_CALL_SPEC_TMP_CV) \ - _(2007, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST) \ - _(2008, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMP) \ - _(2011, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV) \ - _(2012, ZEND_INIT_METHOD_CALL_SPEC_CV_CONST) \ - _(2013, ZEND_INIT_METHOD_CALL_SPEC_CV_TMP) \ - _(2016, ZEND_INIT_METHOD_CALL_SPEC_CV_CV) \ - _(2017, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST) \ - _(2018, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMP) \ - _(2020, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED) \ - _(2021, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV) \ - _(2027, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST) \ - _(2028, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMP) \ - _(2030, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED) \ - _(2031, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV) \ - _(2032, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST) \ - _(2033, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMP) \ - _(2035, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED) \ - _(2036, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV) \ - _(2042, ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED) \ - _(2043, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_UNUSED) \ - _(2046, ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED) \ - _(2047, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST) \ - _(2048, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMP) \ - _(2051, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV) \ - _(2052, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_CONST) \ - _(2053, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_TMP) \ - _(2056, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_CV) \ - _(2067, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST) \ - _(2068, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMP) \ - _(2071, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV) \ - _(2072, ZEND_SEND_VAL_EX_SPEC_CONST_CONST) \ - _(2073, ZEND_SEND_VAL_EX_SPEC_CONST_CONST) \ - _(2078, ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED) \ - _(2079, ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK) \ - _(2082, ZEND_SEND_VAL_EX_SPEC_TMP_CONST) \ - _(2083, ZEND_SEND_VAL_EX_SPEC_TMP_CONST) \ - _(2088, ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED) \ - _(2089, ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK) \ - _(2132, ZEND_SEND_VAR_SPEC_VAR_CONST) \ - _(2135, ZEND_SEND_VAR_SPEC_VAR_UNUSED) \ - _(2142, ZEND_SEND_VAR_SPEC_CV_CONST) \ - _(2145, ZEND_SEND_VAR_SPEC_CV_UNUSED) \ - _(2147, ZEND_INIT_USER_CALL_SPEC_CONST_CONST) \ - _(2148, ZEND_INIT_USER_CALL_SPEC_CONST_TMP) \ - _(2151, ZEND_INIT_USER_CALL_SPEC_CONST_CV) \ - _(2152, ZEND_SEND_ARRAY_SPEC) \ - _(2153, ZEND_SEND_USER_SPEC_CONST) \ - _(2154, ZEND_SEND_USER_SPEC_TMP) \ - _(2157, ZEND_SEND_USER_SPEC_CV) \ - _(2158, ZEND_STRLEN_SPEC_CONST) \ - _(2159, ZEND_STRLEN_SPEC_TMP) \ - _(2162, ZEND_STRLEN_SPEC_CV) \ - _(2163, ZEND_DEFINED_SPEC_CONST) \ - _(2164, ZEND_TYPE_CHECK_SPEC_CONST) \ - _(2165, ZEND_TYPE_CHECK_SPEC_TMP) \ - _(2168, ZEND_TYPE_CHECK_SPEC_CV) \ - _(2169, ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED) \ - _(2170, ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED) \ - _(2171, ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED) \ - _(2172, ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED) \ - _(2173, ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED) \ - _(2174, ZEND_FE_RESET_RW_SPEC_CONST) \ - _(2175, ZEND_FE_RESET_RW_SPEC_TMP) \ - _(2176, ZEND_FE_RESET_RW_SPEC_VAR) \ - _(2178, ZEND_FE_RESET_RW_SPEC_CV) \ - _(2179, ZEND_FE_FETCH_RW_SPEC_VAR) \ - _(2180, ZEND_FE_FREE_SPEC_TMPVAR) \ - _(2181, ZEND_INIT_DYNAMIC_CALL_SPEC_CONST) \ - _(2182, ZEND_INIT_DYNAMIC_CALL_SPEC_TMP) \ - _(2185, ZEND_INIT_DYNAMIC_CALL_SPEC_CV) \ - _(2186, ZEND_DO_ICALL_SPEC_RETVAL_UNUSED) \ - _(2187, ZEND_DO_ICALL_SPEC_RETVAL_USED) \ - _(2188, ZEND_DO_ICALL_SPEC_OBSERVER) \ - _(2189, ZEND_DO_ICALL_SPEC_OBSERVER) \ - _(2190, ZEND_DO_UCALL_SPEC_RETVAL_UNUSED) \ - _(2191, ZEND_DO_UCALL_SPEC_RETVAL_USED) \ - _(2192, ZEND_DO_UCALL_SPEC_OBSERVER) \ - _(2193, ZEND_DO_UCALL_SPEC_OBSERVER) \ - _(2194, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED) \ - _(2195, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED) \ - _(2196, ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER) \ - _(2197, ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER) \ - _(2208, ZEND_PRE_INC_OBJ_SPEC_VAR_CONST) \ - _(2209, ZEND_PRE_INC_OBJ_SPEC_VAR_TMP) \ - _(2212, ZEND_PRE_INC_OBJ_SPEC_VAR_CV) \ - _(2213, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST) \ - _(2214, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMP) \ - _(2217, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV) \ - _(2218, ZEND_PRE_INC_OBJ_SPEC_CV_CONST) \ - _(2219, ZEND_PRE_INC_OBJ_SPEC_CV_TMP) \ - _(2222, ZEND_PRE_INC_OBJ_SPEC_CV_CV) \ - _(2233, ZEND_POST_INC_OBJ_SPEC_VAR_CONST) \ - _(2234, ZEND_POST_INC_OBJ_SPEC_VAR_TMP) \ - _(2237, ZEND_POST_INC_OBJ_SPEC_VAR_CV) \ - _(2238, ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST) \ - _(2239, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMP) \ - _(2242, ZEND_POST_INC_OBJ_SPEC_UNUSED_CV) \ - _(2243, ZEND_POST_INC_OBJ_SPEC_CV_CONST) \ - _(2244, ZEND_POST_INC_OBJ_SPEC_CV_TMP) \ - _(2247, ZEND_POST_INC_OBJ_SPEC_CV_CV) \ - _(2248, ZEND_ECHO_SPEC_CONST) \ - _(2249, ZEND_ECHO_SPEC_TMP) \ - _(2252, ZEND_ECHO_SPEC_CV) \ - _(2259, ZEND_INSTANCEOF_SPEC_TMP_CONST) \ - _(2261, ZEND_INSTANCEOF_SPEC_TMP_VAR) \ - _(2262, ZEND_INSTANCEOF_SPEC_TMP_UNUSED) \ - _(2274, ZEND_INSTANCEOF_SPEC_CV_CONST) \ - _(2276, ZEND_INSTANCEOF_SPEC_CV_VAR) \ - _(2277, ZEND_INSTANCEOF_SPEC_CV_UNUSED) \ - _(2279, ZEND_GENERATOR_CREATE_SPEC) \ - _(2282, ZEND_MAKE_REF_SPEC_VAR_UNUSED) \ - _(2284, ZEND_MAKE_REF_SPEC_CV_UNUSED) \ - _(2285, ZEND_DECLARE_FUNCTION_SPEC) \ - _(2286, ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST) \ - _(2287, ZEND_DECLARE_CONST_SPEC_CONST_CONST) \ - _(2288, ZEND_DECLARE_CLASS_SPEC_CONST) \ - _(2289, ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST) \ - _(2290, ZEND_DECLARE_ANON_CLASS_SPEC) \ - _(2291, ZEND_ADD_ARRAY_UNPACK_SPEC) \ - _(2292, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST) \ - _(2293, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMP) \ - _(2296, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV) \ - _(2297, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_CONST) \ - _(2298, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_TMP) \ - _(2301, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_CV) \ - _(2307, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST) \ - _(2308, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMP) \ - _(2311, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV) \ - _(2312, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST) \ - _(2313, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMP) \ - _(2316, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV) \ - _(2317, ZEND_HANDLE_EXCEPTION_SPEC) \ - _(2318, ZEND_USER_OPCODE_SPEC) \ - _(2319, ZEND_ASSERT_CHECK_SPEC) \ - _(2320, ZEND_JMP_SET_SPEC_CONST) \ - _(2321, ZEND_JMP_SET_SPEC_TMP) \ - _(2324, ZEND_JMP_SET_SPEC_CV) \ - _(2325, ZEND_UNSET_CV_SPEC_CV_UNUSED) \ - _(2326, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET) \ - _(2327, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY) \ - _(2328, ZEND_FETCH_LIST_W_SPEC_VAR_CONST) \ - _(2329, ZEND_FETCH_LIST_W_SPEC_VAR_TMP) \ - _(2332, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \ - _(2333, ZEND_SEPARATE_SPEC_VAR_UNUSED) \ - _(2335, ZEND_FETCH_CLASS_NAME_SPEC_TMP) \ - _(2337, ZEND_FETCH_CLASS_NAME_SPEC_UNUSED) \ - _(2338, ZEND_FETCH_CLASS_NAME_SPEC_CV) \ - _(2339, ZEND_CALL_TRAMPOLINE_SPEC) \ - _(2340, ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER) \ - _(2341, ZEND_DISCARD_EXCEPTION_SPEC) \ - _(2342, ZEND_YIELD_SPEC_CONST_CONST) \ - _(2343, ZEND_YIELD_SPEC_CONST_TMP) \ - _(2345, ZEND_YIELD_SPEC_CONST_UNUSED) \ - _(2346, ZEND_YIELD_SPEC_CONST_CV) \ - _(2347, ZEND_YIELD_SPEC_TMP_CONST) \ - _(2348, ZEND_YIELD_SPEC_TMP_TMP) \ - _(2350, ZEND_YIELD_SPEC_TMP_UNUSED) \ - _(2351, ZEND_YIELD_SPEC_TMP_CV) \ - _(2352, ZEND_YIELD_SPEC_VAR_CONST) \ - _(2353, ZEND_YIELD_SPEC_VAR_TMP) \ - _(2355, ZEND_YIELD_SPEC_VAR_UNUSED) \ - _(2356, ZEND_YIELD_SPEC_VAR_CV) \ - _(2357, ZEND_YIELD_SPEC_UNUSED_CONST) \ - _(2358, ZEND_YIELD_SPEC_UNUSED_TMP) \ - _(2360, ZEND_YIELD_SPEC_UNUSED_UNUSED) \ - _(2361, ZEND_YIELD_SPEC_UNUSED_CV) \ - _(2362, ZEND_YIELD_SPEC_CV_CONST) \ - _(2363, ZEND_YIELD_SPEC_CV_TMP) \ - _(2365, ZEND_YIELD_SPEC_CV_UNUSED) \ - _(2366, ZEND_YIELD_SPEC_CV_CV) \ - _(2367, ZEND_GENERATOR_RETURN_SPEC_CONST) \ - _(2368, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \ - _(2369, ZEND_GENERATOR_RETURN_SPEC_TMP) \ - _(2370, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \ - _(2371, ZEND_GENERATOR_RETURN_SPEC_VAR) \ - _(2372, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \ - _(2375, ZEND_GENERATOR_RETURN_SPEC_CV) \ - _(2376, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \ - _(2377, ZEND_FAST_CALL_SPEC) \ - _(2378, ZEND_FAST_RET_SPEC) \ - _(2379, ZEND_RECV_VARIADIC_SPEC_UNUSED) \ - _(2380, ZEND_SEND_UNPACK_SPEC) \ - _(2381, ZEND_YIELD_FROM_SPEC_CONST) \ - _(2382, ZEND_YIELD_FROM_SPEC_TMP) \ - _(2385, ZEND_YIELD_FROM_SPEC_CV) \ - _(2386, ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED) \ - _(2387, ZEND_BIND_GLOBAL_SPEC_CV_CONST) \ - _(2388, ZEND_COALESCE_SPEC_CONST) \ - _(2389, ZEND_COALESCE_SPEC_TMP) \ - _(2392, ZEND_COALESCE_SPEC_CV) \ - _(2393, ZEND_SPACESHIP_SPEC_CONST_CONST) \ - _(2394, ZEND_SPACESHIP_SPEC_CONST_TMP) \ - _(2397, ZEND_SPACESHIP_SPEC_CONST_CV) \ - _(2398, ZEND_SPACESHIP_SPEC_TMP_CONST) \ - _(2399, ZEND_SPACESHIP_SPEC_TMP_TMP) \ - _(2402, ZEND_SPACESHIP_SPEC_TMP_CV) \ - _(2413, ZEND_SPACESHIP_SPEC_CV_CONST) \ - _(2414, ZEND_SPACESHIP_SPEC_CV_TMP) \ - _(2417, ZEND_SPACESHIP_SPEC_CV_CV) \ - _(2418, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED) \ - _(2419, ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED) \ - _(2422, ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED) \ - _(2424, ZEND_FETCH_STATIC_PROP_R_SPEC) \ - _(2425, ZEND_FETCH_STATIC_PROP_W_SPEC) \ - _(2426, ZEND_FETCH_STATIC_PROP_RW_SPEC) \ - _(2427, ZEND_FETCH_STATIC_PROP_IS_SPEC) \ - _(2428, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC) \ - _(2429, ZEND_FETCH_STATIC_PROP_UNSET_SPEC) \ - _(2430, ZEND_UNSET_STATIC_PROP_SPEC) \ - _(2431, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC) \ - _(2432, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) \ - _(2433, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV) \ - _(2434, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV) \ - _(2436, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV) \ - _(2442, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) \ - _(2443, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV) \ - _(2444, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV) \ - _(2446, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV) \ - _(2447, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST) \ - _(2448, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV) \ - _(2449, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV) \ - _(2451, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV) \ - _(2457, ZEND_BIND_LEXICAL_SPEC_TMP_CV) \ - _(2458, ZEND_BIND_STATIC_SPEC_CV) \ - _(2459, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED) \ - _(2460, ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST) \ - _(2463, ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED) \ - _(2465, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED) \ - _(2466, ZEND_SWITCH_LONG_SPEC_CONST_CONST) \ - _(2467, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(2468, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(2470, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(2471, ZEND_SWITCH_STRING_SPEC_CONST_CONST) \ - _(2472, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(2473, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(2475, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(2476, ZEND_IN_ARRAY_SPEC_CONST_CONST) \ - _(2477, ZEND_IN_ARRAY_SPEC_TMP_CONST) \ - _(2480, ZEND_IN_ARRAY_SPEC_CV_CONST) \ - _(2481, ZEND_COUNT_SPEC_CONST_UNUSED) \ - _(2482, ZEND_COUNT_SPEC_TMP_UNUSED) \ - _(2485, ZEND_COUNT_SPEC_CV_UNUSED) \ - _(2486, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \ - _(2487, ZEND_GET_CLASS_SPEC_TMP_UNUSED) \ - _(2489, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED) \ - _(2490, ZEND_GET_CLASS_SPEC_CV_UNUSED) \ - _(2491, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED) \ - _(2492, ZEND_GET_TYPE_SPEC_CONST_UNUSED) \ - _(2493, ZEND_GET_TYPE_SPEC_TMP_UNUSED) \ - _(2496, ZEND_GET_TYPE_SPEC_CV_UNUSED) \ - _(2497, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \ - _(2498, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMP) \ - _(2501, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \ - _(2502, ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_CONST) \ - _(2503, ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_TMP) \ - _(2506, ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_CV) \ - _(2517, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \ - _(2518, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMP) \ - _(2521, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \ - _(2522, ZEND_MATCH_SPEC_CONST_CONST) \ - _(2523, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ - _(2524, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ - _(2526, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ - _(2527, ZEND_CASE_STRICT_SPEC_TMP_CONST) \ - _(2528, ZEND_CASE_STRICT_SPEC_TMP_TMP) \ - _(2531, ZEND_CASE_STRICT_SPEC_TMP_CV) \ - _(2532, ZEND_MATCH_ERROR_SPEC_CONST_UNUSED) \ - _(2533, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ - _(2534, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ - _(2536, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ - _(2537, ZEND_JMP_NULL_SPEC_CONST) \ - _(2538, ZEND_JMP_NULL_SPEC_TMP) \ - _(2541, ZEND_JMP_NULL_SPEC_CV) \ - _(2542, ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED) \ - _(2543, ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED) \ - _(2544, ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED) \ - _(2545, ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED) \ - _(2546, ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV) \ - _(2547, ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED) \ - _(2548, ZEND_FRAMELESS_ICALL_0_SPEC_OBSERVER) \ - _(2549, ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED) \ - _(2550, ZEND_FRAMELESS_ICALL_1_SPEC_OBSERVER) \ - _(2551, ZEND_FRAMELESS_ICALL_2_SPEC) \ - _(2552, ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVER) \ - _(2553, ZEND_FRAMELESS_ICALL_3_SPEC) \ - _(2554, ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER) \ - _(2555, ZEND_JMP_FRAMELESS_SPEC_CONST) \ - _(2556, ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED) \ - _(2557, ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST) \ - _(2558, ZEND_TYPE_ASSERT_SPEC_CONST) \ - _(2559, ZEND_INIT_FCALL_OFFSET_SPEC_CONST) \ - _(2560, ZEND_RECV_NOTYPE_SPEC) \ - _(2562, ZEND_COUNT_ARRAY_SPEC_TMP_UNUSED) \ - _(2565, ZEND_COUNT_ARRAY_SPEC_CV_UNUSED) \ - _(2566, ZEND_JMP_FORWARD_SPEC) \ - _(2572, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2573, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2574, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2576, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(1935, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ + _(1936, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMP) \ + _(1939, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ + _(1945, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ + _(1946, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMP) \ + _(1949, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ + _(1950, ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST) \ + _(1951, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST) \ + _(1952, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST) \ + _(1957, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED) \ + _(1958, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK) \ + _(1961, ZEND_EXT_STMT_SPEC) \ + _(1962, ZEND_EXT_FCALL_BEGIN_SPEC) \ + _(1963, ZEND_EXT_FCALL_END_SPEC) \ + _(1964, ZEND_EXT_NOP_SPEC) \ + _(1965, ZEND_TICKS_SPEC) \ + _(1966, ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST) \ + _(1969, ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED) \ + _(1971, ZEND_CATCH_SPEC_CONST) \ + _(1972, ZEND_THROW_SPEC_CONST) \ + _(1973, ZEND_THROW_SPEC_TMP) \ + _(1976, ZEND_THROW_SPEC_CV) \ + _(1977, ZEND_FETCH_CLASS_SPEC_UNUSED_CONST) \ + _(1978, ZEND_FETCH_CLASS_SPEC_UNUSED_TMP) \ + _(1980, ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED) \ + _(1981, ZEND_FETCH_CLASS_SPEC_UNUSED_CV) \ + _(1982, ZEND_CLONE_SPEC_CONST) \ + _(1983, ZEND_CLONE_SPEC_TMP) \ + _(1985, ZEND_CLONE_SPEC_UNUSED) \ + _(1986, ZEND_CLONE_SPEC_CV) \ + _(1987, ZEND_RETURN_BY_REF_SPEC_CONST) \ + _(1988, ZEND_RETURN_BY_REF_SPEC_OBSERVER) \ + _(1989, ZEND_RETURN_BY_REF_SPEC_TMP) \ + _(1990, ZEND_RETURN_BY_REF_SPEC_OBSERVER) \ + _(1991, ZEND_RETURN_BY_REF_SPEC_VAR) \ + _(1992, ZEND_RETURN_BY_REF_SPEC_OBSERVER) \ + _(1995, ZEND_RETURN_BY_REF_SPEC_CV) \ + _(1996, ZEND_RETURN_BY_REF_SPEC_OBSERVER) \ + _(1997, ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST) \ + _(1998, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMP) \ + _(2001, ZEND_INIT_METHOD_CALL_SPEC_CONST_CV) \ + _(2002, ZEND_INIT_METHOD_CALL_SPEC_TMP_CONST) \ + _(2003, ZEND_INIT_METHOD_CALL_SPEC_TMP_TMP) \ + _(2006, ZEND_INIT_METHOD_CALL_SPEC_TMP_CV) \ + _(2012, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST) \ + _(2013, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMP) \ + _(2016, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV) \ + _(2017, ZEND_INIT_METHOD_CALL_SPEC_CV_CONST) \ + _(2018, ZEND_INIT_METHOD_CALL_SPEC_CV_TMP) \ + _(2021, ZEND_INIT_METHOD_CALL_SPEC_CV_CV) \ + _(2022, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST) \ + _(2023, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMP) \ + _(2025, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED) \ + _(2026, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV) \ + _(2032, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST) \ + _(2033, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMP) \ + _(2035, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED) \ + _(2036, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV) \ + _(2037, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST) \ + _(2038, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMP) \ + _(2040, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED) \ + _(2041, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV) \ + _(2047, ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED) \ + _(2048, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_UNUSED) \ + _(2051, ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED) \ + _(2052, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST) \ + _(2053, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMP) \ + _(2056, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV) \ + _(2057, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_CONST) \ + _(2058, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_TMP) \ + _(2061, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_CV) \ + _(2072, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST) \ + _(2073, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMP) \ + _(2076, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV) \ + _(2077, ZEND_SEND_VAL_EX_SPEC_CONST_CONST) \ + _(2078, ZEND_SEND_VAL_EX_SPEC_CONST_CONST) \ + _(2083, ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED) \ + _(2084, ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK) \ + _(2087, ZEND_SEND_VAL_EX_SPEC_TMP_CONST) \ + _(2088, ZEND_SEND_VAL_EX_SPEC_TMP_CONST) \ + _(2093, ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED) \ + _(2094, ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK) \ + _(2137, ZEND_SEND_VAR_SPEC_VAR_CONST) \ + _(2140, ZEND_SEND_VAR_SPEC_VAR_UNUSED) \ + _(2147, ZEND_SEND_VAR_SPEC_CV_CONST) \ + _(2150, ZEND_SEND_VAR_SPEC_CV_UNUSED) \ + _(2152, ZEND_INIT_USER_CALL_SPEC_CONST_CONST) \ + _(2153, ZEND_INIT_USER_CALL_SPEC_CONST_TMP) \ + _(2156, ZEND_INIT_USER_CALL_SPEC_CONST_CV) \ + _(2157, ZEND_SEND_ARRAY_SPEC) \ + _(2158, ZEND_SEND_USER_SPEC_CONST) \ + _(2159, ZEND_SEND_USER_SPEC_TMP) \ + _(2162, ZEND_SEND_USER_SPEC_CV) \ + _(2163, ZEND_STRLEN_SPEC_CONST) \ + _(2164, ZEND_STRLEN_SPEC_TMP) \ + _(2167, ZEND_STRLEN_SPEC_CV) \ + _(2168, ZEND_DEFINED_SPEC_CONST) \ + _(2169, ZEND_TYPE_CHECK_SPEC_CONST) \ + _(2170, ZEND_TYPE_CHECK_SPEC_TMP) \ + _(2173, ZEND_TYPE_CHECK_SPEC_CV) \ + _(2174, ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED) \ + _(2175, ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED) \ + _(2176, ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED) \ + _(2177, ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED) \ + _(2178, ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED) \ + _(2179, ZEND_FE_RESET_RW_SPEC_CONST) \ + _(2180, ZEND_FE_RESET_RW_SPEC_TMP) \ + _(2181, ZEND_FE_RESET_RW_SPEC_VAR) \ + _(2183, ZEND_FE_RESET_RW_SPEC_CV) \ + _(2184, ZEND_FE_FETCH_RW_SPEC_VAR) \ + _(2185, ZEND_FE_FREE_SPEC_TMPVAR) \ + _(2186, ZEND_INIT_DYNAMIC_CALL_SPEC_CONST) \ + _(2187, ZEND_INIT_DYNAMIC_CALL_SPEC_TMP) \ + _(2190, ZEND_INIT_DYNAMIC_CALL_SPEC_CV) \ + _(2191, ZEND_DO_ICALL_SPEC_RETVAL_UNUSED) \ + _(2192, ZEND_DO_ICALL_SPEC_RETVAL_USED) \ + _(2193, ZEND_DO_ICALL_SPEC_OBSERVER) \ + _(2194, ZEND_DO_ICALL_SPEC_OBSERVER) \ + _(2195, ZEND_DO_UCALL_SPEC_RETVAL_UNUSED) \ + _(2196, ZEND_DO_UCALL_SPEC_RETVAL_USED) \ + _(2197, ZEND_DO_UCALL_SPEC_OBSERVER) \ + _(2198, ZEND_DO_UCALL_SPEC_OBSERVER) \ + _(2199, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED) \ + _(2200, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED) \ + _(2201, ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER) \ + _(2202, ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER) \ + _(2213, ZEND_PRE_INC_OBJ_SPEC_VAR_CONST) \ + _(2214, ZEND_PRE_INC_OBJ_SPEC_VAR_TMP) \ + _(2217, ZEND_PRE_INC_OBJ_SPEC_VAR_CV) \ + _(2218, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST) \ + _(2219, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMP) \ + _(2222, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV) \ + _(2223, ZEND_PRE_INC_OBJ_SPEC_CV_CONST) \ + _(2224, ZEND_PRE_INC_OBJ_SPEC_CV_TMP) \ + _(2227, ZEND_PRE_INC_OBJ_SPEC_CV_CV) \ + _(2238, ZEND_POST_INC_OBJ_SPEC_VAR_CONST) \ + _(2239, ZEND_POST_INC_OBJ_SPEC_VAR_TMP) \ + _(2242, ZEND_POST_INC_OBJ_SPEC_VAR_CV) \ + _(2243, ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST) \ + _(2244, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMP) \ + _(2247, ZEND_POST_INC_OBJ_SPEC_UNUSED_CV) \ + _(2248, ZEND_POST_INC_OBJ_SPEC_CV_CONST) \ + _(2249, ZEND_POST_INC_OBJ_SPEC_CV_TMP) \ + _(2252, ZEND_POST_INC_OBJ_SPEC_CV_CV) \ + _(2253, ZEND_ECHO_SPEC_CONST) \ + _(2254, ZEND_ECHO_SPEC_TMP) \ + _(2257, ZEND_ECHO_SPEC_CV) \ + _(2264, ZEND_INSTANCEOF_SPEC_TMP_CONST) \ + _(2266, ZEND_INSTANCEOF_SPEC_TMP_VAR) \ + _(2267, ZEND_INSTANCEOF_SPEC_TMP_UNUSED) \ + _(2279, ZEND_INSTANCEOF_SPEC_CV_CONST) \ + _(2281, ZEND_INSTANCEOF_SPEC_CV_VAR) \ + _(2282, ZEND_INSTANCEOF_SPEC_CV_UNUSED) \ + _(2284, ZEND_GENERATOR_CREATE_SPEC) \ + _(2287, ZEND_MAKE_REF_SPEC_VAR_UNUSED) \ + _(2289, ZEND_MAKE_REF_SPEC_CV_UNUSED) \ + _(2290, ZEND_DECLARE_FUNCTION_SPEC) \ + _(2291, ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST) \ + _(2292, ZEND_DECLARE_CONST_SPEC_CONST_CONST) \ + _(2293, ZEND_DECLARE_CLASS_SPEC_CONST) \ + _(2294, ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST) \ + _(2295, ZEND_DECLARE_ANON_CLASS_SPEC) \ + _(2296, ZEND_ADD_ARRAY_UNPACK_SPEC) \ + _(2297, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST) \ + _(2298, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMP) \ + _(2301, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV) \ + _(2302, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_CONST) \ + _(2303, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_TMP) \ + _(2306, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_CV) \ + _(2312, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST) \ + _(2313, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMP) \ + _(2316, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV) \ + _(2317, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST) \ + _(2318, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMP) \ + _(2321, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV) \ + _(2322, ZEND_HANDLE_EXCEPTION_SPEC) \ + _(2323, ZEND_USER_OPCODE_SPEC) \ + _(2324, ZEND_ASSERT_CHECK_SPEC) \ + _(2325, ZEND_JMP_SET_SPEC_CONST) \ + _(2326, ZEND_JMP_SET_SPEC_TMP) \ + _(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_TMP) \ + _(2337, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \ + _(2338, ZEND_SEPARATE_SPEC_VAR_UNUSED) \ + _(2340, ZEND_FETCH_CLASS_NAME_SPEC_TMP) \ + _(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_TMP) \ + _(2350, ZEND_YIELD_SPEC_CONST_UNUSED) \ + _(2351, ZEND_YIELD_SPEC_CONST_CV) \ + _(2352, ZEND_YIELD_SPEC_TMP_CONST) \ + _(2353, ZEND_YIELD_SPEC_TMP_TMP) \ + _(2355, ZEND_YIELD_SPEC_TMP_UNUSED) \ + _(2356, ZEND_YIELD_SPEC_TMP_CV) \ + _(2357, ZEND_YIELD_SPEC_VAR_CONST) \ + _(2358, ZEND_YIELD_SPEC_VAR_TMP) \ + _(2360, ZEND_YIELD_SPEC_VAR_UNUSED) \ + _(2361, ZEND_YIELD_SPEC_VAR_CV) \ + _(2362, ZEND_YIELD_SPEC_UNUSED_CONST) \ + _(2363, ZEND_YIELD_SPEC_UNUSED_TMP) \ + _(2365, ZEND_YIELD_SPEC_UNUSED_UNUSED) \ + _(2366, ZEND_YIELD_SPEC_UNUSED_CV) \ + _(2367, ZEND_YIELD_SPEC_CV_CONST) \ + _(2368, ZEND_YIELD_SPEC_CV_TMP) \ + _(2370, ZEND_YIELD_SPEC_CV_UNUSED) \ + _(2371, ZEND_YIELD_SPEC_CV_CV) \ + _(2372, ZEND_GENERATOR_RETURN_SPEC_CONST) \ + _(2373, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \ + _(2374, ZEND_GENERATOR_RETURN_SPEC_TMP) \ + _(2375, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \ + _(2376, ZEND_GENERATOR_RETURN_SPEC_VAR) \ + _(2377, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \ + _(2380, ZEND_GENERATOR_RETURN_SPEC_CV) \ + _(2381, ZEND_GENERATOR_RETURN_SPEC_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_TMP) \ + _(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) \ + _(2397, ZEND_COALESCE_SPEC_CV) \ + _(2398, ZEND_SPACESHIP_SPEC_CONST_CONST) \ + _(2399, ZEND_SPACESHIP_SPEC_CONST_TMP) \ + _(2402, ZEND_SPACESHIP_SPEC_CONST_CV) \ + _(2403, ZEND_SPACESHIP_SPEC_TMP_CONST) \ + _(2404, ZEND_SPACESHIP_SPEC_TMP_TMP) \ + _(2407, ZEND_SPACESHIP_SPEC_TMP_CV) \ + _(2418, ZEND_SPACESHIP_SPEC_CV_CONST) \ + _(2419, ZEND_SPACESHIP_SPEC_CV_TMP) \ + _(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) \ + _(2438, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV) \ + _(2439, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV) \ + _(2441, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV) \ + _(2447, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) \ + _(2448, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV) \ + _(2449, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV) \ + _(2451, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV) \ + _(2452, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST) \ + _(2453, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV) \ + _(2454, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV) \ + _(2456, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV) \ + _(2462, ZEND_BIND_LEXICAL_SPEC_TMP_CV) \ + _(2463, ZEND_BIND_STATIC_SPEC_CV) \ + _(2464, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED) \ + _(2465, ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST) \ + _(2468, ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED) \ + _(2470, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED) \ + _(2471, ZEND_SWITCH_LONG_SPEC_CONST_CONST) \ + _(2472, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(2473, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(2475, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(2476, ZEND_SWITCH_STRING_SPEC_CONST_CONST) \ + _(2477, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(2478, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(2480, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(2481, ZEND_IN_ARRAY_SPEC_CONST_CONST) \ + _(2482, ZEND_IN_ARRAY_SPEC_TMP_CONST) \ + _(2485, ZEND_IN_ARRAY_SPEC_CV_CONST) \ + _(2486, ZEND_COUNT_SPEC_CONST_UNUSED) \ + _(2487, ZEND_COUNT_SPEC_TMP_UNUSED) \ + _(2490, ZEND_COUNT_SPEC_CV_UNUSED) \ + _(2491, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \ + _(2492, ZEND_GET_CLASS_SPEC_TMP_UNUSED) \ + _(2494, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED) \ + _(2495, ZEND_GET_CLASS_SPEC_CV_UNUSED) \ + _(2496, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED) \ + _(2497, ZEND_GET_TYPE_SPEC_CONST_UNUSED) \ + _(2498, ZEND_GET_TYPE_SPEC_TMP_UNUSED) \ + _(2501, ZEND_GET_TYPE_SPEC_CV_UNUSED) \ + _(2502, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \ + _(2503, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMP) \ + _(2506, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \ + _(2507, ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_CONST) \ + _(2508, ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_TMP) \ + _(2511, ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_CV) \ + _(2522, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \ + _(2523, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMP) \ + _(2526, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \ + _(2527, ZEND_MATCH_SPEC_CONST_CONST) \ + _(2528, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ + _(2529, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ + _(2531, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ + _(2532, ZEND_CASE_STRICT_SPEC_TMP_CONST) \ + _(2533, ZEND_CASE_STRICT_SPEC_TMP_TMP) \ + _(2536, ZEND_CASE_STRICT_SPEC_TMP_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_TMP) \ + _(2546, ZEND_JMP_NULL_SPEC_CV) \ + _(2547, ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED) \ + _(2548, ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED) \ + _(2549, ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED) \ + _(2550, ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED) \ + _(2551, ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV) \ + _(2552, ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED) \ + _(2553, ZEND_FRAMELESS_ICALL_0_SPEC_OBSERVER) \ + _(2554, ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED) \ + _(2555, ZEND_FRAMELESS_ICALL_1_SPEC_OBSERVER) \ + _(2556, ZEND_FRAMELESS_ICALL_2_SPEC) \ + _(2557, ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVER) \ + _(2558, ZEND_FRAMELESS_ICALL_3_SPEC) \ + _(2559, ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER) \ + _(2560, ZEND_JMP_FRAMELESS_SPEC_CONST) \ + _(2561, ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED) \ + _(2562, ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST) \ + _(2563, ZEND_TYPE_ASSERT_SPEC_CONST) \ + _(2564, ZEND_INIT_FCALL_OFFSET_SPEC_CONST) \ + _(2565, ZEND_RECV_NOTYPE_SPEC) \ + _(2567, ZEND_COUNT_ARRAY_SPEC_TMP_UNUSED) \ + _(2570, ZEND_COUNT_ARRAY_SPEC_CV_UNUSED) \ + _(2571, ZEND_JMP_FORWARD_SPEC) \ _(2577, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2578, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2579, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2581, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2587, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2588, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2589, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2591, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2597, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2598, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2599, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2601, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2582, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2583, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2584, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2586, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2592, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2593, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2594, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2596, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2602, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ _(2603, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2604, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2606, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2612, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2613, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2614, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2616, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2622, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2623, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2624, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2626, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2607, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2608, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2609, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2611, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2617, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2618, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2619, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2621, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2627, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2628, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2629, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2631, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2637, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2638, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2639, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2641, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2643, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2644, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2646, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2647, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2648, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2649, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2651, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2632, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2633, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2634, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2636, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2642, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2643, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2644, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2646, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2648, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2649, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2651, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ _(2652, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2653, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2654, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2656, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2662, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2663, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2664, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2666, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2668, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2669, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2671, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2672, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2673, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2674, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2676, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2657, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2658, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2659, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2661, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2667, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2668, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2669, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2671, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2673, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2674, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2676, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ _(2677, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ _(2678, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2679, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2681, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2687, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2688, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2689, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2691, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2693, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2694, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2696, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2697, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2698, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2699, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2701, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2682, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2683, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2684, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2686, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2692, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2693, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2694, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2696, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2698, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2699, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2701, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ _(2702, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2703, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2704, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2706, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2712, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2713, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2714, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2716, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2722, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2723, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2724, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2726, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2707, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2708, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2709, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2711, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2717, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2718, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2719, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2721, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2727, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2728, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2729, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2731, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2737, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2738, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2739, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2741, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2747, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2748, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2749, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2751, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2732, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2733, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2734, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2736, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2742, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2743, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2744, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2746, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2752, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ _(2753, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2754, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2756, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2762, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2763, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2764, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2766, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2772, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2773, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2774, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2776, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2757, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2758, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2759, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2761, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2767, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2768, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2769, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2771, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2777, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2778, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2779, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2781, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2787, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2788, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2789, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2791, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(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) \ - _(2822, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2823, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2824, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2825, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2826, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2827, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2828, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2829, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2830, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2834, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2835, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2836, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2852, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2853, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2854, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2855, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2856, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2857, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2858, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2859, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2860, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2864, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2865, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2866, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(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) \ - _(2897, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2898, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2899, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2900, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2901, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2902, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2903, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2904, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2905, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2909, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2910, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2911, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2927, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2928, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2929, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2930, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2931, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2932, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2933, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2934, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2935, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2939, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2940, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2941, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(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) \ - _(2972, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2973, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2974, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2975, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2976, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2977, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2978, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2979, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2980, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2984, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2985, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2986, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3002, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3003, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3004, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3005, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3006, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3007, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3008, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3009, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3010, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3014, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3015, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3016, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(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_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3048, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3049, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3050, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3051, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3052, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3053, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3054, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3055, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3059, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3060, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3061, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3077, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3078, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3079, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3080, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3081, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3082, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3083, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3084, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3085, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3089, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3090, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3091, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3092, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST) \ - _(3093, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3094, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3095, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST) \ - _(3096, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3097, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3098, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(3102, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(3103, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(3107, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(3111, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3112, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3113, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3114, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3115, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3116, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3120, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3121, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3122, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3123, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3124, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3125, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3126, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3127, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3128, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(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_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3136, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3137, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3138, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3139, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3140, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3141, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3142, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3143, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3144, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3145, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3146, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3150, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3151, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3152, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3168, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3169, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3170, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3171, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3172, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3173, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3174, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3175, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3176, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3180, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3181, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3182, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3186, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3187, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3188, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3189, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3190, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3191, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3195, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3196, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3197, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3198, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3199, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3200, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3201, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3202, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3203, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(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_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3211, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3212, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3213, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3214, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3215, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3216, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3217, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3218, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3219, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3220, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3221, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3225, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3226, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3227, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3243, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3244, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3245, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3246, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3247, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3248, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3249, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3250, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3251, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3255, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3256, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3257, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3261, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3262, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3263, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3264, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3265, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3266, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3270, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3271, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3272, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3273, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3274, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3275, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3276, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3277, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3278, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(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_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3286, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3287, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3288, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3289, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3290, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3291, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3292, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3293, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3294, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3295, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3296, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3300, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3301, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3302, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3318, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3319, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3320, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3321, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3322, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3323, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3324, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3325, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3326, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3330, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3331, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3332, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3336, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3337, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3338, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3339, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3340, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3341, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3345, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3346, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3347, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3348, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3349, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3350, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3351, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3352, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3353, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(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) \ - _(3360, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3361, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3362, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3363, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3364, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3365, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3366, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3367, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3368, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3369, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3370, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3371, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3375, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3376, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3377, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3393, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3394, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3395, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3396, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3397, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3398, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3399, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3400, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3401, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3405, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3406, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3407, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3408, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3409, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3410, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3411, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ - _(3412, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3413, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3414, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3415, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ - _(3416, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3417, ZEND_POST_INC_LONG_SPEC_CV) \ - _(3418, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3419, ZEND_POST_DEC_LONG_SPEC_CV) \ - _(3420, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ - _(3421, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3422, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3424, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3425, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ - _(3426, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3427, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3429, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3430, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ - _(3431, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3432, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3434, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3436, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3437, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3439, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3440, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(3441, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3442, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3444, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(2782, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2783, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2784, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2786, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2792, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2793, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2794, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2796, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2812, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2813, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2814, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2815, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2816, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2817, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2818, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2819, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2820, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2824, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2825, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2826, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2827, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2828, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2829, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2830, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2831, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2832, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2833, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2834, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2835, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2839, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2840, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2841, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2857, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2858, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2859, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2860, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2861, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2862, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2863, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2864, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2865, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2869, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2870, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2871, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2887, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2888, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2889, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2890, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2891, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2892, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2893, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2894, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2895, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2899, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2900, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2901, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2902, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2903, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2904, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2905, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2906, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2907, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2908, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2909, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2910, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2914, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2915, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2916, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2932, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2933, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2934, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2935, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2936, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2937, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2938, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2939, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2940, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2944, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2945, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2946, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2962, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2963, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2964, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2965, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2966, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2967, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2968, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2969, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2970, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2974, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2975, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2976, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2977, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2978, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2979, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2980, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2981, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2982, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2983, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2984, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2985, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2989, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2990, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2991, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3007, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3008, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3009, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3010, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3011, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3012, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3013, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3014, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3015, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3019, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3020, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3021, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3037, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3038, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3039, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3040, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3041, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3042, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3043, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3044, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3045, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3049, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3050, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3051, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3052, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3053, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3054, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3055, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3056, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3057, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3058, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3059, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3060, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3064, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3065, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3066, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3082, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3083, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3084, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3085, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3086, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3087, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3088, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3089, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3090, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3094, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3095, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3096, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3097, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST) \ + _(3098, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3099, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3100, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST) \ + _(3101, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3102, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3103, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3107, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3108, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3112, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3116, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3117, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3118, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3119, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3120, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3121, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3125, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3126, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3127, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3128, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3129, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3130, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3131, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3132, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3133, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3134, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3135, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3136, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3140, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3141, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3142, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3143, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3144, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3145, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3146, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3147, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3148, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3149, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3150, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3151, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3155, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3156, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3157, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3173, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3174, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3175, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3176, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3177, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3178, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3179, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3180, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3181, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3185, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3186, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3187, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3191, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3192, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3193, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3194, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3195, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3196, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3200, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3201, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3202, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3203, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3204, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3205, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3206, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3207, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3208, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3209, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3210, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3211, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3215, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3216, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3217, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3218, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3219, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3220, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3221, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3222, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3223, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3224, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3225, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3226, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3230, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3231, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3232, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3248, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3249, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3250, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3251, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3252, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3253, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3254, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3255, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3256, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3260, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3261, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3262, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3266, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3267, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3268, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3269, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3270, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3271, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3275, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3276, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3277, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3278, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3279, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3280, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3281, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3282, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3283, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3284, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3285, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3286, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3290, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3291, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3292, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3293, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3294, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3295, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3296, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3297, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3298, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3299, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3300, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3301, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3305, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3306, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3307, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3323, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3324, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3325, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3326, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3327, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3328, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3329, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3330, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3331, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3335, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3336, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3337, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3341, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3342, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3343, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3344, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3345, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3346, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3350, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3351, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3352, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3353, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3354, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3355, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3356, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3357, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3358, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3359, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3360, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3361, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3365, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3366, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3367, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3368, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3369, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3370, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3371, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3372, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3373, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3374, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3375, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3376, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3380, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3381, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3382, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3398, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3399, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3400, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3401, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3402, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3403, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3404, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3405, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3406, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3410, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3411, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3412, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3413, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3414, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3415, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3416, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ + _(3417, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3418, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3419, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3420, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ + _(3421, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3422, ZEND_POST_INC_LONG_SPEC_CV) \ + _(3423, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3424, ZEND_POST_DEC_LONG_SPEC_CV) \ + _(3425, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ + _(3426, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3427, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3429, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3430, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ + _(3431, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3432, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3434, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3435, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ + _(3436, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3437, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3439, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3441, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3442, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3444, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ _(3445, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ _(3446, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ _(3447, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ _(3449, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3455, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ - _(3456, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3457, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3459, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3462, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ - _(3464, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ - _(3467, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ - _(3469, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ - _(3470, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ - _(3471, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ - _(3472, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ - _(3473, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ - _(3473+1, ZEND_NULL) + _(3450, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3451, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3452, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3454, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3460, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ + _(3461, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3462, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3464, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3467, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ + _(3469, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ + _(3472, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ + _(3474, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ + _(3475, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ + _(3476, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ + _(3477, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ + _(3478, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ + _(3478+1, ZEND_NULL) diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c index 0ece3e6f0c66..7072875b5da5 100644 --- a/Zend/zend_vm_opcodes.c +++ b/Zend/zend_vm_opcodes.c @@ -67,7 +67,7 @@ static const char *zend_vm_opcodes_names[212] = { "ZEND_JMP", "ZEND_JMPZ", "ZEND_JMPNZ", - NULL, + "ZEND_CAST_VALUE_FOR_RETURN_TYPE", "ZEND_JMPZ_EX", "ZEND_JMPNZ_EX", "ZEND_CASE", @@ -282,7 +282,7 @@ static uint32_t zend_vm_opcodes_flags[212] = { 0x00000020, 0x00002003, 0x00002003, - 0x00000000, + 0x00000103, 0x00002003, 0x00002003, 0x00000301, diff --git a/Zend/zend_vm_opcodes.h b/Zend/zend_vm_opcodes.h index 92b46e6628f3..c22cba03ade4 100644 --- a/Zend/zend_vm_opcodes.h +++ b/Zend/zend_vm_opcodes.h @@ -166,6 +166,7 @@ END_EXTERN_C() #define ZEND_JMP 42 #define ZEND_JMPZ 43 #define ZEND_JMPNZ 44 +#define ZEND_CAST_VALUE_FOR_RETURN_TYPE 45 #define ZEND_JMPZ_EX 46 #define ZEND_JMPNZ_EX 47 #define ZEND_CASE 48 diff --git a/ext/opcache/tests/opt/type_inference_class_consts1.phpt b/ext/opcache/tests/opt/type_inference_class_consts1.phpt index fb9be49a6f14..b73814b7c5fa 100644 --- a/ext/opcache/tests/opt/type_inference_class_consts1.phpt +++ b/ext/opcache/tests/opt/type_inference_class_consts1.phpt @@ -73,7 +73,7 @@ Test1::getStaticFoo: ; (after optimizer) ; %s 0000 T0 = FETCH_CLASS_CONSTANT (static) (exception) string("FOO") -0001 VERIFY_RETURN_TYPE T0 +0001 CAST_VALUE_FOR_RETURN_TYPE T0 0002 RETURN T0 LIVE RANGES: 0: 0001 - 0002 (tmp/var) diff --git a/ext/opcache/tests/opt/type_inference_class_consts4.phpt b/ext/opcache/tests/opt/type_inference_class_consts4.phpt index 03c0c1248bce..14d7c8d82d37 100644 --- a/ext/opcache/tests/opt/type_inference_class_consts4.phpt +++ b/ext/opcache/tests/opt/type_inference_class_consts4.phpt @@ -57,7 +57,7 @@ Test4::getSelfA: ; (after optimizer) ; %s 0000 T0 = FETCH_CLASS_CONSTANT (self) (exception) string("A") -0001 VERIFY_RETURN_TYPE T0 +0001 CAST_VALUE_FOR_RETURN_TYPE T0 0002 RETURN T0 LIVE RANGES: 0: 0001 - 0002 (tmp/var) @@ -67,7 +67,7 @@ Test4::getSelfB: ; (after optimizer) ; %s 0000 T0 = FETCH_CLASS_CONSTANT (self) (exception) string("B") -0001 VERIFY_RETURN_TYPE T0 +0001 CAST_VALUE_FOR_RETURN_TYPE T0 0002 RETURN T0 LIVE RANGES: 0: 0001 - 0002 (tmp/var) @@ -77,7 +77,7 @@ Test4::getStaticA: ; (after optimizer) ; %s 0000 T0 = FETCH_CLASS_CONSTANT (static) (exception) string("A") -0001 VERIFY_RETURN_TYPE T0 +0001 CAST_VALUE_FOR_RETURN_TYPE T0 0002 RETURN T0 LIVE RANGES: 0: 0001 - 0002 (tmp/var) @@ -87,7 +87,7 @@ Test4::getStaticB: ; (after optimizer) ; %s 0000 T0 = FETCH_CLASS_CONSTANT (static) (exception) string("B") -0001 VERIFY_RETURN_TYPE T0 +0001 CAST_VALUE_FOR_RETURN_TYPE T0 0002 RETURN T0 LIVE RANGES: 0: 0001 - 0002 (tmp/var) diff --git a/ext/opcache/tests/opt/verify_return_type.phpt b/ext/opcache/tests/opt/verify_return_type.phpt index 7b43cbc8fdd9..669ba853a126 100644 --- a/ext/opcache/tests/opt/verify_return_type.phpt +++ b/ext/opcache/tests/opt/verify_return_type.phpt @@ -129,7 +129,7 @@ Test2::getInt3: 0001 INIT_METHOD_CALL 1 THIS string("getIntOrFloat") 0002 SEND_VAR CV0($i) 1 0003 V1 = DO_FCALL -0004 VERIFY_RETURN_TYPE V1 +0004 CAST_VALUE_FOR_RETURN_TYPE T0 0005 RETURN V1 Test3::getBool: diff --git a/ext/opcache/tests/opt/verify_return_type_to_cast.phpt b/ext/opcache/tests/opt/verify_return_type_to_cast.phpt new file mode 100644 index 000000000000..b58f93184e0d --- /dev/null +++ b/ext/opcache/tests/opt/verify_return_type_to_cast.phpt @@ -0,0 +1,202 @@ +--TEST-- +Return type check converted to a cast +--INI-- +opcache.enable=1 +opcache.enable_cli=1 +opcache.optimization_level=-1 +opcache.opt_debug_level=0x20000 +opcache.preload= +--EXTENSIONS-- +opcache +--FILE-- + +--EXPECTF-- +$_main: + ; (lines=1, args=0, vars=0, tmps=0) + ; (after optimizer) + ; %s:1-58 +0000 RETURN int(1) + +strToBool: + ; (lines=3, args=1, vars=1, tmps=0) + ; (after optimizer) + ; %s:3-5 +0000 CV0($v) = RECV 1 +0001 VERIFY_RETURN_TYPE CV0($v) +0002 RETURN CV0($v) + +intToBool: + ; (lines=3, args=1, vars=1, tmps=0) + ; (after optimizer) + ; %s:6-8 +0000 CV0($v) = RECV 1 +0001 VERIFY_RETURN_TYPE CV0($v) +0002 RETURN CV0($v) + +floatToBool: + ; (lines=3, args=1, vars=1, tmps=0) + ; (after optimizer) + ; %s:9-11 +0000 CV0($v) = RECV 1 +0001 VERIFY_RETURN_TYPE CV0($v) +0002 RETURN CV0($v) + +strToInt: + ; (lines=3, args=1, vars=1, tmps=0) + ; (after optimizer) + ; %s:13-15 +0000 CV0($v) = RECV 1 +0001 VERIFY_RETURN_TYPE CV0($v) +0002 RETURN CV0($v) + +floatToInt: + ; (lines=3, args=1, vars=1, tmps=0) + ; (after optimizer) + ; %s:16-18 +0000 CV0($v) = RECV 1 +0001 VERIFY_RETURN_TYPE CV0($v) +0002 RETURN CV0($v) + +boolToInt: + ; (lines=3, args=1, vars=1, tmps=0) + ; (after optimizer) + ; %s:19-21 +0000 CV0($v) = RECV 1 +0001 CAST_VALUE_FOR_RETURN_TYPE CV0($v) +0002 RETURN CV0($v) + +strToFloat: + ; (lines=3, args=1, vars=1, tmps=0) + ; (after optimizer) + ; %s:23-25 +0000 CV0($v) = RECV 1 +0001 VERIFY_RETURN_TYPE CV0($v) +0002 RETURN CV0($v) + +intToFloat: + ; (lines=3, args=1, vars=1, tmps=0) + ; (after optimizer) + ; %s:26-28 +0000 CV0($v) = RECV 1 +0001 CAST_VALUE_FOR_RETURN_TYPE CV0($v) +0002 RETURN CV0($v) + +boolToFloat: + ; (lines=3, args=1, vars=1, tmps=0) + ; (after optimizer) + ; %s:29-31 +0000 CV0($v) = RECV 1 +0001 CAST_VALUE_FOR_RETURN_TYPE CV0($v) +0002 RETURN CV0($v) + +floatToString: + ; (lines=3, args=1, vars=1, tmps=0) + ; (after optimizer) + ; %s:33-35 +0000 CV0($v) = RECV 1 +0001 VERIFY_RETURN_TYPE CV0($v) +0002 RETURN CV0($v) + +intToString: + ; (lines=3, args=1, vars=1, tmps=0) + ; (after optimizer) + ; %s:36-38 +0000 CV0($v) = RECV 1 +0001 CAST_VALUE_FOR_RETURN_TYPE CV0($v) +0002 RETURN CV0($v) + +boolToString: + ; (lines=3, args=1, vars=1, tmps=0) + ; (after optimizer) + ; %s:39-41 +0000 CV0($v) = RECV 1 +0001 CAST_VALUE_FOR_RETURN_TYPE CV0($v) +0002 RETURN CV0($v) + +floatToUnion: + ; (lines=3, args=1, vars=1, tmps=0) + ; (after optimizer) + ; %s:43-45 +0000 CV0($v) = RECV 1 +0001 VERIFY_RETURN_TYPE CV0($v) +0002 RETURN CV0($v) + +intToUnion: + ; (lines=3, args=1, vars=1, tmps=0) + ; (after optimizer) + ; %s:46-48 +0000 CV0($v) = RECV 1 +0001 CAST_VALUE_FOR_RETURN_TYPE CV0($v) +0002 RETURN CV0($v) + +boolToUnion: + ; (lines=3, args=1, vars=1, tmps=0) + ; (after optimizer) + ; %s:49-51 +0000 CV0($v) = RECV 1 +0001 CAST_VALUE_FOR_RETURN_TYPE CV0($v) +0002 RETURN CV0($v) + +stringToUnion: + ; (lines=3, args=1, vars=1, tmps=0) + ; (after optimizer) + ; %s:52-54 +0000 CV0($v) = RECV 1 +0001 VERIFY_RETURN_TYPE CV0($v) +0002 RETURN CV0($v)