From 98e0681f8640e38ae6e37b304dff252930b2a16c Mon Sep 17 00:00:00 2001 From: Ilija Tovilo Date: Mon, 9 Jun 2025 01:23:33 +0200 Subject: [PATCH 01/19] Mark some opcode ops as unused They will be used for quick op flags. --- Zend/zend_vm_def.h | 18 +- Zend/zend_vm_execute.h | 654 ++++++++++++++++++++-------------------- Zend/zend_vm_handlers.h | 28 +- Zend/zend_vm_opcodes.c | 16 +- 4 files changed, 358 insertions(+), 358 deletions(-) diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 617e114dd05db..d0e5dd21cd03b 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -944,7 +944,7 @@ ZEND_VM_HELPER(zend_bw_not_helper, ANY, ANY, zval *op_1) ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -ZEND_VM_HOT_NOCONST_HANDLER(13, ZEND_BW_NOT, CONST|TMPVARCV, ANY) +ZEND_VM_HOT_NOCONST_HANDLER(13, ZEND_BW_NOT, CONST|TMPVARCV, UNUSED) { USE_OPLINE zval *op1; @@ -958,7 +958,7 @@ ZEND_VM_HOT_NOCONST_HANDLER(13, ZEND_BW_NOT, CONST|TMPVARCV, ANY) ZEND_VM_DISPATCH_TO_HELPER(zend_bw_not_helper, op_1, op1); } -ZEND_VM_COLD_CONST_HANDLER(14, ZEND_BOOL_NOT, CONST|TMPVAR|CV, ANY) +ZEND_VM_COLD_CONST_HANDLER(14, ZEND_BOOL_NOT, CONST|TMPVAR|CV, UNUSED) { USE_OPLINE zval *val; @@ -5695,7 +5695,7 @@ ZEND_VM_HOT_HANDLER(63, ZEND_RECV, NUM, UNUSED) ZEND_VM_NEXT_OPCODE(); } -ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_RECV, op->op2.num == MAY_BE_ANY, ZEND_RECV_NOTYPE, NUM, NUM) +ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_RECV, op->op2.num == MAY_BE_ANY, ZEND_RECV_NOTYPE, NUM, UNUSED) { USE_OPLINE uint32_t arg_num = opline->op1.num; @@ -8784,7 +8784,7 @@ ZEND_VM_COLD_CONST_HANDLER(121, ZEND_STRLEN, CONST|TMPVAR|CV, ANY) ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -ZEND_VM_HOT_NOCONST_HANDLER(123, ZEND_TYPE_CHECK, CONST|TMPVAR|CV, ANY, TYPE_MASK) +ZEND_VM_HOT_NOCONST_HANDLER(123, ZEND_TYPE_CHECK, CONST|TMPVAR|CV, UNUSED, TYPE_MASK) { USE_OPLINE zval *value; @@ -8820,7 +8820,7 @@ ZEND_VM_C_LABEL(type_check_resource): } } -ZEND_VM_HOT_HANDLER(122, ZEND_DEFINED, CONST, ANY, CACHE_SLOT) +ZEND_VM_HOT_HANDLER(122, ZEND_DEFINED, CONST, UNUSED, CACHE_SLOT) { USE_OPLINE zend_constant *c; @@ -9727,7 +9727,7 @@ ZEND_VM_C_LABEL(try_again): } } -ZEND_VM_HANDLER(204, ZEND_FRAMELESS_ICALL_0, UNUSED, UNUSED, SPEC(OBSERVER)) +ZEND_VM_HANDLER(204, ZEND_FRAMELESS_ICALL_0, UNUSED, UNUSED, NUM, SPEC(OBSERVER)) { USE_OPLINE SAVE_OPLINE(); @@ -9747,7 +9747,7 @@ ZEND_VM_HANDLER(204, ZEND_FRAMELESS_ICALL_0, UNUSED, UNUSED, SPEC(OBSERVER)) ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -ZEND_VM_HANDLER(205, ZEND_FRAMELESS_ICALL_1, ANY, UNUSED, SPEC(OBSERVER)) +ZEND_VM_HANDLER(205, ZEND_FRAMELESS_ICALL_1, ANY, UNUSED, NUM, SPEC(OBSERVER)) { USE_OPLINE SAVE_OPLINE(); @@ -9773,7 +9773,7 @@ ZEND_VM_HANDLER(205, ZEND_FRAMELESS_ICALL_1, ANY, UNUSED, SPEC(OBSERVER)) ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -ZEND_VM_HANDLER(206, ZEND_FRAMELESS_ICALL_2, ANY, ANY, SPEC(OBSERVER)) +ZEND_VM_HANDLER(206, ZEND_FRAMELESS_ICALL_2, ANY, ANY, NUM, SPEC(OBSERVER)) { USE_OPLINE SAVE_OPLINE(); @@ -9807,7 +9807,7 @@ ZEND_VM_HANDLER(206, ZEND_FRAMELESS_ICALL_2, ANY, ANY, SPEC(OBSERVER)) ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -ZEND_VM_HANDLER(207, ZEND_FRAMELESS_ICALL_3, ANY, ANY, SPEC(OBSERVER)) +ZEND_VM_HANDLER(207, ZEND_FRAMELESS_ICALL_3, ANY, ANY, NUM, SPEC(OBSERVER)) { USE_OPLINE SAVE_OPLINE(); diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 791e4b4e88437..9afcccdd08127 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -2767,18 +2767,6 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_verify_recv_ ZEND_VM_NEXT_OPCODE(); } -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RECV_NOTYPE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - uint32_t arg_num = opline->op1.num; - - if (UNEXPECTED(arg_num > EX_NUM_ARGS())) { - ZEND_VM_TAIL_CALL(zend_missing_arg_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); - } - - ZEND_VM_NEXT_OPCODE(); -} - static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_case_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2) { int ret; @@ -4275,6 +4263,18 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RECV_SPEC_UNUSED_H ZEND_VM_NEXT_OPCODE(); } +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RECV_NOTYPE_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + uint32_t arg_num = opline->op1.num; + + if (UNEXPECTED(arg_num > EX_NUM_ARGS())) { + ZEND_VM_TAIL_CALL(zend_missing_arg_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + } + + ZEND_VM_NEXT_OPCODE(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RECV_VARIADIC_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -4452,46 +4452,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_DYNAMIC_CALL_SPEC_CV_HAND ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1; - - op1 = RT_CONSTANT(opline, opline->op1); - if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) { - ZVAL_LONG(EX_VAR(opline->result.var), ~Z_LVAL_P(op1)); - ZEND_VM_NEXT_OPCODE(); - } - - ZEND_VM_TAIL_CALL(zend_bw_not_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1)); -} - -static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *val; - - val = RT_CONSTANT(opline, opline->op1); - if (Z_TYPE_INFO_P(val) == IS_TRUE) { - ZVAL_FALSE(EX_VAR(opline->result.var)); - } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) { - /* The result and op1 can be the same cv zval */ - const uint32_t orig_val_type = Z_TYPE_INFO_P(val); - ZVAL_TRUE(EX_VAR(opline->result.var)); - if (IS_CONST == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) { - SAVE_OPLINE(); - ZVAL_UNDEFINED_OP1(); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } - } else { - SAVE_OPLINE(); - ZVAL_BOOL(EX_VAR(opline->result.var), !i_zend_is_true(val)); - - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } - ZEND_VM_NEXT_OPCODE(); -} - static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -5984,65 +5944,6 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_STRLEN_SPEC_CONST ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_TYPE_CHECK_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *value; - int result = 0; - - value = RT_CONSTANT(opline, opline->op1); - if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) { -type_check_resource: - if (opline->extended_value != MAY_BE_RESOURCE - || EXPECTED(NULL != zend_rsrc_list_get_rsrc_type(Z_RES_P(value)))) { - result = 1; - } - } else if ((IS_CONST & (IS_CV|IS_VAR)) && Z_ISREF_P(value)) { - value = Z_REFVAL_P(value); - if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) { - goto type_check_resource; - } - } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { - result = ((1 << IS_NULL) & opline->extended_value) != 0; - SAVE_OPLINE(); - ZVAL_UNDEFINED_OP1(); - if (UNEXPECTED(EG(exception))) { - ZVAL_UNDEF(EX_VAR(opline->result.var)); - HANDLE_EXCEPTION(); - } - } - if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { - SAVE_OPLINE(); - - ZEND_VM_SMART_BRANCH(result, 1); - } else { - ZEND_VM_SMART_BRANCH(result, 0); - } -} - -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DEFINED_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zend_constant *c; - - c = CACHED_PTR(opline->extended_value); - if (EXPECTED(c != NULL)) { - if (!IS_SPECIAL_CACHE_VAL(c)) { -defined_true: - ZEND_VM_SMART_BRANCH_TRUE(); - } else if (EXPECTED(zend_hash_num_elements(EG(zend_constants)) == DECODE_SPECIAL_CACHE_NUM(c))) { -defined_false: - ZEND_VM_SMART_BRANCH_FALSE(); - } - } - if (zend_quick_check_constant(RT_CONSTANT(opline, opline->op1) OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) { - CACHE_PTR(opline->extended_value, ENCODE_SPECIAL_CACHE_NUM(zend_hash_num_elements(EG(zend_constants)))); - goto defined_false; - } else { - goto defined_true; - } -} - static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_FRAMELESS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -10553,6 +10454,46 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_TMPVAR_HANDLE ZEND_VM_RETURN(); } +static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_NOT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1; + + op1 = RT_CONSTANT(opline, opline->op1); + if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) { + ZVAL_LONG(EX_VAR(opline->result.var), ~Z_LVAL_P(op1)); + ZEND_VM_NEXT_OPCODE(); + } + + ZEND_VM_TAIL_CALL(zend_bw_not_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1)); +} + +static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *val; + + val = RT_CONSTANT(opline, opline->op1); + if (Z_TYPE_INFO_P(val) == IS_TRUE) { + ZVAL_FALSE(EX_VAR(opline->result.var)); + } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) { + /* The result and op1 can be the same cv zval */ + const uint32_t orig_val_type = Z_TYPE_INFO_P(val); + ZVAL_TRUE(EX_VAR(opline->result.var)); + if (IS_CONST == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + } else { + SAVE_OPLINE(); + ZVAL_BOOL(EX_VAR(opline->result.var), !i_zend_is_true(val)); + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + ZEND_VM_NEXT_OPCODE(); +} + static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_UNUSED(ZEND_OPCODE_HANDLER_ARGS_EX int type) { USE_OPLINE @@ -11397,6 +11338,65 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_UNUSED_HANDLE ZEND_VM_RETURN(); } +static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_TYPE_CHECK_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + int result = 0; + + value = RT_CONSTANT(opline, opline->op1); + if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) { +type_check_resource: + if (opline->extended_value != MAY_BE_RESOURCE + || EXPECTED(NULL != zend_rsrc_list_get_rsrc_type(Z_RES_P(value)))) { + result = 1; + } + } else if ((IS_CONST & (IS_CV|IS_VAR)) && Z_ISREF_P(value)) { + value = Z_REFVAL_P(value); + if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) { + goto type_check_resource; + } + } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { + result = ((1 << IS_NULL) & opline->extended_value) != 0; + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception))) { + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); + } + } + if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { + SAVE_OPLINE(); + + ZEND_VM_SMART_BRANCH(result, 1); + } else { + ZEND_VM_SMART_BRANCH(result, 0); + } +} + +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DEFINED_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_constant *c; + + c = CACHED_PTR(opline->extended_value); + if (EXPECTED(c != NULL)) { + if (!IS_SPECIAL_CACHE_VAL(c)) { +defined_true: + ZEND_VM_SMART_BRANCH_TRUE(); + } else if (EXPECTED(zend_hash_num_elements(EG(zend_constants)) == DECODE_SPECIAL_CACHE_NUM(c))) { +defined_false: + ZEND_VM_SMART_BRANCH_FALSE(); + } + } + if (zend_quick_check_constant(RT_CONSTANT(opline, opline->op1) OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) { + CACHE_PTR(opline->extended_value, ENCODE_SPECIAL_CACHE_NUM(zend_hash_num_elements(EG(zend_constants)))); + goto defined_false; + } else { + goto defined_true; + } +} + static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MATCH_ERROR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -13043,20 +13043,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZE ZEND_VM_RETURN(); } -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_NOT_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1; - - op1 = EX_VAR(opline->op1.var); - if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) { - ZVAL_LONG(EX_VAR(opline->result.var), ~Z_LVAL_P(op1)); - ZEND_VM_NEXT_OPCODE(); - } - - ZEND_VM_TAIL_CALL(zend_bw_not_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1)); -} - static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -15103,6 +15089,20 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMP ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_NOT_SPEC_TMPVARCV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1; + + op1 = EX_VAR(opline->op1.var); + if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) { + ZVAL_LONG(EX_VAR(opline->result.var), ~Z_LVAL_P(op1)); + ZEND_VM_NEXT_OPCODE(); + } + + ZEND_VM_TAIL_CALL(zend_bw_not_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1)); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -15126,32 +15126,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *val; - - val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - if (Z_TYPE_INFO_P(val) == IS_TRUE) { - ZVAL_FALSE(EX_VAR(opline->result.var)); - } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) { - /* The result and op1 can be the same cv zval */ - const uint32_t orig_val_type = Z_TYPE_INFO_P(val); - ZVAL_TRUE(EX_VAR(opline->result.var)); - if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) { - SAVE_OPLINE(); - ZVAL_UNDEFINED_OP1(); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } - } else { - SAVE_OPLINE(); - ZVAL_BOOL(EX_VAR(opline->result.var), !i_zend_is_true(val)); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } - ZEND_VM_NEXT_OPCODE(); -} - static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ECHO_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -15727,42 +15701,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_STRLEN_SPEC_TMPVAR_HANDLER(ZEN ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_TYPE_CHECK_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *value; - int result = 0; - - value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) { -type_check_resource: - if (opline->extended_value != MAY_BE_RESOURCE - || EXPECTED(NULL != zend_rsrc_list_get_rsrc_type(Z_RES_P(value)))) { - result = 1; - } - } else if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && Z_ISREF_P(value)) { - value = Z_REFVAL_P(value); - if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) { - goto type_check_resource; - } - } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { - result = ((1 << IS_NULL) & opline->extended_value) != 0; - SAVE_OPLINE(); - ZVAL_UNDEFINED_OP1(); - if (UNEXPECTED(EG(exception))) { - ZVAL_UNDEF(EX_VAR(opline->result.var)); - HANDLE_EXCEPTION(); - } - } - if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { - SAVE_OPLINE(); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 1); - } else { - ZEND_VM_SMART_BRANCH(result, 0); - } -} - static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { uint32_t fetch_type; @@ -18674,6 +18612,32 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_HAN ZEND_VM_SMART_BRANCH(result, 1); } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *val; + + val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + if (Z_TYPE_INFO_P(val) == IS_TRUE) { + ZVAL_FALSE(EX_VAR(opline->result.var)); + } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) { + /* The result and op1 can be the same cv zval */ + const uint32_t orig_val_type = Z_TYPE_INFO_P(val); + ZVAL_TRUE(EX_VAR(opline->result.var)); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + } else { + SAVE_OPLINE(); + ZVAL_BOOL(EX_VAR(opline->result.var), !i_zend_is_true(val)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + ZEND_VM_NEXT_OPCODE(); +} + static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(ZEND_OPCODE_HANDLER_ARGS_EX int type) { USE_OPLINE @@ -18965,6 +18929,42 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_ ZEND_VM_SMART_BRANCH(result, 1); } +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_TYPE_CHECK_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + int result = 0; + + value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) { +type_check_resource: + if (opline->extended_value != MAY_BE_RESOURCE + || EXPECTED(NULL != zend_rsrc_list_get_rsrc_type(Z_RES_P(value)))) { + result = 1; + } + } else if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && Z_ISREF_P(value)) { + value = Z_REFVAL_P(value); + if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) { + goto type_check_resource; + } + } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { + result = ((1 << IS_NULL) & opline->extended_value) != 0; + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception))) { + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); + } + } + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + SAVE_OPLINE(); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_SMART_BRANCH(result, 1); + } else { + ZEND_VM_SMART_BRANCH(result, 0); + } +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COUNT_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -40339,32 +40339,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(Z ZEND_VM_RETURN(); } -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *val; - - val = EX_VAR(opline->op1.var); - if (Z_TYPE_INFO_P(val) == IS_TRUE) { - ZVAL_FALSE(EX_VAR(opline->result.var)); - } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) { - /* The result and op1 can be the same cv zval */ - const uint32_t orig_val_type = Z_TYPE_INFO_P(val); - ZVAL_TRUE(EX_VAR(opline->result.var)); - if (IS_CV == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) { - SAVE_OPLINE(); - ZVAL_UNDEFINED_OP1(); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } - } else { - SAVE_OPLINE(); - ZVAL_BOOL(EX_VAR(opline->result.var), !i_zend_is_true(val)); - - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } - ZEND_VM_NEXT_OPCODE(); -} - static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_inc_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -41727,42 +41701,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_STRLEN_SPEC_CV_HANDLER(ZEND_OP ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_TYPE_CHECK_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *value; - int result = 0; - - value = EX_VAR(opline->op1.var); - if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) { -type_check_resource: - if (opline->extended_value != MAY_BE_RESOURCE - || EXPECTED(NULL != zend_rsrc_list_get_rsrc_type(Z_RES_P(value)))) { - result = 1; - } - } else if ((IS_CV & (IS_CV|IS_VAR)) && Z_ISREF_P(value)) { - value = Z_REFVAL_P(value); - if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) { - goto type_check_resource; - } - } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { - result = ((1 << IS_NULL) & opline->extended_value) != 0; - SAVE_OPLINE(); - ZVAL_UNDEFINED_OP1(); - if (UNEXPECTED(EG(exception))) { - ZVAL_UNDEF(EX_VAR(opline->result.var)); - HANDLE_EXCEPTION(); - } - } - if (IS_CV & (IS_TMP_VAR|IS_VAR)) { - SAVE_OPLINE(); - - ZEND_VM_SMART_BRANCH(result, 1); - } else { - ZEND_VM_SMART_BRANCH(result, 0); - } -} - static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { uint32_t fetch_type; @@ -49737,6 +49675,32 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_CV_VAR_HANDLER ZEND_VM_SMART_BRANCH(result, 1); } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *val; + + val = EX_VAR(opline->op1.var); + if (Z_TYPE_INFO_P(val) == IS_TRUE) { + ZVAL_FALSE(EX_VAR(opline->result.var)); + } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) { + /* The result and op1 can be the same cv zval */ + const uint32_t orig_val_type = Z_TYPE_INFO_P(val); + ZVAL_TRUE(EX_VAR(opline->result.var)); + if (IS_CV == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + } else { + SAVE_OPLINE(); + ZVAL_BOOL(EX_VAR(opline->result.var), !i_zend_is_true(val)); + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + ZEND_VM_NEXT_OPCODE(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -51330,6 +51294,42 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(Z ZEND_VM_RETURN(); } +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_TYPE_CHECK_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + int result = 0; + + value = EX_VAR(opline->op1.var); + if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) { +type_check_resource: + if (opline->extended_value != MAY_BE_RESOURCE + || EXPECTED(NULL != zend_rsrc_list_get_rsrc_type(Z_RES_P(value)))) { + result = 1; + } + } else if ((IS_CV & (IS_CV|IS_VAR)) && Z_ISREF_P(value)) { + value = Z_REFVAL_P(value); + if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) { + goto type_check_resource; + } + } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { + result = ((1 << IS_NULL) & opline->extended_value) != 0; + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception))) { + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); + } + } + if (IS_CV & (IS_TMP_VAR|IS_VAR)) { + SAVE_OPLINE(); + + ZEND_VM_SMART_BRANCH(result, 1); + } else { + ZEND_VM_SMART_BRANCH(result, 0); + } +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CHECK_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -55464,16 +55464,16 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_POW_SPEC_CV_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_POW_SPEC_CV_CV_LABEL, - (void*)&&ZEND_BW_NOT_SPEC_CONST_LABEL, - (void*)&&ZEND_BW_NOT_SPEC_TMPVARCV_LABEL, - (void*)&&ZEND_BW_NOT_SPEC_TMPVARCV_LABEL, + (void*)&&ZEND_BW_NOT_SPEC_CONST_UNUSED_LABEL, + (void*)&&ZEND_BW_NOT_SPEC_TMPVARCV_UNUSED_LABEL, + (void*)&&ZEND_BW_NOT_SPEC_TMPVARCV_UNUSED_LABEL, (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_BW_NOT_SPEC_TMPVARCV_LABEL, - (void*)&&ZEND_BOOL_NOT_SPEC_CONST_LABEL, - (void*)&&ZEND_BOOL_NOT_SPEC_TMPVAR_LABEL, - (void*)&&ZEND_BOOL_NOT_SPEC_TMPVAR_LABEL, + (void*)&&ZEND_BW_NOT_SPEC_TMPVARCV_UNUSED_LABEL, + (void*)&&ZEND_BOOL_NOT_SPEC_CONST_UNUSED_LABEL, + (void*)&&ZEND_BOOL_NOT_SPEC_TMPVAR_UNUSED_LABEL, + (void*)&&ZEND_BOOL_NOT_SPEC_TMPVAR_UNUSED_LABEL, (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_BOOL_NOT_SPEC_CV_LABEL, + (void*)&&ZEND_BOOL_NOT_SPEC_CV_UNUSED_LABEL, (void*)&&ZEND_BOOL_XOR_SPEC_CONST_CONST_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -57326,12 +57326,12 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_STRLEN_SPEC_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_STRLEN_SPEC_CV_LABEL, - (void*)&&ZEND_DEFINED_SPEC_CONST_LABEL, - (void*)&&ZEND_TYPE_CHECK_SPEC_CONST_LABEL, - (void*)&&ZEND_TYPE_CHECK_SPEC_TMPVAR_LABEL, - (void*)&&ZEND_TYPE_CHECK_SPEC_TMPVAR_LABEL, + (void*)&&ZEND_DEFINED_SPEC_CONST_UNUSED_LABEL, + (void*)&&ZEND_TYPE_CHECK_SPEC_CONST_UNUSED_LABEL, + (void*)&&ZEND_TYPE_CHECK_SPEC_TMPVAR_UNUSED_LABEL, + (void*)&&ZEND_TYPE_CHECK_SPEC_TMPVAR_UNUSED_LABEL, (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_TYPE_CHECK_SPEC_CV_LABEL, + (void*)&&ZEND_TYPE_CHECK_SPEC_CV_UNUSED_LABEL, (void*)&&ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED_LABEL, (void*)&&ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED_LABEL, (void*)&&ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED_LABEL, @@ -57742,7 +57742,7 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED_LABEL, (void*)&&ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST_LABEL, (void*)&&ZEND_INIT_FCALL_OFFSET_SPEC_CONST_LABEL, - (void*)&&ZEND_RECV_NOTYPE_SPEC_LABEL, + (void*)&&ZEND_RECV_NOTYPE_SPEC_UNUSED_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_LABEL, (void*)&&ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_LABEL, @@ -58987,11 +58987,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_SEND_ARRAY_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_SEND_ARRAY_SPEC) HYBRID_BREAK(); - HYBRID_CASE(ZEND_RECV_NOTYPE_SPEC): - VM_TRACE(ZEND_RECV_NOTYPE_SPEC) - ZEND_RECV_NOTYPE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_RECV_NOTYPE_SPEC) - HYBRID_BREAK(); HYBRID_CASE(ZEND_ADD_ARRAY_UNPACK_SPEC): VM_TRACE(ZEND_ADD_ARRAY_UNPACK_SPEC) ZEND_ADD_ARRAY_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -59157,6 +59152,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_RECV_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_RECV_SPEC_UNUSED) HYBRID_BREAK(); + HYBRID_CASE(ZEND_RECV_NOTYPE_SPEC_UNUSED): + VM_TRACE(ZEND_RECV_NOTYPE_SPEC_UNUSED) + ZEND_RECV_NOTYPE_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_RECV_NOTYPE_SPEC_UNUSED) + HYBRID_BREAK(); HYBRID_CASE(ZEND_RECV_VARIADIC_SPEC_UNUSED): VM_TRACE(ZEND_RECV_VARIADIC_SPEC_UNUSED) ZEND_RECV_VARIADIC_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -59177,16 +59177,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_INIT_DYNAMIC_CALL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_INIT_DYNAMIC_CALL_SPEC_CV) HYBRID_BREAK(); - HYBRID_CASE(ZEND_BW_NOT_SPEC_CONST): - VM_TRACE(ZEND_BW_NOT_SPEC_CONST) - ZEND_BW_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_BW_NOT_SPEC_CONST) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_BOOL_NOT_SPEC_CONST): - VM_TRACE(ZEND_BOOL_NOT_SPEC_CONST) - ZEND_BOOL_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_BOOL_NOT_SPEC_CONST) - HYBRID_BREAK(); HYBRID_CASE(ZEND_ECHO_SPEC_CONST): VM_TRACE(ZEND_ECHO_SPEC_CONST) ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -59481,16 +59471,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_STRLEN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_STRLEN_SPEC_CONST) HYBRID_BREAK(); - HYBRID_CASE(ZEND_TYPE_CHECK_SPEC_CONST): - VM_TRACE(ZEND_TYPE_CHECK_SPEC_CONST) - ZEND_TYPE_CHECK_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_TYPE_CHECK_SPEC_CONST) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_DEFINED_SPEC_CONST): - VM_TRACE(ZEND_DEFINED_SPEC_CONST) - ZEND_DEFINED_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_DEFINED_SPEC_CONST) - HYBRID_BREAK(); HYBRID_CASE(ZEND_JMP_FRAMELESS_SPEC_CONST): VM_TRACE(ZEND_JMP_FRAMELESS_SPEC_CONST) ZEND_JMP_FRAMELESS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -59996,6 +59976,16 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_YIELD_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_YIELD_SPEC_CONST_TMPVAR) HYBRID_BREAK(); + HYBRID_CASE(ZEND_BW_NOT_SPEC_CONST_UNUSED): + VM_TRACE(ZEND_BW_NOT_SPEC_CONST_UNUSED) + ZEND_BW_NOT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_BW_NOT_SPEC_CONST_UNUSED) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_BOOL_NOT_SPEC_CONST_UNUSED): + VM_TRACE(ZEND_BOOL_NOT_SPEC_CONST_UNUSED) + ZEND_BOOL_NOT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_BOOL_NOT_SPEC_CONST_UNUSED) + HYBRID_BREAK(); HYBRID_CASE(ZEND_FETCH_R_SPEC_CONST_UNUSED): VM_TRACE(ZEND_FETCH_R_SPEC_CONST_UNUSED) ZEND_FETCH_R_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -60086,6 +60076,16 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_YIELD_SPEC_CONST_UNUSED) HYBRID_BREAK(); + HYBRID_CASE(ZEND_TYPE_CHECK_SPEC_CONST_UNUSED): + VM_TRACE(ZEND_TYPE_CHECK_SPEC_CONST_UNUSED) + ZEND_TYPE_CHECK_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_TYPE_CHECK_SPEC_CONST_UNUSED) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_DEFINED_SPEC_CONST_UNUSED): + VM_TRACE(ZEND_DEFINED_SPEC_CONST_UNUSED) + ZEND_DEFINED_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_DEFINED_SPEC_CONST_UNUSED) + HYBRID_BREAK(); HYBRID_CASE(ZEND_MATCH_ERROR_SPEC_CONST_UNUSED): VM_TRACE(ZEND_MATCH_ERROR_SPEC_CONST_UNUSED) ZEND_MATCH_ERROR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -60221,11 +60221,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_YIELD_SPEC_CONST_CV) HYBRID_BREAK(); - HYBRID_CASE(ZEND_BW_NOT_SPEC_TMPVARCV): - VM_TRACE(ZEND_BW_NOT_SPEC_TMPVARCV) - ZEND_BW_NOT_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_BW_NOT_SPEC_TMPVARCV) - HYBRID_BREAK(); HYBRID_CASE(ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV): VM_TRACE(ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -60776,6 +60771,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) HYBRID_BREAK(); + HYBRID_CASE(ZEND_BW_NOT_SPEC_TMPVARCV_UNUSED): + VM_TRACE(ZEND_BW_NOT_SPEC_TMPVARCV_UNUSED) + ZEND_BW_NOT_SPEC_TMPVARCV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_BW_NOT_SPEC_TMPVARCV_UNUSED) + HYBRID_BREAK(); HYBRID_CASE(ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED): VM_TRACE(ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -60786,11 +60786,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) HYBRID_BREAK(); - HYBRID_CASE(ZEND_BOOL_NOT_SPEC_TMPVAR): - VM_TRACE(ZEND_BOOL_NOT_SPEC_TMPVAR) - ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_BOOL_NOT_SPEC_TMPVAR) - HYBRID_BREAK(); HYBRID_CASE(ZEND_ECHO_SPEC_TMPVAR): VM_TRACE(ZEND_ECHO_SPEC_TMPVAR) ZEND_ECHO_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -60856,11 +60851,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_STRLEN_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_STRLEN_SPEC_TMPVAR) HYBRID_BREAK(); - HYBRID_CASE(ZEND_TYPE_CHECK_SPEC_TMPVAR): - VM_TRACE(ZEND_TYPE_CHECK_SPEC_TMPVAR) - ZEND_TYPE_CHECK_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_TYPE_CHECK_SPEC_TMPVAR) - HYBRID_BREAK(); HYBRID_CASE(ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR): VM_TRACE(ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -61101,6 +61091,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) HYBRID_BREAK(); + HYBRID_CASE(ZEND_BOOL_NOT_SPEC_TMPVAR_UNUSED): + VM_TRACE(ZEND_BOOL_NOT_SPEC_TMPVAR_UNUSED) + ZEND_BOOL_NOT_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_BOOL_NOT_SPEC_TMPVAR_UNUSED) + HYBRID_BREAK(); HYBRID_CASE(ZEND_FETCH_R_SPEC_TMPVAR_UNUSED): VM_TRACE(ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -61151,6 +61146,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) HYBRID_BREAK(); + HYBRID_CASE(ZEND_TYPE_CHECK_SPEC_TMPVAR_UNUSED): + VM_TRACE(ZEND_TYPE_CHECK_SPEC_TMPVAR_UNUSED) + ZEND_TYPE_CHECK_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_TYPE_CHECK_SPEC_TMPVAR_UNUSED) + HYBRID_BREAK(); HYBRID_CASE(ZEND_COUNT_SPEC_TMPVAR_UNUSED): VM_TRACE(ZEND_COUNT_SPEC_TMPVAR_UNUSED) ZEND_COUNT_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -62959,11 +62959,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_YIELD_SPEC_UNUSED_CV) HYBRID_BREAK(); - HYBRID_CASE(ZEND_BOOL_NOT_SPEC_CV): - VM_TRACE(ZEND_BOOL_NOT_SPEC_CV) - ZEND_BOOL_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_BOOL_NOT_SPEC_CV) - HYBRID_BREAK(); HYBRID_CASE(ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED): VM_TRACE(ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED) ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -63178,11 +63173,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_STRLEN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_STRLEN_SPEC_CV) HYBRID_BREAK(); - HYBRID_CASE(ZEND_TYPE_CHECK_SPEC_CV): - VM_TRACE(ZEND_TYPE_CHECK_SPEC_CV) - ZEND_TYPE_CHECK_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_TYPE_CHECK_SPEC_CV) - HYBRID_BREAK(); HYBRID_CASE(ZEND_FETCH_CLASS_NAME_SPEC_CV): VM_TRACE(ZEND_FETCH_CLASS_NAME_SPEC_CV) ZEND_FETCH_CLASS_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -63863,6 +63853,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_INSTANCEOF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_CV_VAR) HYBRID_BREAK(); + HYBRID_CASE(ZEND_BOOL_NOT_SPEC_CV_UNUSED): + VM_TRACE(ZEND_BOOL_NOT_SPEC_CV_UNUSED) + ZEND_BOOL_NOT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_BOOL_NOT_SPEC_CV_UNUSED) + HYBRID_BREAK(); HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED): VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED) ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -64003,6 +63998,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_YIELD_SPEC_CV_UNUSED) HYBRID_BREAK(); + HYBRID_CASE(ZEND_TYPE_CHECK_SPEC_CV_UNUSED): + VM_TRACE(ZEND_TYPE_CHECK_SPEC_CV_UNUSED) + ZEND_TYPE_CHECK_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_TYPE_CHECK_SPEC_CV_UNUSED) + HYBRID_BREAK(); HYBRID_CASE(ZEND_CHECK_VAR_SPEC_CV_UNUSED): VM_TRACE(ZEND_CHECK_VAR_SPEC_CV_UNUSED) ZEND_CHECK_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -64692,16 +64692,16 @@ void zend_vm_init(void) ZEND_POW_SPEC_CV_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_POW_SPEC_CV_CV_HANDLER, - ZEND_BW_NOT_SPEC_CONST_HANDLER, - ZEND_BW_NOT_SPEC_TMPVARCV_HANDLER, - ZEND_BW_NOT_SPEC_TMPVARCV_HANDLER, + ZEND_BW_NOT_SPEC_CONST_UNUSED_HANDLER, + ZEND_BW_NOT_SPEC_TMPVARCV_UNUSED_HANDLER, + ZEND_BW_NOT_SPEC_TMPVARCV_UNUSED_HANDLER, ZEND_NULL_HANDLER, - ZEND_BW_NOT_SPEC_TMPVARCV_HANDLER, - ZEND_BOOL_NOT_SPEC_CONST_HANDLER, - ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER, - ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER, + ZEND_BW_NOT_SPEC_TMPVARCV_UNUSED_HANDLER, + ZEND_BOOL_NOT_SPEC_CONST_UNUSED_HANDLER, + ZEND_BOOL_NOT_SPEC_TMPVAR_UNUSED_HANDLER, + ZEND_BOOL_NOT_SPEC_TMPVAR_UNUSED_HANDLER, ZEND_NULL_HANDLER, - ZEND_BOOL_NOT_SPEC_CV_HANDLER, + ZEND_BOOL_NOT_SPEC_CV_UNUSED_HANDLER, ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, @@ -66554,12 +66554,12 @@ void zend_vm_init(void) ZEND_STRLEN_SPEC_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_STRLEN_SPEC_CV_HANDLER, - ZEND_DEFINED_SPEC_CONST_HANDLER, - ZEND_TYPE_CHECK_SPEC_CONST_HANDLER, - ZEND_TYPE_CHECK_SPEC_TMPVAR_HANDLER, - ZEND_TYPE_CHECK_SPEC_TMPVAR_HANDLER, + ZEND_DEFINED_SPEC_CONST_UNUSED_HANDLER, + ZEND_TYPE_CHECK_SPEC_CONST_UNUSED_HANDLER, + ZEND_TYPE_CHECK_SPEC_TMPVAR_UNUSED_HANDLER, + ZEND_TYPE_CHECK_SPEC_TMPVAR_UNUSED_HANDLER, ZEND_NULL_HANDLER, - ZEND_TYPE_CHECK_SPEC_CV_HANDLER, + ZEND_TYPE_CHECK_SPEC_CV_UNUSED_HANDLER, ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED_HANDLER, ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED_HANDLER, ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED_HANDLER, @@ -66970,7 +66970,7 @@ void zend_vm_init(void) ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED_HANDLER, ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST_HANDLER, ZEND_INIT_FCALL_OFFSET_SPEC_CONST_HANDLER, - ZEND_RECV_NOTYPE_SPEC_HANDLER, + ZEND_RECV_NOTYPE_SPEC_UNUSED_HANDLER, ZEND_NULL_HANDLER, ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_HANDLER, ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_HANDLER, diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h index 33d951141550e..40321dcb91e66 100644 --- a/Zend/zend_vm_handlers.h +++ b/Zend/zend_vm_handlers.h @@ -179,14 +179,14 @@ _(297, ZEND_POW_SPEC_CV_TMPVAR) \ _(298, ZEND_POW_SPEC_CV_TMPVAR) \ _(300, ZEND_POW_SPEC_CV_CV) \ - _(301, ZEND_BW_NOT_SPEC_CONST) \ - _(302, ZEND_BW_NOT_SPEC_TMPVARCV) \ - _(303, ZEND_BW_NOT_SPEC_TMPVARCV) \ - _(305, ZEND_BW_NOT_SPEC_TMPVARCV) \ - _(306, ZEND_BOOL_NOT_SPEC_CONST) \ - _(307, ZEND_BOOL_NOT_SPEC_TMPVAR) \ - _(308, ZEND_BOOL_NOT_SPEC_TMPVAR) \ - _(310, ZEND_BOOL_NOT_SPEC_CV) \ + _(301, ZEND_BW_NOT_SPEC_CONST_UNUSED) \ + _(302, ZEND_BW_NOT_SPEC_TMPVARCV_UNUSED) \ + _(303, ZEND_BW_NOT_SPEC_TMPVARCV_UNUSED) \ + _(305, ZEND_BW_NOT_SPEC_TMPVARCV_UNUSED) \ + _(306, ZEND_BOOL_NOT_SPEC_CONST_UNUSED) \ + _(307, ZEND_BOOL_NOT_SPEC_TMPVAR_UNUSED) \ + _(308, ZEND_BOOL_NOT_SPEC_TMPVAR_UNUSED) \ + _(310, ZEND_BOOL_NOT_SPEC_CV_UNUSED) \ _(311, ZEND_BOOL_XOR_SPEC_CONST_CONST) \ _(316, ZEND_BOOL_XOR_SPEC_TMPVAR_CONST) \ _(317, ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR) \ @@ -1082,11 +1082,11 @@ _(2159, ZEND_STRLEN_SPEC_TMPVAR) \ _(2160, ZEND_STRLEN_SPEC_TMPVAR) \ _(2162, ZEND_STRLEN_SPEC_CV) \ - _(2163, ZEND_DEFINED_SPEC_CONST) \ - _(2164, ZEND_TYPE_CHECK_SPEC_CONST) \ - _(2165, ZEND_TYPE_CHECK_SPEC_TMPVAR) \ - _(2166, ZEND_TYPE_CHECK_SPEC_TMPVAR) \ - _(2168, ZEND_TYPE_CHECK_SPEC_CV) \ + _(2163, ZEND_DEFINED_SPEC_CONST_UNUSED) \ + _(2164, ZEND_TYPE_CHECK_SPEC_CONST_UNUSED) \ + _(2165, ZEND_TYPE_CHECK_SPEC_TMPVAR_UNUSED) \ + _(2166, ZEND_TYPE_CHECK_SPEC_TMPVAR_UNUSED) \ + _(2168, ZEND_TYPE_CHECK_SPEC_CV_UNUSED) \ _(2169, ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED) \ _(2170, ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED) \ _(2171, ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED) \ @@ -1374,7 +1374,7 @@ _(2576, ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED) \ _(2577, ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST) \ _(2578, ZEND_INIT_FCALL_OFFSET_SPEC_CONST) \ - _(2579, ZEND_RECV_NOTYPE_SPEC) \ + _(2579, ZEND_RECV_NOTYPE_SPEC_UNUSED) \ _(2581, ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED) \ _(2582, ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED) \ _(2584, ZEND_COUNT_ARRAY_SPEC_CV_UNUSED) \ diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c index 00ad38baaafeb..e190e341735b0 100644 --- a/Zend/zend_vm_opcodes.c +++ b/Zend/zend_vm_opcodes.c @@ -250,8 +250,8 @@ static uint32_t zend_vm_opcodes_flags[211] = { 0x80000b0b, 0x80000b0b, 0x00000707, - 0x0000000b, - 0x00000007, + 0x0000010b, + 0x00000107, 0x80000707, 0x80000303, 0x80000303, @@ -359,8 +359,8 @@ static uint32_t zend_vm_opcodes_flags[211] = { 0x01000000, 0x00001003, 0x00000007, - 0x00040003, - 0x09000007, + 0x00040103, + 0x09000107, 0x00000103, 0x00002003, 0x03000001, @@ -441,10 +441,10 @@ static uint32_t zend_vm_opcodes_flags[211] = { 0x00000101, 0x00000101, 0x00002001, - 0x00000101, - 0x00000100, - 0x00000000, - 0x00000000, + 0x01000101, + 0x01000100, + 0x01000000, + 0x01000000, 0x01042003, 0x01001103, 0x00000303, From ecf30d879b641238e313642a44c039d8e18dec8d Mon Sep 17 00:00:00 2001 From: Ilija Tovilo Date: Thu, 8 May 2025 01:30:23 +0200 Subject: [PATCH 02/19] Introduce slim ops --- Zend/Optimizer/block_pass.c | 22 +- Zend/Optimizer/dce.c | 3 +- Zend/Optimizer/dfa_pass.c | 22 +- Zend/Optimizer/pass1.c | 5 +- Zend/Optimizer/sccp.c | 15 +- Zend/Optimizer/zend_dump.c | 23 +- Zend/Optimizer/zend_optimizer.c | 257 ++-- Zend/zend.c | 25 +- Zend/zend.h | 2 +- Zend/zend_attributes.c | 13 +- Zend/zend_builtin_functions.c | 24 +- Zend/zend_compile.c | 19 +- Zend/zend_compile.h | 112 +- Zend/zend_exceptions.c | 12 +- Zend/zend_exceptions.h | 4 +- Zend/zend_execute.c | 312 +++-- Zend/zend_execute_API.c | 15 +- Zend/zend_frameless_function.h | 2 +- Zend/zend_gc.c | 4 +- Zend/zend_generators.c | 25 +- Zend/zend_globals.h | 4 +- Zend/zend_object_handlers.c | 9 +- Zend/zend_objects.c | 2 +- Zend/zend_observer.c | 1 + Zend/zend_opcode.c | 129 +- Zend/zend_vm.h | 3 +- Zend/zend_vm_def.h | 356 ++--- Zend/zend_vm_execute.h | 1832 ++++++++++++++----------- Zend/zend_vm_execute.skl | 2 +- Zend/zend_vm_gen.php | 402 ++++-- Zend/zend_vm_opcodes.c | 200 +-- Zend/zend_vm_opcodes.h | 10 +- ext/opcache/ZendAccelerator.c | 22 +- ext/opcache/jit/zend_jit_internal.h | 7 - ext/opcache/jit/zend_jit_vm_helpers.c | 6 +- ext/opcache/zend_file_cache.c | 105 +- ext/opcache/zend_persist.c | 113 +- ext/opcache/zend_persist_calc.c | 3 +- ext/reflection/php_reflection.c | 4 +- ext/zend_test/observer.c | 2 +- main/main.c | 2 +- sapi/phpdbg/phpdbg_utils.c | 2 +- 42 files changed, 2319 insertions(+), 1813 deletions(-) diff --git a/Zend/Optimizer/block_pass.c b/Zend/Optimizer/block_pass.c index 96a0e81f03825..5a3d56419dbc9 100644 --- a/Zend/Optimizer/block_pass.c +++ b/Zend/Optimizer/block_pass.c @@ -306,7 +306,7 @@ static void zend_optimize_block(zend_basic_block *block, zend_op_array *op_array if (src < op_array->opcodes + block->start) { break; } - src->result_type = IS_UNUSED; + SET_UNUSED(src->result); VAR_SOURCE(opline->op1) = NULL; MAKE_NOP(opline); ++(*opt_count); @@ -325,7 +325,7 @@ static void zend_optimize_block(zend_basic_block *block, zend_op_array *op_array src->opcode != ZEND_FETCH_OBJ_R && src->opcode != ZEND_NEW && src->opcode != ZEND_FETCH_THIS) { - src->result_type = IS_UNUSED; + SET_UNUSED(src->result); MAKE_NOP(opline); ++(*opt_count); if (src->opcode == ZEND_QM_ASSIGN) { @@ -413,8 +413,8 @@ static void zend_optimize_block(zend_basic_block *block, zend_op_array *op_array literal_dtor(&ZEND_OP1_LITERAL(opline)); literal_dtor(&ZEND_OP2_LITERAL(opline)); opline->opcode = ZEND_JMP; - opline->op1_type = IS_UNUSED; - opline->op2_type = IS_UNUSED; + SET_UNUSED(opline->op1); + SET_UNUSED(opline->op2); block->successors_count = 1; block->successors[0] = target; } @@ -821,8 +821,7 @@ static void zend_optimize_block(zend_basic_block *block, zend_op_array *op_array opline->opcode = ZEND_CAST; opline->extended_value = IS_STRING; COPY_NODE(opline->op1, opline->op2); - opline->op2_type = IS_UNUSED; - opline->op2.var = 0; + SET_UNUSED(opline->op2); ++(*opt_count); } else if (opline->op2_type == IS_CONST && Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING && @@ -831,8 +830,7 @@ static void zend_optimize_block(zend_basic_block *block, zend_op_array *op_array literal_dtor(&ZEND_OP2_LITERAL(opline)); opline->opcode = ZEND_CAST; opline->extended_value = IS_STRING; - opline->op2_type = IS_UNUSED; - opline->op2.var = 0; + SET_UNUSED(opline->op2); ++(*opt_count); } else if (opline->opcode == ZEND_CONCAT && (opline->op1_type == IS_CONST || @@ -1148,8 +1146,8 @@ static void assemble_code_blocks(zend_cfg *cfg, zend_op_array *op_array, zend_op zend_op *end = opline + len; while (opline < end) { if (opline->opcode == ZEND_FAST_RET && - opline->op2.num != (uint32_t)-1 && - opline->op2.num < (uint32_t)j) { + opline->op2.num != (uint16_t)-1 && + opline->op2.num < (uint16_t)j) { opline->op2.num = map[opline->op2.num]; } opline++; @@ -1606,7 +1604,7 @@ static void zend_t_usage(zend_cfg *cfg, zend_op_array *op_array, zend_bitset use case ZEND_DO_ICALL: case ZEND_DO_UCALL: case ZEND_DO_FCALL_BY_NAME: - opline->result_type = IS_UNUSED; + SET_UNUSED(opline->result); break; case ZEND_POST_INC: case ZEND_POST_DEC: @@ -1615,7 +1613,7 @@ static void zend_t_usage(zend_cfg *cfg, zend_op_array *op_array, zend_bitset use case ZEND_POST_INC_STATIC_PROP: case ZEND_POST_DEC_STATIC_PROP: opline->opcode -= 2; - opline->result_type = IS_UNUSED; + SET_UNUSED(opline->result); break; case ZEND_QM_ASSIGN: case ZEND_BOOL: diff --git a/Zend/Optimizer/dce.c b/Zend/Optimizer/dce.c index a00fd8bc6ad30..e4bf9ad6d5baf 100644 --- a/Zend/Optimizer/dce.c +++ b/Zend/Optimizer/dce.c @@ -377,8 +377,7 @@ static bool try_remove_var_def(context *ctx, int free_var, int use_chain, zend_o case ZEND_YIELD: case ZEND_YIELD_FROM: case ZEND_ASSERT_CHECK: - def_opline->result_type = IS_UNUSED; - def_opline->result.var = 0; + SET_UNUSED(def_opline->result); def_op->result_def = -1; var->definition = -1; return 1; diff --git a/Zend/Optimizer/dfa_pass.c b/Zend/Optimizer/dfa_pass.c index bf85764c93b49..b9817017ab965 100644 --- a/Zend/Optimizer/dfa_pass.c +++ b/Zend/Optimizer/dfa_pass.c @@ -801,7 +801,7 @@ static int zend_dfa_optimize_jmps(zend_op_array *op_array, zend_ssa *ssa) if (ssa->vars[ssa_op->result_def].use_chain < 0 && ssa->vars[ssa_op->result_def].phi_use_chain == NULL) { opline->opcode = ZEND_JMPZ; - opline->result_type = IS_UNUSED; + SET_UNUSED(opline->result); zend_ssa_remove_result_def(ssa, ssa_op); goto optimize_jmpz; } else if (opline->op1_type == IS_CONST) { @@ -815,7 +815,7 @@ static int zend_dfa_optimize_jmps(zend_op_array *op_array, zend_ssa *ssa) if (ssa->vars[ssa_op->result_def].use_chain < 0 && ssa->vars[ssa_op->result_def].phi_use_chain == NULL) { opline->opcode = ZEND_JMPNZ; - opline->result_type = IS_UNUSED; + SET_UNUSED(opline->result); zend_ssa_remove_result_def(ssa, ssa_op); goto optimize_jmpnz; } else if (opline->op1_type == IS_CONST) { @@ -829,7 +829,7 @@ static int zend_dfa_optimize_jmps(zend_op_array *op_array, zend_ssa *ssa) if (ssa->vars[ssa_op->result_def].use_chain < 0 && ssa->vars[ssa_op->result_def].phi_use_chain == NULL) { opline->opcode = ZEND_JMPNZ; - opline->result_type = IS_UNUSED; + SET_UNUSED(opline->result); zend_ssa_remove_result_def(ssa, ssa_op); goto optimize_jmpnz; } else if (opline->op1_type == IS_CONST) { @@ -855,7 +855,7 @@ static int zend_dfa_optimize_jmps(zend_op_array *op_array, zend_ssa *ssa) goto optimize_nop; } else { opline->opcode = ZEND_JMP; - opline->result_type = IS_UNUSED; + SET_UNUSED(opline->result); zend_ssa_remove_result_def(ssa, ssa_op); COPY_NODE(opline->op1, opline->op2); take_successor_0(ssa, block_num, block); @@ -871,7 +871,7 @@ static int zend_dfa_optimize_jmps(zend_op_array *op_array, zend_ssa *ssa) && var->use_chain < 0 && var->phi_use_chain == NULL) { if (Z_TYPE_P(CT_CONSTANT_EX(op_array, opline->op1.constant)) == IS_NULL) { opline->opcode = ZEND_JMP; - opline->result_type = IS_UNUSED; + SET_UNUSED(opline->result); zend_ssa_remove_result_def(ssa, ssa_op); COPY_NODE(opline->op1, opline->op2); take_successor_0(ssa, block_num, block); @@ -1000,8 +1000,7 @@ static bool zend_dfa_try_to_replace_result(zend_op_array *op_array, zend_ssa *ss ssa->vars[result_var].use_chain = -1; ssa->ops[def].result_def = -1; - op_array->opcodes[def].result_type = IS_UNUSED; - op_array->opcodes[def].result.var = 0; + SET_UNUSED(op_array->opcodes[def].result); if (ssa->ops[use].op1_use == result_var) { ssa->ops[use].op1_use = cv_var; @@ -1167,8 +1166,7 @@ void zend_dfa_optimize_op_array(zend_op_array *op_array, zend_optimizer_ctx *ctx opline->opcode = ZEND_QM_ASSIGN; opline->op1_type = opline->op2_type; opline->op1.var = opline->op2.var; - opline->op2_type = IS_UNUSED; - opline->op2.num = 0; + SET_UNUSED(opline->op2); ssa->ops[op_1].op1_use = ssa->ops[op_1].op2_use; ssa->ops[op_1].op1_use_chain = ssa->ops[op_1].op2_use_chain; ssa->ops[op_1].op2_use = -1; @@ -1216,8 +1214,7 @@ void zend_dfa_optimize_op_array(zend_op_array *op_array, zend_optimizer_ctx *ctx // op_1: #v.? = ADD #?.? [double,long], 0 => #v.? = QM_ASSIGN #?.? opline->opcode = ZEND_QM_ASSIGN; - opline->op2_type = IS_UNUSED; - opline->op2.num = 0; + SET_UNUSED(opline->op2); } } else if (opline->opcode == ZEND_MUL && (OP1_INFO() & ((MAY_BE_ANY|MAY_BE_UNDEF)-(MAY_BE_LONG|MAY_BE_DOUBLE))) == 0) { @@ -1587,8 +1584,7 @@ void zend_dfa_optimize_op_array(zend_op_array *op_array, zend_optimizer_ctx *ctx opline->result.var = opline->op1.var; opline->op1_type = opline->op2_type; opline->op1.var = opline->op2.var; - opline->op2_type = IS_UNUSED; - opline->op2.var = 0; + SET_UNUSED(opline->op2); opline->opcode = ZEND_QM_ASSIGN; } } diff --git a/Zend/Optimizer/pass1.c b/Zend/Optimizer/pass1.c index fe92db583fcd9..3d537af59d29a 100644 --- a/Zend/Optimizer/pass1.c +++ b/Zend/Optimizer/pass1.c @@ -236,10 +236,9 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx) opline->opcode = ZEND_DECLARE_CONST; opline->op1_type = IS_CONST; opline->op2_type = IS_CONST; - opline->result_type = IS_UNUSED; + SET_UNUSED(opline->result); opline->op1.constant = send1_opline->op1.constant; opline->op2.constant = send2_opline->op1.constant; - opline->result.num = 0; literal_dtor(&ZEND_OP2_LITERAL(init_opline)); MAKE_NOP(init_opline); @@ -321,7 +320,7 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx) should_jmp = !should_jmp; } literal_dtor(&ZEND_OP1_LITERAL(opline)); - opline->op1_type = IS_UNUSED; + SET_UNUSED(opline->op1); if (should_jmp) { opline->opcode = ZEND_JMP; COPY_NODE(opline->op1, opline->op2); diff --git a/Zend/Optimizer/sccp.c b/Zend/Optimizer/sccp.c index c86672a8dd248..16b077a9a543a 100644 --- a/Zend/Optimizer/sccp.c +++ b/Zend/Optimizer/sccp.c @@ -804,14 +804,15 @@ static inline zend_result ct_eval_func_call_ex( zend_execute_data *prev_execute_data = EG(current_execute_data); zend_execute_data *execute_data, dummy_frame; - zend_op dummy_opline; + zend_slim_op dummy_opline; /* Add a dummy frame to get the correct strict_types behavior. */ memset(&dummy_frame, 0, sizeof(zend_execute_data)); - memset(&dummy_opline, 0, sizeof(zend_op)); + memset(&dummy_opline, 0, sizeof(zend_slim_op)); dummy_frame.func = (zend_function *) op_array; dummy_frame.opline = &dummy_opline; - dummy_opline.opcode = ZEND_DO_FCALL; + // FIXME: Do we need this? + // dummy_opline.opcode = ZEND_DO_FCALL; execute_data = safe_emalloc(num_args, sizeof(zval), ZEND_CALL_FRAME_SLOT * sizeof(zval)); memset(execute_data, 0, sizeof(zend_execute_data)); @@ -2134,7 +2135,7 @@ static int try_remove_definition(sccp_ctx *ctx, int var_num, zend_ssa_var *var, if (opline->opcode == ZEND_ASSIGN) { /* We can't drop the ASSIGN, but we can remove the result. */ if (var->use_chain < 0 && var->phi_use_chain == NULL) { - opline->result_type = IS_UNUSED; + SET_UNUSED(opline->result); zend_ssa_remove_result_def(ssa, ssa_op); } return 0; @@ -2165,7 +2166,7 @@ static int try_remove_definition(sccp_ctx *ctx, int var_num, zend_ssa_var *var, case ZEND_YIELD: case ZEND_YIELD_FROM: case ZEND_ASSERT_CHECK: - opline->result_type = IS_UNUSED; + SET_UNUSED(opline->result); zend_ssa_remove_result_def(ssa, ssa_op); break; default: @@ -2237,7 +2238,7 @@ static int try_remove_definition(sccp_ctx *ctx, int var_num, zend_ssa_var *var, * operand, based on type inference information. Make sure the operand is * freed and leave further cleanup to DCE. */ opline->opcode = ZEND_FREE; - opline->result_type = IS_UNUSED; + SET_UNUSED(opline->result); removed_ops++; } else { return 0; @@ -2305,7 +2306,7 @@ static int try_remove_definition(sccp_ctx *ctx, int var_num, zend_ssa_var *var, if (ssa->vars[ssa_op->result_def].use_chain < 0 && ssa->vars[ssa_op->result_def].phi_use_chain == NULL) { zend_ssa_remove_result_def(ssa, ssa_op); - opline->result_type = IS_UNUSED; + SET_UNUSED(opline->result); } else if (opline->opcode != ZEND_PRE_INC && opline->opcode != ZEND_PRE_DEC) { /* op1_def and result_def are different */ diff --git a/Zend/Optimizer/zend_dump.c b/Zend/Optimizer/zend_dump.c index 4e46b38a8eb5e..88da9e22df980 100644 --- a/Zend/Optimizer/zend_dump.c +++ b/Zend/Optimizer/zend_dump.c @@ -25,6 +25,19 @@ #include "zend_dump.h" #include "zend_smart_str.h" +#define SOP_TO_WOP_OFFSET(node) \ + (uint16_t)((int16_t)(node) / (uint16_t)sizeof(zend_slim_op) * (uint16_t)sizeof(zend_op)) + +#define CRT_OP_JMP_ADDR(op_array, opline, op) \ + ((((op_array)->fn_flags) & ZEND_ACC_DONE_PASS_TWO) \ + ? ((zend_op*)(((char*)(opline)) + (int16_t)SOP_TO_WOP_OFFSET((op).num))) \ + : OP_JMP_ADDR(opline, op)) + +#define CRT_OFFSET_TO_OPLINE_NUM(op_array, base, offset) \ + ((((op_array)->fn_flags) & ZEND_ACC_DONE_PASS_TWO) \ + ? ((zend_op*)(((char*)(base)) + (int16_t)SOP_TO_WOP_OFFSET(offset))) - op_array->opcodes \ + : ZEND_OFFSET_TO_OPLINE(base, offset) - op_array->opcodes) + void zend_dump_ht(HashTable *ht) { zend_ulong index; @@ -133,7 +146,7 @@ static void zend_dump_unused_op(const zend_op *opline, znode_op op, uint32_t fla if (ZEND_VM_OP_NUM == (flags & ZEND_VM_OP_MASK)) { fprintf(stderr, " %u", op.num); } else if (ZEND_VM_OP_TRY_CATCH == (flags & ZEND_VM_OP_MASK)) { - if (op.num != (uint32_t)-1) { + if (op.num != (uint16_t)-1) { fprintf(stderr, " try-catch(%u)", op.num); } } else if (ZEND_VM_OP_THIS == (flags & ZEND_VM_OP_MASK)) { @@ -662,7 +675,7 @@ ZEND_API void zend_dump_op(const zend_op_array *op_array, const zend_basic_block if (b) { fprintf(stderr, " BB%d", b->successors[n++]); } else { - fprintf(stderr, " %04u", (uint32_t)(OP_JMP_ADDR(opline, opline->op1) - op_array->opcodes)); + fprintf(stderr, " %04u", (uint32_t)(CRT_OP_JMP_ADDR(op_array, opline, opline->op1) - op_array->opcodes)); } } else { zend_dump_unused_op(opline, opline->op1, op1_flags); @@ -689,7 +702,7 @@ ZEND_API void zend_dump_op(const zend_op_array *op_array, const zend_basic_block if (b) { fprintf(stderr, " BB%d,", b->successors[n++]); } else { - fprintf(stderr, " %04u,", (uint32_t)ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, Z_LVAL_P(zv))); + fprintf(stderr, " %04u,", (uint32_t)CRT_OFFSET_TO_OPLINE_NUM(op_array, opline, Z_LVAL_P(zv))); } } ZEND_HASH_FOREACH_END(); fprintf(stderr, " default:"); @@ -724,7 +737,7 @@ ZEND_API void zend_dump_op(const zend_op_array *op_array, const zend_basic_block if (b) { fprintf(stderr, " BB%d", b->successors[n++]); } else { - fprintf(stderr, " %04u", (uint32_t)(OP_JMP_ADDR(opline, opline->op2) - op_array->opcodes)); + fprintf(stderr, " %04u", (uint32_t)(CRT_OP_JMP_ADDR(op_array, opline, opline->op2) - op_array->opcodes)); } } } else { @@ -736,7 +749,7 @@ ZEND_API void zend_dump_op(const zend_op_array *op_array, const zend_basic_block if (b) { fprintf(stderr, " BB%d", b->successors[n++]); } else { - fprintf(stderr, " %04u", (uint32_t)ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, opline->extended_value)); + fprintf(stderr, " %04u", (uint32_t)CRT_OFFSET_TO_OPLINE_NUM(op_array, opline, opline->extended_value)); } } if (opline->result_type == IS_CONST) { diff --git a/Zend/Optimizer/zend_optimizer.c b/Zend/Optimizer/zend_optimizer.c index 1c58d6b7372fb..3c629f27ea68c 100644 --- a/Zend/Optimizer/zend_optimizer.c +++ b/Zend/Optimizer/zend_optimizer.c @@ -1159,6 +1159,14 @@ static void zend_optimize(zend_op_array *op_array, } } +#define SOP_TO_WOP_OFFSET(node) do { \ + (node) = (uint16_t)((int16_t)(node) / (uint16_t)sizeof(zend_slim_op) * (uint16_t)sizeof(zend_op)); \ + } while (0) + +#define WOP_TO_SOP_OFFSET(node) do { \ + (node) = (uint16_t)((int16_t)(node) / (uint16_t)sizeof(zend_op) * (uint16_t)sizeof(zend_slim_op)); \ + } while (0) + static void zend_revert_pass_two(zend_op_array *op_array) { zend_op *opline, *end; @@ -1176,88 +1184,98 @@ static void zend_revert_pass_two(zend_op_array *op_array) } /* reset smart branch flags IS_SMART_BRANCH_JMP[N]Z */ opline->result_type &= (IS_TMP_VAR|IS_VAR|IS_CV|IS_CONST); + + /* zend_op stores offset for zend_slim_op, adjust for optimizer. */ + uint32_t op_flags = zend_get_opcode_flags(opline->opcode); + if (ZEND_VM_OP1_FLAGS(op_flags) == ZEND_VM_OP_JMP_ADDR) { + SOP_TO_WOP_OFFSET(opline->op1.jmp_offset); + } + if (ZEND_VM_OP2_FLAGS(op_flags) == ZEND_VM_OP_JMP_ADDR) { + SOP_TO_WOP_OFFSET(opline->op2.jmp_offset); + } + if ((op_flags & ZEND_VM_EXT_MASK) == ZEND_VM_EXT_JMP_ADDR) { + SOP_TO_WOP_OFFSET(opline->extended_value); + } + switch (opline->opcode) { + case ZEND_SWITCH_LONG: + case ZEND_SWITCH_STRING: + case ZEND_MATCH: + { + HashTable *jumptable = Z_ARRVAL_P(CT_CONSTANT_EX(op_array, opline->op2.constant)); + ZEND_HASH_FOREACH_VAL(jumptable, zval *zv) { + SOP_TO_WOP_OFFSET(Z_LVAL_P(zv)); + } ZEND_HASH_FOREACH_END(); + + break; + } + } + opline++; } -#if !ZEND_USE_ABS_CONST_ADDR if (op_array->literals) { zval *literals = emalloc(sizeof(zval) * op_array->last_literal); memcpy(literals, op_array->literals, sizeof(zval) * op_array->last_literal); op_array->literals = literals; } -#endif op_array->fn_flags &= ~ZEND_ACC_DONE_PASS_TWO; } +static void zend_restore_sop_offset(zend_op_array *op_array, zend_op *opline) +{ + /* Restore zend_op to store zend_slim_op offsets. */ + uint32_t op_flags = zend_get_opcode_flags(opline->opcode); + if (ZEND_VM_OP1_FLAGS(op_flags) == ZEND_VM_OP_JMP_ADDR) { + WOP_TO_SOP_OFFSET(opline->op1.jmp_offset); + } + if (ZEND_VM_OP2_FLAGS(op_flags) == ZEND_VM_OP_JMP_ADDR) { + WOP_TO_SOP_OFFSET(opline->op2.jmp_offset); + } + if ((op_flags & ZEND_VM_EXT_MASK) == ZEND_VM_EXT_JMP_ADDR) { + WOP_TO_SOP_OFFSET(opline->extended_value); + } + switch (opline->opcode) { + case ZEND_SWITCH_LONG: + case ZEND_SWITCH_STRING: + case ZEND_MATCH: + { + HashTable *jumptable = Z_ARRVAL_P(CT_CONSTANT_EX(op_array, opline->op2.constant)); + ZEND_HASH_FOREACH_VAL(jumptable, zval *zv) { + WOP_TO_SOP_OFFSET(Z_LVAL_P(zv)); + } ZEND_HASH_FOREACH_END(); + + break; + } + } +} + static void zend_redo_pass_two(zend_op_array *op_array) { zend_op *opline, *end; -#if ZEND_USE_ABS_JMP_ADDR && !ZEND_USE_ABS_CONST_ADDR - zend_op *old_opcodes = op_array->opcodes; -#endif ZEND_ASSERT((op_array->fn_flags & ZEND_ACC_DONE_PASS_TWO) == 0); -#if !ZEND_USE_ABS_CONST_ADDR + op_array->opcodes = (zend_op *) erealloc(op_array->opcodes, + ZEND_MM_ALIGNED_SIZE_EX(sizeof(zend_op) * op_array->last, 16) + + ZEND_MM_ALIGNED_SIZE_EX(sizeof(zend_slim_op) * op_array->last, 16) + + sizeof(zval) * op_array->last_literal); + op_array->slim_opcodes = (zend_slim_op*)(((char*)op_array->opcodes) + ZEND_MM_ALIGNED_SIZE_EX(sizeof(zend_op) * op_array->last, 16)); if (op_array->last_literal) { - op_array->opcodes = (zend_op *) erealloc(op_array->opcodes, - ZEND_MM_ALIGNED_SIZE_EX(sizeof(zend_op) * op_array->last, 16) + - sizeof(zval) * op_array->last_literal); - memcpy(((char*)op_array->opcodes) + ZEND_MM_ALIGNED_SIZE_EX(sizeof(zend_op) * op_array->last, 16), - op_array->literals, sizeof(zval) * op_array->last_literal); + zval *literals = op_array->literals; + op_array->literals = (zval*)(((char*)op_array->slim_opcodes) + ZEND_MM_ALIGNED_SIZE_EX(sizeof(zend_slim_op) * op_array->last, 16)); + memcpy(op_array->literals, literals, sizeof(zval) * op_array->last_literal); + efree(literals); + } else if (op_array->literals) { efree(op_array->literals); - op_array->literals = (zval*)(((char*)op_array->opcodes) + ZEND_MM_ALIGNED_SIZE_EX(sizeof(zend_op) * op_array->last, 16)); - } else { - if (op_array->literals) { - efree(op_array->literals); - } op_array->literals = NULL; } -#endif opline = op_array->opcodes; end = opline + op_array->last; + zend_slim_op *slim_op = op_array->slim_opcodes; while (opline < end) { - if (opline->op1_type == IS_CONST) { - ZEND_PASS_TWO_UPDATE_CONSTANT(op_array, opline, opline->op1); - } - if (opline->op2_type == IS_CONST) { - ZEND_PASS_TWO_UPDATE_CONSTANT(op_array, opline, opline->op2); - } /* fix jumps to point to new array */ switch (opline->opcode) { -#if ZEND_USE_ABS_JMP_ADDR && !ZEND_USE_ABS_CONST_ADDR - case ZEND_JMP: - case ZEND_FAST_CALL: - opline->op1.jmp_addr = &op_array->opcodes[opline->op1.jmp_addr - old_opcodes]; - break; - case ZEND_JMPZ: - case ZEND_JMPNZ: - case ZEND_JMPZ_EX: - case ZEND_JMPNZ_EX: - case ZEND_JMP_SET: - case ZEND_COALESCE: - case ZEND_FE_RESET_R: - case ZEND_FE_RESET_RW: - case ZEND_ASSERT_CHECK: - case ZEND_JMP_NULL: - case ZEND_BIND_INIT_STATIC_OR_JMP: - case ZEND_JMP_FRAMELESS: - opline->op2.jmp_addr = &op_array->opcodes[opline->op2.jmp_addr - old_opcodes]; - break; - case ZEND_CATCH: - if (!(opline->extended_value & ZEND_LAST_CATCH)) { - opline->op2.jmp_addr = &op_array->opcodes[opline->op2.jmp_addr - old_opcodes]; - } - break; - case ZEND_FE_FETCH_R: - case ZEND_FE_FETCH_RW: - case ZEND_SWITCH_LONG: - case ZEND_SWITCH_STRING: - case ZEND_MATCH: - /* relative extended_value don't have to be changed */ - break; -#endif case ZEND_IS_IDENTICAL: case ZEND_IS_NOT_IDENTICAL: case ZEND_IS_EQUAL: @@ -1292,8 +1310,40 @@ static void zend_redo_pass_two(zend_op_array *op_array) } break; } + + zend_restore_sop_offset(op_array, opline); + + slim_op->op1 = opline->op1; + slim_op->op2 = opline->op2; + slim_op->result = opline->result; + + if (opline->op1_type == IS_CONST) { + ZEND_PASS_TWO_UPDATE_CONSTANT(op_array, slim_op, slim_op->op1); + ZEND_PASS_TWO_UPDATE_CONSTANT(op_array, opline, opline->op1); + } + if (opline->op2_type == IS_CONST) { + ZEND_PASS_TWO_UPDATE_CONSTANT(op_array, slim_op, slim_op->op2); + ZEND_PASS_TWO_UPDATE_CONSTANT(op_array, opline, opline->op2); + } + + uint8_t prev_op1_type = opline->op1_type; ZEND_VM_SET_OPCODE_HANDLER(opline); + + /* Check if operands were swapped. */ + if (opline->op1_type != prev_op1_type) { + znode_op tmp = slim_op->op1; + slim_op->op1 = slim_op->op2; + slim_op->op2 = tmp; + } + + slim_op->handler = opline->handler; + slim_op->result = opline->result; + slim_op->extended_value = opline->extended_value; + + zend_setup_quick_op_flags(opline, slim_op); + opline++; + slim_op++; } op_array->fn_flags |= ZEND_ACC_DONE_PASS_TWO; @@ -1302,31 +1352,27 @@ static void zend_redo_pass_two(zend_op_array *op_array) static void zend_redo_pass_two_ex(zend_op_array *op_array, zend_ssa *ssa) { zend_op *opline, *end; -#if ZEND_USE_ABS_JMP_ADDR && !ZEND_USE_ABS_CONST_ADDR - zend_op *old_opcodes = op_array->opcodes; -#endif ZEND_ASSERT((op_array->fn_flags & ZEND_ACC_DONE_PASS_TWO) == 0); -#if !ZEND_USE_ABS_CONST_ADDR + op_array->opcodes = (zend_op *) erealloc(op_array->opcodes, + ZEND_MM_ALIGNED_SIZE_EX(sizeof(zend_op) * op_array->last, 16) + + ZEND_MM_ALIGNED_SIZE_EX(sizeof(zend_slim_op) * op_array->last, 16) + + sizeof(zval) * op_array->last_literal); + op_array->slim_opcodes = (zend_slim_op*)(((char*)op_array->opcodes) + ZEND_MM_ALIGNED_SIZE_EX(sizeof(zend_op) * op_array->last, 16)); if (op_array->last_literal) { - op_array->opcodes = (zend_op *) erealloc(op_array->opcodes, - ZEND_MM_ALIGNED_SIZE_EX(sizeof(zend_op) * op_array->last, 16) + - sizeof(zval) * op_array->last_literal); - memcpy(((char*)op_array->opcodes) + ZEND_MM_ALIGNED_SIZE_EX(sizeof(zend_op) * op_array->last, 16), - op_array->literals, sizeof(zval) * op_array->last_literal); + zval *literals = op_array->literals; + op_array->literals = (zval*)(((char*)op_array->slim_opcodes) + ZEND_MM_ALIGNED_SIZE_EX(sizeof(zend_slim_op) * op_array->last, 16)); + memcpy(op_array->literals, literals, sizeof(zval) * op_array->last_literal); + efree(literals); + } else if (op_array->literals) { efree(op_array->literals); - op_array->literals = (zval*)(((char*)op_array->opcodes) + ZEND_MM_ALIGNED_SIZE_EX(sizeof(zend_op) * op_array->last, 16)); - } else { - if (op_array->literals) { - efree(op_array->literals); - } op_array->literals = NULL; } -#endif opline = op_array->opcodes; end = opline + op_array->last; + zend_slim_op *slim_op = op_array->slim_opcodes; while (opline < end) { zend_ssa_op *ssa_op = &ssa->ops[opline - op_array->opcodes]; uint32_t op1_info = opline->op1_type == IS_UNUSED ? 0 : (OP1_INFO() & (MAY_BE_UNDEF|MAY_BE_ANY|MAY_BE_REF|MAY_BE_ARRAY_OF_ANY|MAY_BE_ARRAY_KEY_ANY)); @@ -1339,47 +1385,8 @@ static void zend_redo_pass_two_ex(zend_op_array *op_array, zend_ssa *ssa) ((ssa->ops[opline - op_array->opcodes].op1_def >= 0) ? (OP1_DEF_INFO() & (MAY_BE_UNDEF|MAY_BE_ANY|MAY_BE_REF|MAY_BE_ARRAY_OF_ANY|MAY_BE_ARRAY_KEY_ANY)) : MAY_BE_ANY) : (opline->result_type == IS_UNUSED ? 0 : (RES_INFO() & (MAY_BE_UNDEF|MAY_BE_ANY|MAY_BE_REF|MAY_BE_ARRAY_OF_ANY|MAY_BE_ARRAY_KEY_ANY))); - if (opline->op1_type == IS_CONST) { - ZEND_PASS_TWO_UPDATE_CONSTANT(op_array, opline, opline->op1); - } - if (opline->op2_type == IS_CONST) { - ZEND_PASS_TWO_UPDATE_CONSTANT(op_array, opline, opline->op2); - } - /* fix jumps to point to new array */ switch (opline->opcode) { -#if ZEND_USE_ABS_JMP_ADDR && !ZEND_USE_ABS_CONST_ADDR - case ZEND_JMP: - case ZEND_FAST_CALL: - opline->op1.jmp_addr = &op_array->opcodes[opline->op1.jmp_addr - old_opcodes]; - break; - case ZEND_JMPZ: - case ZEND_JMPNZ: - case ZEND_JMPZ_EX: - case ZEND_JMPNZ_EX: - case ZEND_JMP_SET: - case ZEND_COALESCE: - case ZEND_FE_RESET_R: - case ZEND_FE_RESET_RW: - case ZEND_ASSERT_CHECK: - case ZEND_JMP_NULL: - case ZEND_BIND_INIT_STATIC_OR_JMP: - case ZEND_JMP_FRAMELESS: - opline->op2.jmp_addr = &op_array->opcodes[opline->op2.jmp_addr - old_opcodes]; - break; - case ZEND_CATCH: - if (!(opline->extended_value & ZEND_LAST_CATCH)) { - opline->op2.jmp_addr = &op_array->opcodes[opline->op2.jmp_addr - old_opcodes]; - } - break; - case ZEND_FE_FETCH_R: - case ZEND_FE_FETCH_RW: - case ZEND_SWITCH_LONG: - case ZEND_SWITCH_STRING: - case ZEND_MATCH: - /* relative extended_value don't have to be changed */ - break; -#endif case ZEND_IS_IDENTICAL: case ZEND_IS_NOT_IDENTICAL: case ZEND_IS_EQUAL: @@ -1414,6 +1421,22 @@ static void zend_redo_pass_two_ex(zend_op_array *op_array, zend_ssa *ssa) } break; } + + zend_restore_sop_offset(op_array, opline); + + slim_op->op1 = opline->op1; + slim_op->op2 = opline->op2; + slim_op->result = opline->result; + + if (opline->op1_type == IS_CONST) { + ZEND_PASS_TWO_UPDATE_CONSTANT(op_array, slim_op, slim_op->op1); + ZEND_PASS_TWO_UPDATE_CONSTANT(op_array, opline, opline->op1); + } + if (opline->op2_type == IS_CONST) { + ZEND_PASS_TWO_UPDATE_CONSTANT(op_array, slim_op, slim_op->op2); + ZEND_PASS_TWO_UPDATE_CONSTANT(op_array, opline, opline->op2); + } + #ifdef ZEND_VERIFY_TYPE_INFERENCE if (ssa_op->op1_use >= 0) { opline->op1_use_type = ssa->var_info[ssa_op->op1_use].type; @@ -1434,8 +1457,24 @@ static void zend_redo_pass_two_ex(zend_op_array *op_array, zend_ssa *ssa) opline->result_def_type = ssa->var_info[ssa_op->result_def].type; } #endif + uint8_t prev_op1_type = opline->op1_type; zend_vm_set_opcode_handler_ex(opline, op1_info, op2_info, res_info); + + /* Check if operands were swapped. */ + if (opline->op1_type != prev_op1_type) { + znode_op tmp = slim_op->op1; + slim_op->op1 = slim_op->op2; + slim_op->op2 = tmp; + } + + slim_op->handler = opline->handler; + slim_op->result = opline->result; + slim_op->extended_value = opline->extended_value; + + zend_setup_quick_op_flags(opline, slim_op); + opline++; + slim_op++; } op_array->fn_flags |= ZEND_ACC_DONE_PASS_TWO; diff --git a/Zend/zend.c b/Zend/zend.c index 2d8a0f455f8b4..2726567eba83f 100644 --- a/Zend/zend.c +++ b/Zend/zend.c @@ -679,6 +679,11 @@ static void zend_init_exception_op(void) /* {{{ */ ZEND_VM_SET_OPCODE_HANDLER(EG(exception_op)+1); EG(exception_op)[2].opcode = ZEND_HANDLE_EXCEPTION; ZEND_VM_SET_OPCODE_HANDLER(EG(exception_op)+2); + + memset(EG(exception_slim_op), 0, sizeof(EG(exception_slim_op))); + EG(exception_slim_op)[0].handler = EG(exception_op)[0].handler; + EG(exception_slim_op)[1].handler = EG(exception_op)[1].handler; + EG(exception_slim_op)[2].handler = EG(exception_op)[2].handler; } /* }}} */ @@ -687,6 +692,9 @@ static void zend_init_call_trampoline_op(void) /* {{{ */ memset(&EG(call_trampoline_op), 0, sizeof(EG(call_trampoline_op))); EG(call_trampoline_op).opcode = ZEND_CALL_TRAMPOLINE; ZEND_VM_SET_OPCODE_HANDLER(&EG(call_trampoline_op)); + + memset(&EG(call_trampoline_sop), 0, sizeof(EG(call_trampoline_sop))); + EG(call_trampoline_sop).handler = EG(call_trampoline_op).handler; } /* }}} */ @@ -1473,7 +1481,7 @@ ZEND_API ZEND_COLD void zend_error_zstr_at( /* Report about uncaught exception in case of fatal errors */ if (EG(exception)) { zend_execute_data *ex; - const zend_op *opline; + const zend_slim_op *opline; if (type & E_FATAL_ERRORS) { ex = EG(current_execute_data); @@ -1481,7 +1489,7 @@ ZEND_API ZEND_COLD void zend_error_zstr_at( while (ex && (!ex->func || !ZEND_USER_CODE(ex->func->type))) { ex = ex->prev_execute_data; } - if (ex && ex->opline->opcode == ZEND_HANDLE_EXCEPTION && + if (ex && ex->opline == EG(exception_slim_op) && EG(opline_before_exception)) { opline = EG(opline_before_exception); } @@ -1587,12 +1595,13 @@ ZEND_API ZEND_COLD void zend_error_zstr_at( if (type == E_PARSE) { /* eval() errors do not affect exit_status */ - if (!(EG(current_execute_data) && - EG(current_execute_data)->func && - ZEND_USER_CODE(EG(current_execute_data)->func->type) && - EG(current_execute_data)->opline->opcode == ZEND_INCLUDE_OR_EVAL && - EG(current_execute_data)->opline->extended_value == ZEND_EVAL)) { - EG(exit_status) = 255; + if (!(EG(current_execute_data) + && EG(current_execute_data)->func + && ZEND_USER_CODE(EG(current_execute_data)->func->type))) { + zend_op *opline = Z_WOP; + if (opline->opcode == ZEND_INCLUDE_OR_EVAL && opline->extended_value == ZEND_EVAL) { + EG(exit_status) = 255; + } } } } diff --git a/Zend/zend.h b/Zend/zend.h index 0cf1faeb653fe..6576a78ad08ac 100644 --- a/Zend/zend.h +++ b/Zend/zend.h @@ -52,7 +52,7 @@ #define USED_RET() \ (!EX(prev_execute_data) || \ !ZEND_USER_CODE(EX(prev_execute_data)->func->common.type) || \ - (EX(prev_execute_data)->opline->result_type != IS_UNUSED)) + (Z_WOP_FROM_EX(EX(prev_execute_data))->result_type != IS_UNUSED)) #ifdef ZEND_ENABLE_STATIC_TSRMLS_CACHE #define ZEND_TSRMG TSRMG_STATIC diff --git a/Zend/zend_attributes.c b/Zend/zend_attributes.c index c3633801be83e..2744e5383c354 100644 --- a/Zend/zend_attributes.c +++ b/Zend/zend_attributes.c @@ -294,12 +294,14 @@ ZEND_API zend_result zend_get_attribute_object(zval *obj, zend_class_entry *attr * from where it occurs in the code. */ zend_function dummy_func; zend_op *opline; + zend_slim_op *sop; memset(&dummy_func, 0, sizeof(zend_function)); call = zend_vm_stack_push_call_frame_ex( ZEND_MM_ALIGNED_SIZE_EX(sizeof(zend_execute_data), sizeof(zval)) + ZEND_MM_ALIGNED_SIZE_EX(sizeof(zend_op), sizeof(zval)) + + ZEND_MM_ALIGNED_SIZE_EX(sizeof(zend_slim_op), sizeof(zval)) + ZEND_MM_ALIGNED_SIZE_EX(sizeof(zend_function), sizeof(zval)), 0, &dummy_func, 0, NULL); @@ -308,10 +310,15 @@ ZEND_API zend_result zend_get_attribute_object(zval *obj, zend_class_entry *attr opline->opcode = ZEND_DO_FCALL; opline->lineno = attribute_data->lineno; - call->opline = opline; + sop = (zend_slim_op*)(opline + 1); + memset(opline, 0, sizeof(zend_op)); + opline->opcode = ZEND_DO_FCALL; + opline->lineno = attribute_data->lineno; + + call->opline = sop; call->call = NULL; call->return_value = NULL; - call->func = (zend_function*)(call->opline + 1); + call->func = (zend_function*)(sop + 1); call->prev_execute_data = EG(current_execute_data); memset(call->func, 0, sizeof(zend_function)); @@ -320,6 +327,8 @@ ZEND_API zend_result zend_get_attribute_object(zval *obj, zend_class_entry *attr attribute_data->flags & ZEND_ATTRIBUTE_STRICT_TYPES ? ZEND_ACC_STRICT_TYPES : 0; call->func->op_array.fn_flags |= ZEND_ACC_CALL_VIA_TRAMPOLINE; call->func->op_array.filename = filename; + call->func->op_array.opcodes = opline; + call->func->op_array.slim_opcodes = sop; EG(current_execute_data) = call; } diff --git a/Zend/zend_builtin_functions.c b/Zend/zend_builtin_functions.c index 7a07ceadce2e2..04ca067366146 100644 --- a/Zend/zend_builtin_functions.c +++ b/Zend/zend_builtin_functions.c @@ -1863,7 +1863,7 @@ ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int array_init(return_value); call = EG(current_execute_data); - if (!call) { + if (!call || EG(capture_warnings_during_sccp) != 0) { return; } @@ -1923,7 +1923,7 @@ ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int /* For frameless calls we add an additional frame for the call itself. */ if (ZEND_USER_CODE(call->func->type)) { - const zend_op *opline = call->opline; + const zend_op *opline = Z_WOP_FROM_EX(call); if (!ZEND_OP_IS_FRAMELESS_ICALL(opline->opcode)) { goto not_frameless_call; } @@ -1957,14 +1957,15 @@ ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int /* Steal file and line from the previous frame. */ if (call->func && ZEND_USER_CODE(call->func->common.type)) { filename = call->func->op_array.filename; - if (call->opline->opcode == ZEND_HANDLE_EXCEPTION) { + zend_op *call_op = Z_WOP_FROM_EX(call); + if (call_op->opcode == ZEND_HANDLE_EXCEPTION) { if (EG(opline_before_exception)) { - lineno = EG(opline_before_exception)->lineno; + lineno = Z_WOP_FROM_EX_OP(call, EG(opline_before_exception))->lineno; } else { lineno = call->func->op_array.line_end; } } else { - lineno = call->opline->lineno; + lineno = call_op->lineno; } ZVAL_STR_COPY(&tmp, filename); _zend_hash_append_ex(stack_frame, ZSTR_KNOWN(ZEND_STR_FILE), &tmp, 1); @@ -2008,14 +2009,15 @@ ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int if (prev && prev->func && ZEND_USER_CODE(prev->func->common.type)) { filename = prev->func->op_array.filename; - if (prev->opline->opcode == ZEND_HANDLE_EXCEPTION) { + zend_op *prev_op = Z_WOP_FROM_EX(prev); + if (prev_op->opcode == ZEND_HANDLE_EXCEPTION) { if (EG(opline_before_exception)) { - lineno = EG(opline_before_exception)->lineno; + lineno = Z_WOP_FROM_EX_OP(prev, EG(opline_before_exception))->lineno; } else { lineno = prev->func->op_array.line_end; } } else { - lineno = prev->opline->lineno; + lineno = prev_op->lineno; } ZVAL_STR_COPY(&tmp, filename); _zend_hash_append_ex(stack_frame, ZSTR_KNOWN(ZEND_STR_FILE), &tmp, 1); @@ -2042,7 +2044,7 @@ ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int if (prev && prev->func && ZEND_USER_CODE(prev->func->common.type)) { ZVAL_STR_COPY(&tmp, prev->func->op_array.filename); _zend_hash_append_ex(stack_frame, ZSTR_KNOWN(ZEND_STR_FILE), &tmp, 1); - ZVAL_LONG(&tmp, prev->opline->lineno); + ZVAL_LONG(&tmp, Z_WOP_FROM_EX(prev)->lineno); _zend_hash_append_ex(stack_frame, ZSTR_KNOWN(ZEND_STR_LINE), &tmp, 1); break; } @@ -2092,7 +2094,7 @@ ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int bool build_filename_arg = 1; zend_string *pseudo_function_name; uint32_t include_kind = 0; - if (prev && prev->func && ZEND_USER_CODE(prev->func->common.type) && prev->opline->opcode == ZEND_INCLUDE_OR_EVAL) { + if (prev && prev->func && ZEND_USER_CODE(prev->func->common.type) && Z_WOP_FROM_EX(prev)->opcode == ZEND_INCLUDE_OR_EVAL) { include_kind = prev->opline->extended_value; } @@ -2154,7 +2156,7 @@ ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int && prev && prev->func && ZEND_USER_CODE(prev->func->common.type) - && prev->opline->opcode == ZEND_INCLUDE_OR_EVAL) { + && Z_WOP_FROM_EX(prev)->opcode == ZEND_INCLUDE_OR_EVAL) { fake_frame = 1; } else { fake_frame = 0; diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index 0669d106f15e9..ab03e43b95f19 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -531,6 +531,7 @@ ZEND_API bool zend_is_compiling(void) /* {{{ */ static zend_always_inline uint32_t get_temporary_variable(void) /* {{{ */ { + ZEND_ASSERT(((uint32_t)CG(active_op_array)->T + 1) <= UINT16_MAX); return (uint32_t)CG(active_op_array)->T++; } /* }}} */ @@ -5847,7 +5848,7 @@ static void zend_compile_break_continue(zend_ast *ast) /* {{{ */ void zend_resolve_goto_label(zend_op_array *op_array, zend_op *opline) /* {{{ */ { zend_label *dest; - int current, remove_oplines = opline->op1.num; + int16_t current, remove_oplines = opline->op1.num; zval *label; uint32_t opnum = opline - op_array->opcodes; @@ -5896,11 +5897,19 @@ void zend_resolve_goto_label(zend_op_array *op_array, zend_op *opline) /* {{{ */ opline->op1.opline_num = dest->opline_num; opline->extended_value = 0; + zend_slim_op *sop = op_array->slim_opcodes + opnum; + ZEND_ASSERT(remove_oplines >= 0); while (remove_oplines--) { opline--; MAKE_NOP(opline); ZEND_VM_SET_OPCODE_HANDLER(opline); + + sop--; + sop->handler = opline->handler; + sop->op1.num = (uint16_t) -1; + sop->op2.num = (uint16_t) -1; + sop->result.num = (uint16_t) -1; } } /* }}} */ @@ -8361,10 +8370,10 @@ static zend_op_array *zend_compile_func_decl_ex( "nodiscard", sizeof("nodiscard")-1 ); - + if (nodiscard_attribute) { op_array->fn_flags |= ZEND_ACC_NODISCARD; - } + } } /* Do not leak the class scope into free standing functions, even if they are dynamically @@ -11043,11 +11052,11 @@ static void zend_compile_rope_finalize(znode *result, uint32_t rope_elements, ze while (opline != init_opline) { opline--; if (opline->opcode == ZEND_ROPE_ADD && - opline->result.var == (uint32_t)-1) { + opline->result.var == (uint16_t)-1) { opline->op1.var = var; opline->result.var = var; } else if (opline->opcode == ZEND_ROPE_INIT && - opline->result.var == (uint32_t)-1) { + opline->result.var == (uint16_t)-1) { opline->result.var = var; } } diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h index 62d0fbcded2ee..ad3f9d1862b67 100644 --- a/Zend/zend_compile.h +++ b/Zend/zend_compile.h @@ -34,7 +34,7 @@ #define SET_UNUSED(op) do { \ op ## _type = IS_UNUSED; \ - op.num = (uint32_t) -1; \ + op.num = (uint16_t) -1; \ } while (0) #define MAKE_NOP(opline) do { \ @@ -54,30 +54,12 @@ typedef struct _zend_op_array zend_op_array; typedef struct _zend_op zend_op; -/* On 64-bit systems less optimal, but more compact VM code leads to better - * performance. So on 32-bit systems we use absolute addresses for jump - * targets and constants, but on 64-bit systems relative 32-bit offsets */ -#if SIZEOF_SIZE_T == 4 -# define ZEND_USE_ABS_JMP_ADDR 1 -# define ZEND_USE_ABS_CONST_ADDR 1 -#else -# define ZEND_USE_ABS_JMP_ADDR 0 -# define ZEND_USE_ABS_CONST_ADDR 0 -#endif - typedef union _znode_op { - uint32_t constant; - uint32_t var; - uint32_t num; - uint32_t opline_num; /* Needs to be signed */ -#if ZEND_USE_ABS_JMP_ADDR - zend_op *jmp_addr; -#else - uint32_t jmp_offset; -#endif -#if ZEND_USE_ABS_CONST_ADDR - zval *zv; -#endif + uint16_t constant; + uint16_t var; + uint16_t num; + uint16_t opline_num; /* Needs to be signed */ + uint16_t jmp_offset; } znode_op; typedef struct _znode { /* used only during compilation */ @@ -139,7 +121,7 @@ struct _zend_op { znode_op op1; znode_op op2; znode_op result; - uint32_t extended_value; + uint16_t extended_value; uint32_t lineno; uint8_t opcode; /* Opcodes defined in Zend/zend_vm_opcodes.h */ uint8_t op1_type; /* IS_UNUSED, IS_CONST, IS_TMP_VAR, IS_VAR, IS_CV */ @@ -155,6 +137,15 @@ struct _zend_op { #endif }; +/* A slimmer, more cache-friendly version of zend_op used at run-time. It should + * only be used within the VM. */ +typedef struct _zend_slim_op { + const void *handler; + znode_op op1; + znode_op op2; + znode_op result; + uint16_t extended_value; +} zend_slim_op; typedef struct _zend_brk_cont_element { int start; @@ -533,6 +524,8 @@ struct _zend_op_array { uint32_t last; /* number of opcodes */ zend_op *opcodes; + zend_slim_op *slim_opcodes; + ZEND_MAP_PTR_DEF(HashTable *, static_variables_ptr); HashTable *static_variables; zend_string **vars; /* names of CV variables */ @@ -621,7 +614,7 @@ union _zend_function { }; struct _zend_execute_data { - const zend_op *opline; /* executed opline */ + const zend_slim_op *opline; /* executed opline */ zend_execute_data *call; /* current call */ zval *return_value; zend_function *func; /* executed function */ @@ -733,42 +726,45 @@ ZEND_STATIC_ASSERT(ZEND_MM_ALIGNED_SIZE(sizeof(zval)) == sizeof(zval), #define EX_VAR(n) ZEND_CALL_VAR(execute_data, n) #define EX_VAR_NUM(n) ZEND_CALL_VAR_NUM(execute_data, n) -#define EX_VAR_TO_NUM(n) ((uint32_t)((n) / sizeof(zval) - ZEND_CALL_FRAME_SLOT)) -#define EX_NUM_TO_VAR(n) ((uint32_t)(((n) + ZEND_CALL_FRAME_SLOT) * sizeof(zval))) +#define EX_VAR_TO_NUM(n) ((uint16_t)((n) / sizeof(zval) - ZEND_CALL_FRAME_SLOT)) +#define EX_NUM_TO_VAR(n) ((uint16_t)(((n) + ZEND_CALL_FRAME_SLOT) * sizeof(zval))) #define ZEND_OPLINE_TO_OFFSET(opline, target) \ ((char*)(target) - (char*)(opline)) #define ZEND_OPLINE_NUM_TO_OFFSET(op_array, opline, opline_num) \ - ((char*)&(op_array)->opcodes[opline_num] - (char*)(opline)) + _Generic((opline), \ + zend_op*: ((char*)&(op_array)->opcodes[opline_num] - (char*)(opline)), \ + const zend_op*: ((char*)&(op_array)->opcodes[opline_num] - (char*)(opline)), \ + zend_slim_op*: ((char*)&(op_array)->slim_opcodes[opline_num] - (char*)(opline)), \ + const zend_slim_op*: ((char*)&(op_array)->slim_opcodes[opline_num] - (char*)(opline))) #define ZEND_OFFSET_TO_OPLINE(base, offset) \ - ((zend_op*)(((char*)(base)) + (int)offset)) + _Generic((base), \ + zend_op*: ((zend_op*)(((char*)(base)) + (int16_t)offset)), \ + const zend_op*: ((zend_op*)(((char*)(base)) + (int16_t)offset)), \ + zend_slim_op*: ((zend_slim_op*)(((char*)(base)) + (int16_t)offset)), \ + const zend_slim_op*: ((zend_slim_op*)(((char*)(base)) + (int16_t)offset))) #define ZEND_OFFSET_TO_OPLINE_NUM(op_array, base, offset) \ (ZEND_OFFSET_TO_OPLINE(base, offset) - op_array->opcodes) -#if ZEND_USE_ABS_JMP_ADDR - -/* run-time jump target */ -# define OP_JMP_ADDR(opline, node) \ - (node).jmp_addr - -# define ZEND_SET_OP_JMP_ADDR(opline, node, val) do { \ - (node).jmp_addr = (val); \ - } while (0) - -/* convert jump target from compile-time to run-time */ -# define ZEND_PASS_TWO_UPDATE_JMP_TARGET(op_array, opline, node) do { \ - (node).jmp_addr = (op_array)->opcodes + (node).opline_num; \ - } while (0) +#define OP_OPERAND_IS_WIDE(op) ((op) > UINT16_MAX) -/* convert jump target back from run-time to compile-time */ -# define ZEND_PASS_TWO_UNDO_JMP_TARGET(op_array, opline, node) do { \ - (node).opline_num = (node).jmp_addr - (op_array)->opcodes; \ - } while (0) +static zend_always_inline zend_op *_zend_sop_to_wop(const zend_op_array *op_array, const zend_slim_op *slim_op) +{ + return &op_array->opcodes[slim_op - op_array->slim_opcodes]; +} -#else +#define Z_WOP_FROM_EX_OP(ex, op) \ + /* (EXPECTED((op) != EG(exception_slim_op)) */ \ + ((op) != EG(exception_slim_op) \ + ? _zend_sop_to_wop(&(ex)->func->op_array, op) \ + : EG(exception_op)) +#define Z_WOP_FROM_EX(ex) Z_WOP_FROM_EX_OP(ex, (ex)->opline) +#define Z_WOP_FROM_OP(op) Z_WOP_FROM_EX_OP(EG(current_execute_data), op) +#define Z_WOP Z_WOP_FROM_EX(EG(current_execute_data)) +#define EX_WOP Z_WOP_FROM_EX(execute_data) /* run-time jump target */ # define OP_JMP_ADDR(opline, node) \ @@ -788,8 +784,6 @@ ZEND_STATIC_ASSERT(ZEND_MM_ALIGNED_SIZE(sizeof(zval)) == sizeof(zval), (node).opline_num = ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, (node).jmp_offset); \ } while (0) -#endif - /* constant-time constant */ # define CT_CONSTANT_EX(op_array, num) \ ((op_array)->literals + (num)) @@ -797,19 +791,6 @@ ZEND_STATIC_ASSERT(ZEND_MM_ALIGNED_SIZE(sizeof(zval)) == sizeof(zval), # define CT_CONSTANT(node) \ CT_CONSTANT_EX(CG(active_op_array), (node).constant) -#if ZEND_USE_ABS_CONST_ADDR - -/* run-time constant */ -# define RT_CONSTANT(opline, node) \ - (node).zv - -/* convert constant from compile-time to run-time */ -# define ZEND_PASS_TWO_UPDATE_CONSTANT(op_array, opline, node) do { \ - (node).zv = CT_CONSTANT_EX(op_array, (node).constant); \ - } while (0) - -#else - /* At run-time, constants are allocated together with op_array->opcodes * and addressed relatively to current opline. */ @@ -825,8 +806,6 @@ ZEND_STATIC_ASSERT(ZEND_MM_ALIGNED_SIZE(sizeof(zval)) == sizeof(zval), ((char*)opline)); \ } while (0) -#endif - /* convert constant back from run-time to compile-time */ #define ZEND_PASS_TWO_UNDO_CONSTANT(op_array, opline, node) do { \ (node).constant = RT_CONSTANT(opline, node) - (op_array)->literals; \ @@ -993,6 +972,7 @@ ZEND_API void zend_initialize_class_data(zend_class_entry *ce, bool nullify_hand uint32_t zend_get_class_fetch_type(const zend_string *name); ZEND_API uint8_t zend_get_call_op(const zend_op *init_op, zend_function *fbc, bool result_used); ZEND_API bool zend_is_smart_branch(const zend_op *opline); +ZEND_API void zend_setup_quick_op_flags(zend_op *opline, zend_slim_op *slim_op); typedef bool (*zend_auto_global_callback)(zend_string *name); typedef struct _zend_auto_global { diff --git a/Zend/zend_exceptions.c b/Zend/zend_exceptions.c index 7777c5fa62e48..5e99921d6e106 100644 --- a/Zend/zend_exceptions.c +++ b/Zend/zend_exceptions.c @@ -174,9 +174,9 @@ void zend_exception_restore(void) /* {{{ */ static zend_always_inline bool is_handle_exception_set(void) { zend_execute_data *execute_data = EG(current_execute_data); return !execute_data - || !execute_data->func - || !ZEND_USER_CODE(execute_data->func->common.type) - || execute_data->opline->opcode == ZEND_HANDLE_EXCEPTION; + || !EX(func) + || !ZEND_USER_CODE(EX(func)->common.type) + || EX_WOP->opcode == ZEND_HANDLE_EXCEPTION; } ZEND_API ZEND_COLD void zend_throw_exception_internal(zend_object *exception) /* {{{ */ @@ -235,7 +235,7 @@ ZEND_API ZEND_COLD void zend_throw_exception_internal(zend_object *exception) /* return; } EG(opline_before_exception) = EG(current_execute_data)->opline; - EG(current_execute_data)->opline = EG(exception_op); + EG(current_execute_data)->opline = EG(exception_slim_op); } /* }}} */ @@ -1078,7 +1078,7 @@ ZEND_API ZEND_COLD void zend_throw_unwind_exit(void) ZEND_ASSERT(!EG(exception)); EG(exception) = zend_create_unwind_exit(); EG(opline_before_exception) = EG(current_execute_data)->opline; - EG(current_execute_data)->opline = EG(exception_op); + EG(current_execute_data)->opline = EG(exception_slim_op); } ZEND_API ZEND_COLD void zend_throw_graceful_exit(void) @@ -1086,7 +1086,7 @@ ZEND_API ZEND_COLD void zend_throw_graceful_exit(void) ZEND_ASSERT(!EG(exception)); EG(exception) = zend_create_graceful_exit(); EG(opline_before_exception) = EG(current_execute_data)->opline; - EG(current_execute_data)->opline = EG(exception_op); + EG(current_execute_data)->opline = EG(exception_slim_op); } ZEND_API bool zend_is_unwind_exit(const zend_object *ex) diff --git a/Zend/zend_exceptions.h b/Zend/zend_exceptions.h index d0138021d1ea3..fbdbadd66e991 100644 --- a/Zend/zend_exceptions.h +++ b/Zend/zend_exceptions.h @@ -85,9 +85,9 @@ ZEND_API bool zend_is_graceful_exit(const zend_object *ex); static zend_always_inline void zend_rethrow_exception(zend_execute_data *execute_data) { - if (EX(opline)->opcode != ZEND_HANDLE_EXCEPTION) { + if (EX(opline) != EG(exception_slim_op)) { EG(opline_before_exception) = EX(opline); - EX(opline) = EG(exception_op); + EX(opline) = EG(exception_slim_op); } } diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c index 0fbfdfa07ef04..7eb35b483bcc8 100644 --- a/Zend/zend_execute.c +++ b/Zend/zend_execute.c @@ -97,7 +97,7 @@ # define OPLINE_DC # define OPLINE_CC #else -# define OPLINE_D const zend_op* opline +# define OPLINE_D const zend_slim_op* opline # define OPLINE_C opline # define OPLINE_DC , OPLINE_D # define OPLINE_CC , OPLINE_C @@ -105,7 +105,7 @@ #if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)) # pragma GCC diagnostic ignored "-Wvolatile-register-var" - register const zend_op* volatile opline __asm__(ZEND_VM_IP_GLOBAL_REG); + register const zend_slim_op* volatile opline __asm__(ZEND_VM_IP_GLOBAL_REG); # pragma GCC diagnostic warning "-Wvolatile-register-var" #else #endif @@ -116,6 +116,8 @@ #define _UNUSED_CODE 3 #define _CV_CODE 4 +#define EX_WOP2 Z_WOP_FROM_EX_OP(execute_data, opline) + typedef int (ZEND_FASTCALL *incdec_t)(zval *); #define get_zval_ptr(op_type, node, type) _get_zval_ptr(op_type, node, type EXECUTE_DATA_CC OPLINE_CC) @@ -584,7 +586,7 @@ static zend_never_inline zval* zend_assign_to_typed_property_reference(zend_prop return prop; } -static zend_never_inline ZEND_COLD zval *zend_wrong_assign_to_variable_reference(zval *variable_ptr, zval *value_ptr, zend_refcounted **garbage_ptr OPLINE_DC EXECUTE_DATA_DC) +static zend_never_inline ZEND_COLD zval *zend_wrong_assign_to_variable_reference(zval *variable_ptr, zval *value_ptr, zend_refcounted **garbage_ptr EXECUTE_DATA_DC) { zend_error(E_NOTICE, "Only variables should be assigned by reference"); if (UNEXPECTED(EG(exception) != NULL)) { @@ -642,19 +644,20 @@ static zend_never_inline ZEND_COLD void ZEND_FASTCALL zend_throw_non_object_erro { zend_string *tmp_property_name; zend_string *property_name = zval_get_tmp_string(property, &tmp_property_name); + zend_op *wop = EX_WOP; - if (opline->opcode == ZEND_PRE_INC_OBJ - || opline->opcode == ZEND_PRE_DEC_OBJ - || opline->opcode == ZEND_POST_INC_OBJ - || opline->opcode == ZEND_POST_DEC_OBJ) { + if (wop->opcode == ZEND_PRE_INC_OBJ + || wop->opcode == ZEND_PRE_DEC_OBJ + || wop->opcode == ZEND_POST_INC_OBJ + || wop->opcode == ZEND_POST_DEC_OBJ) { zend_throw_error(NULL, "Attempt to increment/decrement property \"%s\" on %s", ZSTR_VAL(property_name), zend_zval_value_name(object) ); - } else if (opline->opcode == ZEND_FETCH_OBJ_W - || opline->opcode == ZEND_FETCH_OBJ_RW - || opline->opcode == ZEND_FETCH_OBJ_FUNC_ARG - || opline->opcode == ZEND_ASSIGN_OBJ_REF) { + } else if (wop->opcode == ZEND_FETCH_OBJ_W + || wop->opcode == ZEND_FETCH_OBJ_RW + || wop->opcode == ZEND_FETCH_OBJ_FUNC_ARG + || wop->opcode == ZEND_ASSIGN_OBJ_REF) { zend_throw_error(NULL, "Attempt to modify property \"%s\" on %s", ZSTR_VAL(property_name), zend_zval_value_name(object) @@ -667,8 +670,8 @@ static zend_never_inline ZEND_COLD void ZEND_FASTCALL zend_throw_non_object_erro } zend_tmp_string_release(tmp_property_name); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if (UNEXPECTED(RETURN_VALUE_USED(wop))) { + ZVAL_NULL(EX_VAR(wop->result.var)); } } @@ -709,9 +712,10 @@ ZEND_API ZEND_COLD void zend_verify_arg_error( ZEND_ASSERT(zf->common.type == ZEND_USER_FUNCTION && "Arginfo verification is not performed for internal functions"); if (ptr && ptr->func && ZEND_USER_CODE(ptr->func->common.type)) { + zend_op *wop = Z_WOP_FROM_EX(ptr); zend_argument_type_error(arg_num, "must be of type %s, %s given, called in %s on line %d", ZSTR_VAL(need_msg), given_msg, - ZSTR_VAL(ptr->func->op_array.filename), ptr->opline->lineno + ZSTR_VAL(ptr->func->op_array.filename), wop->lineno ); } else { zend_argument_type_error(arg_num, @@ -1389,13 +1393,14 @@ ZEND_API ZEND_COLD void ZEND_FASTCALL zend_missing_arg_error(const zend_execute_ const zend_execute_data *ptr = EX(prev_execute_data); if (ptr && ptr->func && ZEND_USER_CODE(ptr->func->common.type)) { + zend_op *wop = Z_WOP_FROM_EX(ptr); zend_throw_error(zend_ce_argument_count_error, "Too few arguments to function %s%s%s(), %d passed in %s on line %d and %s %d expected", EX(func)->common.scope ? ZSTR_VAL(EX(func)->common.scope->name) : "", EX(func)->common.scope ? "::" : "", ZSTR_VAL(EX(func)->common.function_name), EX_NUM_ARGS(), ZSTR_VAL(ptr->func->op_array.filename), - ptr->opline->lineno, + wop->lineno, EX(func)->common.required_num_args == EX(func)->common.num_args ? "exactly" : "at least", EX(func)->common.required_num_args); } else { @@ -1551,7 +1556,7 @@ static zend_never_inline void zend_assign_to_object_dim(zend_object *obj, zval * { obj->handlers->write_dimension(obj, dim, value); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } } @@ -1567,7 +1572,7 @@ static void frameless_observed_call_copy(zend_execute_data *call, uint32_t arg, ZEND_API void zend_frameless_observed_call(zend_execute_data *execute_data) { - const zend_op *opline = EX(opline); + const zend_op *opline = EX_WOP; uint8_t num_args = ZEND_FLF_NUM_ARGS(opline->opcode); zend_function *fbc = ZEND_FLF_FUNC(opline); zval *result = EX_VAR(opline->result.var); @@ -1636,7 +1641,9 @@ static zend_never_inline void zend_binary_assign_op_obj_dim(zend_object *obj, zv if (property && UNEXPECTED(Z_ISUNDEF_P(property))) { property = ZVAL_UNDEFINED_OP2(); } - value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1); + zend_op *wop = EX_WOP; + zend_op *wop_data = wop + 1; + value = get_op_data_zval_ptr_r(wop_data->op1_type, (opline+1)->op1); if ((z = obj->handlers->read_dimension(obj, property, BP_VAR_R, &rv)) != NULL) { if (zend_binary_op(&res, z, value OPLINE_CC) == SUCCESS) { @@ -1645,17 +1652,17 @@ static zend_never_inline void zend_binary_assign_op_obj_dim(zend_object *obj, zv if (z == &rv) { zval_ptr_dtor(&rv); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), &res); + if (UNEXPECTED(RETURN_VALUE_USED(wop))) { + ZVAL_COPY(EX_VAR(wop->result.var), &res); } zval_ptr_dtor(&res); } else { zend_use_object_as_array(obj); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if (UNEXPECTED(RETURN_VALUE_USED(wop))) { + ZVAL_NULL(EX_VAR(wop->result.var)); } } - FREE_OP((opline+1)->op1_type, (opline+1)->op1.var); + FREE_OP(wop_data->op1_type, wop_data->op1.var); if (UNEXPECTED(GC_DELREF(obj) == 0)) { zend_objects_store_del(obj); } @@ -1746,8 +1753,7 @@ static zend_never_inline zend_long zend_check_string_offset(zval *dim, int type ZEND_API ZEND_COLD void zend_wrong_string_offset_error(void) { const char *msg = NULL; - const zend_execute_data *execute_data = EG(current_execute_data); - const zend_op *opline = execute_data->opline; + const zend_op *opline = Z_WOP; if (UNEXPECTED(EG(exception) != NULL)) { return; @@ -2009,6 +2015,8 @@ static zend_never_inline void zend_assign_to_string_offset(zval *str, zval *dim, zend_long offset; zend_string *s; + zend_op *wop = EX_WOP; + /* separate string */ if (Z_REFCOUNTED_P(str) && Z_REFCOUNT_P(str) == 1) { s = Z_STR_P(str); @@ -2030,15 +2038,15 @@ static zend_never_inline void zend_assign_to_string_offset(zval *str, zval *dim, offset = zend_check_string_offset(dim, BP_VAR_W EXECUTE_DATA_CC); if (UNEXPECTED(GC_DELREF(s) == 0)) { zend_string_efree(s); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if (UNEXPECTED(RETURN_VALUE_USED(wop))) { + ZVAL_NULL(EX_VAR(wop->result.var)); } return; } /* Illegal offset assignment */ if (UNEXPECTED(EG(exception) != NULL)) { - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_UNDEF(EX_VAR(opline->result.var)); + if (UNEXPECTED(RETURN_VALUE_USED(wop))) { + ZVAL_UNDEF(EX_VAR(wop->result.var)); } return; } @@ -2047,8 +2055,8 @@ static zend_never_inline void zend_assign_to_string_offset(zval *str, zval *dim, if (UNEXPECTED(offset < -(zend_long)ZSTR_LEN(s))) { /* Error on negative offset */ zend_error(E_WARNING, "Illegal string offset " ZEND_LONG_FMT, offset); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if (UNEXPECTED(RETURN_VALUE_USED(wop))) { + ZVAL_NULL(EX_VAR(wop->result.var)); } return; } @@ -2073,14 +2081,14 @@ static zend_never_inline void zend_assign_to_string_offset(zval *str, zval *dim, if (tmp) { zend_string_release_ex(tmp, 0); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if (UNEXPECTED(RETURN_VALUE_USED(wop))) { + ZVAL_NULL(EX_VAR(wop->result.var)); } return; } if (UNEXPECTED(!tmp)) { - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_UNDEF(EX_VAR(opline->result.var)); + if (UNEXPECTED(RETURN_VALUE_USED(wop))) { + ZVAL_UNDEF(EX_VAR(wop->result.var)); } return; } @@ -2097,8 +2105,8 @@ static zend_never_inline void zend_assign_to_string_offset(zval *str, zval *dim, if (string_len == 0) { /* Error on empty input string */ zend_throw_error(NULL, "Cannot assign an empty string to a string offset"); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if (UNEXPECTED(RETURN_VALUE_USED(wop))) { + ZVAL_NULL(EX_VAR(wop->result.var)); } return; } @@ -2109,15 +2117,15 @@ static zend_never_inline void zend_assign_to_string_offset(zval *str, zval *dim, zend_error(E_WARNING, "Only the first byte will be assigned to the string offset"); if (UNEXPECTED(GC_DELREF(s) == 0)) { zend_string_efree(s); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if (UNEXPECTED(RETURN_VALUE_USED(wop))) { + ZVAL_NULL(EX_VAR(wop->result.var)); } return; } /* Illegal offset assignment */ if (UNEXPECTED(EG(exception) != NULL)) { - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_UNDEF(EX_VAR(opline->result.var)); + if (UNEXPECTED(RETURN_VALUE_USED(wop))) { + ZVAL_UNDEF(EX_VAR(wop->result.var)); } return; } @@ -2135,9 +2143,9 @@ static zend_never_inline void zend_assign_to_string_offset(zval *str, zval *dim, Z_STRVAL_P(str)[offset] = c; - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED(RETURN_VALUE_USED(wop))) { /* Return the new character */ - ZVAL_CHAR(EX_VAR(opline->result.var), c); + ZVAL_CHAR(EX_VAR(wop->result.var), c); } } @@ -2156,7 +2164,7 @@ static ZEND_COLD zend_long zend_throw_incdec_ref_error( zend_reference *ref, zend_property_info *error_prop OPLINE_DC) { zend_string *type_str = zend_type_to_string(error_prop->type); - if (ZEND_IS_INCREMENT(opline->opcode)) { + if (ZEND_IS_INCREMENT(Z_WOP_FROM_OP(opline)->opcode)) { zend_type_error( "Cannot increment a reference held by property %s::$%s of type %s past its maximal value", ZSTR_VAL(error_prop->ce->name), @@ -2175,7 +2183,8 @@ static ZEND_COLD zend_long zend_throw_incdec_ref_error( } } -static ZEND_COLD zend_long zend_throw_incdec_prop_error(zend_property_info *prop OPLINE_DC) { +static ZEND_COLD zend_long zend_throw_incdec_prop_error(zend_property_info *prop) { + zend_op *opline = Z_WOP; zend_string *type_str = zend_type_to_string(prop->type); if (ZEND_IS_INCREMENT(opline->opcode)) { zend_type_error("Cannot increment property %s::$%s of type %s past its maximal value", @@ -2205,7 +2214,7 @@ static void zend_incdec_typed_ref(zend_reference *ref, zval *copy OPLINE_DC EXEC ZVAL_COPY(copy, var_ptr); - if (ZEND_IS_INCREMENT(opline->opcode)) { + if (ZEND_IS_INCREMENT(EX_WOP->opcode)) { increment_function(var_ptr); } else { decrement_function(var_ptr); @@ -2236,7 +2245,7 @@ static void zend_incdec_typed_prop(zend_property_info *prop_info, zval *var_ptr, ZVAL_COPY(copy, var_ptr); - if (ZEND_IS_INCREMENT(opline->opcode)) { + if (ZEND_IS_INCREMENT(EX_WOP->opcode)) { increment_function(var_ptr); } else { decrement_function(var_ptr); @@ -2244,7 +2253,7 @@ static void zend_incdec_typed_prop(zend_property_info *prop_info, zval *var_ptr, if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_DOUBLE) && Z_TYPE_P(copy) == IS_LONG) { if (!(ZEND_TYPE_FULL_MASK(prop_info->type) & MAY_BE_DOUBLE)) { - zend_long val = zend_throw_incdec_prop_error(prop_info OPLINE_CC); + zend_long val = zend_throw_incdec_prop_error(prop_info); ZVAL_LONG(var_ptr, val); } } else if (UNEXPECTED(!zend_verify_property_type(prop_info, var_ptr, EX_USES_STRICT_TYPES()))) { @@ -2258,15 +2267,18 @@ static void zend_incdec_typed_prop(zend_property_info *prop_info, zval *var_ptr, static void zend_pre_incdec_property_zval(zval *prop, zend_property_info *prop_info OPLINE_DC EXECUTE_DATA_DC) { + // FIXME: If this may be inlined, fetch wop only if needed. + zend_op *wop = EX_WOP; + if (EXPECTED(Z_TYPE_P(prop) == IS_LONG)) { - if (ZEND_IS_INCREMENT(opline->opcode)) { + if (ZEND_IS_INCREMENT(wop->opcode)) { fast_long_increment_function(prop); } else { fast_long_decrement_function(prop); } if (UNEXPECTED(Z_TYPE_P(prop) != IS_LONG) && prop_info && !(ZEND_TYPE_FULL_MASK(prop_info->type) & MAY_BE_DOUBLE)) { - zend_long val = zend_throw_incdec_prop_error(prop_info OPLINE_CC); + zend_long val = zend_throw_incdec_prop_error(prop_info); ZVAL_LONG(prop, val); } } else { @@ -2282,30 +2294,33 @@ static void zend_pre_incdec_property_zval(zval *prop, zend_property_info *prop_i if (prop_info) { zend_incdec_typed_prop(prop_info, prop, NULL OPLINE_CC EXECUTE_DATA_CC); - } else if (ZEND_IS_INCREMENT(opline->opcode)) { + } else if (ZEND_IS_INCREMENT(wop->opcode)) { increment_function(prop); } else { decrement_function(prop); } } while (0); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), prop); + if (UNEXPECTED(RETURN_VALUE_USED(wop))) { + ZVAL_COPY(EX_VAR(wop->result.var), prop); } } static void zend_post_incdec_property_zval(zval *prop, zend_property_info *prop_info OPLINE_DC EXECUTE_DATA_DC) { + // FIXME: If this may be inlined, fetch wop only if needed. + zend_op *wop = EX_WOP; + if (EXPECTED(Z_TYPE_P(prop) == IS_LONG)) { - ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(prop)); - if (ZEND_IS_INCREMENT(opline->opcode)) { + ZVAL_LONG(EX_VAR(wop->result.var), Z_LVAL_P(prop)); + if (ZEND_IS_INCREMENT(wop->opcode)) { fast_long_increment_function(prop); } else { fast_long_decrement_function(prop); } if (UNEXPECTED(Z_TYPE_P(prop) != IS_LONG) && prop_info && !(ZEND_TYPE_FULL_MASK(prop_info->type) & MAY_BE_DOUBLE)) { - zend_long val = zend_throw_incdec_prop_error(prop_info OPLINE_CC); + zend_long val = zend_throw_incdec_prop_error(prop_info); ZVAL_LONG(prop, val); } } else { @@ -2313,16 +2328,16 @@ static void zend_post_incdec_property_zval(zval *prop, zend_property_info *prop_ zend_reference *ref = Z_REF_P(prop); prop = Z_REFVAL_P(prop); if (ZEND_REF_HAS_TYPE_SOURCES(ref)) { - zend_incdec_typed_ref(ref, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC); + zend_incdec_typed_ref(ref, EX_VAR(wop->result.var) OPLINE_CC EXECUTE_DATA_CC); return; } } if (prop_info) { - zend_incdec_typed_prop(prop_info, prop, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC); + zend_incdec_typed_prop(prop_info, prop, EX_VAR(wop->result.var) OPLINE_CC EXECUTE_DATA_CC); } else { - ZVAL_COPY(EX_VAR(opline->result.var), prop); - if (ZEND_IS_INCREMENT(opline->opcode)) { + ZVAL_COPY(EX_VAR(wop->result.var), prop); + if (ZEND_IS_INCREMENT(wop->opcode)) { increment_function(prop); } else { decrement_function(prop); @@ -2336,18 +2351,19 @@ static zend_never_inline void zend_post_incdec_overloaded_property(zend_object * zval rv; zval *z; zval z_copy; + zend_op *wop = EX_WOP; GC_ADDREF(object); z =object->handlers->read_property(object, name, BP_VAR_R, cache_slot, &rv); if (UNEXPECTED(EG(exception))) { OBJ_RELEASE(object); - ZVAL_UNDEF(EX_VAR(opline->result.var)); + ZVAL_UNDEF(EX_VAR(wop->result.var)); return; } ZVAL_COPY_DEREF(&z_copy, z); - ZVAL_COPY(EX_VAR(opline->result.var), &z_copy); - if (ZEND_IS_INCREMENT(opline->opcode)) { + ZVAL_COPY(EX_VAR(wop->result.var), &z_copy); + if (ZEND_IS_INCREMENT(wop->opcode)) { increment_function(&z_copy); } else { decrement_function(&z_copy); @@ -2365,25 +2381,26 @@ static zend_never_inline void zend_pre_incdec_overloaded_property(zend_object *o zval rv; zval *z; zval z_copy; + zend_op *wop = EX_WOP; GC_ADDREF(object); z = object->handlers->read_property(object, name, BP_VAR_R, cache_slot, &rv); if (UNEXPECTED(EG(exception))) { OBJ_RELEASE(object); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); + if (UNEXPECTED(RETURN_VALUE_USED(wop))) { + ZVAL_NULL(EX_VAR(wop->result.var)); } return; } ZVAL_COPY_DEREF(&z_copy, z); - if (ZEND_IS_INCREMENT(opline->opcode)) { + if (ZEND_IS_INCREMENT(wop->opcode)) { increment_function(&z_copy); } else { decrement_function(&z_copy); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), &z_copy); + if (UNEXPECTED(RETURN_VALUE_USED(wop))) { + ZVAL_COPY(EX_VAR(wop->result.var), &z_copy); } object->handlers->write_property(object, name, &z_copy, cache_slot); OBJ_RELEASE(object); @@ -2398,20 +2415,22 @@ static zend_never_inline void zend_assign_op_overloaded_property(zend_object *ob zval *z; zval rv, res; + zend_op *wop = EX_WOP; + GC_ADDREF(object); z = object->handlers->read_property(object, name, BP_VAR_R, cache_slot, &rv); if (UNEXPECTED(EG(exception))) { OBJ_RELEASE(object); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_UNDEF(EX_VAR(opline->result.var)); + if (UNEXPECTED(RETURN_VALUE_USED(wop))) { + ZVAL_UNDEF(EX_VAR(wop->result.var)); } return; } if (zend_binary_op(&res, z, value OPLINE_CC) == SUCCESS) { object->handlers->write_property(object, name, &res, cache_slot); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), &res); + if (UNEXPECTED(RETURN_VALUE_USED(wop))) { + ZVAL_COPY(EX_VAR(wop->result.var), &res); } if (z == &rv) { zval_ptr_dtor(z); @@ -2589,7 +2608,7 @@ ZEND_API zend_never_inline ZEND_COLD void ZEND_FASTCALL zend_call_stack_size_err static ZEND_COLD void zend_binary_assign_op_dim_slow(zval *container, zval *dim OPLINE_DC EXECUTE_DATA_DC) { if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) { - if (opline->op2_type == IS_UNUSED) { + if (EX_WOP->op2_type == IS_UNUSED) { zend_use_new_element_for_string(); } else { zend_check_string_offset(dim, BP_VAR_RW EXECUTE_DATA_CC); @@ -3548,8 +3567,9 @@ static zend_always_inline void zend_fetch_property_address(zval *result, zval *c static zend_always_inline void zend_assign_to_property_reference(zval *container, uint32_t container_op_type, zval *prop_ptr, uint32_t prop_op_type, zval *value_ptr OPLINE_DC EXECUTE_DATA_DC) { + zend_op *wop = EX_WOP; zval variable, *variable_ptr = &variable; - void **cache_addr = (prop_op_type == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL; + void **cache_addr = (prop_op_type == IS_CONST) ? CACHE_ADDR(wop->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL; zend_refcounted *garbage = NULL; zend_property_info *prop_info = NULL; @@ -3559,11 +3579,11 @@ static zend_always_inline void zend_assign_to_property_reference(zval *container if (EXPECTED(Z_TYPE_P(variable_ptr) == IS_INDIRECT)) { variable_ptr = Z_INDIRECT_P(variable_ptr); if (/*OP_DATA_TYPE == IS_VAR &&*/ - (opline->extended_value & ZEND_RETURNS_FUNCTION) && + (wop->extended_value & ZEND_RETURNS_FUNCTION) && UNEXPECTED(!Z_ISREF_P(value_ptr))) { variable_ptr = zend_wrong_assign_to_variable_reference( - variable_ptr, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC); + variable_ptr, value_ptr, &garbage EXECUTE_DATA_CC); } else if (prop_info && ZEND_TYPE_IS_SET(prop_info->type)) { variable_ptr = zend_assign_to_typed_property_reference(prop_info, variable_ptr, value_ptr, &garbage EXECUTE_DATA_CC); } else { @@ -3577,8 +3597,8 @@ static zend_always_inline void zend_assign_to_property_reference(zval *container variable_ptr = &EG(uninitialized_zval); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr); + if (UNEXPECTED(RETURN_VALUE_USED(wop))) { + ZVAL_COPY(EX_VAR(wop->result.var), variable_ptr); } if (garbage) { GC_DTOR(garbage); @@ -3615,7 +3635,8 @@ static zend_never_inline zval* zend_fetch_static_property_address_ex(zend_proper zend_class_entry *ce; zend_property_info *property_info; - uint8_t op1_type = opline->op1_type, op2_type = opline->op2_type; + zend_op *wop = EX_WOP; + uint8_t op1_type = wop->op1_type, op2_type = wop->op2_type; if (EXPECTED(op2_type == IS_CONST)) { zval *class_name = RT_CONSTANT(opline, opline->op2); @@ -3625,7 +3646,7 @@ static zend_never_inline zval* zend_fetch_static_property_address_ex(zend_proper if (EXPECTED((ce = CACHED_PTR(cache_slot)) == NULL)) { ce = zend_fetch_class_by_name(Z_STR_P(class_name), Z_STR_P(class_name + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); if (UNEXPECTED(ce == NULL)) { - FREE_OP(op1_type, opline->op1.var); + FREE_OP(op1_type, wop->op1.var); return NULL; } if (UNEXPECTED(op1_type != IS_CONST)) { @@ -3634,13 +3655,13 @@ static zend_never_inline zval* zend_fetch_static_property_address_ex(zend_proper } } else { if (EXPECTED(op2_type == IS_UNUSED)) { - ce = zend_fetch_class(NULL, opline->op2.num); + ce = zend_fetch_class(NULL, wop->op2.num); if (UNEXPECTED(ce == NULL)) { - FREE_OP(op1_type, opline->op1.var); + FREE_OP(op1_type, wop->op1.var); return NULL; } } else { - ce = Z_CE_P(EX_VAR(opline->op2.var)); + ce = Z_CE_P(EX_VAR(wop->op2.var)); } if (EXPECTED(op1_type == IS_CONST) && EXPECTED(CACHED_PTR(cache_slot) == ce)) { result = CACHED_PTR(cache_slot + sizeof(void *)); @@ -3654,13 +3675,13 @@ static zend_never_inline zval* zend_fetch_static_property_address_ex(zend_proper result = zend_std_get_static_property_with_info(ce, name, fetch_type, &property_info); } else { zend_string *tmp_name; - zval *varname = get_zval_ptr_undef(opline->op1_type, opline->op1, BP_VAR_R); + zval *varname = get_zval_ptr_undef(wop->op1_type, wop->op1, BP_VAR_R); if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) { name = Z_STR_P(varname); tmp_name = NULL; } else { if (op1_type == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) { - zval_undefined_cv(opline->op1.var EXECUTE_DATA_CC); + zval_undefined_cv(wop->op1.var EXECUTE_DATA_CC); } name = zval_get_tmp_string(varname, &tmp_name); } @@ -3668,7 +3689,7 @@ static zend_never_inline zval* zend_fetch_static_property_address_ex(zend_proper zend_tmp_string_release(tmp_name); - FREE_OP(op1_type, opline->op1.var); + FREE_OP(op1_type, wop->op1.var); } if (UNEXPECTED(result == NULL)) { @@ -3687,13 +3708,13 @@ static zend_never_inline zval* zend_fetch_static_property_address_ex(zend_proper } -static zend_always_inline zval* zend_fetch_static_property_address(zend_property_info **prop_info, uint32_t cache_slot, int fetch_type, int flags OPLINE_DC EXECUTE_DATA_DC) { +static zend_always_inline zval* zend_fetch_static_property_address(zend_property_info **prop_info, uint32_t cache_slot, int fetch_type, int flags, uint8_t op1_type, uint8_t op2_type OPLINE_DC EXECUTE_DATA_DC) { zval *result; zend_property_info *property_info; - if (opline->op1_type == IS_CONST - && (opline->op2_type == IS_CONST - || (opline->op2_type == IS_UNUSED + if (op1_type == IS_CONST + && (op2_type == IS_CONST + || (op2_type == IS_UNUSED && ((opline->op2.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF || (opline->op2.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT))) && EXPECTED(CACHED_PTR(cache_slot + sizeof(void *)) != NULL)) { @@ -3737,17 +3758,18 @@ ZEND_API zval* ZEND_FASTCALL zend_fetch_static_property(zend_execute_data *ex, i #endif execute_data = ex; #if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)) - const zend_op *orig_opline = opline; + const zend_slim_op *orig_opline = opline; #else - const zend_op *opline; + const zend_slim_op *opline; #endif opline = execute_data->opline; + zend_op *wop = EX_WOP; - uint32_t cache_slot = opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS; + uint32_t cache_slot = wop->extended_value & ~ZEND_FETCH_OBJ_FLAGS; uint32_t flags = 0; if (fetch_type == BP_VAR_W) { - flags = opline->extended_value & ZEND_FETCH_OBJ_FLAGS; + flags = wop->extended_value & ZEND_FETCH_OBJ_FLAGS; } result = zend_fetch_static_property_address_ex(&property_info, cache_slot, fetch_type OPLINE_CC EXECUTE_DATA_CC); if (EXPECTED(result)) { @@ -4314,9 +4336,9 @@ static zend_always_inline void i_init_func_execute_data(zend_op_array *op_array, ZEND_ASSERT(EX(func) == (zend_function*)op_array); #if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)) - opline = op_array->opcodes; + opline = op_array->slim_opcodes; #else - EX(opline) = op_array->opcodes; + EX(opline) = op_array->slim_opcodes; #endif EX(call) = NULL; EX(return_value) = return_value; @@ -4404,7 +4426,7 @@ static zend_always_inline void i_init_code_execute_data(zend_execute_data *execu { ZEND_ASSERT(EX(func) == (zend_function*)op_array); - EX(opline) = op_array->opcodes; + EX(opline) = op_array->slim_opcodes; EX(call) = NULL; EX(return_value) = return_value; @@ -4432,7 +4454,7 @@ ZEND_API void zend_init_func_execute_data(zend_execute_data *ex, zend_op_array * zend_execute_data *orig_execute_data = execute_data; #endif #if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)) - const zend_op *orig_opline = opline; + const zend_slim_op *orig_opline = opline; #endif #if defined(ZEND_VM_FP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)) execute_data = ex; @@ -4911,10 +4933,10 @@ ZEND_API HashTable *zend_unfinished_execution_gc_ex(zend_execute_data *execute_d } uint32_t op_num; - if (UNEXPECTED(execute_data->opline->opcode == ZEND_HANDLE_EXCEPTION)) { - op_num = EG(opline_before_exception) - op_array->opcodes; + if (UNEXPECTED(execute_data->opline == EG(exception_slim_op))) { + op_num = EG(opline_before_exception) - op_array->slim_opcodes; } else { - op_num = execute_data->opline - op_array->opcodes; + op_num = execute_data->opline - op_array->slim_opcodes; } ZEND_ASSERT(op_num < op_array->last); @@ -4922,7 +4944,7 @@ ZEND_API HashTable *zend_unfinished_execution_gc_ex(zend_execute_data *execute_d zend_unfinished_calls_gc(execute_data, call, op_num, gc_buffer); } - if (execute_data->opline != op_array->opcodes) { + if (execute_data->opline != op_array->slim_opcodes) { uint32_t i; for (i = 0; i < op_array->last_live_range; i++) { const zend_live_range *range = &op_array->live_range[i]; @@ -5312,7 +5334,7 @@ static zend_never_inline bool ZEND_FASTCALL zend_fe_reset_iterator(zval *array_p /* }}} */ static zend_always_inline zend_result _zend_quick_get_constant( - const zval *key, uint32_t flags, bool check_defined_only OPLINE_DC EXECUTE_DATA_DC) /* {{{ */ + const zval *key, uint32_t flags, bool check_defined_only, uint32_t cache_slot OPLINE_DC EXECUTE_DATA_DC) /* {{{ */ { zval *zv; zend_constant *c = NULL; @@ -5349,21 +5371,21 @@ static zend_always_inline zend_result _zend_quick_get_constant( } } - CACHE_PTR(opline->extended_value, c); + CACHE_PTR(cache_slot, c); return SUCCESS; } /* }}} */ static zend_never_inline void ZEND_FASTCALL zend_quick_get_constant( - const zval *key, uint32_t flags OPLINE_DC EXECUTE_DATA_DC) /* {{{ */ + const zval *key, uint32_t flags, uint32_t cache_slot OPLINE_DC EXECUTE_DATA_DC) /* {{{ */ { - _zend_quick_get_constant(key, flags, 0 OPLINE_CC EXECUTE_DATA_CC); + _zend_quick_get_constant(key, flags, 0, cache_slot OPLINE_CC EXECUTE_DATA_CC); } /* }}} */ static zend_never_inline zend_result ZEND_FASTCALL zend_quick_check_constant( - const zval *key OPLINE_DC EXECUTE_DATA_DC) /* {{{ */ + const zval *key, uint32_t cache_slot OPLINE_DC EXECUTE_DATA_DC) /* {{{ */ { - return _zend_quick_get_constant(key, 0, 1 OPLINE_CC EXECUTE_DATA_CC); + return _zend_quick_get_constant(key, 0, 1, cache_slot OPLINE_CC EXECUTE_DATA_CC); } /* }}} */ static zend_always_inline uint32_t zend_get_arg_offset_by_name( @@ -5468,7 +5490,7 @@ zval * ZEND_FASTCALL zend_handle_named_arg( return arg; } -static zend_execute_data *start_fake_frame(zend_execute_data *call, const zend_op *opline) { +static zend_execute_data *start_fake_frame(zend_execute_data *call, const zend_slim_op *opline) { zend_execute_data *old_prev_execute_data = call->prev_execute_data; call->prev_execute_data = EG(current_execute_data); call->opline = opline; @@ -5497,6 +5519,7 @@ ZEND_API zend_result ZEND_FASTCALL zend_handle_undef_args(zend_execute_data *cal } zend_op *opline = &op_array->opcodes[i]; + zend_slim_op *sop = &op_array->slim_opcodes[i]; if (EXPECTED(opline->opcode == ZEND_RECV_INIT)) { zval *default_value = RT_CONSTANT(opline, opline->op2); if (Z_OPT_TYPE_P(default_value) == IS_CONSTANT_AST) { @@ -5516,7 +5539,7 @@ ZEND_API zend_result ZEND_FASTCALL zend_handle_undef_args(zend_execute_data *cal * value is not accessible through back traces. */ zval tmp; ZVAL_COPY(&tmp, default_value); - zend_execute_data *old = start_fake_frame(call, opline); + zend_execute_data *old = start_fake_frame(call, sop); zend_result ret = zval_update_constant_ex(&tmp, fbc->op_array.scope); end_fake_frame(call, old); if (UNEXPECTED(ret == FAILURE)) { @@ -5533,7 +5556,7 @@ ZEND_API zend_result ZEND_FASTCALL zend_handle_undef_args(zend_execute_data *cal } } else { ZEND_ASSERT(opline->opcode == ZEND_RECV); - zend_execute_data *old = start_fake_frame(call, opline); + zend_execute_data *old = start_fake_frame(call, sop); zend_argument_error(zend_ce_argument_count_error, i + 1, "not passed"); end_fake_frame(call, old); return FAILURE; @@ -5686,21 +5709,24 @@ static zend_always_inline zend_execute_data *_zend_vm_stack_push_call_frame(uint #define ZEND_VM_REPEATABLE_OPCODE \ + const void *prev_handler; \ do { #define ZEND_VM_REPEAT_OPCODE(_opcode) \ - } while (UNEXPECTED((++opline)->opcode == _opcode)); \ + prev_handler = opline->handler; \ + opline++; \ + } while (UNEXPECTED(prev_handler == opline->handler)); \ OPLINE = opline; \ ZEND_VM_CONTINUE() -#define ZEND_VM_SMART_BRANCH(_result, _check) do { \ +#define ZEND_VM_SMART_BRANCH_EX(_result, _check, _check_jmpz, _check_jmpnz) do { \ if ((_check) && UNEXPECTED(EG(exception))) { \ OPLINE = EX(opline); \ - } else if (EXPECTED(opline->result_type == (IS_SMART_BRANCH_JMPZ|IS_TMP_VAR))) { \ + } else if (EXPECTED(_check_jmpz)) { \ if (_result) { \ ZEND_VM_SET_NEXT_OPCODE(opline + 2); \ } else { \ ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline + 1, (opline+1)->op2)); \ } \ - } else if (EXPECTED(opline->result_type == (IS_SMART_BRANCH_JMPNZ|IS_TMP_VAR))) { \ + } else if (EXPECTED(_check_jmpnz)) { \ if (!(_result)) { \ ZEND_VM_SET_NEXT_OPCODE(opline + 2); \ } else { \ @@ -5712,6 +5738,10 @@ static zend_always_inline zend_execute_data *_zend_vm_stack_push_call_frame(uint } \ ZEND_VM_CONTINUE(); \ } while (0) +#define ZEND_VM_SMART_BRANCH(_result, _check) do { \ + zend_op *wop = EX_WOP2; \ + ZEND_VM_SMART_BRANCH_EX(_result, _check, wop->result_type == (IS_SMART_BRANCH_JMPZ|IS_TMP_VAR), wop->result_type == (IS_SMART_BRANCH_JMPNZ|IS_TMP_VAR)); \ + } while (0) #define ZEND_VM_SMART_BRANCH_JMPZ(_result, _check) do { \ if ((_check) && UNEXPECTED(EG(exception))) { \ OPLINE = EX(opline); \ @@ -5737,10 +5767,10 @@ static zend_always_inline zend_execute_data *_zend_vm_stack_push_call_frame(uint ZEND_VM_NEXT_OPCODE_EX(_check, 1); \ ZEND_VM_CONTINUE(); \ } while (0) -#define ZEND_VM_SMART_BRANCH_TRUE() do { \ - if (EXPECTED(opline->result_type == (IS_SMART_BRANCH_JMPNZ|IS_TMP_VAR))) { \ +#define ZEND_VM_SMART_BRANCH_TRUE_EX(_check_jmpz, _check_jmpnz) do { \ + if (EXPECTED(_check_jmpnz)) { \ ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline + 1, (opline+1)->op2)); \ - } else if (EXPECTED(opline->result_type == (IS_SMART_BRANCH_JMPZ|IS_TMP_VAR))) { \ + } else if (EXPECTED(_check_jmpz)) { \ ZEND_VM_SET_NEXT_OPCODE(opline + 2); \ } else { \ ZVAL_TRUE(EX_VAR(opline->result.var)); \ @@ -5748,6 +5778,10 @@ static zend_always_inline zend_execute_data *_zend_vm_stack_push_call_frame(uint } \ ZEND_VM_CONTINUE(); \ } while (0) +#define ZEND_VM_SMART_BRANCH_TRUE() do { \ + zend_op *wop = EX_WOP2; \ + ZEND_VM_SMART_BRANCH_TRUE_EX(wop->result_type == (IS_SMART_BRANCH_JMPZ|IS_TMP_VAR), wop->result_type == (IS_SMART_BRANCH_JMPNZ|IS_TMP_VAR)); \ + } while (0) #define ZEND_VM_SMART_BRANCH_TRUE_JMPZ() do { \ ZEND_VM_SET_NEXT_OPCODE(opline + 2); \ ZEND_VM_CONTINUE(); \ @@ -5760,10 +5794,10 @@ static zend_always_inline zend_execute_data *_zend_vm_stack_push_call_frame(uint ZVAL_TRUE(EX_VAR(opline->result.var)); \ ZEND_VM_NEXT_OPCODE(); \ } while (0) -#define ZEND_VM_SMART_BRANCH_FALSE() do { \ - if (EXPECTED(opline->result_type == (IS_SMART_BRANCH_JMPNZ|IS_TMP_VAR))) { \ +#define ZEND_VM_SMART_BRANCH_FALSE_EX(_check_jmpz, _check_jmpnz) do { \ + if (EXPECTED(_check_jmpnz)) { \ ZEND_VM_SET_NEXT_OPCODE(opline + 2); \ - } else if (EXPECTED(opline->result_type == (IS_SMART_BRANCH_JMPZ|IS_TMP_VAR))) { \ + } else if (EXPECTED(_check_jmpz)) { \ ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline + 1, (opline+1)->op2)); \ } else { \ ZVAL_FALSE(EX_VAR(opline->result.var)); \ @@ -5771,6 +5805,10 @@ static zend_always_inline zend_execute_data *_zend_vm_stack_push_call_frame(uint } \ ZEND_VM_CONTINUE(); \ } while (0) +#define ZEND_VM_SMART_BRANCH_FALSE() do { \ + zend_op *wop = EX_WOP2; \ + ZEND_VM_SMART_BRANCH_FALSE_EX(wop->result_type == (IS_SMART_BRANCH_JMPZ|IS_TMP_VAR), wop->result_type == (IS_SMART_BRANCH_JMPNZ|IS_TMP_VAR)); \ + } while (0) #define ZEND_VM_SMART_BRANCH_FALSE_JMPZ() do { \ ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline + 1, (opline+1)->op2)); \ ZEND_VM_CONTINUE(); \ @@ -5791,16 +5829,44 @@ static zend_always_inline zend_execute_data *_zend_vm_stack_push_call_frame(uint #endif #define UNDEF_RESULT() do { \ - if (opline->result_type & (IS_VAR | IS_TMP_VAR)) { \ - ZVAL_UNDEF(EX_VAR(opline->result.var)); \ + zend_op *wop = EX_WOP2; \ + if (wop->result_type & (IS_VAR | IS_TMP_VAR)) { \ + ZVAL_UNDEF(EX_VAR(wop->result.var)); \ } \ } while (0) /* This callback disables optimization of "vm_stack_data" variable in VM */ ZEND_API void (ZEND_FASTCALL *zend_touch_vm_stack_data)(void *vm_stack_data) = NULL; +/* Redeclare Z_WOP_FROM_EX_OP to omit exception check. */ +#undef Z_WOP_FROM_EX_OP +#define Z_WOP_FROM_EX_OP(ex, op) _zend_sop_to_wop(&(ex)->func->op_array, op) +#define QUICK_OP_FLAGS_OP1_TYPE(field) (((field) & 0x00f) >> 0) +#define QUICK_OP_FLAGS_OP2_TYPE(field) (((field) & 0x0f0) >> 4) +#define QUICK_OP_FLAGS_OP_DATA_TYPE(field) (((field) & 0xf00) >> 8) +#define QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(field) ((field) & 0x1000) +#define QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(field) ((field) & 0x2000) +#define RT_OP1_TYPE (EX_WOP2->op1_type) +#define RT_OP2_TYPE (EX_WOP2->op2_type) +#define RT_OP_DATA_TYPE ((EX_WOP2+1)->op1_type) + #include "zend_vm_execute.h" +#undef Z_WOP_FROM_EX_OP +#define Z_WOP_FROM_EX_OP(ex, op) \ + /* (EXPECTED((op) != EG(exception_slim_op)) */ \ + ((op) != EG(exception_slim_op) \ + ? _zend_sop_to_wop(&(ex)->func->op_array, op) \ + : EG(exception_op)) +#undef QUICK_OPFLAGS_OP1_TYPE +#undef QUICK_OPFLAGS_OP2_TYPE +#undef QUICK_OPFLAGS_OP_DATA_TYPE +#undef QUICK_OP_FLAGS_SMART_BRANCH_JMPZ +#undef QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ +#undef RT_OP1_TYPE +#undef RT_OP2_TYPE +#undef RT_OP_DATA_TYPE + ZEND_API zend_result zend_set_user_opcode_handler(zend_uchar opcode, user_opcode_handler_t handler) { if (opcode != ZEND_USER_OPCODE) { diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c index 9a7803e44e66e..274ec555550ce 100644 --- a/Zend/zend_execute_API.c +++ b/Zend/zend_execute_API.c @@ -597,7 +597,7 @@ ZEND_API zend_function *zend_active_function_ex(zend_execute_data *execute_data) /* Resolve function if op is a frameless call. */ if (ZEND_USER_CODE(func->type)) { - const zend_op *op = EX(opline); + const zend_op *op = EX_WOP; if (ZEND_OP_IS_FRAMELESS_ICALL(op->opcode)) { func = ZEND_FLF_FUNC(op); } @@ -684,6 +684,10 @@ ZEND_API uint32_t zend_get_executed_lineno(void) /* {{{ */ return lineno_override; } + if (EG(capture_warnings_during_sccp) != 0) { + return 0; + } + zend_execute_data *ex = EG(current_execute_data); while (ex && (!ex->func || !ZEND_USER_CODE(ex->func->type))) { @@ -694,11 +698,12 @@ ZEND_API uint32_t zend_get_executed_lineno(void) /* {{{ */ /* Missing SAVE_OPLINE()? Falling back to first line of function */ return ex->func->op_array.opcodes[0].lineno; } - if (EG(exception) && ex->opline->opcode == ZEND_HANDLE_EXCEPTION && - ex->opline->lineno == 0 && EG(opline_before_exception)) { - return EG(opline_before_exception)->lineno; + if (EG(exception) + && ex->opline == EG(exception_slim_op) + && EG(opline_before_exception)) { + return Z_WOP_FROM_EX_OP(ex, EG(opline_before_exception))->lineno; } - return ex->opline->lineno; + return Z_WOP_FROM_EX(ex)->lineno; } else { return 0; } diff --git a/Zend/zend_frameless_function.h b/Zend/zend_frameless_function.h index d64ca7ee15e2f..bc91dc83e73ae 100644 --- a/Zend/zend_frameless_function.h +++ b/Zend/zend_frameless_function.h @@ -37,7 +37,7 @@ #define ZEND_OP_IS_FRAMELESS_ICALL(opcode) ((opcode) >= ZEND_FRAMELESS_ICALL_0 && (opcode) <= ZEND_FRAMELESS_ICALL_3) #define ZEND_FLF_NUM_ARGS(opcode) ((opcode) - ZEND_FRAMELESS_ICALL_0) #define ZEND_FLF_FUNC(opline) (zend_flf_functions[(opline)->extended_value]) -#define ZEND_FLF_HANDLER(opline) (zend_flf_handlers[(opline)->extended_value]) +#define ZEND_FLF_HANDLER(extended_value) (zend_flf_handlers[extended_value]) #define ZEND_FRAMELESS_FUNCTION(name, arity) \ void ZEND_FRAMELESS_FUNCTION_NAME(name, arity)(ZEND_FRAMELESS_FUNCTION_PARAMETERS_##arity) diff --git a/Zend/zend_gc.c b/Zend/zend_gc.c index 8da55fcd48f66..f2e71cfab273d 100644 --- a/Zend/zend_gc.c +++ b/Zend/zend_gc.c @@ -2161,7 +2161,7 @@ static void zend_gc_check_root_tmpvars(void) { continue; } - uint32_t op_num = ex->opline - ex->func->op_array.opcodes; + uint32_t op_num = Z_WOP_FROM_EX(ex) - ex->func->op_array.opcodes; for (uint32_t i = 0; i < func->op_array.last_live_range; i++) { const zend_live_range *range = &func->op_array.live_range[i]; if (range->start > op_num) { @@ -2191,7 +2191,7 @@ static void zend_gc_remove_root_tmpvars(void) { continue; } - uint32_t op_num = ex->opline - ex->func->op_array.opcodes; + uint32_t op_num = Z_WOP_FROM_EX(ex) - ex->func->op_array.opcodes; for (uint32_t i = 0; i < func->op_array.last_live_range; i++) { const zend_live_range *range = &func->op_array.live_range[i]; if (range->start > op_num) { diff --git a/Zend/zend_generators.c b/Zend/zend_generators.c index a6ea91a7425b9..7db9d40fc98e4 100644 --- a/Zend/zend_generators.c +++ b/Zend/zend_generators.c @@ -115,8 +115,8 @@ static void zend_generator_cleanup_unfinished_execution( zend_generator *generator, zend_execute_data *execute_data, uint32_t catch_op_num) /* {{{ */ { zend_op_array *op_array = &execute_data->func->op_array; - if (execute_data->opline != op_array->opcodes) { - uint32_t op_num = execute_data->opline - op_array->opcodes; + if (execute_data->opline != op_array->slim_opcodes) { + uint32_t op_num = execute_data->opline - op_array->slim_opcodes; if (UNEXPECTED(generator->frozen_call_stack)) { /* Temporarily restore generator->execute_data if it has been NULLed out already. */ @@ -285,7 +285,7 @@ static void zend_generator_dtor_storage(zend_object *object) /* {{{ */ return; } - op_num = ex->opline - ex->func->op_array.opcodes; + op_num = ex->opline - ex->func->op_array.slim_opcodes; try_catch_offset = -1; /* Find the innermost try/catch that we are inside of. */ @@ -310,13 +310,13 @@ static void zend_generator_dtor_storage(zend_object *object) /* {{{ */ zend_generator_cleanup_unfinished_execution(generator, ex, try_catch->finally_op); zend_object *old_exception = EG(exception); - const zend_op *old_opline_before_exception = EG(opline_before_exception); + const zend_slim_op *old_opline_before_exception = EG(opline_before_exception); EG(exception) = NULL; Z_OBJ_P(fast_call) = NULL; Z_OPLINE_NUM_P(fast_call) = (uint32_t)-1; /* -1 because zend_generator_resume() will increment it */ - ex->opline = &ex->func->op_array.opcodes[try_catch->finally_op] - 1; + ex->opline = &ex->func->op_array.slim_opcodes[try_catch->finally_op] - 1; generator->flags |= ZEND_GENERATOR_FORCED_CLOSE; zend_generator_resume(generator); @@ -605,7 +605,7 @@ ZEND_API zend_generator *zend_generator_update_current(zend_generator *generator zend_generator_remove_child(&new_root_parent->node, new_root); if (EXPECTED(EG(exception) == NULL) && EXPECTED((OBJ_FLAGS(&generator->std) & IS_OBJ_DESTRUCTOR_CALLED) == 0)) { - zend_op *yield_from = (zend_op *) new_root->execute_data->opline; + zend_op *yield_from = Z_WOP_FROM_EX(new_root->execute_data); if (yield_from->opcode == ZEND_YIELD_FROM) { if (Z_ISUNDEF(new_root_parent->retval)) { @@ -807,15 +807,18 @@ ZEND_API void zend_generator_resume(zend_generator *orig_generator) /* {{{ */ } /* Resume execution */ - ZEND_ASSERT(generator->execute_data->opline->opcode == ZEND_GENERATOR_CREATE - || generator->execute_data->opline->opcode == ZEND_YIELD - || generator->execute_data->opline->opcode == ZEND_YIELD_FROM +#if ZEND_DEBUG + zend_op *op = Z_WOP_FROM_EX(generator->execute_data); + ZEND_ASSERT(op->opcode == ZEND_GENERATOR_CREATE + || op->opcode == ZEND_YIELD + || op->opcode == ZEND_YIELD_FROM /* opline points to EG(exception_op), which is a sequence of * ZEND_HANDLE_EXCEPTION ops, so the following increment is safe */ - || generator->execute_data->opline->opcode == ZEND_HANDLE_EXCEPTION + || op->opcode == ZEND_HANDLE_EXCEPTION /* opline points to the start of a finally block minus one op to * account for the following increment */ || (generator->flags & ZEND_GENERATOR_FORCED_CLOSE)); +#endif generator->execute_data->opline++; generator->flags |= ZEND_GENERATOR_CURRENTLY_RUNNING; if (!ZEND_OBSERVER_ENABLED) { @@ -863,7 +866,7 @@ ZEND_API void zend_generator_resume(zend_generator *orig_generator) /* {{{ */ } /* yield from was used, try another resume. */ - if (UNEXPECTED((generator != orig_generator && !Z_ISUNDEF(generator->retval)) || (generator->execute_data && generator->execute_data->opline->opcode == ZEND_YIELD_FROM))) { + if (UNEXPECTED((generator != orig_generator && !Z_ISUNDEF(generator->retval)) || (generator->execute_data && Z_WOP_FROM_EX(generator->execute_data)->opcode == ZEND_YIELD_FROM))) { generator = zend_generator_get_current(orig_generator); goto try_again; } diff --git a/Zend/zend_globals.h b/Zend/zend_globals.h index 079bfb99caccf..6db31e1783b5a 100644 --- a/Zend/zend_globals.h +++ b/Zend/zend_globals.h @@ -256,8 +256,9 @@ struct _zend_executor_globals { zend_objects_store objects_store; zend_lazy_objects_store lazy_objects_store; zend_object *exception, *prev_exception; - const zend_op *opline_before_exception; + const zend_slim_op *opline_before_exception; zend_op exception_op[3]; + zend_slim_op exception_slim_op[3]; struct _zend_module_entry *current_module; @@ -278,6 +279,7 @@ struct _zend_executor_globals { zend_function trampoline; zend_op call_trampoline_op; + zend_slim_op call_trampoline_sop; HashTable weakrefs; diff --git a/Zend/zend_object_handlers.c b/Zend/zend_object_handlers.c index ba26ac7128a3d..3949e53845324 100644 --- a/Zend/zend_object_handlers.c +++ b/Zend/zend_object_handlers.c @@ -839,7 +839,7 @@ ZEND_API zval *zend_std_read_property(zend_object *zobj, zend_string *name, int /* Reads from backing store can only occur in hooks, and hence will always remain simple. */ zend_execute_data *execute_data = EG(current_execute_data); - if (cache_slot && EX(opline) && EX(opline)->opcode == ZEND_FETCH_OBJ_R && EX(opline)->op1_type == IS_UNUSED) { + if (cache_slot && EX(opline) && EX_WOP->opcode == ZEND_FETCH_OBJ_R && EX_WOP->op1_type == IS_UNUSED) { ZEND_SET_PROPERTY_HOOK_SIMPLE_READ(cache_slot); } @@ -1104,8 +1104,8 @@ found:; && EX(func) && ZEND_USER_CODE(EX(func)->common.type) && EX(opline) - && EX(opline)->opcode == ZEND_ASSIGN_OBJ - && EX(opline)->result_type) { + && EX_WOP->opcode == ZEND_ASSIGN_OBJ + && EX_WOP->result_type) { ZVAL_COPY_DEREF(EX_VAR(EX(opline)->result.var), variable_ptr); variable_ptr = NULL; } @@ -1164,7 +1164,7 @@ found:; /* Writes to backing store can only occur in hooks, and hence will always remain simple. */ zend_execute_data *execute_data = EG(current_execute_data); - if (cache_slot && EX(opline) && EX(opline)->opcode == ZEND_ASSIGN_OBJ && EX(opline)->op1_type == IS_UNUSED) { + if (cache_slot && EX(opline) && EX_WOP->opcode == ZEND_ASSIGN_OBJ && EX_WOP->op1_type == IS_UNUSED) { ZEND_SET_PROPERTY_HOOK_SIMPLE_WRITE(cache_slot); } @@ -1695,6 +1695,7 @@ ZEND_API zend_function *zend_get_call_trampoline_func(const zend_class_entry *ce func->fn_flags |= ZEND_ACC_STATIC; } func->opcodes = &EG(call_trampoline_op); + func->slim_opcodes = &EG(call_trampoline_sop); ZEND_MAP_PTR_INIT(func->run_time_cache, (void**)dummy); func->scope = fbc->common.scope; /* reserve space for arguments, local and temporary variables */ diff --git a/Zend/zend_objects.c b/Zend/zend_objects.c index fd0e97c5f4131..f9a349912ed7e 100644 --- a/Zend/zend_objects.c +++ b/Zend/zend_objects.c @@ -121,7 +121,7 @@ ZEND_API void zend_objects_destroy_object(zend_object *object) } zend_object *old_exception; - const zend_op *old_opline_before_exception; + const zend_slim_op *old_opline_before_exception; if (destructor->op_array.fn_flags & (ZEND_ACC_PRIVATE|ZEND_ACC_PROTECTED)) { if (destructor->op_array.fn_flags & ZEND_ACC_PRIVATE) { diff --git a/Zend/zend_observer.c b/Zend/zend_observer.c index 15722eb6b2eb3..f7a538dcb9017 100644 --- a/Zend/zend_observer.c +++ b/Zend/zend_observer.c @@ -76,6 +76,7 @@ ZEND_API void zend_observer_post_startup(void) * is called before any extensions have registered as an observer. So we * adjust the offset to the observed handler when we know we need to observe. */ ZEND_VM_SET_OPCODE_HANDLER(&EG(call_trampoline_op)); + EG(call_trampoline_sop).handler = EG(call_trampoline_op).handler; /* ZEND_HANDLE_EXCEPTION also has SPEC(OBSERVER) and no observer extensions * exist when zend_init_exception_op() is called. */ diff --git a/Zend/zend_opcode.c b/Zend/zend_opcode.c index 6e7d31e15a40f..67fb59be3215f 100644 --- a/Zend/zend_opcode.c +++ b/Zend/zend_opcode.c @@ -56,6 +56,8 @@ void init_op_array(zend_op_array *op_array, uint8_t type, int initial_ops_size) *op_array->refcount = 1; op_array->last = 0; op_array->opcodes = emalloc(initial_ops_size * sizeof(zend_op)); + /* Initialized in pass_two(). */ + op_array->slim_opcodes = NULL; op_array->last_var = 0; op_array->vars = NULL; @@ -599,8 +601,7 @@ ZEND_API void destroy_op_array(zend_op_array *op_array) zval_ptr_dtor_nogc(literal); literal++; } - if (ZEND_USE_ABS_CONST_ADDR - || !(op_array->fn_flags & ZEND_ACC_DONE_PASS_TWO)) { + if (!(op_array->fn_flags & ZEND_ACC_DONE_PASS_TWO)) { efree(op_array->literals); } } @@ -1049,6 +1050,49 @@ ZEND_API void zend_recalc_live_ranges( zend_calc_live_ranges(op_array, needs_live_range); } +ZEND_API void zend_setup_quick_op_flags(zend_op *opline, zend_slim_op *slim_op) +{ + if (opline->opcode == ZEND_OP_DATA) { + return; + } + + uint64_t opcode_flags = zend_get_opcode_flags(opline->opcode); + uint64_t field = (opcode_flags & ZEND_VM_QUICK_OP_FLAGS_FIELD_MASK); + if (field == ZEND_VM_QUICK_OP_FLAGS_FIELD_NONE) { + return; + } + + uint16_t quick_flags = 0; + quick_flags |= (opline->op1_type << 0); + quick_flags |= (opline->op2_type << 4); + if ((opline+1)->opcode == ZEND_OP_DATA) { + quick_flags |= ((opline+1)->op1_type << 8); + } + if (opline->result_type == (IS_SMART_BRANCH_JMPZ|IS_TMP_VAR)) { + quick_flags |= 0x1000; + } else if (opline->result_type == (IS_SMART_BRANCH_JMPNZ|IS_TMP_VAR)) { + quick_flags |= 0x2000; + } + + switch (field) { + case ZEND_VM_QUICK_OP_FLAGS_FIELD_EXT_VALUE: + slim_op->extended_value = quick_flags; + break; + case ZEND_VM_QUICK_OP_FLAGS_FIELD_OP1: + slim_op->op1.num = quick_flags; + break; + case ZEND_VM_QUICK_OP_FLAGS_FIELD_OP2: + slim_op->op2.num = quick_flags; + break; + case ZEND_VM_QUICK_OP_FLAGS_FIELD_RESULT: + slim_op->result.num = quick_flags; + break; + case ZEND_VM_QUICK_OP_FLAGS_FIELD_OP_DATA_OP2: + (slim_op+1)->op2.num = quick_flags; + break; + } +} + ZEND_API void pass_two(zend_op_array *op_array) { zend_op *opline, *end; @@ -1070,28 +1114,19 @@ ZEND_API void pass_two(zend_op_array *op_array) CG(context).vars_size = op_array->last_var; } -#if ZEND_USE_ABS_CONST_ADDR - if (CG(context).opcodes_size != op_array->last) { - op_array->opcodes = (zend_op *) erealloc(op_array->opcodes, sizeof(zend_op)*op_array->last); - CG(context).opcodes_size = op_array->last; - } - if (CG(context).literals_size != op_array->last_literal) { - op_array->literals = (zval*)erealloc(op_array->literals, sizeof(zval) * op_array->last_literal); - CG(context).literals_size = op_array->last_literal; - } -#else op_array->opcodes = (zend_op *) erealloc(op_array->opcodes, - ZEND_MM_ALIGNED_SIZE_EX(sizeof(zend_op) * op_array->last, 16) + - sizeof(zval) * op_array->last_literal); + ZEND_MM_ALIGNED_SIZE_EX(sizeof(zend_op) * op_array->last, 16) + + ZEND_MM_ALIGNED_SIZE_EX(sizeof(zend_slim_op) * op_array->last, 16) + + sizeof(zval) * op_array->last_literal); + op_array->slim_opcodes = (zend_slim_op*)(((char*)op_array->opcodes) + ZEND_MM_ALIGNED_SIZE_EX(sizeof(zend_op) * op_array->last, 16)); if (op_array->literals) { - memcpy(((char*)op_array->opcodes) + ZEND_MM_ALIGNED_SIZE_EX(sizeof(zend_op) * op_array->last, 16), - op_array->literals, sizeof(zval) * op_array->last_literal); - efree(op_array->literals); - op_array->literals = (zval*)(((char*)op_array->opcodes) + ZEND_MM_ALIGNED_SIZE_EX(sizeof(zend_op) * op_array->last, 16)); + zval *literals = op_array->literals; + op_array->literals = (zval*)(((char*)op_array->slim_opcodes) + ZEND_MM_ALIGNED_SIZE_EX(sizeof(zend_slim_op) * op_array->last, 16)); + memcpy(op_array->literals, literals, sizeof(zval) * op_array->last_literal); + efree(literals); } CG(context).opcodes_size = op_array->last; CG(context).literals_size = op_array->last_literal; -#endif op_array->T += ZEND_OBSERVER_ENABLED; // reserve last temporary for observers if enabled @@ -1101,6 +1136,7 @@ ZEND_API void pass_two(zend_op_array *op_array) opline = op_array->opcodes; end = opline + op_array->last; + zend_slim_op *slim_op = op_array->slim_opcodes; while (opline < end) { switch (opline->opcode) { case ZEND_RECV_INIT: @@ -1115,7 +1151,7 @@ ZEND_API void pass_two(zend_op_array *op_array) break; case ZEND_FAST_CALL: opline->op1.opline_num = op_array->try_catch_array[opline->op1.num].finally_op; - ZEND_PASS_TWO_UPDATE_JMP_TARGET(op_array, opline, opline->op1); + ZEND_PASS_TWO_UPDATE_JMP_TARGET(op_array, slim_op, opline->op1); break; case ZEND_BRK: case ZEND_CONT: @@ -1128,7 +1164,7 @@ ZEND_API void pass_two(zend_op_array *op_array) opline->opcode = ZEND_JMP; opline->op1.opline_num = jmp_target; opline->op2.num = 0; - ZEND_PASS_TWO_UPDATE_JMP_TARGET(op_array, opline, opline->op1); + ZEND_PASS_TWO_UPDATE_JMP_TARGET(op_array, slim_op, opline->op1); } break; case ZEND_GOTO: @@ -1138,7 +1174,7 @@ ZEND_API void pass_two(zend_op_array *op_array) } ZEND_FALLTHROUGH; case ZEND_JMP: - ZEND_PASS_TWO_UPDATE_JMP_TARGET(op_array, opline, opline->op1); + ZEND_PASS_TWO_UPDATE_JMP_TARGET(op_array, slim_op, opline->op1); break; case ZEND_JMPZ: case ZEND_JMPNZ: @@ -1151,7 +1187,7 @@ ZEND_API void pass_two(zend_op_array *op_array) case ZEND_JMP_NULL: case ZEND_BIND_INIT_STATIC_OR_JMP: case ZEND_JMP_FRAMELESS: - ZEND_PASS_TWO_UPDATE_JMP_TARGET(op_array, opline, opline->op2); + ZEND_PASS_TWO_UPDATE_JMP_TARGET(op_array, slim_op, opline->op2); break; case ZEND_ASSERT_CHECK: { @@ -1161,19 +1197,19 @@ ZEND_API void pass_two(zend_op_array *op_array) call--; } if (call->result_type == IS_UNUSED) { - opline->result_type = IS_UNUSED; + SET_UNUSED(opline->result); } - ZEND_PASS_TWO_UPDATE_JMP_TARGET(op_array, opline, opline->op2); + ZEND_PASS_TWO_UPDATE_JMP_TARGET(op_array, slim_op, opline->op2); break; } case ZEND_FE_FETCH_R: case ZEND_FE_FETCH_RW: /* absolute index to relative offset */ - opline->extended_value = ZEND_OPLINE_NUM_TO_OFFSET(op_array, opline, opline->extended_value); + opline->extended_value = ZEND_OPLINE_NUM_TO_OFFSET(op_array, slim_op, opline->extended_value); break; case ZEND_CATCH: if (!(opline->extended_value & ZEND_LAST_CATCH)) { - ZEND_PASS_TWO_UPDATE_JMP_TARGET(op_array, opline, opline->op2); + ZEND_PASS_TWO_UPDATE_JMP_TARGET(op_array, slim_op, opline->op2); } break; case ZEND_RETURN: @@ -1190,28 +1226,57 @@ ZEND_API void pass_two(zend_op_array *op_array) HashTable *jumptable = Z_ARRVAL_P(CT_CONSTANT(opline->op2)); zval *zv; ZEND_HASH_FOREACH_VAL(jumptable, zv) { - Z_LVAL_P(zv) = ZEND_OPLINE_NUM_TO_OFFSET(op_array, opline, Z_LVAL_P(zv)); + Z_LVAL_P(zv) = ZEND_OPLINE_NUM_TO_OFFSET(op_array, slim_op, Z_LVAL_P(zv)); } ZEND_HASH_FOREACH_END(); - opline->extended_value = ZEND_OPLINE_NUM_TO_OFFSET(op_array, opline, opline->extended_value); + opline->extended_value = ZEND_OPLINE_NUM_TO_OFFSET(op_array, slim_op, opline->extended_value); break; } } + + slim_op->op1 = opline->op1; + slim_op->op2 = opline->op2; + slim_op->result = opline->result; + if (opline->op1_type == IS_CONST) { + ZEND_PASS_TWO_UPDATE_CONSTANT(op_array, slim_op, slim_op->op1); ZEND_PASS_TWO_UPDATE_CONSTANT(op_array, opline, opline->op1); } else if (opline->op1_type & (IS_VAR|IS_TMP_VAR)) { - opline->op1.var = EX_NUM_TO_VAR(op_array->last_var + opline->op1.var); + opline->op1.var = slim_op->op1.var = EX_NUM_TO_VAR(op_array->last_var + opline->op1.var); } if (opline->op2_type == IS_CONST) { + ZEND_PASS_TWO_UPDATE_CONSTANT(op_array, slim_op, slim_op->op2); ZEND_PASS_TWO_UPDATE_CONSTANT(op_array, opline, opline->op2); } else if (opline->op2_type & (IS_VAR|IS_TMP_VAR)) { - opline->op2.var = EX_NUM_TO_VAR(op_array->last_var + opline->op2.var); + opline->op2.var = slim_op->op2.var = EX_NUM_TO_VAR(op_array->last_var + opline->op2.var); } if (opline->result_type & (IS_VAR|IS_TMP_VAR)) { - opline->result.var = EX_NUM_TO_VAR(op_array->last_var + opline->result.var); + opline->result.var = slim_op->result.var = EX_NUM_TO_VAR(op_array->last_var + opline->result.var); } + + uint8_t prev_op1_type = opline->op1_type; ZEND_VM_SET_OPCODE_HANDLER(opline); + + /* Check if operands were swapped. */ + if (opline->op1_type != prev_op1_type) { + znode_op tmp = slim_op->op1; + slim_op->op1 = slim_op->op2; + slim_op->op2 = tmp; + } + + slim_op->handler = opline->handler; + slim_op->result = opline->result; + slim_op->extended_value = opline->extended_value; + + zend_setup_quick_op_flags(opline, slim_op); + + // FIXME: Ugly workaround, we break op_data->extended_value, repeat for previous opcode + if (opline->opcode == ZEND_OP_DATA) { + zend_setup_quick_op_flags(opline-1, slim_op-1); + } + opline++; + slim_op++; } zend_calc_live_ranges(op_array, NULL); diff --git a/Zend/zend_vm.h b/Zend/zend_vm.h index c9c41c75c72a2..5c2a62e7758b6 100644 --- a/Zend/zend_vm.h +++ b/Zend/zend_vm.h @@ -22,6 +22,7 @@ #include "zend_portability.h" typedef struct _zend_op zend_op; +typedef struct _zend_slim_op zend_slim_op; typedef struct _zend_execute_data zend_execute_data; BEGIN_EXTERN_C() @@ -31,7 +32,7 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* opcode, uint3 ZEND_API void ZEND_FASTCALL zend_serialize_opcode_handler(zend_op *op); ZEND_API void ZEND_FASTCALL zend_deserialize_opcode_handler(zend_op *op); ZEND_API const void* ZEND_FASTCALL zend_get_opcode_handler_func(const zend_op *op); -ZEND_API const zend_op *zend_get_halt_op(void); +ZEND_API const zend_slim_op *zend_get_halt_op(void); ZEND_API int ZEND_FASTCALL zend_vm_call_opcode_handler(zend_execute_data *ex); ZEND_API int zend_vm_kind(void); ZEND_API bool zend_gcc_global_regs(void); diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index d0e5dd21cd03b..71f434b2356ca 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -23,7 +23,7 @@ * php zend_vm_gen.php */ -ZEND_VM_HELPER(zend_add_helper, ANY, ANY, zval *op_1, zval *op_2) +ZEND_VM_HELPER(zend_add_helper, ANY, ANY, zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) { USE_OPLINE @@ -35,10 +35,10 @@ ZEND_VM_HELPER(zend_add_helper, ANY, ANY, zval *op_1, zval *op_2) op_2 = ZVAL_UNDEFINED_OP2(); } add_function(EX_VAR(opline->result.var), op_1, op_2); - if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) { + if (op1_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) { + if (op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -79,10 +79,12 @@ ZEND_VM_C_LABEL(add_double): } } - ZEND_VM_DISPATCH_TO_HELPER(zend_add_helper, op_1, op1, op_2, op2); + uint8_t op1_type = RT_OP1_TYPE; + uint8_t op2_type = RT_OP2_TYPE; + ZEND_VM_DISPATCH_TO_HELPER(zend_add_helper, op_1, op1, op_2, op2, op1_type, op1_type, op2_type, op2_type); } -ZEND_VM_HELPER(zend_sub_helper, ANY, ANY, zval *op_1, zval *op_2) +ZEND_VM_HELPER(zend_sub_helper, ANY, ANY, zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) { USE_OPLINE @@ -94,10 +96,10 @@ ZEND_VM_HELPER(zend_sub_helper, ANY, ANY, zval *op_1, zval *op_2) op_2 = ZVAL_UNDEFINED_OP2(); } sub_function(EX_VAR(opline->result.var), op_1, op_2); - if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) { + if (op1_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) { + if (op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -138,10 +140,12 @@ ZEND_VM_C_LABEL(sub_double): } } - ZEND_VM_DISPATCH_TO_HELPER(zend_sub_helper, op_1, op1, op_2, op2); + uint8_t op1_type = RT_OP1_TYPE; + uint8_t op2_type = RT_OP2_TYPE; + ZEND_VM_DISPATCH_TO_HELPER(zend_sub_helper, op_1, op1, op_2, op2, op1_type, op1_type, op2_type, op2_type); } -ZEND_VM_HELPER(zend_mul_helper, ANY, ANY, zval *op_1, zval *op_2) +ZEND_VM_HELPER(zend_mul_helper, ANY, ANY, zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) { USE_OPLINE @@ -153,10 +157,10 @@ ZEND_VM_HELPER(zend_mul_helper, ANY, ANY, zval *op_1, zval *op_2) op_2 = ZVAL_UNDEFINED_OP2(); } mul_function(EX_VAR(opline->result.var), op_1, op_2); - if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) { + if (op1_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) { + if (op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -200,7 +204,9 @@ ZEND_VM_C_LABEL(mul_double): } } - ZEND_VM_DISPATCH_TO_HELPER(zend_mul_helper, op_1, op1, op_2, op2); + uint8_t op1_type = RT_OP1_TYPE; + uint8_t op2_type = RT_OP2_TYPE; + ZEND_VM_DISPATCH_TO_HELPER(zend_mul_helper, op_1, op1, op_2, op2, op1_type, op1_type, op2_type, op2_type); } ZEND_VM_COLD_CONSTCONST_HANDLER(4, ZEND_DIV, CONST|TMPVAR|CV, CONST|TMPVAR|CV) @@ -227,7 +233,7 @@ ZEND_VM_COLD_HELPER(zend_mod_by_zero_helper, ANY, ANY) HANDLE_EXCEPTION(); } -ZEND_VM_HELPER(zend_mod_helper, ANY, ANY, zval *op_1, zval *op_2) +ZEND_VM_HELPER(zend_mod_helper, ANY, ANY, zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) { USE_OPLINE @@ -239,10 +245,10 @@ ZEND_VM_HELPER(zend_mod_helper, ANY, ANY, zval *op_1, zval *op_2) op_2 = ZVAL_UNDEFINED_OP2(); } mod_function(EX_VAR(opline->result.var), op_1, op_2); - if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) { + if (op1_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) { + if (op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -272,10 +278,12 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(5, ZEND_MOD, CONST|TMPVARCV, CONST|TMPVARCV) } } - ZEND_VM_DISPATCH_TO_HELPER(zend_mod_helper, op_1, op1, op_2, op2); + uint8_t op1_type = RT_OP1_TYPE; + uint8_t op2_type = RT_OP2_TYPE; + ZEND_VM_DISPATCH_TO_HELPER(zend_mod_helper, op_1, op1, op_2, op2, op1_type, op1_type, op2_type, op2_type); } -ZEND_VM_HELPER(zend_shift_left_helper, ANY, ANY, zval *op_1, zval *op_2) +ZEND_VM_HELPER(zend_shift_left_helper, ANY, ANY, zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) { USE_OPLINE @@ -287,10 +295,10 @@ ZEND_VM_HELPER(zend_shift_left_helper, ANY, ANY, zval *op_1, zval *op_2) op_2 = ZVAL_UNDEFINED_OP2(); } shift_left_function(EX_VAR(opline->result.var), op_1, op_2); - if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) { + if (op1_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) { + if (op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -314,10 +322,12 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(6, ZEND_SL, CONST|TMPVARCV, CONST|TMPVARCV) ZEND_VM_NEXT_OPCODE(); } - ZEND_VM_DISPATCH_TO_HELPER(zend_shift_left_helper, op_1, op1, op_2, op2); + uint8_t op1_type = RT_OP1_TYPE; + uint8_t op2_type = RT_OP2_TYPE; + ZEND_VM_DISPATCH_TO_HELPER(zend_shift_left_helper, op_1, op1, op_2, op2, op1_type, op1_type, op2_type, op2_type); } -ZEND_VM_HELPER(zend_shift_right_helper, ANY, ANY, zval *op_1, zval *op_2) +ZEND_VM_HELPER(zend_shift_right_helper, ANY, ANY, zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) { USE_OPLINE @@ -329,10 +339,10 @@ ZEND_VM_HELPER(zend_shift_right_helper, ANY, ANY, zval *op_1, zval *op_2) op_2 = ZVAL_UNDEFINED_OP2(); } shift_right_function(EX_VAR(opline->result.var), op_1, op_2); - if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) { + if (op1_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) { + if (op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -354,7 +364,9 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(7, ZEND_SR, CONST|TMPVARCV, CONST|TMPVARCV) ZEND_VM_NEXT_OPCODE(); } - ZEND_VM_DISPATCH_TO_HELPER(zend_shift_right_helper, op_1, op1, op_2, op2); + uint8_t op1_type = RT_OP1_TYPE; + uint8_t op2_type = RT_OP2_TYPE; + ZEND_VM_DISPATCH_TO_HELPER(zend_shift_right_helper, op_1, op1, op_2, op2, op1_type, op1_type, op2_type, op2_type); } ZEND_VM_COLD_CONSTCONST_HANDLER(12, ZEND_POW, CONST|TMPVAR|CV, CONST|TMPVAR|CV) @@ -492,7 +504,7 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(17, ZEND_IS_NOT_IDENTICAL, CONST|TMP|VAR|CV, CON ZEND_VM_SMART_BRANCH(result, 1); } -ZEND_VM_HELPER(zend_is_equal_helper, ANY, ANY, zval *op_1, zval *op_2) +ZEND_VM_HELPER(zend_is_equal_helper, ANY, ANY, zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) { int ret; USE_OPLINE @@ -505,10 +517,10 @@ ZEND_VM_HELPER(zend_is_equal_helper, ANY, ANY, zval *op_1, zval *op_2) op_2 = ZVAL_UNDEFINED_OP2(); } ret = zend_compare(op_1, op_2); - if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) { + if (op1_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) { + if (op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_SMART_BRANCH(ret == 0, 1); @@ -569,10 +581,12 @@ ZEND_VM_C_LABEL(is_equal_double): } } } - ZEND_VM_DISPATCH_TO_HELPER(zend_is_equal_helper, op_1, op1, op_2, op2); + uint8_t op1_type = RT_OP1_TYPE; + uint8_t op2_type = RT_OP2_TYPE; + ZEND_VM_DISPATCH_TO_HELPER(zend_is_equal_helper, op_1, op1, op_2, op2, op1_type, op1_type, op2_type, op2_type); } -ZEND_VM_HELPER(zend_is_not_equal_helper, ANY, ANY, zval *op_1, zval *op_2) +ZEND_VM_HELPER(zend_is_not_equal_helper, ANY, ANY, zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) { int ret; USE_OPLINE @@ -585,10 +599,10 @@ ZEND_VM_HELPER(zend_is_not_equal_helper, ANY, ANY, zval *op_1, zval *op_2) op_2 = ZVAL_UNDEFINED_OP2(); } ret = zend_compare(op_1, op_2); - if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) { + if (op1_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) { + if (op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_SMART_BRANCH(ret != 0, 1); @@ -649,10 +663,12 @@ ZEND_VM_C_LABEL(is_not_equal_double): } } } - ZEND_VM_DISPATCH_TO_HELPER(zend_is_not_equal_helper, op_1, op1, op_2, op2); + uint8_t op1_type = RT_OP1_TYPE; + uint8_t op2_type = RT_OP2_TYPE; + ZEND_VM_DISPATCH_TO_HELPER(zend_is_not_equal_helper, op_1, op1, op_2, op2, op1_type, op1_type, op2_type, op2_type); } -ZEND_VM_HELPER(zend_is_smaller_helper, ANY, ANY, zval *op_1, zval *op_2) +ZEND_VM_HELPER(zend_is_smaller_helper, ANY, ANY, zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) { int ret; USE_OPLINE @@ -665,10 +681,10 @@ ZEND_VM_HELPER(zend_is_smaller_helper, ANY, ANY, zval *op_1, zval *op_2) op_2 = ZVAL_UNDEFINED_OP2(); } ret = zend_compare(op_1, op_2); - if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) { + if (op1_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) { + if (op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_SMART_BRANCH(ret < 0, 1); @@ -714,10 +730,12 @@ ZEND_VM_C_LABEL(is_smaller_double): ZEND_VM_C_GOTO(is_smaller_double); } } - ZEND_VM_DISPATCH_TO_HELPER(zend_is_smaller_helper, op_1, op1, op_2, op2); + uint8_t op1_type = RT_OP1_TYPE; + uint8_t op2_type = RT_OP2_TYPE; + ZEND_VM_DISPATCH_TO_HELPER(zend_is_smaller_helper, op_1, op1, op_2, op2, op1_type, op1_type, op2_type, op2_type); } -ZEND_VM_HELPER(zend_is_smaller_or_equal_helper, ANY, ANY, zval *op_1, zval *op_2) +ZEND_VM_HELPER(zend_is_smaller_or_equal_helper, ANY, ANY, zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) { int ret; USE_OPLINE @@ -730,10 +748,10 @@ ZEND_VM_HELPER(zend_is_smaller_or_equal_helper, ANY, ANY, zval *op_1, zval *op_2 op_2 = ZVAL_UNDEFINED_OP2(); } ret = zend_compare(op_1, op_2); - if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) { + if (op1_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) { + if (op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_SMART_BRANCH(ret <= 0, 1); @@ -783,7 +801,9 @@ ZEND_VM_C_LABEL(is_smaller_or_equal_double): ZEND_VM_C_GOTO(is_smaller_or_equal_double); } } - ZEND_VM_DISPATCH_TO_HELPER(zend_is_smaller_or_equal_helper, op_1, op1, op_2, op2); + uint8_t op1_type = RT_OP1_TYPE; + uint8_t op2_type = RT_OP2_TYPE; + ZEND_VM_DISPATCH_TO_HELPER(zend_is_smaller_or_equal_helper, op_1, op1, op_2, op2, op1_type, op1_type, op2_type, op2_type); } ZEND_VM_COLD_CONSTCONST_HANDLER(170, ZEND_SPACESHIP, CONST|TMPVAR|CV, CONST|TMPVAR|CV) @@ -800,7 +820,7 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(170, ZEND_SPACESHIP, CONST|TMPVAR|CV, CONST|TMPV ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -ZEND_VM_HELPER(zend_bw_or_helper, ANY, ANY, zval *op_1, zval *op_2) +ZEND_VM_HELPER(zend_bw_or_helper, ANY, ANY, zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) { USE_OPLINE @@ -812,10 +832,10 @@ ZEND_VM_HELPER(zend_bw_or_helper, ANY, ANY, zval *op_1, zval *op_2) op_2 = ZVAL_UNDEFINED_OP2(); } bitwise_or_function(EX_VAR(opline->result.var), op_1, op_2); - if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) { + if (op1_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) { + if (op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -836,10 +856,12 @@ ZEND_VM_HOT_NOCONSTCONST_HANDLER(9, ZEND_BW_OR, CONST|TMPVARCV, CONST|TMPVARCV, ZEND_VM_NEXT_OPCODE(); } - ZEND_VM_DISPATCH_TO_HELPER(zend_bw_or_helper, op_1, op1, op_2, op2); + uint8_t op1_type = RT_OP1_TYPE; + uint8_t op2_type = RT_OP2_TYPE; + ZEND_VM_DISPATCH_TO_HELPER(zend_bw_or_helper, op_1, op1, op_2, op2, op1_type, op1_type, op2_type, op2_type); } -ZEND_VM_HELPER(zend_bw_and_helper, ANY, ANY, zval *op_1, zval *op_2) +ZEND_VM_HELPER(zend_bw_and_helper, ANY, ANY, zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) { USE_OPLINE @@ -851,10 +873,10 @@ ZEND_VM_HELPER(zend_bw_and_helper, ANY, ANY, zval *op_1, zval *op_2) op_2 = ZVAL_UNDEFINED_OP2(); } bitwise_and_function(EX_VAR(opline->result.var), op_1, op_2); - if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) { + if (op1_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) { + if (op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -875,10 +897,12 @@ ZEND_VM_HOT_NOCONSTCONST_HANDLER(10, ZEND_BW_AND, CONST|TMPVARCV, CONST|TMPVARCV ZEND_VM_NEXT_OPCODE(); } - ZEND_VM_DISPATCH_TO_HELPER(zend_bw_and_helper, op_1, op1, op_2, op2); + uint8_t op1_type = RT_OP1_TYPE; + uint8_t op2_type = RT_OP2_TYPE; + ZEND_VM_DISPATCH_TO_HELPER(zend_bw_and_helper, op_1, op1, op_2, op2, op1_type, op1_type, op2_type, op2_type); } -ZEND_VM_HELPER(zend_bw_xor_helper, ANY, ANY, zval *op_1, zval *op_2) +ZEND_VM_HELPER(zend_bw_xor_helper, ANY, ANY, zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) { USE_OPLINE @@ -890,10 +914,10 @@ ZEND_VM_HELPER(zend_bw_xor_helper, ANY, ANY, zval *op_1, zval *op_2) op_2 = ZVAL_UNDEFINED_OP2(); } bitwise_xor_function(EX_VAR(opline->result.var), op_1, op_2); - if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) { + if (op1_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) { + if (op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -914,7 +938,9 @@ ZEND_VM_HOT_NOCONSTCONST_HANDLER(11, ZEND_BW_XOR, CONST|TMPVARCV, CONST|TMPVARCV ZEND_VM_NEXT_OPCODE(); } - ZEND_VM_DISPATCH_TO_HELPER(zend_bw_xor_helper, op_1, op1, op_2, op2); + uint8_t op1_type = RT_OP1_TYPE; + uint8_t op2_type = RT_OP2_TYPE; + ZEND_VM_DISPATCH_TO_HELPER(zend_bw_xor_helper, op_1, op1, op_2, op2, op1_type, op1_type, op2_type, op2_type); } ZEND_VM_COLD_CONSTCONST_HANDLER(15, ZEND_BOOL_XOR, CONST|TMPVAR|CV, CONST|TMPVAR|CV, SPEC(COMMUTATIVE)) @@ -931,7 +957,7 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(15, ZEND_BOOL_XOR, CONST|TMPVAR|CV, CONST|TMPVAR ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -ZEND_VM_HELPER(zend_bw_not_helper, ANY, ANY, zval *op_1) +ZEND_VM_HELPER(zend_bw_not_helper, ANY, ANY, zval *op_1, uint8_t op1_type) { USE_OPLINE @@ -940,7 +966,9 @@ ZEND_VM_HELPER(zend_bw_not_helper, ANY, ANY, zval *op_1) op_1 = ZVAL_UNDEFINED_OP1(); } bitwise_not_function(EX_VAR(opline->result.var), op_1); - FREE_OP1(); + if (op1_type & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_nogc(op_1); + } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -955,7 +983,8 @@ ZEND_VM_HOT_NOCONST_HANDLER(13, ZEND_BW_NOT, CONST|TMPVARCV, UNUSED) ZEND_VM_NEXT_OPCODE(); } - ZEND_VM_DISPATCH_TO_HELPER(zend_bw_not_helper, op_1, op1); + uint8_t op1_type = RT_OP1_TYPE; + ZEND_VM_DISPATCH_TO_HELPER(zend_bw_not_helper, op_1, op1, op1_type, op1_type); } ZEND_VM_COLD_CONST_HANDLER(14, ZEND_BOOL_NOT, CONST|TMPVAR|CV, UNUSED) @@ -1053,7 +1082,7 @@ ZEND_VM_C_LABEL(assign_op_object): cache_slot = (OP2_TYPE == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot; if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) { if (UNEXPECTED(Z_ISERROR_P(zptr))) { - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } else { @@ -1078,7 +1107,7 @@ ZEND_VM_C_LABEL(assign_op_object): } } while (0); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { ZVAL_COPY(EX_VAR(opline->result.var), zptr); } } @@ -1109,7 +1138,7 @@ ZEND_VM_HANDLER(29, ZEND_ASSIGN_STATIC_PROP_OP, ANY, ANY, OP) SAVE_OPLINE(); - prop = zend_fetch_static_property_address(&prop_info, (opline+1)->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC); + prop = zend_fetch_static_property_address(&prop_info, (opline+1)->extended_value, BP_VAR_RW, 0, OP1_TYPE, OP2_TYPE OPLINE_CC EXECUTE_DATA_CC); if (UNEXPECTED(!prop)) { UNDEF_RESULT(); FREE_OP_DATA(); @@ -1144,7 +1173,7 @@ ZEND_VM_HANDLER(29, ZEND_ASSIGN_STATIC_PROP_OP, ANY, ANY, OP) } } while (0); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { ZVAL_COPY(EX_VAR(opline->result.var), prop); } @@ -1186,7 +1215,7 @@ ZEND_VM_C_LABEL(assign_dim_op_new_array): } } - value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1); + value = get_op_data_zval_ptr_r(RT_OP_DATA_TYPE, (opline+1)->op1); do { if (OP2_TYPE != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) { @@ -1200,10 +1229,10 @@ ZEND_VM_C_LABEL(assign_dim_op_new_array): zend_binary_op(var_ptr, var_ptr, value OPLINE_CC); } while (0); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } - FREE_OP((opline+1)->op1_type, (opline+1)->op1.var); + FREE_OP_DATA(); } else { if (EXPECTED(Z_ISREF_P(container))) { container = Z_REFVAL_P(container); @@ -1243,7 +1272,7 @@ ZEND_VM_C_LABEL(assign_dim_op_new_array): zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC); ZEND_VM_C_LABEL(assign_dim_op_ret_null): FREE_OP_DATA(); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -1276,7 +1305,7 @@ ZEND_VM_HANDLER(26, ZEND_ASSIGN_OP, VAR|CV, CONST|TMPVAR|CV, OP) zend_binary_op(var_ptr, var_ptr, value OPLINE_CC); } while (0); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } @@ -1330,7 +1359,7 @@ ZEND_VM_C_LABEL(pre_incdec_object): cache_slot = (OP2_TYPE == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot; if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) { if (UNEXPECTED(Z_ISERROR_P(zptr))) { - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } else { @@ -1432,7 +1461,7 @@ ZEND_VM_HANDLER(38, ZEND_PRE_INC_STATIC_PROP, ANY, ANY, CACHE_SLOT) SAVE_OPLINE(); - prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC); + prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_RW, 0, OP1_TYPE, OP2_TYPE OPLINE_CC EXECUTE_DATA_CC); if (UNEXPECTED(!prop)) { UNDEF_RESULT(); HANDLE_EXCEPTION(); @@ -1466,7 +1495,7 @@ ZEND_VM_HANDLER(40, ZEND_POST_INC_STATIC_PROP, ANY, ANY, CACHE_SLOT) SAVE_OPLINE(); - prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC); + prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_RW, 0, OP1_TYPE, OP2_TYPE OPLINE_CC EXECUTE_DATA_CC); if (UNEXPECTED(!prop)) { UNDEF_RESULT(); HANDLE_EXCEPTION(); @@ -1516,7 +1545,7 @@ ZEND_VM_HELPER(zend_pre_inc_helper, VAR|CV, ANY) increment_function(var_ptr); } while (0); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } @@ -1533,7 +1562,7 @@ ZEND_VM_HOT_HANDLER(34, ZEND_PRE_INC, VAR|CV, ANY, SPEC(RETVAL)) if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) { fast_long_increment_function(var_ptr); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr); } ZEND_VM_NEXT_OPCODE(); @@ -1568,7 +1597,7 @@ ZEND_VM_HELPER(zend_pre_dec_helper, VAR|CV, ANY) decrement_function(var_ptr); } while (0); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } @@ -1585,7 +1614,7 @@ ZEND_VM_HOT_HANDLER(35, ZEND_PRE_DEC, VAR|CV, ANY, SPEC(RETVAL)) if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) { fast_long_decrement_function(var_ptr); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr); } ZEND_VM_NEXT_OPCODE(); @@ -1854,7 +1883,7 @@ ZEND_VM_HANDLER(89, ZEND_FETCH_IS, CONST|TMPVAR|CV, UNUSED, VAR_FETCH) } /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ -ZEND_VM_INLINE_HELPER(zend_fetch_static_prop_helper, ANY, ANY, int type) +ZEND_VM_INLINE_HELPER(zend_fetch_static_prop_helper, ANY, ANY, int type, uint8_t op1_type, uint8_t op2_type) { USE_OPLINE zval *prop; @@ -1864,7 +1893,7 @@ ZEND_VM_INLINE_HELPER(zend_fetch_static_prop_helper, ANY, ANY, int type) prop = zend_fetch_static_property_address( &prop_info, opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS, type, - type == BP_VAR_W ? opline->extended_value : 0 OPLINE_CC EXECUTE_DATA_CC); + type == BP_VAR_W ? opline->extended_value : 0, op1_type, op2_type OPLINE_CC EXECUTE_DATA_CC); if (UNEXPECTED(!prop)) { ZEND_ASSERT(EG(exception) || (type == BP_VAR_IS)); prop = &EG(uninitialized_zval); @@ -1891,19 +1920,25 @@ ZEND_VM_C_LABEL(copy_deref): /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ ZEND_VM_HANDLER(173, ZEND_FETCH_STATIC_PROP_R, ANY, CLASS_FETCH, CACHE_SLOT) { - ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper, type, BP_VAR_R); + uint8_t op1_type = OP1_TYPE; + uint8_t op2_type = OP2_TYPE; + ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper, type, BP_VAR_R, op1_type, op1_type, op2_type, op2_type); } /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ ZEND_VM_HANDLER(174, ZEND_FETCH_STATIC_PROP_W, ANY, CLASS_FETCH, FETCH_REF|DIM_WRITE|CACHE_SLOT) { - ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper, type, BP_VAR_W); + uint8_t op1_type = OP1_TYPE; + uint8_t op2_type = OP2_TYPE; + ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper, type, BP_VAR_W, op1_type, op1_type, op2_type, op2_type); } /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ ZEND_VM_HANDLER(175, ZEND_FETCH_STATIC_PROP_RW, ANY, CLASS_FETCH, CACHE_SLOT) { - ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper, type, BP_VAR_RW); + uint8_t op1_type = OP1_TYPE; + uint8_t op2_type = OP2_TYPE; + ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper, type, BP_VAR_RW, op1_type, op1_type, op2_type, op2_type); } /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ @@ -1919,13 +1954,17 @@ ZEND_VM_HANDLER(177, ZEND_FETCH_STATIC_PROP_FUNC_ARG, ANY, CLASS_FETCH, FETCH_RE /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ ZEND_VM_HANDLER(178, ZEND_FETCH_STATIC_PROP_UNSET, ANY, CLASS_FETCH, CACHE_SLOT) { - ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper, type, BP_VAR_UNSET); + uint8_t op1_type = OP1_TYPE; + uint8_t op2_type = OP2_TYPE; + ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper, type, BP_VAR_UNSET, op1_type, op1_type, op2_type, op2_type); } /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ ZEND_VM_HANDLER(176, ZEND_FETCH_STATIC_PROP_IS, ANY, CLASS_FETCH, CACHE_SLOT) { - ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper, type, BP_VAR_IS); + uint8_t op1_type = OP1_TYPE; + uint8_t op2_type = OP2_TYPE; + ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper, type, BP_VAR_IS, op1_type, op1_type, op2_type, op2_type); } ZEND_VM_COLD_CONSTCONST_HANDLER(81, ZEND_FETCH_DIM_R, CONST|TMPVAR|CV, CONST|TMPVAR|CV) @@ -2143,9 +2182,9 @@ ZEND_VM_C_LABEL(fetch_obj_r_fast_copy): zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC); #if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)) - opline = hook->op_array.opcodes; + opline = hook->op_array.slim_opcodes; #else - EX(opline) = hook->op_array.opcodes; + EX(opline) = hook->op_array.slim_opcodes; #endif LOAD_OPLINE_EX(); ZEND_OBSERVER_SAVE_OPLINE(); @@ -2504,7 +2543,7 @@ ZEND_VM_C_LABEL(assign_obj_simple): } else { ZEND_VM_C_LABEL(fast_assign_obj): value = zend_assign_to_variable_ex(property_val, value, OP_DATA_TYPE, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } ZEND_VM_C_GOTO(exit_assign_obj); @@ -2561,7 +2600,7 @@ ZEND_VM_C_LABEL(fast_assign_obj): } } zend_hash_add_new(zobj->properties, name, value); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } ZEND_VM_C_GOTO(exit_assign_obj); @@ -2600,7 +2639,7 @@ ZEND_VM_C_LABEL(fast_assign_obj): } ZEND_VM_C_LABEL(free_and_exit_assign_obj): - if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2)) && value) { ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); } FREE_OP_DATA(); @@ -2624,7 +2663,7 @@ ZEND_VM_HANDLER(25, ZEND_ASSIGN_STATIC_PROP, ANY, ANY, CACHE_SLOT, SPEC(OP_DATA= SAVE_OPLINE(); - prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC); + prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_W, 0, OP1_TYPE, OP2_TYPE OPLINE_CC EXECUTE_DATA_CC); if (UNEXPECTED(!prop)) { FREE_OP_DATA(); UNDEF_RESULT(); @@ -2640,7 +2679,7 @@ ZEND_VM_HANDLER(25, ZEND_ASSIGN_STATIC_PROP, ANY, ANY, CACHE_SLOT, SPEC(OP_DATA= value = zend_assign_to_variable_ex(prop, value, OP_DATA_TYPE, EX_USES_STRICT_TYPES(), &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } @@ -2717,7 +2756,7 @@ ZEND_VM_C_LABEL(try_assign_dim_array): value = GET_OP_DATA_ZVAL_PTR(BP_VAR_R); value = zend_assign_to_variable_ex(variable_ptr, value, OP_DATA_TYPE, EX_USES_STRICT_TYPES(), &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } if (garbage) { @@ -2792,7 +2831,7 @@ ZEND_VM_C_LABEL(try_assign_dim_array): dim = GET_OP2_ZVAL_PTR(BP_VAR_R); ZEND_VM_C_LABEL(assign_dim_error): FREE_OP_DATA(); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -2815,11 +2854,11 @@ ZEND_VM_HANDLER(22, ZEND_ASSIGN, VAR|CV, CONST|TMP|VAR|CV, SPEC(RETVAL)) value = GET_OP2_ZVAL_PTR(BP_VAR_R); variable_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_W); - if (!ZEND_VM_SPEC || UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (!ZEND_VM_SPEC || UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { zend_refcounted *garbage = NULL; value = zend_assign_to_variable_ex(variable_ptr, value, OP2_TYPE, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } if (garbage) { @@ -2855,12 +2894,12 @@ ZEND_VM_HANDLER(30, ZEND_ASSIGN_REF, VAR|CV, VAR|CV, SRC) UNEXPECTED(!Z_ISREF_P(value_ptr))) { variable_ptr = zend_wrong_assign_to_variable_reference( - variable_ptr, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC); + variable_ptr, value_ptr, &garbage EXECUTE_DATA_CC); } else { zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr); } @@ -2919,7 +2958,7 @@ ZEND_VM_HANDLER(33, ZEND_ASSIGN_STATIC_PROP_REF, ANY, ANY, CACHE_SLOT|SRC) SAVE_OPLINE(); - prop = zend_fetch_static_property_address(&prop_info, opline->extended_value & ~ZEND_RETURNS_FUNCTION, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC); + prop = zend_fetch_static_property_address(&prop_info, opline->extended_value & ~ZEND_RETURNS_FUNCTION, BP_VAR_W, 0, OP1_TYPE, OP2_TYPE OPLINE_CC EXECUTE_DATA_CC); if (UNEXPECTED(!prop)) { FREE_OP_DATA(); UNDEF_RESULT(); @@ -2937,7 +2976,7 @@ ZEND_VM_HANDLER(33, ZEND_ASSIGN_STATIC_PROP_REF, ANY, ANY, CACHE_SLOT|SRC) value_ptr = GET_OP_DATA_ZVAL_PTR_PTR(BP_VAR_W); if (OP_DATA_TYPE == IS_VAR && (opline->extended_value & ZEND_RETURNS_FUNCTION) && UNEXPECTED(!Z_ISREF_P(value_ptr))) { - if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(prop, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC))) { + if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(prop, value_ptr, &garbage EXECUTE_DATA_CC))) { prop = &EG(uninitialized_zval); } } else if (ZEND_TYPE_IS_SET(prop_info->type)) { @@ -2946,7 +2985,7 @@ ZEND_VM_HANDLER(33, ZEND_ASSIGN_STATIC_PROP_REF, ANY, ANY, CACHE_SLOT|SRC) zend_assign_to_variable_reference(prop, value_ptr, &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { ZVAL_COPY(EX_VAR(opline->result.var), prop); } @@ -4114,7 +4153,7 @@ ZEND_VM_HOT_HANDLER(129, ZEND_DO_ICALL, ANY, ANY, SPEC(RETVAL,OBSERVER)) bool should_throw = zend_internal_call_should_throw(fbc, call); #endif - ret = RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : &retval; + ret = RETURN_VALUE_USED(EX_WOP2) ? EX_VAR(opline->result.var) : &retval; ZVAL_NULL(ret); ZEND_OBSERVER_FCALL_BEGIN(call); @@ -4148,7 +4187,7 @@ ZEND_VM_HOT_HANDLER(129, ZEND_DO_ICALL, ANY, ANY, SPEC(RETVAL,OBSERVER)) EG(vm_stack_top) = (zval*)call; } - if (!RETURN_VALUE_USED(opline)) { + if (!RETURN_VALUE_USED(EX_WOP2)) { i_zval_ptr_dtor(ret); } @@ -4172,7 +4211,7 @@ ZEND_VM_HOT_HANDLER(130, ZEND_DO_UCALL, ANY, ANY, SPEC(RETVAL,OBSERVER)) EX(call) = call->prev_execute_data; ret = NULL; - if (RETURN_VALUE_USED(opline)) { + if (RETURN_VALUE_USED(EX_WOP2)) { ret = EX_VAR(opline->result.var); } @@ -4197,7 +4236,7 @@ ZEND_VM_HOT_HANDLER(131, ZEND_DO_FCALL_BY_NAME, ANY, ANY, SPEC(RETVAL,OBSERVER)) SAVE_OPLINE(); EX(call) = call->prev_execute_data; - const uint32_t no_discard = RETURN_VALUE_USED(opline) ? 0 : ZEND_ACC_NODISCARD; + const uint32_t no_discard = RETURN_VALUE_USED(EX_WOP2) ? 0 : ZEND_ACC_NODISCARD; if (UNEXPECTED(fbc->common.fn_flags & (ZEND_ACC_DEPRECATED|no_discard))) { if (fbc->common.fn_flags & ZEND_ACC_DEPRECATED) { @@ -4208,7 +4247,7 @@ ZEND_VM_HOT_HANDLER(131, ZEND_DO_FCALL_BY_NAME, ANY, ANY, SPEC(RETVAL,OBSERVER)) } if (UNEXPECTED(EG(exception) != NULL)) { UNDEF_RESULT(); - if (!RETURN_VALUE_USED(opline)) { + if (!RETURN_VALUE_USED(EX_WOP2)) { ret = &retval; ZVAL_UNDEF(ret); } @@ -4218,7 +4257,7 @@ ZEND_VM_HOT_HANDLER(131, ZEND_DO_FCALL_BY_NAME, ANY, ANY, SPEC(RETVAL,OBSERVER)) if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) { ret = NULL; - if (RETURN_VALUE_USED(opline)) { + if (RETURN_VALUE_USED(EX_WOP2)) { ret = EX_VAR(opline->result.var); } @@ -4243,7 +4282,7 @@ ZEND_VM_HOT_HANDLER(131, ZEND_DO_FCALL_BY_NAME, ANY, ANY, SPEC(RETVAL,OBSERVER)) bool should_throw = zend_internal_call_should_throw(fbc, call); #endif - ret = RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : &retval; + ret = RETURN_VALUE_USED(EX_WOP2) ? EX_VAR(opline->result.var) : &retval; ZVAL_NULL(ret); ZEND_OBSERVER_FCALL_BEGIN(call); @@ -4284,7 +4323,7 @@ ZEND_VM_C_LABEL(fcall_by_name_end): EG(vm_stack_top) = (zval*)call; } - if (!RETURN_VALUE_USED(opline)) { + if (!RETURN_VALUE_USED(EX_WOP2)) { i_zval_ptr_dtor(ret); } } @@ -4308,7 +4347,7 @@ ZEND_VM_HOT_HANDLER(60, ZEND_DO_FCALL, ANY, ANY, SPEC(RETVAL,OBSERVER)) SAVE_OPLINE(); EX(call) = call->prev_execute_data; - const uint32_t no_discard = RETURN_VALUE_USED(opline) ? 0 : ZEND_ACC_NODISCARD; + const uint32_t no_discard = RETURN_VALUE_USED(EX_WOP2) ? 0 : ZEND_ACC_NODISCARD; if (UNEXPECTED(fbc->common.fn_flags & (ZEND_ACC_DEPRECATED|no_discard))) { if (fbc->common.fn_flags & ZEND_ACC_DEPRECATED) { @@ -4322,7 +4361,7 @@ ZEND_VM_HOT_HANDLER(60, ZEND_DO_FCALL, ANY, ANY, SPEC(RETVAL,OBSERVER)) OBJ_RELEASE(ZEND_CLOSURE_OBJECT(call->func)); } UNDEF_RESULT(); - if (!RETURN_VALUE_USED(opline)) { + if (!RETURN_VALUE_USED(EX_WOP2)) { ret = &retval; ZVAL_UNDEF(ret); } @@ -4332,7 +4371,7 @@ ZEND_VM_HOT_HANDLER(60, ZEND_DO_FCALL, ANY, ANY, SPEC(RETVAL,OBSERVER)) if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) { ret = NULL; - if (RETURN_VALUE_USED(opline)) { + if (RETURN_VALUE_USED(EX_WOP2)) { ret = EX_VAR(opline->result.var); } @@ -4366,7 +4405,7 @@ ZEND_VM_HOT_HANDLER(60, ZEND_DO_FCALL, ANY, ANY, SPEC(RETVAL,OBSERVER)) bool should_throw = zend_internal_call_should_throw(fbc, call); #endif - ret = RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : &retval; + ret = RETURN_VALUE_USED(EX_WOP2) ? EX_VAR(opline->result.var) : &retval; ZVAL_NULL(ret); ZEND_OBSERVER_FCALL_BEGIN(call); @@ -4405,7 +4444,7 @@ ZEND_VM_C_LABEL(fcall_end): zend_free_extra_named_params(call->extra_named_params); } - if (!RETURN_VALUE_USED(opline)) { + if (!RETURN_VALUE_USED(EX_WOP2)) { i_zval_ptr_dtor(ret); } } @@ -4840,7 +4879,7 @@ ZEND_VM_HANDLER(107, ZEND_CATCH, CONST, JMP_ADDR, LAST_CATCH|CACHE_SLOT) exception = EG(exception); EG(exception) = NULL; - if (RETURN_VALUE_USED(opline)) { + if (RETURN_VALUE_USED(EX_WOP2)) { /* Always perform a strict assignment. There is a reasonable expectation that if you * write "catch (Exception $e)" then $e will actually be instanceof Exception. As such, * we should not permit coercion to string here. */ @@ -5855,7 +5894,7 @@ ZEND_VM_COLD_CONST_HANDLER(52, ZEND_BOOL, CONST|TMPVAR|CV, ANY) ZEND_VM_NEXT_OPCODE(); } -ZEND_VM_HELPER(zend_case_helper, ANY, ANY, zval *op_1, zval *op_2) +ZEND_VM_HELPER(zend_case_helper, ANY, ANY, zval *op_1, zval *op_2, uint8_t op2_type) { int ret; USE_OPLINE @@ -5868,7 +5907,7 @@ ZEND_VM_HELPER(zend_case_helper, ANY, ANY, zval *op_1, zval *op_2) op_2 = ZVAL_UNDEFINED_OP2(); } ret = zend_compare(op_1, op_2); - if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) { + if (op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_SMART_BRANCH(ret == 0, 1); @@ -5922,7 +5961,8 @@ ZEND_VM_C_LABEL(case_double): } } } - ZEND_VM_DISPATCH_TO_HELPER(zend_case_helper, op_1, op1, op_2, op2); + uint8_t op2_type = RT_OP2_TYPE; + ZEND_VM_DISPATCH_TO_HELPER(zend_case_helper, op_1, op1, op_2, op2, op2_type, op2_type); } ZEND_VM_HANDLER(68, ZEND_NEW, UNUSED|CLASS_FETCH|CONST|VAR, UNUSED|CACHE_SLOT, NUM) @@ -5964,7 +6004,7 @@ ZEND_VM_HANDLER(68, ZEND_NEW, UNUSED|CLASS_FETCH|CONST|VAR, UNUSED|CACHE_SLOT, N if (constructor == NULL) { /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next * opcode is DO_FCALL in case EXT instructions are used. */ - if (EXPECTED(opline->extended_value == 0 && (opline+1)->opcode == ZEND_DO_FCALL)) { + if (EXPECTED(opline->extended_value == 0 && Z_WOP_FROM_OP(opline+1)->opcode == ZEND_DO_FCALL)) { ZEND_VM_NEXT_OPCODE_EX(1, 2); } @@ -6070,7 +6110,7 @@ ZEND_VM_HOT_HANDLER(99, ZEND_FETCH_CONSTANT, UNUSED|CONST_FETCH, CONST, CACHE_SL } SAVE_OPLINE(); - zend_quick_get_constant(RT_CONSTANT(opline, opline->op2) + 1, opline->op1.num OPLINE_CC EXECUTE_DATA_CC); + zend_quick_get_constant(RT_CONSTANT(opline, opline->op2) + 1, opline->op1.num, opline->extended_value OPLINE_CC EXECUTE_DATA_CC); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -6526,18 +6566,18 @@ ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMPVAR|CV, ANY, EVAL, SPEC(OBSER UNDEF_RESULT(); HANDLE_EXCEPTION(); } else if (new_op_array == ZEND_FAKE_OP_ARRAY) { - if (RETURN_VALUE_USED(opline)) { + if (RETURN_VALUE_USED(EX_WOP2)) { ZVAL_TRUE(EX_VAR(opline->result.var)); } } else if (UNEXPECTED(new_op_array == NULL)) { - if (RETURN_VALUE_USED(opline)) { + if (RETURN_VALUE_USED(EX_WOP2)) { ZVAL_FALSE(EX_VAR(opline->result.var)); } } else if (new_op_array->last == 1 && new_op_array->opcodes[0].opcode == ZEND_RETURN && new_op_array->opcodes[0].op1_type == IS_CONST && EXPECTED(zend_execute_ex == execute_ex)) { - if (RETURN_VALUE_USED(opline)) { + if (RETURN_VALUE_USED(EX_WOP2)) { const zend_op *op = new_op_array->opcodes; ZVAL_COPY(EX_VAR(opline->result.var), RT_CONSTANT(op, op->op1)); @@ -6548,7 +6588,7 @@ ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMPVAR|CV, ANY, EVAL, SPEC(OBSER } else { zval *return_value = NULL; zend_execute_data *call; - if (RETURN_VALUE_USED(opline)) { + if (RETURN_VALUE_USED(EX_WOP2)) { return_value = EX_VAR(opline->result.var); } @@ -7058,7 +7098,7 @@ ZEND_VM_HELPER(zend_fe_fetch_object_helper, ANY, ANY) p++; } EG(ht_iterators)[Z_FE_ITER_P(array)].pos = pos; - if (RETURN_VALUE_USED(opline)) { + if (RETURN_VALUE_USED(EX_WOP2)) { if (UNEXPECTED(!p->key)) { ZVAL_LONG(EX_VAR(opline->result.var), p->h); } else if (ZSTR_VAL(p->key)[0]) { @@ -7101,7 +7141,7 @@ ZEND_VM_C_LABEL(fe_fetch_r_exit): /* failure in get_current_data */ ZEND_VM_C_GOTO(fe_fetch_r_exit); } - if (RETURN_VALUE_USED(opline)) { + if (RETURN_VALUE_USED(EX_WOP2)) { if (funcs->get_current_key) { funcs->get_current_key(iter, EX_VAR(opline->result.var)); if (UNEXPECTED(EG(exception) != NULL)) { @@ -7162,7 +7202,7 @@ ZEND_VM_HOT_HANDLER(78, ZEND_FE_FETCH_R, VAR, ANY, JMP_ADDR) value++; } Z_FE_POS_P(array) = pos + 1; - if (RETURN_VALUE_USED(opline)) { + if (RETURN_VALUE_USED(EX_WOP2)) { ZVAL_LONG(EX_VAR(opline->result.var), pos); } } else { @@ -7185,7 +7225,7 @@ ZEND_VM_HOT_HANDLER(78, ZEND_FE_FETCH_R, VAR, ANY, JMP_ADDR) p++; } Z_FE_POS_P(array) = pos; - if (RETURN_VALUE_USED(opline)) { + if (RETURN_VALUE_USED(EX_WOP2)) { if (!p->key) { ZVAL_LONG(EX_VAR(opline->result.var), p->h); } else { @@ -7243,7 +7283,7 @@ ZEND_VM_HANDLER(126, ZEND_FE_FETCH_RW, VAR, ANY, JMP_ADDR) value++; } EG(ht_iterators)[Z_FE_ITER_P(EX_VAR(opline->op1.var))].pos = pos + 1; - if (RETURN_VALUE_USED(opline)) { + if (RETURN_VALUE_USED(EX_WOP2)) { ZVAL_LONG(EX_VAR(opline->result.var), pos); } } else { @@ -7263,7 +7303,7 @@ ZEND_VM_HANDLER(126, ZEND_FE_FETCH_RW, VAR, ANY, JMP_ADDR) p++; } EG(ht_iterators)[Z_FE_ITER_P(EX_VAR(opline->op1.var))].pos = pos; - if (RETURN_VALUE_USED(opline)) { + if (RETURN_VALUE_USED(EX_WOP2)) { if (!p->key) { ZVAL_LONG(EX_VAR(opline->result.var), p->h); } else { @@ -7323,7 +7363,7 @@ ZEND_VM_HANDLER(126, ZEND_FE_FETCH_RW, VAR, ANY, JMP_ADDR) p++; } EG(ht_iterators)[Z_FE_ITER_P(EX_VAR(opline->op1.var))].pos = pos; - if (RETURN_VALUE_USED(opline)) { + if (RETURN_VALUE_USED(EX_WOP2)) { if (UNEXPECTED(!p->key)) { ZVAL_LONG(EX_VAR(opline->result.var), p->h); } else if (ZSTR_VAL(p->key)[0]) { @@ -7364,7 +7404,7 @@ ZEND_VM_HANDLER(126, ZEND_FE_FETCH_RW, VAR, ANY, JMP_ADDR) /* failure in get_current_data */ ZEND_VM_C_GOTO(fe_fetch_w_exit); } - if (RETURN_VALUE_USED(opline)) { + if (RETURN_VALUE_USED(EX_WOP2)) { if (funcs->get_current_key) { funcs->get_current_key(iter, EX_VAR(opline->result.var)); if (UNEXPECTED(EG(exception) != NULL)) { @@ -7487,7 +7527,7 @@ ZEND_VM_HANDLER(180, ZEND_ISSET_ISEMPTY_STATIC_PROP, ANY, CLASS_FETCH, ISSET|CAC SAVE_OPLINE(); - value = zend_fetch_static_property_address(NULL, opline->extended_value & ~ZEND_ISEMPTY, BP_VAR_IS, 0 OPLINE_CC EXECUTE_DATA_CC); + value = zend_fetch_static_property_address(NULL, opline->extended_value & ~ZEND_ISEMPTY, BP_VAR_IS, 0, OP1_TYPE, OP2_TYPE OPLINE_CC EXECUTE_DATA_CC); if (!(opline->extended_value & ZEND_ISEMPTY)) { result = value != NULL && Z_TYPE_P(value) > IS_NULL && @@ -8053,20 +8093,20 @@ ZEND_VM_HOT_HANDLER(0, ZEND_NOP, ANY, ANY) ZEND_VM_NEXT_OPCODE(); } -ZEND_VM_HELPER(zend_dispatch_try_catch_finally_helper, ANY, ANY, uint32_t try_catch_offset, uint32_t op_num) +ZEND_VM_HELPER(zend_dispatch_try_catch_finally_helper, ANY, ANY, uint16_t try_catch_offset, uint16_t op_num) { /* May be NULL during generator closing (only finally blocks are executed) */ zend_object *ex = EG(exception); /* Walk try/catch/finally structures upwards, performing the necessary actions */ - for (; try_catch_offset != (uint32_t) -1; try_catch_offset--) { + for (; try_catch_offset != (uint16_t) -1; try_catch_offset--) { zend_try_catch_element *try_catch = &EX(func)->op_array.try_catch_array[try_catch_offset]; if (op_num < try_catch->catch_op && ex) { /* Go to catch block */ cleanup_live_vars(execute_data, op_num, try_catch->catch_op); - ZEND_VM_JMP_EX(&EX(func)->op_array.opcodes[try_catch->catch_op], 0); + ZEND_VM_JMP_EX(&EX(func)->op_array.slim_opcodes[try_catch->catch_op], 0); } else if (op_num < try_catch->finally_op) { if (ex && zend_is_unwind_exit(ex)) { @@ -8080,7 +8120,7 @@ ZEND_VM_HELPER(zend_dispatch_try_catch_finally_helper, ANY, ANY, uint32_t try_ca Z_OBJ_P(fast_call) = EG(exception); EG(exception) = NULL; Z_OPLINE_NUM_P(fast_call) = (uint32_t)-1; - ZEND_VM_JMP_EX(&EX(func)->op_array.opcodes[try_catch->finally_op], 0); + ZEND_VM_JMP_EX(&EX(func)->op_array.slim_opcodes[try_catch->finally_op], 0); } else if (op_num < try_catch->finally_end) { zval *fast_call = EX_VAR(EX(func)->op_array.opcodes[try_catch->finally_end].op1.var); @@ -8132,14 +8172,15 @@ ZEND_VM_HELPER(zend_dispatch_try_catch_finally_helper, ANY, ANY, uint32_t try_ca ZEND_VM_HANDLER(149, ZEND_HANDLE_EXCEPTION, ANY, ANY) { - const zend_op *throw_op = EG(opline_before_exception); + const zend_slim_op *throw_sop = EG(opline_before_exception); /* Exception was thrown before executing any op */ - if (UNEXPECTED(!throw_op)) { + if (UNEXPECTED(!throw_sop)) { ZEND_VM_DISPATCH_TO_HELPER(zend_dispatch_try_catch_finally_helper, try_catch_offset, -1, op_num, 0); } - uint32_t throw_op_num = throw_op - EX(func)->op_array.opcodes; + const zend_op *throw_op = Z_WOP_FROM_OP(throw_sop); + uint32_t throw_op_num = throw_sop - EX(func)->op_array.slim_opcodes; int i, current_try_catch_offset = -1; if ((throw_op->opcode == ZEND_FREE || throw_op->opcode == ZEND_FE_FREE) @@ -8208,8 +8249,11 @@ ZEND_VM_HANDLER(150, ZEND_USER_OPCODE, ANY, ANY) USE_OPLINE int ret; + zend_op *wop = Z_WOP; + SAVE_OPLINE(); - ret = zend_user_opcode_handlers[opline->opcode](execute_data); + ret = zend_user_opcode_handlers[wop->opcode](execute_data); + // FIXME: Why is this needed? opline = EX(opline); switch (ret) { @@ -8229,7 +8273,7 @@ ZEND_VM_HANDLER(150, ZEND_USER_OPCODE, ANY, ANY) case ZEND_USER_OPCODE_LEAVE: ZEND_VM_LEAVE(); case ZEND_USER_OPCODE_DISPATCH: - ZEND_VM_DISPATCH(opline->opcode, opline); + ZEND_VM_DISPATCH(wop->opcode, opline); default: ZEND_VM_DISPATCH((uint8_t)(ret & 0xff), opline); } @@ -8469,7 +8513,7 @@ ZEND_VM_HANDLER(160, ZEND_YIELD, CONST|TMP|VAR|CV|UNUSED, CONST|TMPVAR|CV|UNUSED ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } - if (RETURN_VALUE_USED(opline)) { + if (RETURN_VALUE_USED(EX_WOP2)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ generator->send_target = EX_VAR(opline->result.var); @@ -8532,7 +8576,7 @@ ZEND_VM_C_LABEL(yield_from_try_again): zend_generator_yield_from(generator, new_gen); } } else { - if (RETURN_VALUE_USED(opline)) { + if (RETURN_VALUE_USED(EX_WOP2)) { ZVAL_COPY(EX_VAR(opline->result.var), &new_gen->retval); } ZEND_VM_NEXT_OPCODE(); @@ -8573,7 +8617,7 @@ ZEND_VM_C_LABEL(yield_from_try_again): /* This is the default return value * when the expression is a Generator, it will be overwritten in zend_generator_resume() */ - if (RETURN_VALUE_USED(opline)) { + if (RETURN_VALUE_USED(EX_WOP2)) { ZVAL_NULL(EX_VAR(opline->result.var)); } @@ -8618,7 +8662,7 @@ ZEND_VM_HANDLER(162, ZEND_FAST_CALL, JMP_ADDR, ANY) Z_OBJ_P(fast_call) = NULL; /* set return address */ - Z_OPLINE_NUM_P(fast_call) = opline - EX(func)->op_array.opcodes; + Z_OPLINE_NUM_P(fast_call) = opline - EX(func)->op_array.slim_opcodes; ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op1), 0); } @@ -8626,10 +8670,10 @@ ZEND_VM_HANDLER(163, ZEND_FAST_RET, ANY, TRY_CATCH) { USE_OPLINE zval *fast_call = EX_VAR(opline->op1.var); - uint32_t current_try_catch_offset, current_op_num; + uint16_t current_try_catch_offset, current_op_num; if (Z_OPLINE_NUM_P(fast_call) != (uint32_t)-1) { - const zend_op *fast_ret = EX(func)->op_array.opcodes + Z_OPLINE_NUM_P(fast_call); + const zend_slim_op *fast_ret = EX(func)->op_array.slim_opcodes + Z_OPLINE_NUM_P(fast_call); ZEND_VM_JMP_EX(fast_ret + 1, 0); } @@ -8638,7 +8682,7 @@ ZEND_VM_HANDLER(163, ZEND_FAST_RET, ANY, TRY_CATCH) EG(exception) = Z_OBJ_P(fast_call); Z_OBJ_P(fast_call) = NULL; current_try_catch_offset = opline->op2.num; - current_op_num = opline - EX(func)->op_array.opcodes; + current_op_num = opline - EX(func)->op_array.slim_opcodes; ZEND_VM_DISPATCH_TO_HELPER(zend_dispatch_try_catch_finally_helper, try_catch_offset, current_try_catch_offset, op_num, current_op_num); } @@ -8835,7 +8879,7 @@ ZEND_VM_C_LABEL(defined_false): ZEND_VM_SMART_BRANCH_FALSE(); } } - if (zend_quick_check_constant(RT_CONSTANT(opline, opline->op1) OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) { + if (zend_quick_check_constant(RT_CONSTANT(opline, opline->op1), opline->extended_value OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) { CACHE_PTR(opline->extended_value, ENCODE_SPECIAL_CACHE_NUM(zend_hash_num_elements(EG(zend_constants)))); ZEND_VM_C_GOTO(defined_false); } else { @@ -8848,8 +8892,8 @@ ZEND_VM_HANDLER(151, ZEND_ASSERT_CHECK, ANY, JMP_ADDR) USE_OPLINE if (EG(assertions) <= 0) { - zend_op *target = OP_JMP_ADDR(opline, opline->op2); - if (RETURN_VALUE_USED(opline)) { + zend_slim_op *target = OP_JMP_ADDR(opline, opline->op2); + if (RETURN_VALUE_USED(EX_WOP2)) { ZVAL_TRUE(EX_VAR(opline->result.var)); } ZEND_VM_JMP_EX(target, 0); @@ -9741,7 +9785,7 @@ ZEND_VM_HANDLER(204, ZEND_FRAMELESS_ICALL_0, UNUSED, UNUSED, NUM, SPEC(OBSERVER) } else #endif { - zend_frameless_function_0 function = (zend_frameless_function_0)ZEND_FLF_HANDLER(opline); + zend_frameless_function_0 function = (zend_frameless_function_0)ZEND_FLF_HANDLER(opline->extended_value); function(EX_VAR(opline->result.var)); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -9766,7 +9810,7 @@ ZEND_VM_HANDLER(205, ZEND_FRAMELESS_ICALL_1, ANY, UNUSED, NUM, SPEC(OBSERVER)) } else #endif { - zend_frameless_function_1 function = (zend_frameless_function_1)ZEND_FLF_HANDLER(opline); + zend_frameless_function_1 function = (zend_frameless_function_1)ZEND_FLF_HANDLER(opline->extended_value); function(result, arg1); } FREE_OP1(); @@ -9794,7 +9838,7 @@ ZEND_VM_HANDLER(206, ZEND_FRAMELESS_ICALL_2, ANY, ANY, NUM, SPEC(OBSERVER)) } else #endif { - zend_frameless_function_2 function = (zend_frameless_function_2)ZEND_FLF_HANDLER(opline); + zend_frameless_function_2 function = (zend_frameless_function_2)ZEND_FLF_HANDLER(opline->extended_value); function(result, arg1, arg2); } @@ -9830,7 +9874,7 @@ ZEND_VM_HANDLER(207, ZEND_FRAMELESS_ICALL_3, ANY, ANY, NUM, SPEC(OBSERVER)) } else #endif { - zend_frameless_function_3 function = (zend_frameless_function_3)ZEND_FLF_HANDLER(opline); + zend_frameless_function_3 function = (zend_frameless_function_3)ZEND_FLF_HANDLER(opline->extended_value); function(result, arg1, arg2, arg3); } @@ -10179,7 +10223,7 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_PRE_INC, (res_info == MAY_BE_LONG && op1_info var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW); Z_LVAL_P(var_ptr)++; - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr)); } ZEND_VM_NEXT_OPCODE(); @@ -10192,7 +10236,7 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_PRE_INC, (op1_info == MAY_BE_LONG), ZEND_PRE_ var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW); fast_long_increment_function(var_ptr); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr); } ZEND_VM_NEXT_OPCODE(); @@ -10205,7 +10249,7 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_PRE_DEC, (res_info == MAY_BE_LONG && op1_info var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW); Z_LVAL_P(var_ptr)--; - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr)); } ZEND_VM_NEXT_OPCODE(); @@ -10218,7 +10262,7 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_PRE_DEC, (op1_info == MAY_BE_LONG), ZEND_PRE_ var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW); fast_long_decrement_function(var_ptr); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr); } ZEND_VM_NEXT_OPCODE(); @@ -10448,7 +10492,7 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_FE_FETCH_R, op->op2_type == IS_CV && (op1_inf value++; } Z_FE_POS_P(array) = pos + 1; - if (RETURN_VALUE_USED(opline)) { + if (RETURN_VALUE_USED(EX_WOP2)) { ZVAL_LONG(EX_VAR(opline->result.var), pos); } } else { @@ -10471,7 +10515,7 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_FE_FETCH_R, op->op2_type == IS_CV && (op1_inf p++; } Z_FE_POS_P(array) = pos; - if (RETURN_VALUE_USED(opline)) { + if (RETURN_VALUE_USED(EX_WOP2)) { if (!p->key) { ZVAL_LONG(EX_VAR(opline->result.var), p->h); } else { @@ -10497,7 +10541,7 @@ ZEND_VM_HELPER(zend_interrupt_helper, ANY, ANY) zend_interrupt_function(execute_data); if (EG(exception)) { /* We have to UNDEF result, because ZEND_HANDLE_EXCEPTION is going to free it */ - const zend_op *throw_op = EG(opline_before_exception); + const zend_op *throw_op = Z_WOP_FROM_OP(EG(opline_before_exception)); if (throw_op && throw_op->result_type & (IS_TMP_VAR|IS_VAR) diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 9afcccdd08127..ad29cb7aeb81c 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -325,7 +325,7 @@ static const void * const *zend_opcode_handlers; static int zend_handlers_count; #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID) static const void * const * zend_opcode_handler_funcs; -static zend_op hybrid_halt_op; +static zend_slim_op hybrid_halt_op; #endif #if (ZEND_VM_KIND != ZEND_VM_KIND_HYBRID) || !ZEND_VM_SPEC static const void *zend_vm_get_opcode_handler(uint8_t opcode, const zend_op* op); @@ -372,7 +372,7 @@ static const void *zend_vm_get_opcode_handler_func(uint8_t opcode, const zend_op # define ZEND_OPCODE_HANDLER_ARGS_EX # define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX #else -# define ZEND_OPCODE_HANDLER_ARGS zend_execute_data *execute_data, const zend_op *opline +# define ZEND_OPCODE_HANDLER_ARGS zend_execute_data *execute_data, const zend_slim_op *opline # define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU execute_data, opline # define ZEND_OPCODE_HANDLER_ARGS_EX ZEND_OPCODE_HANDLER_ARGS, # define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX ZEND_OPCODE_HANDLER_ARGS_PASSTHRU, @@ -396,10 +396,10 @@ static const void *zend_vm_get_opcode_handler_func(uint8_t opcode, const zend_op # define ZEND_VM_COLD ZEND_COLD ZEND_OPT_SIZE # endif #else -# define ZEND_OPCODE_HANDLER_RET const zend_op * +# define ZEND_OPCODE_HANDLER_RET const zend_slim_op * # define ZEND_VM_TAIL_CALL(call) return call # define ZEND_VM_CONTINUE() return opline -# define ZEND_VM_RETURN() return (const zend_op*)ZEND_VM_ENTER_BIT +# define ZEND_VM_RETURN() return (const zend_slim_op*)ZEND_VM_ENTER_BIT # define ZEND_VM_HOT # define ZEND_VM_COLD ZEND_COLD ZEND_OPT_SIZE #endif @@ -416,7 +416,7 @@ typedef ZEND_OPCODE_HANDLER_RET (ZEND_FASTCALL *opcode_handler_t) (ZEND_OPCODE_H # define SAVE_OPLINE() EX(opline) = opline # define SAVE_OPLINE_EX() SAVE_OPLINE() #else -# define DCL_OPLINE const zend_op *opline; +# define DCL_OPLINE const zend_slim_op *opline; # define OPLINE opline # define USE_OPLINE # define LOAD_OPLINE() opline = EX(opline) @@ -437,18 +437,18 @@ typedef ZEND_OPCODE_HANDLER_RET (ZEND_FASTCALL *opcode_handler_t) (ZEND_OPCODE_H # define ZEND_VM_LEAVE() return 2 #else # define ZEND_VM_ENTER_BIT 1ULL -# define ZEND_VM_ENTER_EX() return (zend_op*)((uintptr_t)opline | ZEND_VM_ENTER_BIT) +# define ZEND_VM_ENTER_EX() return (zend_slim_op*)((uintptr_t)opline | ZEND_VM_ENTER_BIT) # define ZEND_VM_ENTER() execute_data = EG(current_execute_data); LOAD_OPLINE(); ZEND_VM_ENTER_EX() -# define ZEND_VM_LEAVE() return (zend_op*)((uintptr_t)opline | ZEND_VM_ENTER_BIT) +# define ZEND_VM_LEAVE() return (zend_slim_op*)((uintptr_t)opline | ZEND_VM_ENTER_BIT) #endif #define ZEND_VM_INTERRUPT() ZEND_VM_TAIL_CALL(zend_interrupt_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); #define ZEND_VM_LOOP_INTERRUPT() zend_interrupt_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); -#define ZEND_VM_DISPATCH(opcode, opline) ZEND_VM_TAIL_CALL(((opcode_handler_t)zend_vm_get_opcode_handler_func(opcode, opline))(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); +#define ZEND_VM_DISPATCH(opcode, opline) ZEND_VM_TAIL_CALL(((opcode_handler_t)zend_vm_get_opcode_handler_func(opcode, EX_WOP2))(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_interrupt_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS); static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS); -static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_add_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_add_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) { USE_OPLINE @@ -460,16 +460,16 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_add_helper_S op_2 = ZVAL_UNDEFINED_OP2(); } add_function(EX_VAR(opline->result.var), op_1, op_2); - if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) { + if (op1_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) { + if (op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_sub_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_sub_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) { USE_OPLINE @@ -481,16 +481,16 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_sub_helper_S op_2 = ZVAL_UNDEFINED_OP2(); } sub_function(EX_VAR(opline->result.var), op_1, op_2); - if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) { + if (op1_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) { + if (op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_mul_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_mul_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) { USE_OPLINE @@ -502,10 +502,10 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_mul_helper_S op_2 = ZVAL_UNDEFINED_OP2(); } mul_function(EX_VAR(opline->result.var), op_1, op_2); - if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) { + if (op1_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) { + if (op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -521,7 +521,7 @@ static zend_never_inline ZEND_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_mo HANDLE_EXCEPTION(); } -static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_mod_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_mod_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) { USE_OPLINE @@ -533,16 +533,16 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_mod_helper_S op_2 = ZVAL_UNDEFINED_OP2(); } mod_function(EX_VAR(opline->result.var), op_1, op_2); - if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) { + if (op1_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) { + if (op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_shift_left_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_shift_left_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) { USE_OPLINE @@ -554,16 +554,16 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_shift_left_h op_2 = ZVAL_UNDEFINED_OP2(); } shift_left_function(EX_VAR(opline->result.var), op_1, op_2); - if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) { + if (op1_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) { + if (op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_shift_right_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_shift_right_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) { USE_OPLINE @@ -575,16 +575,16 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_shift_right_ op_2 = ZVAL_UNDEFINED_OP2(); } shift_right_function(EX_VAR(opline->result.var), op_1, op_2); - if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) { + if (op1_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) { + if (op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) { int ret; USE_OPLINE @@ -597,16 +597,16 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_equal_hel op_2 = ZVAL_UNDEFINED_OP2(); } ret = zend_compare(op_1, op_2); - if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) { + if (op1_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) { + if (op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_SMART_BRANCH(ret == 0, 1); } -static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) { int ret; USE_OPLINE @@ -619,16 +619,16 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_not_equal op_2 = ZVAL_UNDEFINED_OP2(); } ret = zend_compare(op_1, op_2); - if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) { + if (op1_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) { + if (op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_SMART_BRANCH(ret != 0, 1); } -static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) { int ret; USE_OPLINE @@ -641,16 +641,16 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_smaller_h op_2 = ZVAL_UNDEFINED_OP2(); } ret = zend_compare(op_1, op_2); - if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) { + if (op1_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) { + if (op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_SMART_BRANCH(ret < 0, 1); } -static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) { int ret; USE_OPLINE @@ -663,16 +663,16 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_smaller_o op_2 = ZVAL_UNDEFINED_OP2(); } ret = zend_compare(op_1, op_2); - if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) { + if (op1_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) { + if (op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_SMART_BRANCH(ret <= 0, 1); } -static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_or_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_or_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) { USE_OPLINE @@ -684,16 +684,16 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_or_helper op_2 = ZVAL_UNDEFINED_OP2(); } bitwise_or_function(EX_VAR(opline->result.var), op_1, op_2); - if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) { + if (op1_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) { + if (op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_and_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_and_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) { USE_OPLINE @@ -705,16 +705,16 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_and_helpe op_2 = ZVAL_UNDEFINED_OP2(); } bitwise_and_function(EX_VAR(opline->result.var), op_1, op_2); - if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) { + if (op1_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) { + if (op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_xor_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_xor_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) { USE_OPLINE @@ -726,16 +726,16 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_xor_helpe op_2 = ZVAL_UNDEFINED_OP2(); } bitwise_xor_function(EX_VAR(opline->result.var), op_1, op_2); - if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) { + if (op1_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) { + if (op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_not_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_not_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, uint8_t op1_type) { USE_OPLINE @@ -744,7 +744,9 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_not_helpe op_1 = ZVAL_UNDEFINED_OP1(); } bitwise_not_function(EX_VAR(opline->result.var), op_1); - FREE_OP(opline->op1_type, opline->op1.var); + if (op1_type & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_nogc(op_1); + } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -780,10 +782,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_OP_SPEC_HAN SAVE_OPLINE(); - prop = zend_fetch_static_property_address(&prop_info, (opline+1)->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC); + prop = zend_fetch_static_property_address(&prop_info, (opline+1)->extended_value, BP_VAR_RW, 0, QUICK_OP_FLAGS_OP1_TYPE((opline+1)->op2.num), QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num) OPLINE_CC EXECUTE_DATA_CC); if (UNEXPECTED(!prop)) { UNDEF_RESULT(); - FREE_OP((opline+1)->op1_type, (opline+1)->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1.var); HANDLE_EXCEPTION(); } @@ -791,11 +793,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_OP_SPEC_HAN && UNEXPECTED(!zend_asymmetric_property_has_set_access(prop_info))) { zend_asymmetric_visibility_property_modification_error(prop_info, "indirectly modify"); UNDEF_RESULT(); - FREE_OP((opline+1)->op1_type, (opline+1)->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1.var); HANDLE_EXCEPTION(); } - value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1); + value = get_op_data_zval_ptr_r(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1); do { if (UNEXPECTED(Z_ISREF_P(prop))) { @@ -815,11 +817,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_OP_SPEC_HAN } } while (0); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), prop); } - FREE_OP((opline+1)->op1_type, (opline+1)->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1.var); /* assign_static_prop has two opcodes! */ ZEND_VM_NEXT_OPCODE_EX(1, 2); } @@ -832,7 +834,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_STATIC_PROP_SPEC_HANDL SAVE_OPLINE(); - prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC); + prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_RW, 0, EX_WOP2->op1_type, EX_WOP2->op2_type OPLINE_CC EXECUTE_DATA_CC); if (UNEXPECTED(!prop)) { UNDEF_RESULT(); HANDLE_EXCEPTION(); @@ -860,7 +862,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_STATIC_PROP_SPEC_HAND SAVE_OPLINE(); - prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC); + prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_RW, 0, EX_WOP2->op1_type, EX_WOP2->op2_type OPLINE_CC EXECUTE_DATA_CC); if (UNEXPECTED(!prop)) { UNDEF_RESULT(); HANDLE_EXCEPTION(); @@ -880,7 +882,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_STATIC_PROP_SPEC_HAND } /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ -static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_fetch_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX int type) +static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_fetch_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX int type, uint8_t op1_type, uint8_t op2_type) { USE_OPLINE zval *prop; @@ -890,7 +892,7 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_fetch_static_prop_helper_ prop = zend_fetch_static_property_address( &prop_info, opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS, type, - type == BP_VAR_W ? opline->extended_value : 0 OPLINE_CC EXECUTE_DATA_CC); + type == BP_VAR_W ? opline->extended_value : 0, op1_type, op2_type OPLINE_CC EXECUTE_DATA_CC); if (UNEXPECTED(!prop)) { ZEND_ASSERT(EG(exception) || (type == BP_VAR_IS)); prop = &EG(uninitialized_zval); @@ -917,19 +919,25 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_fetch_static_prop_helper_ /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_STATIC_PROP_R_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - ZEND_VM_TAIL_CALL(zend_fetch_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_R)); + uint8_t op1_type = EX_WOP2->op1_type; + uint8_t op2_type = EX_WOP2->op2_type; + ZEND_VM_TAIL_CALL(zend_fetch_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_R, op1_type, op2_type)); } /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_STATIC_PROP_W_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - ZEND_VM_TAIL_CALL(zend_fetch_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_W)); + uint8_t op1_type = EX_WOP2->op1_type; + uint8_t op2_type = EX_WOP2->op2_type; + ZEND_VM_TAIL_CALL(zend_fetch_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_W, op1_type, op2_type)); } /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_STATIC_PROP_RW_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - ZEND_VM_TAIL_CALL(zend_fetch_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_RW)); + uint8_t op1_type = EX_WOP2->op1_type; + uint8_t op2_type = EX_WOP2->op2_type; + ZEND_VM_TAIL_CALL(zend_fetch_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_RW, op1_type, op2_type)); } /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ @@ -945,13 +953,17 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPE /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_STATIC_PROP_UNSET_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - ZEND_VM_TAIL_CALL(zend_fetch_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_UNSET)); + uint8_t op1_type = EX_WOP2->op1_type; + uint8_t op2_type = EX_WOP2->op2_type; + ZEND_VM_TAIL_CALL(zend_fetch_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_UNSET, op1_type, op2_type)); } /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_STATIC_PROP_IS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - ZEND_VM_TAIL_CALL(zend_fetch_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_IS)); + uint8_t op1_type = EX_WOP2->op1_type; + uint8_t op2_type = EX_WOP2->op2_type; + ZEND_VM_TAIL_CALL(zend_fetch_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_IS, op1_type, op2_type)); } static zend_never_inline ZEND_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS) @@ -960,8 +972,8 @@ static zend_never_inline ZEND_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_us SAVE_OPLINE(); zend_throw_error(NULL, "Cannot use temporary expression in write context"); - FREE_OP(opline->op2_type, opline->op2.var); - FREE_OP(opline->op1_type, opline->op1.var); + FREE_OP(EX_WOP2->op2_type, opline->op2.var); + FREE_OP(EX_WOP2->op1_type, opline->op1.var); ZVAL_UNDEF(EX_VAR(opline->result.var)); HANDLE_EXCEPTION(); } @@ -972,8 +984,8 @@ static zend_never_inline ZEND_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_us SAVE_OPLINE(); zend_throw_error(NULL, "Cannot use [] for reading"); - FREE_OP(opline->op2_type, opline->op2.var); - FREE_OP(opline->op1_type, opline->op1.var); + FREE_OP(EX_WOP2->op2_type, opline->op2.var); + FREE_OP(EX_WOP2->op1_type, opline->op1.var); ZVAL_UNDEF(EX_VAR(opline->result.var)); HANDLE_EXCEPTION(); } @@ -987,7 +999,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DAT SAVE_OPLINE(); - prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC); + prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_W, 0, QUICK_OP_FLAGS_OP1_TYPE((opline+1)->op2.num), QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num) OPLINE_CC EXECUTE_DATA_CC); if (UNEXPECTED(!prop)) { UNDEF_RESULT(); @@ -1003,7 +1015,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DAT value = zend_assign_to_variable_ex(prop, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } @@ -1024,7 +1036,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DAT SAVE_OPLINE(); - prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC); + prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_W, 0, QUICK_OP_FLAGS_OP1_TYPE((opline+1)->op2.num), QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num) OPLINE_CC EXECUTE_DATA_CC); if (UNEXPECTED(!prop)) { zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); UNDEF_RESULT(); @@ -1040,7 +1052,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DAT value = zend_assign_to_variable_ex(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } @@ -1061,7 +1073,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DAT SAVE_OPLINE(); - prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC); + prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_W, 0, QUICK_OP_FLAGS_OP1_TYPE((opline+1)->op2.num), QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num) OPLINE_CC EXECUTE_DATA_CC); if (UNEXPECTED(!prop)) { zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); UNDEF_RESULT(); @@ -1077,7 +1089,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DAT value = zend_assign_to_variable_ex(prop, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } @@ -1098,7 +1110,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DAT SAVE_OPLINE(); - prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC); + prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_W, 0, QUICK_OP_FLAGS_OP1_TYPE((opline+1)->op2.num), QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num) OPLINE_CC EXECUTE_DATA_CC); if (UNEXPECTED(!prop)) { UNDEF_RESULT(); @@ -1114,7 +1126,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DAT value = zend_assign_to_variable_ex(prop, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } @@ -1135,9 +1147,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_REF_SPEC_HA SAVE_OPLINE(); - prop = zend_fetch_static_property_address(&prop_info, opline->extended_value & ~ZEND_RETURNS_FUNCTION, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC); + prop = zend_fetch_static_property_address(&prop_info, opline->extended_value & ~ZEND_RETURNS_FUNCTION, BP_VAR_W, 0, QUICK_OP_FLAGS_OP1_TYPE((opline+1)->op2.num), QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num) OPLINE_CC EXECUTE_DATA_CC); if (UNEXPECTED(!prop)) { - FREE_OP((opline+1)->op1_type, (opline+1)->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1.var); UNDEF_RESULT(); HANDLE_EXCEPTION(); } @@ -1145,15 +1157,15 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_REF_SPEC_HA if (UNEXPECTED(prop_info->flags & ZEND_ACC_PPP_SET_MASK) && UNEXPECTED(!zend_asymmetric_property_has_set_access(prop_info))) { zend_asymmetric_visibility_property_modification_error(prop_info, "indirectly modify"); - FREE_OP((opline+1)->op1_type, (opline+1)->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1.var); UNDEF_RESULT(); HANDLE_EXCEPTION(); } - value_ptr = get_zval_ptr_ptr((opline+1)->op1_type, (opline+1)->op1, BP_VAR_W); + value_ptr = get_zval_ptr_ptr(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1, BP_VAR_W); - if ((opline+1)->op1_type == IS_VAR && (opline->extended_value & ZEND_RETURNS_FUNCTION) && UNEXPECTED(!Z_ISREF_P(value_ptr))) { - if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(prop, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC))) { + if (QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num) == IS_VAR && (opline->extended_value & ZEND_RETURNS_FUNCTION) && UNEXPECTED(!Z_ISREF_P(value_ptr))) { + if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(prop, value_ptr, &garbage EXECUTE_DATA_CC))) { prop = &EG(uninitialized_zval); } } else if (ZEND_TYPE_IS_SET(prop_info->type)) { @@ -1162,7 +1174,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_REF_SPEC_HA zend_assign_to_variable_reference(prop, value_ptr, &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), prop); } @@ -1170,7 +1182,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_REF_SPEC_HA GC_DTOR(garbage); } - FREE_OP((opline+1)->op1_type, (opline+1)->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1.var); ZEND_VM_NEXT_OPCODE_EX(1, 2); } @@ -1466,7 +1478,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_ICALL_SPEC_OBS bool should_throw = zend_internal_call_should_throw(fbc, call); #endif - ret = RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : &retval; + ret = (opline->result.var != (uint16_t)-1) ? EX_VAR(opline->result.var) : &retval; ZVAL_NULL(ret); zend_observer_fcall_begin_specialized(call, false); @@ -1500,7 +1512,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_ICALL_SPEC_OBS EG(vm_stack_top) = (zval*)call; } - if (!RETURN_VALUE_USED(opline)) { + if (!(opline->result.var != (uint16_t)-1)) { i_zval_ptr_dtor(ret); } @@ -1572,7 +1584,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_OBS EX(call) = call->prev_execute_data; ret = NULL; - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { ret = EX_VAR(opline->result.var); } @@ -1815,7 +1827,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_ SAVE_OPLINE(); EX(call) = call->prev_execute_data; - const uint32_t no_discard = RETURN_VALUE_USED(opline) ? 0 : ZEND_ACC_NODISCARD; + const uint32_t no_discard = (opline->result.var != (uint16_t)-1) ? 0 : ZEND_ACC_NODISCARD; if (UNEXPECTED(fbc->common.fn_flags & (ZEND_ACC_DEPRECATED|no_discard))) { if (fbc->common.fn_flags & ZEND_ACC_DEPRECATED) { @@ -1826,7 +1838,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_ } if (UNEXPECTED(EG(exception) != NULL)) { UNDEF_RESULT(); - if (!RETURN_VALUE_USED(opline)) { + if (!(opline->result.var != (uint16_t)-1)) { ret = &retval; ZVAL_UNDEF(ret); } @@ -1836,7 +1848,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_ if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) { ret = NULL; - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { ret = EX_VAR(opline->result.var); } @@ -1861,7 +1873,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_ bool should_throw = zend_internal_call_should_throw(fbc, call); #endif - ret = RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : &retval; + ret = (opline->result.var != (uint16_t)-1) ? EX_VAR(opline->result.var) : &retval; ZVAL_NULL(ret); zend_observer_fcall_begin_specialized(call, false); @@ -1902,7 +1914,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_ EG(vm_stack_top) = (zval*)call; } - if (!RETURN_VALUE_USED(opline)) { + if (!(opline->result.var != (uint16_t)-1)) { i_zval_ptr_dtor(ret); } } @@ -2176,7 +2188,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_OBS SAVE_OPLINE(); EX(call) = call->prev_execute_data; - const uint32_t no_discard = RETURN_VALUE_USED(opline) ? 0 : ZEND_ACC_NODISCARD; + const uint32_t no_discard = (opline->result.var != (uint16_t)-1) ? 0 : ZEND_ACC_NODISCARD; if (UNEXPECTED(fbc->common.fn_flags & (ZEND_ACC_DEPRECATED|no_discard))) { if (fbc->common.fn_flags & ZEND_ACC_DEPRECATED) { @@ -2190,7 +2202,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_OBS OBJ_RELEASE(ZEND_CLOSURE_OBJECT(call->func)); } UNDEF_RESULT(); - if (!RETURN_VALUE_USED(opline)) { + if (!(opline->result.var != (uint16_t)-1)) { ret = &retval; ZVAL_UNDEF(ret); } @@ -2200,7 +2212,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_OBS if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) { ret = NULL; - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { ret = EX_VAR(opline->result.var); } @@ -2234,7 +2246,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_OBS bool should_throw = zend_internal_call_should_throw(fbc, call); #endif - ret = RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : &retval; + ret = (opline->result.var != (uint16_t)-1) ? EX_VAR(opline->result.var) : &retval; ZVAL_NULL(ret); zend_observer_fcall_begin_specialized(call, false); @@ -2273,7 +2285,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_OBS zend_free_extra_named_params(call->extra_named_params); } - if (!RETURN_VALUE_USED(opline)) { + if (!(opline->result.var != (uint16_t)-1)) { i_zval_ptr_dtor(ret); } } @@ -2376,7 +2388,7 @@ static zend_never_inline ZEND_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_ca SAVE_OPLINE(); zend_cannot_pass_by_reference(_arg_num); - FREE_OP(opline->op1_type, opline->op1.var); + FREE_OP(EX_WOP2->op1_type, opline->op1.var); ZVAL_UNDEF(_arg); HANDLE_EXCEPTION(); } @@ -2388,7 +2400,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_UNPACK_SPEC_HANDLER(ZEND_ uint32_t arg_num; SAVE_OPLINE(); - args = get_zval_ptr_undef(opline->op1_type, opline->op1, BP_VAR_R); + args = get_zval_ptr_undef(QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value), opline->op1, BP_VAR_R); arg_num = ZEND_CALL_NUM_ARGS(EX(call)) + 1; send_again: @@ -2401,7 +2413,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_UNPACK_SPEC_HANDLER(ZEND_ zend_vm_stack_extend_call_frame(&EX(call), arg_num - 1, zend_hash_num_elements(ht)); // TODO: Speed this up using a flag that specifies whether there are any ref parameters. - if ((opline->op1_type & (IS_VAR|IS_CV)) && Z_REFCOUNT_P(args) > 1) { + if ((QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value) & (IS_VAR|IS_CV)) && Z_REFCOUNT_P(args) > 1) { uint32_t tmp_arg_num = arg_num; bool separate = 0; @@ -2430,14 +2442,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_UNPACK_SPEC_HANDLER(ZEND_ have_named_params = 1; top = zend_handle_named_arg(&EX(call), name, &arg_num, cache_slot); if (UNEXPECTED(!top)) { - FREE_OP(opline->op1_type, opline->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value), opline->op1.var); HANDLE_EXCEPTION(); } } else { if (have_named_params) { zend_throw_error(NULL, "Cannot use positional argument after named argument during unpacking"); - FREE_OP(opline->op1_type, opline->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value), opline->op1.var); HANDLE_EXCEPTION(); } @@ -2449,7 +2461,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_UNPACK_SPEC_HANDLER(ZEND_ if (Z_ISREF_P(arg)) { Z_ADDREF_P(arg); ZVAL_REF(top, Z_REF_P(arg)); - } else if (opline->op1_type & (IS_VAR|IS_CV)) { + } else if (QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value) & (IS_VAR|IS_CV)) { /* array is already separated above */ ZVAL_MAKE_REF_EX(arg, 2); ZVAL_REF(top, Z_REF_P(arg)); @@ -2475,7 +2487,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_UNPACK_SPEC_HANDLER(ZEND_ iter = ce->get_iterator(ce, args, 0); if (UNEXPECTED(!iter)) { - FREE_OP(opline->op1_type, opline->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value), opline->op1.var); if (!EG(exception)) { zend_throw_exception_ex( NULL, 0, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name) @@ -2584,13 +2596,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_UNPACK_SPEC_HANDLER(ZEND_ args = Z_REFVAL_P(args); goto send_again; } else { - if (opline->op1_type == IS_CV && UNEXPECTED(Z_TYPE_P(args) == IS_UNDEF)) { + if (QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value) == IS_CV && UNEXPECTED(Z_TYPE_P(args) == IS_UNDEF)) { ZVAL_UNDEFINED_OP1(); } zend_type_error("Only arrays and Traversables can be unpacked, %s given", zend_zval_value_name(args)); } - FREE_OP(opline->op1_type, opline->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value), opline->op1.var); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -2600,18 +2612,18 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_ARRAY_SPEC_HANDLER(ZEND_O zval *args; SAVE_OPLINE(); - args = get_zval_ptr(opline->op1_type, opline->op1, BP_VAR_R); + args = get_zval_ptr(QUICK_OP_FLAGS_OP1_TYPE(opline->result.num), opline->op1, BP_VAR_R); if (UNEXPECTED(Z_TYPE_P(args) != IS_ARRAY)) { - if ((opline->op1_type & (IS_VAR|IS_CV)) && Z_ISREF_P(args)) { + if ((QUICK_OP_FLAGS_OP1_TYPE(opline->result.num) & (IS_VAR|IS_CV)) && Z_ISREF_P(args)) { args = Z_REFVAL_P(args); if (EXPECTED(Z_TYPE_P(args) == IS_ARRAY)) { goto send_array; } } zend_type_error("call_user_func_array(): Argument #2 ($args) must be of type array, %s given", zend_zval_value_name(args)); - FREE_OP(opline->op2_type, opline->op2.var); - FREE_OP(opline->op1_type, opline->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP2_TYPE(opline->result.num), opline->op2.var); + FREE_OP(QUICK_OP_FLAGS_OP1_TYPE(opline->result.num), opline->op1.var); HANDLE_EXCEPTION(); } else { uint32_t arg_num; @@ -2620,10 +2632,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_ARRAY_SPEC_HANDLER(ZEND_O send_array: ht = Z_ARRVAL_P(args); - if (opline->op2_type != IS_UNUSED) { + if (QUICK_OP_FLAGS_OP2_TYPE(opline->result.num) != IS_UNUSED) { /* We don't need to handle named params in this case, * because array_slice() is called with $preserve_keys == false. */ - zval *op2 = get_zval_ptr_deref(opline->op2_type, opline->op2, BP_VAR_R); + zval *op2 = get_zval_ptr_deref(QUICK_OP_FLAGS_OP2_TYPE(opline->result.num), opline->op2, BP_VAR_R); uint32_t skip = opline->extended_value; uint32_t count = zend_hash_num_elements(ht); zend_long len; @@ -2636,8 +2648,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_ARRAY_SPEC_HANDLER(ZEND_O zend_type_error( "array_slice(): Argument #3 ($length) must be of type ?int, %s given", zend_zval_value_name(op2)); - FREE_OP(opline->op2_type, opline->op2.var); - FREE_OP(opline->op1_type, opline->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP2_TYPE(opline->result.num), opline->op2.var); + FREE_OP(QUICK_OP_FLAGS_OP1_TYPE(opline->result.num), opline->op1.var); HANDLE_EXCEPTION(); } @@ -2685,7 +2697,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_ARRAY_SPEC_HANDLER(ZEND_O param++; } ZEND_HASH_FOREACH_END(); } - FREE_OP(opline->op2_type, opline->op2.var); + FREE_OP(QUICK_OP_FLAGS_OP2_TYPE(opline->result.num), opline->op2.var); } else { zend_string *name; bool have_named_params; @@ -2699,13 +2711,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_ARRAY_SPEC_HANDLER(ZEND_O have_named_params = 1; param = zend_handle_named_arg(&EX(call), name, &arg_num, cache_slot); if (!param) { - FREE_OP(opline->op1_type, opline->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP1_TYPE(opline->result.num), opline->op1.var); HANDLE_EXCEPTION(); } } else if (have_named_params) { zend_throw_error(NULL, "Cannot use positional argument after named argument"); - FREE_OP(opline->op1_type, opline->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP1_TYPE(opline->result.num), opline->op1.var); HANDLE_EXCEPTION(); } @@ -2741,7 +2753,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_ARRAY_SPEC_HANDLER(ZEND_O } ZEND_HASH_FOREACH_END(); } } - FREE_OP(opline->op1_type, opline->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP1_TYPE(opline->result.num), opline->op1.var); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -2767,7 +2779,7 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_verify_recv_ ZEND_VM_NEXT_OPCODE(); } -static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_case_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_case_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2, uint8_t op2_type) { int ret; USE_OPLINE @@ -2780,7 +2792,7 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_case_helper_ op_2 = ZVAL_UNDEFINED_OP2(); } ret = zend_compare(op_1, op_2); - if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) { + if (op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_SMART_BRANCH(ret == 0, 1); @@ -2793,7 +2805,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_UNPACK_SPEC_HANDLER( HashTable *result_ht; SAVE_OPLINE(); - op1 = get_zval_ptr(opline->op1_type, opline->op1, BP_VAR_R); + op1 = get_zval_ptr(QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value), opline->op1, BP_VAR_R); result_ht = Z_ARRVAL_P(EX_VAR(opline->result.var)); add_unpack_again: @@ -2842,7 +2854,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_UNPACK_SPEC_HANDLER( } else { iter = ce->get_iterator(ce, op1, 0); if (UNEXPECTED(!iter)) { - FREE_OP(opline->op1_type, opline->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value), opline->op1.var); if (!EG(exception)) { zend_throw_exception_ex( NULL, 0, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name) @@ -2916,7 +2928,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_UNPACK_SPEC_HANDLER( zend_throw_error(NULL, "Only arrays and Traversables can be unpacked, %s given", zend_zval_value_name(op1)); } - FREE_OP(opline->op1_type, opline->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value), opline->op1.var); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -2929,38 +2941,38 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_STATIC_PROP SAVE_OPLINE(); - if (opline->op2_type == IS_CONST) { + if (QUICK_OP_FLAGS_OP2_TYPE(opline->result.num) == IS_CONST) { ce = CACHED_PTR(opline->extended_value); if (UNEXPECTED(ce == NULL)) { ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); if (UNEXPECTED(ce == NULL)) { - FREE_OP(opline->op1_type, opline->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP1_TYPE(opline->result.num), opline->op1.var); HANDLE_EXCEPTION(); } /*CACHE_PTR(opline->extended_value, ce);*/ } - } else if (opline->op2_type == IS_UNUSED) { + } else if (QUICK_OP_FLAGS_OP2_TYPE(opline->result.num) == IS_UNUSED) { ce = zend_fetch_class(NULL, opline->op2.num); if (UNEXPECTED(ce == NULL)) { - FREE_OP(opline->op1_type, opline->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP1_TYPE(opline->result.num), opline->op1.var); HANDLE_EXCEPTION(); } } else { ce = Z_CE_P(EX_VAR(opline->op2.var)); } - varname = get_zval_ptr_undef(opline->op1_type, opline->op1, BP_VAR_R); - if (opline->op1_type == IS_CONST) { + varname = get_zval_ptr_undef(QUICK_OP_FLAGS_OP1_TYPE(opline->result.num), opline->op1, BP_VAR_R); + if (QUICK_OP_FLAGS_OP1_TYPE(opline->result.num) == IS_CONST) { name = Z_STR_P(varname); } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) { name = Z_STR_P(varname); } else { - if (opline->op1_type == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) { + if (QUICK_OP_FLAGS_OP1_TYPE(opline->result.num) == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) { varname = ZVAL_UNDEFINED_OP1(); } name = zval_try_get_tmp_string(varname, &tmp_name); if (UNEXPECTED(!name)) { - FREE_OP(opline->op1_type, opline->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP1_TYPE(opline->result.num), opline->op1.var); HANDLE_EXCEPTION(); } } @@ -2968,7 +2980,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_STATIC_PROP zend_std_unset_static_property(ce, name); zend_tmp_string_release(tmp_name); - FREE_OP(opline->op1_type, opline->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP1_TYPE(opline->result.num), opline->op1.var); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -3018,7 +3030,7 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fe_fetch_obj p++; } EG(ht_iterators)[Z_FE_ITER_P(array)].pos = pos; - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { if (UNEXPECTED(!p->key)) { ZVAL_LONG(EX_VAR(opline->result.var), p->h); } else if (ZSTR_VAL(p->key)[0]) { @@ -3061,7 +3073,7 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fe_fetch_obj /* failure in get_current_data */ goto fe_fetch_r_exit; } - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { if (funcs->get_current_key) { funcs->get_current_key(iter, EX_VAR(opline->result.var)); if (UNEXPECTED(EG(exception) != NULL)) { @@ -3075,7 +3087,7 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fe_fetch_obj value_type = Z_TYPE_INFO_P(value); } - if (EXPECTED(opline->op2_type == IS_CV)) { + if (EXPECTED(EX_WOP2->op2_type == IS_CV)) { zval *variable_ptr = EX_VAR(opline->op2.var); zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES()); } else { @@ -3098,7 +3110,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC SAVE_OPLINE(); - value = zend_fetch_static_property_address(NULL, opline->extended_value & ~ZEND_ISEMPTY, BP_VAR_IS, 0 OPLINE_CC EXECUTE_DATA_CC); + value = zend_fetch_static_property_address(NULL, opline->extended_value & ~ZEND_ISEMPTY, BP_VAR_IS, 0, EX_WOP2->op1_type, EX_WOP2->op2_type OPLINE_CC EXECUTE_DATA_CC); if (!(opline->extended_value & ZEND_ISEMPTY)) { result = value != NULL && Z_TYPE_P(value) > IS_NULL && @@ -3194,7 +3206,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_ANON_CLASS_SPEC_HANDLE ce = Z_CE_P(zv); if (!(ce->ce_flags & ZEND_ACC_LINKED)) { SAVE_OPLINE(); - ce = zend_do_link_class(ce, (opline->op2_type == IS_CONST) ? Z_STR_P(RT_CONSTANT(opline, opline->op2)) : NULL, rtd_key); + ce = zend_do_link_class(ce, (EX_WOP2->op2_type == IS_CONST) ? Z_STR_P(RT_CONSTANT(opline, opline->op2)) : NULL, rtd_key); if (!ce) { HANDLE_EXCEPTION(); } @@ -3247,20 +3259,20 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NOP_SPEC_HANDLER(Z ZEND_VM_NEXT_OPCODE(); } -static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_dispatch_try_catch_finally_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX uint32_t try_catch_offset, uint32_t op_num) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_dispatch_try_catch_finally_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX uint16_t try_catch_offset, uint16_t op_num) { /* May be NULL during generator closing (only finally blocks are executed) */ zend_object *ex = EG(exception); /* Walk try/catch/finally structures upwards, performing the necessary actions */ - for (; try_catch_offset != (uint32_t) -1; try_catch_offset--) { + for (; try_catch_offset != (uint16_t) -1; try_catch_offset--) { zend_try_catch_element *try_catch = &EX(func)->op_array.try_catch_array[try_catch_offset]; if (op_num < try_catch->catch_op && ex) { /* Go to catch block */ cleanup_live_vars(execute_data, op_num, try_catch->catch_op); - ZEND_VM_JMP_EX(&EX(func)->op_array.opcodes[try_catch->catch_op], 0); + ZEND_VM_JMP_EX(&EX(func)->op_array.slim_opcodes[try_catch->catch_op], 0); } else if (op_num < try_catch->finally_op) { if (ex && zend_is_unwind_exit(ex)) { @@ -3274,7 +3286,7 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_dispatch_try Z_OBJ_P(fast_call) = EG(exception); EG(exception) = NULL; Z_OPLINE_NUM_P(fast_call) = (uint32_t)-1; - ZEND_VM_JMP_EX(&EX(func)->op_array.opcodes[try_catch->finally_op], 0); + ZEND_VM_JMP_EX(&EX(func)->op_array.slim_opcodes[try_catch->finally_op], 0); } else if (op_num < try_catch->finally_end) { zval *fast_call = EX_VAR(EX(func)->op_array.opcodes[try_catch->finally_end].op1.var); @@ -3326,14 +3338,15 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_dispatch_try static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - const zend_op *throw_op = EG(opline_before_exception); + const zend_slim_op *throw_sop = EG(opline_before_exception); /* Exception was thrown before executing any op */ - if (UNEXPECTED(!throw_op)) { + if (UNEXPECTED(!throw_sop)) { ZEND_VM_TAIL_CALL(zend_dispatch_try_catch_finally_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX -1, 0)); } - uint32_t throw_op_num = throw_op - EX(func)->op_array.opcodes; + const zend_op *throw_op = Z_WOP_FROM_OP(throw_sop); + uint32_t throw_op_num = throw_sop - EX(func)->op_array.slim_opcodes; int i, current_try_catch_offset = -1; if ((throw_op->opcode == ZEND_FREE || throw_op->opcode == ZEND_FE_FREE) @@ -3402,8 +3415,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_USER_OPCODE_SPEC_HANDLER(ZEND_ USE_OPLINE int ret; + zend_op *wop = Z_WOP; + SAVE_OPLINE(); - ret = zend_user_opcode_handlers[opline->opcode](execute_data); + ret = zend_user_opcode_handlers[wop->opcode](execute_data); + // FIXME: Why is this needed? opline = EX(opline); switch (ret) { @@ -3423,7 +3439,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_USER_OPCODE_SPEC_HANDLER(ZEND_ case ZEND_USER_OPCODE_LEAVE: ZEND_VM_LEAVE(); case ZEND_USER_OPCODE_DISPATCH: - ZEND_VM_DISPATCH(opline->opcode, opline); + ZEND_VM_DISPATCH(wop->opcode, opline); default: ZEND_VM_DISPATCH((uint8_t)(ret & 0xff), opline); } @@ -3435,8 +3451,8 @@ static zend_never_inline ZEND_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_yi SAVE_OPLINE(); zend_throw_error(NULL, "Cannot yield from finally in a force-closed generator"); - FREE_OP(opline->op2_type, opline->op2.var); - FREE_OP(opline->op1_type, opline->op1.var); + FREE_OP(EX_WOP2->op2_type, opline->op2.var); + FREE_OP(EX_WOP2->op1_type, opline->op1.var); UNDEF_RESULT(); HANDLE_EXCEPTION(); } @@ -3472,7 +3488,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CALL_SPEC_HANDLER(ZEND_OP Z_OBJ_P(fast_call) = NULL; /* set return address */ - Z_OPLINE_NUM_P(fast_call) = opline - EX(func)->op_array.opcodes; + Z_OPLINE_NUM_P(fast_call) = opline - EX(func)->op_array.slim_opcodes; ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op1), 0); } @@ -3480,10 +3496,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_RET_SPEC_HANDLER(ZEND_OPC { USE_OPLINE zval *fast_call = EX_VAR(opline->op1.var); - uint32_t current_try_catch_offset, current_op_num; + uint16_t current_try_catch_offset, current_op_num; if (Z_OPLINE_NUM_P(fast_call) != (uint32_t)-1) { - const zend_op *fast_ret = EX(func)->op_array.opcodes + Z_OPLINE_NUM_P(fast_call); + const zend_slim_op *fast_ret = EX(func)->op_array.slim_opcodes + Z_OPLINE_NUM_P(fast_call); ZEND_VM_JMP_EX(fast_ret + 1, 0); } @@ -3492,7 +3508,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_RET_SPEC_HANDLER(ZEND_OPC EG(exception) = Z_OBJ_P(fast_call); Z_OBJ_P(fast_call) = NULL; current_try_catch_offset = opline->op2.num; - current_op_num = opline - EX(func)->op_array.opcodes; + current_op_num = opline - EX(func)->op_array.slim_opcodes; ZEND_VM_TAIL_CALL(zend_dispatch_try_catch_finally_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX current_try_catch_offset, current_op_num)); } @@ -3501,8 +3517,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSERT_CHECK_SPEC_HANDLER(ZEND USE_OPLINE if (EG(assertions) <= 0) { - zend_op *target = OP_JMP_ADDR(opline, opline->op2); - if (RETURN_VALUE_USED(opline)) { + zend_slim_op *target = OP_JMP_ADDR(opline, opline->op2); + if ((opline->result.var != (uint16_t)-1)) { ZVAL_TRUE(EX_VAR(opline->result.var)); } ZEND_VM_JMP_EX(target, 0); @@ -3805,11 +3821,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_2_SPEC_HANDLER zval *result = EX_VAR(opline->result.var); ZVAL_NULL(result); - zval *arg1 = get_zval_ptr_deref(opline->op1_type, opline->op1, BP_VAR_R); - zval *arg2 = get_zval_ptr_deref(opline->op2_type, opline->op2, BP_VAR_R); + zval *arg1 = get_zval_ptr_deref(EX_WOP2->op1_type, opline->op1, BP_VAR_R); + zval *arg2 = get_zval_ptr_deref(EX_WOP2->op2_type, opline->op2, BP_VAR_R); if (EG(exception)) { - FREE_OP(opline->op1_type, opline->op1.var); - FREE_OP(opline->op2_type, opline->op2.var); + FREE_OP(EX_WOP2->op1_type, opline->op1.var); + FREE_OP(EX_WOP2->op2_type, opline->op2.var); HANDLE_EXCEPTION(); } @@ -3819,16 +3835,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_2_SPEC_HANDLER } else #endif { - zend_frameless_function_2 function = (zend_frameless_function_2)ZEND_FLF_HANDLER(opline); + zend_frameless_function_2 function = (zend_frameless_function_2)ZEND_FLF_HANDLER(opline->extended_value); function(result, arg1, arg2); } - FREE_OP(opline->op1_type, opline->op1.var); - /* Set OP1 to UNDEF in case FREE_OP(opline->op2_type, opline->op2.var) throws. */ - if (opline->op1_type & (IS_VAR|IS_TMP_VAR)) { + FREE_OP(EX_WOP2->op1_type, opline->op1.var); + /* Set OP1 to UNDEF in case FREE_OP(EX_WOP2->op2_type, opline->op2.var) throws. */ + if (EX_WOP2->op1_type & (IS_VAR|IS_TMP_VAR)) { ZVAL_UNDEF(EX_VAR(opline->op1.var)); } - FREE_OP(opline->op2_type, opline->op2.var); + FREE_OP(EX_WOP2->op2_type, opline->op2.var); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -3839,11 +3855,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVE zval *result = EX_VAR(opline->result.var); ZVAL_NULL(result); - zval *arg1 = get_zval_ptr_deref(opline->op1_type, opline->op1, BP_VAR_R); - zval *arg2 = get_zval_ptr_deref(opline->op2_type, opline->op2, BP_VAR_R); + zval *arg1 = get_zval_ptr_deref(EX_WOP2->op1_type, opline->op1, BP_VAR_R); + zval *arg2 = get_zval_ptr_deref(EX_WOP2->op2_type, opline->op2, BP_VAR_R); if (EG(exception)) { - FREE_OP(opline->op1_type, opline->op1.var); - FREE_OP(opline->op2_type, opline->op2.var); + FREE_OP(EX_WOP2->op1_type, opline->op1.var); + FREE_OP(EX_WOP2->op2_type, opline->op2.var); HANDLE_EXCEPTION(); } @@ -3853,16 +3869,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVE } else #endif { - zend_frameless_function_2 function = (zend_frameless_function_2)ZEND_FLF_HANDLER(opline); + zend_frameless_function_2 function = (zend_frameless_function_2)ZEND_FLF_HANDLER(opline->extended_value); function(result, arg1, arg2); } - FREE_OP(opline->op1_type, opline->op1.var); - /* Set OP1 to UNDEF in case FREE_OP(opline->op2_type, opline->op2.var) throws. */ - if (opline->op1_type & (IS_VAR|IS_TMP_VAR)) { + FREE_OP(EX_WOP2->op1_type, opline->op1.var); + /* Set OP1 to UNDEF in case FREE_OP(EX_WOP2->op2_type, opline->op2.var) throws. */ + if (EX_WOP2->op1_type & (IS_VAR|IS_TMP_VAR)) { ZVAL_UNDEF(EX_VAR(opline->op1.var)); } - FREE_OP(opline->op2_type, opline->op2.var); + FREE_OP(EX_WOP2->op2_type, opline->op2.var); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -3873,13 +3889,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_3_SPEC_HANDLER zval *result = EX_VAR(opline->result.var); ZVAL_NULL(result); - zval *arg1 = get_zval_ptr_deref(opline->op1_type, opline->op1, BP_VAR_R); - zval *arg2 = get_zval_ptr_deref(opline->op2_type, opline->op2, BP_VAR_R); - zval *arg3 = get_op_data_zval_ptr_deref_r((opline+1)->op1_type, (opline+1)->op1); + zval *arg1 = get_zval_ptr_deref(QUICK_OP_FLAGS_OP1_TYPE((opline+1)->op2.num), opline->op1, BP_VAR_R); + zval *arg2 = get_zval_ptr_deref(QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num), opline->op2, BP_VAR_R); + zval *arg3 = get_op_data_zval_ptr_deref_r(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1); if (EG(exception)) { - FREE_OP(opline->op1_type, opline->op1.var); - FREE_OP(opline->op2_type, opline->op2.var); - FREE_OP((opline+1)->op1_type, (opline+1)->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP1_TYPE((opline+1)->op2.num), opline->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num), opline->op2.var); + FREE_OP(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1.var); HANDLE_EXCEPTION(); } @@ -3889,20 +3905,20 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_3_SPEC_HANDLER } else #endif { - zend_frameless_function_3 function = (zend_frameless_function_3)ZEND_FLF_HANDLER(opline); + zend_frameless_function_3 function = (zend_frameless_function_3)ZEND_FLF_HANDLER(opline->extended_value); function(result, arg1, arg2, arg3); } - FREE_OP(opline->op1_type, opline->op1.var); - /* Set to UNDEF in case FREE_OP(opline->op2_type, opline->op2.var) throws. */ - if (opline->op1_type & (IS_VAR|IS_TMP_VAR)) { + FREE_OP(QUICK_OP_FLAGS_OP1_TYPE((opline+1)->op2.num), opline->op1.var); + /* Set to UNDEF in case FREE_OP(QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num), opline->op2.var) throws. */ + if (QUICK_OP_FLAGS_OP1_TYPE((opline+1)->op2.num) & (IS_VAR|IS_TMP_VAR)) { ZVAL_UNDEF(EX_VAR(opline->op1.var)); } - FREE_OP(opline->op2_type, opline->op2.var); - if (opline->op2_type & (IS_VAR|IS_TMP_VAR)) { + FREE_OP(QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num), opline->op2.var); + if (QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num) & (IS_VAR|IS_TMP_VAR)) { ZVAL_UNDEF(EX_VAR(opline->op2.var)); } - FREE_OP((opline+1)->op1_type, (opline+1)->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1.var); ZEND_VM_NEXT_OPCODE_EX(1, 2); } @@ -3913,13 +3929,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVE zval *result = EX_VAR(opline->result.var); ZVAL_NULL(result); - zval *arg1 = get_zval_ptr_deref(opline->op1_type, opline->op1, BP_VAR_R); - zval *arg2 = get_zval_ptr_deref(opline->op2_type, opline->op2, BP_VAR_R); - zval *arg3 = get_op_data_zval_ptr_deref_r((opline+1)->op1_type, (opline+1)->op1); + zval *arg1 = get_zval_ptr_deref(QUICK_OP_FLAGS_OP1_TYPE((opline+1)->op2.num), opline->op1, BP_VAR_R); + zval *arg2 = get_zval_ptr_deref(QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num), opline->op2, BP_VAR_R); + zval *arg3 = get_op_data_zval_ptr_deref_r(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1); if (EG(exception)) { - FREE_OP(opline->op1_type, opline->op1.var); - FREE_OP(opline->op2_type, opline->op2.var); - FREE_OP((opline+1)->op1_type, (opline+1)->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP1_TYPE((opline+1)->op2.num), opline->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num), opline->op2.var); + FREE_OP(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1.var); HANDLE_EXCEPTION(); } @@ -3929,20 +3945,20 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVE } else #endif { - zend_frameless_function_3 function = (zend_frameless_function_3)ZEND_FLF_HANDLER(opline); + zend_frameless_function_3 function = (zend_frameless_function_3)ZEND_FLF_HANDLER(opline->extended_value); function(result, arg1, arg2, arg3); } - FREE_OP(opline->op1_type, opline->op1.var); - /* Set to UNDEF in case FREE_OP(opline->op2_type, opline->op2.var) throws. */ - if (opline->op1_type & (IS_VAR|IS_TMP_VAR)) { + FREE_OP(QUICK_OP_FLAGS_OP1_TYPE((opline+1)->op2.num), opline->op1.var); + /* Set to UNDEF in case FREE_OP(QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num), opline->op2.var) throws. */ + if (QUICK_OP_FLAGS_OP1_TYPE((opline+1)->op2.num) & (IS_VAR|IS_TMP_VAR)) { ZVAL_UNDEF(EX_VAR(opline->op1.var)); } - FREE_OP(opline->op2_type, opline->op2.var); - if (opline->op2_type & (IS_VAR|IS_TMP_VAR)) { + FREE_OP(QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num), opline->op2.var); + if (QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num) & (IS_VAR|IS_TMP_VAR)) { ZVAL_UNDEF(EX_VAR(opline->op2.var)); } - FREE_OP((opline+1)->op1_type, (opline+1)->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1.var); ZEND_VM_NEXT_OPCODE_EX(1, 2); } @@ -3964,7 +3980,7 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_interrupt_he zend_interrupt_function(execute_data); if (EG(exception)) { /* We have to UNDEF result, because ZEND_HANDLE_EXCEPTION is going to free it */ - const zend_op *throw_op = EG(opline_before_exception); + const zend_op *throw_op = Z_WOP_FROM_OP(EG(opline_before_exception)); if (throw_op && throw_op->result_type & (IS_TMP_VAR|IS_VAR) @@ -4354,9 +4370,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED_ zval *result = EX_VAR(opline->result.var); ZVAL_NULL(result); - zval *arg1 = get_zval_ptr_deref(opline->op1_type, opline->op1, BP_VAR_R); + zval *arg1 = get_zval_ptr_deref(QUICK_OP_FLAGS_OP1_TYPE(opline->op2.num), opline->op1, BP_VAR_R); if (EG(exception)) { - FREE_OP(opline->op1_type, opline->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP1_TYPE(opline->op2.num), opline->op1.var); HANDLE_EXCEPTION(); } @@ -4366,10 +4382,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED_ } else #endif { - zend_frameless_function_1 function = (zend_frameless_function_1)ZEND_FLF_HANDLER(opline); + zend_frameless_function_1 function = (zend_frameless_function_1)ZEND_FLF_HANDLER(opline->extended_value); function(result, arg1); } - FREE_OP(opline->op1_type, opline->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP1_TYPE(opline->op2.num), opline->op1.var); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -4380,9 +4396,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_1_SPEC_OBSERVE zval *result = EX_VAR(opline->result.var); ZVAL_NULL(result); - zval *arg1 = get_zval_ptr_deref(opline->op1_type, opline->op1, BP_VAR_R); + zval *arg1 = get_zval_ptr_deref(QUICK_OP_FLAGS_OP1_TYPE(opline->op2.num), opline->op1, BP_VAR_R); if (EG(exception)) { - FREE_OP(opline->op1_type, opline->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP1_TYPE(opline->op2.num), opline->op1.var); HANDLE_EXCEPTION(); } @@ -4392,10 +4408,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_1_SPEC_OBSERVE } else #endif { - zend_frameless_function_1 function = (zend_frameless_function_1)ZEND_FLF_HANDLER(opline); + zend_frameless_function_1 function = (zend_frameless_function_1)ZEND_FLF_HANDLER(opline->extended_value); function(result, arg1); } - FREE_OP(opline->op1_type, opline->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP1_TYPE(opline->op2.num), opline->op1.var); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -4703,31 +4719,31 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_OBSER zval *return_value; zval observer_retval; - retval_ptr = get_zval_ptr_undef(opline->op1_type, opline->op1, BP_VAR_R); + retval_ptr = get_zval_ptr_undef(QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value), opline->op1, BP_VAR_R); return_value = EX(return_value); if (!return_value) { return_value = &observer_retval; }; - if (opline->op1_type == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) { + if (QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) { SAVE_OPLINE(); retval_ptr = ZVAL_UNDEFINED_OP1(); if (return_value) { ZVAL_NULL(return_value); } } else if (!return_value) { - if (opline->op1_type & (IS_VAR|IS_TMP_VAR)) { + if (QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value) & (IS_VAR|IS_TMP_VAR)) { if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) { SAVE_OPLINE(); rc_dtor_func(Z_COUNTED_P(retval_ptr)); } } } else { - if ((opline->op1_type & (IS_CONST|IS_TMP_VAR))) { + if ((QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value) & (IS_CONST|IS_TMP_VAR))) { ZVAL_COPY_VALUE(return_value, retval_ptr); - if (opline->op1_type == IS_CONST) { + if (QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value) == IS_CONST) { if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) { Z_ADDREF_P(return_value); } } - } else if (opline->op1_type == IS_CV) { + } else if (QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value) == IS_CV) { do { if (Z_OPT_REFCOUNTED_P(retval_ptr)) { if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) { @@ -4752,7 +4768,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_OBSER } ZVAL_COPY_VALUE(return_value, retval_ptr); } while (0); - } else /* if (opline->op1_type == IS_VAR) */ { + } else /* if (QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value) == IS_VAR) */ { if (UNEXPECTED(Z_ISREF_P(retval_ptr))) { zend_refcounted *ref = Z_COUNTED_P(retval_ptr); @@ -4849,38 +4865,38 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPE return_value = EX(return_value); if (!return_value) { return_value = &observer_retval; }; do { - if ((opline->op1_type & (IS_CONST|IS_TMP_VAR)) || - (opline->op1_type == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) { + if ((EX_WOP2->op1_type & (IS_CONST|IS_TMP_VAR)) || + (EX_WOP2->op1_type == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) { /* Not supposed to happen, but we'll allow it */ zend_error(E_NOTICE, "Only variable references should be returned by reference"); - retval_ptr = get_zval_ptr(opline->op1_type, opline->op1, BP_VAR_R); + retval_ptr = get_zval_ptr(EX_WOP2->op1_type, opline->op1, BP_VAR_R); if (!return_value) { - FREE_OP(opline->op1_type, opline->op1.var); + FREE_OP(EX_WOP2->op1_type, opline->op1.var); } else { - if (opline->op1_type == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) { + if (EX_WOP2->op1_type == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) { ZVAL_COPY_VALUE(return_value, retval_ptr); break; } ZVAL_NEW_REF(return_value, retval_ptr); - if (opline->op1_type == IS_CONST) { + if (EX_WOP2->op1_type == IS_CONST) { Z_TRY_ADDREF_P(retval_ptr); } } break; } - retval_ptr = get_zval_ptr_ptr(opline->op1_type, opline->op1, BP_VAR_W); + retval_ptr = get_zval_ptr_ptr(EX_WOP2->op1_type, opline->op1, BP_VAR_W); - if (opline->op1_type == IS_VAR) { + if (EX_WOP2->op1_type == IS_VAR) { ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval)); if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) { zend_error(E_NOTICE, "Only variable references should be returned by reference"); if (return_value) { ZVAL_NEW_REF(return_value, retval_ptr); } else { - FREE_OP(opline->op1_type, opline->op1.var); + FREE_OP(EX_WOP2->op1_type, opline->op1.var); } break; } @@ -4895,7 +4911,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPE ZVAL_REF(return_value, Z_REF_P(retval_ptr)); } - FREE_OP(opline->op1_type, opline->op1.var); + FREE_OP(EX_WOP2->op1_type, opline->op1.var); } while (0); zend_observer_fcall_end(execute_data, return_value); @@ -4956,19 +4972,19 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_OBSERVER zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C); SAVE_OPLINE(); - retval = get_zval_ptr(opline->op1_type, opline->op1, BP_VAR_R); + retval = get_zval_ptr(QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value), opline->op1, BP_VAR_R); /* Copy return value into generator->retval */ - if ((opline->op1_type & (IS_CONST|IS_TMP_VAR))) { + if ((QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value) & (IS_CONST|IS_TMP_VAR))) { ZVAL_COPY_VALUE(&generator->retval, retval); - if (opline->op1_type == IS_CONST) { + if (QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value) == IS_CONST) { if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) { Z_ADDREF(generator->retval); } } - } else if (opline->op1_type == IS_CV) { + } else if (QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value) == IS_CV) { ZVAL_COPY_DEREF(&generator->retval, retval); - } else /* if (opline->op1_type == IS_VAR) */ { + } else /* if (QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value) == IS_VAR) */ { if (UNEXPECTED(Z_ISREF_P(retval))) { zend_refcounted *ref = Z_COUNTED_P(retval); @@ -5069,7 +5085,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CATCH_SPEC_CONST_HANDLER(ZEND_ exception = EG(exception); EG(exception) = NULL; - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { /* Always perform a strict assignment. There is a reasonable expectation that if you * write "catch (Exception $e)" then $e will actually be instanceof Exception. As such, * we should not permit coercion to string here. */ @@ -5256,18 +5272,18 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HAN UNDEF_RESULT(); HANDLE_EXCEPTION(); } else if (new_op_array == ZEND_FAKE_OP_ARRAY) { - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { ZVAL_TRUE(EX_VAR(opline->result.var)); } } else if (UNEXPECTED(new_op_array == NULL)) { - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { ZVAL_FALSE(EX_VAR(opline->result.var)); } } else if (new_op_array->last == 1 && new_op_array->opcodes[0].opcode == ZEND_RETURN && new_op_array->opcodes[0].op1_type == IS_CONST && EXPECTED(zend_execute_ex == execute_ex)) { - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { const zend_op *op = new_op_array->opcodes; ZVAL_COPY(EX_VAR(opline->result.var), RT_CONSTANT(op, op->op1)); @@ -5278,7 +5294,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HAN } else { zval *return_value = NULL; zend_execute_data *call; - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { return_value = EX_VAR(opline->result.var); } @@ -5328,10 +5344,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_ zval *inc_filename; SAVE_OPLINE(); - inc_filename = get_zval_ptr(opline->op1_type, opline->op1, BP_VAR_R); + inc_filename = get_zval_ptr(EX_WOP2->op1_type, opline->op1, BP_VAR_R); new_op_array = zend_include_or_eval(inc_filename, opline->extended_value); if (UNEXPECTED(EG(exception) != NULL)) { - FREE_OP(opline->op1_type, opline->op1.var); + FREE_OP(EX_WOP2->op1_type, opline->op1.var); if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) { destroy_op_array(new_op_array); efree_size(new_op_array, sizeof(zend_op_array)); @@ -5339,18 +5355,18 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_ UNDEF_RESULT(); HANDLE_EXCEPTION(); } else if (new_op_array == ZEND_FAKE_OP_ARRAY) { - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { ZVAL_TRUE(EX_VAR(opline->result.var)); } } else if (UNEXPECTED(new_op_array == NULL)) { - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { ZVAL_FALSE(EX_VAR(opline->result.var)); } } else if (new_op_array->last == 1 && new_op_array->opcodes[0].opcode == ZEND_RETURN && new_op_array->opcodes[0].op1_type == IS_CONST && EXPECTED(zend_execute_ex == execute_ex)) { - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { const zend_op *op = new_op_array->opcodes; ZVAL_COPY(EX_VAR(opline->result.var), RT_CONSTANT(op, op->op1)); @@ -5361,7 +5377,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_ } else { zval *return_value = NULL; zend_execute_data *call; - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { return_value = EX_VAR(opline->result.var); } @@ -5382,7 +5398,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_ i_init_code_execute_data(call, new_op_array, return_value); zend_observer_fcall_begin_specialized(call, false); if (EXPECTED(zend_execute_ex == execute_ex)) { - FREE_OP(opline->op1_type, opline->op1.var); + FREE_OP(EX_WOP2->op1_type, opline->op1.var); ZEND_VM_ENTER(); } else { ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP); @@ -5395,12 +5411,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_ efree_size(new_op_array, sizeof(zend_op_array)); if (UNEXPECTED(EG(exception) != NULL)) { zend_rethrow_exception(execute_data); - FREE_OP(opline->op1_type, opline->op1.var); + FREE_OP(EX_WOP2->op1_type, opline->op1.var); UNDEF_RESULT(); HANDLE_EXCEPTION(); } } - FREE_OP(opline->op1_type, opline->op1.var); + FREE_OP(EX_WOP2->op1_type, opline->op1.var); ZEND_VM_NEXT_OPCODE(); } @@ -5751,7 +5767,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_CLASS_SPEC_CONST_HANDL USE_OPLINE SAVE_OPLINE(); - do_bind_class(RT_CONSTANT(opline, opline->op1), (opline->op2_type == IS_CONST) ? Z_STR_P(RT_CONSTANT(opline, opline->op2)) : NULL); + do_bind_class(RT_CONSTANT(opline, opline->op1), (QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value) == IS_CONST) ? Z_STR_P(RT_CONSTANT(opline, opline->op2)) : NULL); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -5828,7 +5844,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_FROM_SPEC_CONST_HANDLER( zend_generator_yield_from(generator, new_gen); } } else { - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { ZVAL_COPY(EX_VAR(opline->result.var), &new_gen->retval); } ZEND_VM_NEXT_OPCODE(); @@ -5868,7 +5884,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_FROM_SPEC_CONST_HANDLER( /* This is the default return value * when the expression is a Generator, it will be overwritten in zend_generator_resume() */ - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { ZVAL_NULL(EX_VAR(opline->result.var)); } @@ -6058,7 +6074,9 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_CONST_CO } } - ZEND_VM_TAIL_CALL(zend_add_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_add_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -6096,7 +6114,9 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_CONST_CO } } - ZEND_VM_TAIL_CALL(zend_sub_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_sub_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -6137,7 +6157,9 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_SPEC_CONST_CO } } - ZEND_VM_TAIL_CALL(zend_mul_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_mul_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -6178,7 +6200,9 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_CONST_CO } } - ZEND_VM_TAIL_CALL(zend_mod_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_mod_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -6199,7 +6223,9 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_CONST_CON ZEND_VM_NEXT_OPCODE(); } - ZEND_VM_TAIL_CALL(zend_shift_left_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_shift_left_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -6218,7 +6244,9 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_CONST_CON ZEND_VM_NEXT_OPCODE(); } - ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -6247,7 +6275,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC result = fast_is_identical_function(op1, op2); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -6262,7 +6290,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_ result = fast_is_not_identical_function(op1, op2); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -6279,10 +6307,10 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CON if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { is_equal_true: - ZEND_VM_SMART_BRANCH_TRUE(); + ZEND_VM_SMART_BRANCH_TRUE_EX(QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } else { is_equal_false: - ZEND_VM_SMART_BRANCH_FALSE(); + ZEND_VM_SMART_BRANCH_FALSE_EX(QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { d1 = (double)Z_LVAL_P(op1); @@ -6320,7 +6348,9 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CON } } } - ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -6337,10 +6367,10 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) { is_not_equal_true: - ZEND_VM_SMART_BRANCH_TRUE(); + ZEND_VM_SMART_BRANCH_TRUE_EX(QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } else { is_not_equal_false: - ZEND_VM_SMART_BRANCH_FALSE(); + ZEND_VM_SMART_BRANCH_FALSE_EX(QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { d1 = (double)Z_LVAL_P(op1); @@ -6378,7 +6408,9 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC } } } - ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -6395,10 +6427,10 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_C if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) { if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) { is_smaller_true: - ZEND_VM_SMART_BRANCH_TRUE(); + ZEND_VM_SMART_BRANCH_TRUE_EX(QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } else { is_smaller_false: - ZEND_VM_SMART_BRANCH_FALSE(); + ZEND_VM_SMART_BRANCH_FALSE_EX(QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) { d1 = (double)Z_LVAL_P(op1); @@ -6421,7 +6453,9 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_C goto is_smaller_double; } } - ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -6438,12 +6472,12 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQU if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) { if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) { is_smaller_or_equal_true: - ZEND_VM_SMART_BRANCH_TRUE(); + ZEND_VM_SMART_BRANCH_TRUE_EX(QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); ZVAL_TRUE(EX_VAR(opline->result.var)); ZEND_VM_NEXT_OPCODE(); } else { is_smaller_or_equal_false: - ZEND_VM_SMART_BRANCH_FALSE(); + ZEND_VM_SMART_BRANCH_FALSE_EX(QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); ZVAL_FALSE(EX_VAR(opline->result.var)); ZEND_VM_NEXT_OPCODE(); } @@ -6468,7 +6502,9 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQU goto is_smaller_or_equal_double; } } - ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -6500,7 +6536,9 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_CONST_ ZEND_VM_NEXT_OPCODE(); } - ZEND_VM_TAIL_CALL(zend_bw_or_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_bw_or_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -6518,7 +6556,9 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_CONST ZEND_VM_NEXT_OPCODE(); } - ZEND_VM_TAIL_CALL(zend_bw_and_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_bw_and_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -6536,7 +6576,9 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_CONST ZEND_VM_NEXT_OPCODE(); } - ZEND_VM_TAIL_CALL(zend_bw_xor_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_bw_xor_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -6699,9 +6741,9 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_ zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC); #if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)) - opline = hook->op_array.opcodes; + opline = hook->op_array.slim_opcodes; #else - EX(opline) = hook->op_array.opcodes; + EX(opline) = hook->op_array.slim_opcodes; #endif LOAD_OPLINE_EX(); @@ -7895,7 +7937,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CO } - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -7980,7 +8022,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_ ZEND_VM_NEXT_OPCODE_EX(1, 2); } - HashTable *attributes = Z_PTR_P(get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1)); + HashTable *attributes = Z_PTR_P(get_op_data_zval_ptr_r(QUICK_OP_FLAGS_OP_DATA_TYPE(opline->extended_value), (opline+1)->op1)); zend_constant *registered = zend_get_constant_ptr(c.name); ZEND_ASSERT(attributes != NULL); ZEND_ASSERT(registered != NULL); @@ -8094,7 +8136,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CONST_HANDLER ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ generator->send_target = EX_VAR(opline->result.var); @@ -8319,7 +8361,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_CONST_TMP } } - ZEND_VM_TAIL_CALL(zend_add_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_add_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -8357,7 +8401,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_CONST_TMP } } - ZEND_VM_TAIL_CALL(zend_sub_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_sub_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -8384,7 +8430,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_CONST_TMPVARCV_HANDLE } } - ZEND_VM_TAIL_CALL(zend_mod_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_mod_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -8405,7 +8453,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_CONST_TMPVARCV_HANDLER ZEND_VM_NEXT_OPCODE(); } - ZEND_VM_TAIL_CALL(zend_shift_left_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_shift_left_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -8424,7 +8474,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_CONST_TMPVARCV_HANDLER ZEND_VM_NEXT_OPCODE(); } - ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -8467,7 +8519,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV goto is_smaller_double; } } - ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -8510,7 +8564,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CO goto is_smaller_double; } } - ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -8553,7 +8609,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CO goto is_smaller_double; } } - ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -8600,7 +8658,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST goto is_smaller_or_equal_double; } } - ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -8647,7 +8707,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUA goto is_smaller_or_equal_double; } } - ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -8694,7 +8756,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUA goto is_smaller_or_equal_double; } } - ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -8721,7 +8785,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_CONS ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); if (UNEXPECTED(ce == NULL)) { ZVAL_UNDEF(EX_VAR(opline->result.var)); - FREE_OP(opline->op2_type, opline->op2.var); + FREE_OP(EX_WOP2->op2_type, opline->op2.var); HANDLE_EXCEPTION(); } CACHE_PTR(opline->extended_value, ce); @@ -8730,7 +8794,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_CONS ce = zend_fetch_class(NULL, opline->op1.num); if (UNEXPECTED(ce == NULL)) { ZVAL_UNDEF(EX_VAR(opline->result.var)); - FREE_OP(opline->op2_type, opline->op2.var); + FREE_OP(EX_WOP2->op2_type, opline->op2.var); HANDLE_EXCEPTION(); } } else { @@ -8743,18 +8807,18 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_CONS break; } - constant_zv = _get_zval_ptr_tmpvarcv(opline->op2_type, opline->op2, BP_VAR_R EXECUTE_DATA_CC); + constant_zv = _get_zval_ptr_tmpvarcv(EX_WOP2->op2_type, opline->op2, BP_VAR_R EXECUTE_DATA_CC); if (UNEXPECTED(Z_TYPE_P(constant_zv) != IS_STRING)) { zend_invalid_class_constant_type_error(Z_TYPE_P(constant_zv)); ZVAL_UNDEF(EX_VAR(opline->result.var)); - FREE_OP(opline->op2_type, opline->op2.var); + FREE_OP(EX_WOP2->op2_type, opline->op2.var); HANDLE_EXCEPTION(); } constant_name = Z_STR_P(constant_zv); /* Magic 'class' for constant OP2 is caught at compile-time */ if ((IS_TMP_VAR|IS_VAR|IS_CV) != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) { ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name); - FREE_OP(opline->op2_type, opline->op2.var); + FREE_OP(EX_WOP2->op2_type, opline->op2.var); ZEND_VM_NEXT_OPCODE(); } zv = (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST @@ -8767,14 +8831,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_CONS if (!zend_verify_const_access(c, scope)) { zend_throw_error(NULL, "Cannot access %s constant %s::%s", zend_visibility_string(ZEND_CLASS_CONST_FLAGS(c)), ZSTR_VAL(ce->name), ZSTR_VAL(constant_name)); ZVAL_UNDEF(EX_VAR(opline->result.var)); - FREE_OP(opline->op2_type, opline->op2.var); + FREE_OP(EX_WOP2->op2_type, opline->op2.var); HANDLE_EXCEPTION(); } if (ce->ce_flags & ZEND_ACC_TRAIT) { zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name)); ZVAL_UNDEF(EX_VAR(opline->result.var)); - FREE_OP(opline->op2_type, opline->op2.var); + FREE_OP(EX_WOP2->op2_type, opline->op2.var); HANDLE_EXCEPTION(); } @@ -8791,7 +8855,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_CONS if (EG(exception)) { ZVAL_UNDEF(EX_VAR(opline->result.var)); - FREE_OP(opline->op2_type, opline->op2.var); + FREE_OP(EX_WOP2->op2_type, opline->op2.var); HANDLE_EXCEPTION(); } } @@ -8801,14 +8865,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_CONS if (ce->ce_flags & ZEND_ACC_ENUM && ce->enum_backing_type != IS_UNDEF && ce->type == ZEND_USER_CLASS && !(ce->ce_flags & ZEND_ACC_CONSTANTS_UPDATED)) { if (UNEXPECTED(zend_update_class_constants(ce) == FAILURE)) { ZVAL_UNDEF(EX_VAR(opline->result.var)); - FREE_OP(opline->op2_type, opline->op2.var); + FREE_OP(EX_WOP2->op2_type, opline->op2.var); HANDLE_EXCEPTION(); } } if (Z_TYPE_P(value) == IS_CONSTANT_AST) { if (UNEXPECTED(zend_update_class_constant(c, constant_name, c->ce) != SUCCESS)) { ZVAL_UNDEF(EX_VAR(opline->result.var)); - FREE_OP(opline->op2_type, opline->op2.var); + FREE_OP(EX_WOP2->op2_type, opline->op2.var); HANDLE_EXCEPTION(); } } @@ -8819,14 +8883,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_CONS zend_throw_error(NULL, "Undefined constant %s::%s", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name)); ZVAL_UNDEF(EX_VAR(opline->result.var)); - FREE_OP(opline->op2_type, opline->op2.var); + FREE_OP(EX_WOP2->op2_type, opline->op2.var); HANDLE_EXCEPTION(); } } while (0); ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), value); - FREE_OP(opline->op2_type, opline->op2.var); + FREE_OP(EX_WOP2->op2_type, opline->op2.var); ZEND_VM_NEXT_OPCODE(); } @@ -9330,9 +9394,9 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_ zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC); #if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)) - opline = hook->op_array.opcodes; + opline = hook->op_array.slim_opcodes; #else - EX(opline) = hook->op_array.opcodes; + EX(opline) = hook->op_array.slim_opcodes; #endif LOAD_OPLINE_EX(); @@ -10331,7 +10395,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TM zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -10438,7 +10502,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_TMPVAR_HANDLE ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ generator->send_target = EX_VAR(opline->result.var); @@ -10465,7 +10529,8 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_NOT_SPEC_CONST ZEND_VM_NEXT_OPCODE(); } - ZEND_VM_TAIL_CALL(zend_bw_not_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_bw_not_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op1_type)); } static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -10989,7 +11054,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_CONST_UNUSED_HANDLER( if (constructor == NULL) { /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next * opcode is DO_FCALL in case EXT instructions are used. */ - if (EXPECTED(opline->extended_value == 0 && (opline+1)->opcode == ZEND_DO_FCALL)) { + if (EXPECTED(opline->extended_value == 0 && Z_WOP_FROM_OP(opline+1)->opcode == ZEND_DO_FCALL)) { ZEND_VM_NEXT_OPCODE_EX(1, 2); } @@ -11215,7 +11280,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_U } } - ZEND_VM_SMART_BRANCH(result, true); + ZEND_VM_SMART_BRANCH_EX(result, true, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->op2.num)); } /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ @@ -11322,7 +11387,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_UNUSED_HANDLE ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ generator->send_target = EX_VAR(opline->result.var); @@ -11368,9 +11433,9 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_TYPE_CHECK_SPEC_C if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { SAVE_OPLINE(); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->op2.num)); } else { - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_EX(result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->op2.num)); } } @@ -11383,13 +11448,13 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DEFINED_SPEC_CONST if (EXPECTED(c != NULL)) { if (!IS_SPECIAL_CACHE_VAL(c)) { defined_true: - ZEND_VM_SMART_BRANCH_TRUE(); + ZEND_VM_SMART_BRANCH_TRUE_EX(QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->op2.num)); } else if (EXPECTED(zend_hash_num_elements(EG(zend_constants)) == DECODE_SPECIAL_CACHE_NUM(c))) { defined_false: - ZEND_VM_SMART_BRANCH_FALSE(); + ZEND_VM_SMART_BRANCH_FALSE_EX(QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->op2.num)); } } - if (zend_quick_check_constant(RT_CONSTANT(opline, opline->op1) OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) { + if (zend_quick_check_constant(RT_CONSTANT(opline, opline->op1), opline->extended_value OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) { CACHE_PTR(opline->extended_value, ENCODE_SPECIAL_CACHE_NUM(zend_hash_num_elements(EG(zend_constants)))); goto defined_false; } else { @@ -11922,9 +11987,9 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_ zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC); #if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)) - opline = hook->op_array.opcodes; + opline = hook->op_array.slim_opcodes; #else - EX(opline) = hook->op_array.opcodes; + EX(opline) = hook->op_array.slim_opcodes; #endif LOAD_OPLINE_EX(); @@ -12921,7 +12986,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV } - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -13027,7 +13092,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZE ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ generator->send_target = EX_VAR(opline->result.var); @@ -13108,7 +13173,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_TMPVARCV_ } } - ZEND_VM_TAIL_CALL(zend_add_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_add_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -13146,7 +13213,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_TMPVARCV_ } } - ZEND_VM_TAIL_CALL(zend_sub_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_sub_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -13187,7 +13256,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_SPEC_TMPVARCV_CONST_HANDLE } } - ZEND_VM_TAIL_CALL(zend_mul_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_mul_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -13214,7 +13285,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_TMPVARCV_CONST_HANDLE } } - ZEND_VM_TAIL_CALL(zend_mod_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_mod_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -13235,7 +13308,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_TMPVARCV_CONST_HANDLER ZEND_VM_NEXT_OPCODE(); } - ZEND_VM_TAIL_CALL(zend_shift_left_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_shift_left_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -13254,7 +13329,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_TMPVARCV_CONST_HANDLER ZEND_VM_NEXT_OPCODE(); } - ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -13297,7 +13374,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST goto is_smaller_double; } } - ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -13340,7 +13419,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TM goto is_smaller_double; } } - ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -13383,7 +13464,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TM goto is_smaller_double; } } - ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -13430,7 +13513,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVA goto is_smaller_or_equal_double; } } - ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -13477,7 +13562,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUA goto is_smaller_or_equal_double; } } - ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -13524,7 +13611,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUA goto is_smaller_or_equal_double; } } - ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -13542,7 +13631,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_TMPVARC ZEND_VM_NEXT_OPCODE(); } - ZEND_VM_TAIL_CALL(zend_bw_or_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_bw_or_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -13560,7 +13651,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_TMPVAR ZEND_VM_NEXT_OPCODE(); } - ZEND_VM_TAIL_CALL(zend_bw_and_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_bw_and_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -13578,7 +13671,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMPVAR ZEND_VM_NEXT_OPCODE(); } - ZEND_VM_TAIL_CALL(zend_bw_xor_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_bw_xor_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -13955,9 +14050,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_ zval *op1; bool result; - op1 = _get_zval_ptr_tmpvarcv(opline->op1_type, opline->op1, BP_VAR_R EXECUTE_DATA_CC); + op1 = _get_zval_ptr_tmpvarcv(QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value), opline->op1, BP_VAR_R EXECUTE_DATA_CC); result = Z_TYPE_P(op1) == IS_ARRAY && zend_hash_num_elements(Z_ARR_P(op1)) == 0; - FREE_OP(opline->op1_type, opline->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value), opline->op1.var); ZEND_VM_SMART_BRANCH_NONE(result, 0); } @@ -13968,9 +14063,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_ zval *op1; bool result; - op1 = _get_zval_ptr_tmpvarcv(opline->op1_type, opline->op1, BP_VAR_R EXECUTE_DATA_CC); + op1 = _get_zval_ptr_tmpvarcv(QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value), opline->op1, BP_VAR_R EXECUTE_DATA_CC); result = Z_TYPE_P(op1) == IS_ARRAY && zend_hash_num_elements(Z_ARR_P(op1)) == 0; - FREE_OP(opline->op1_type, opline->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value), opline->op1.var); ZEND_VM_SMART_BRANCH_JMPZ(result, 0); } @@ -13981,9 +14076,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_ zval *op1; bool result; - op1 = _get_zval_ptr_tmpvarcv(opline->op1_type, opline->op1, BP_VAR_R EXECUTE_DATA_CC); + op1 = _get_zval_ptr_tmpvarcv(QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value), opline->op1, BP_VAR_R EXECUTE_DATA_CC); result = Z_TYPE_P(op1) == IS_ARRAY && zend_hash_num_elements(Z_ARR_P(op1)) == 0; - FREE_OP(opline->op1_type, opline->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value), opline->op1.var); ZEND_VM_SMART_BRANCH_JMPNZ(result, 0); } @@ -13994,9 +14089,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_S zval *op1; bool result; - op1 = _get_zval_ptr_tmpvarcv(opline->op1_type, opline->op1, BP_VAR_R EXECUTE_DATA_CC); + op1 = _get_zval_ptr_tmpvarcv(QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value), opline->op1, BP_VAR_R EXECUTE_DATA_CC); result = Z_TYPE_P(op1) != IS_ARRAY || zend_hash_num_elements(Z_ARR_P(op1)) > 0; - FREE_OP(opline->op1_type, opline->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value), opline->op1.var); ZEND_VM_SMART_BRANCH_NONE(result, 0); } @@ -14007,9 +14102,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_S zval *op1; bool result; - op1 = _get_zval_ptr_tmpvarcv(opline->op1_type, opline->op1, BP_VAR_R EXECUTE_DATA_CC); + op1 = _get_zval_ptr_tmpvarcv(QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value), opline->op1, BP_VAR_R EXECUTE_DATA_CC); result = Z_TYPE_P(op1) != IS_ARRAY || zend_hash_num_elements(Z_ARR_P(op1)) > 0; - FREE_OP(opline->op1_type, opline->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value), opline->op1.var); ZEND_VM_SMART_BRANCH_JMPZ(result, 0); } @@ -14020,9 +14115,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_S zval *op1; bool result; - op1 = _get_zval_ptr_tmpvarcv(opline->op1_type, opline->op1, BP_VAR_R EXECUTE_DATA_CC); + op1 = _get_zval_ptr_tmpvarcv(QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value), opline->op1, BP_VAR_R EXECUTE_DATA_CC); result = Z_TYPE_P(op1) != IS_ARRAY || zend_hash_num_elements(Z_ARR_P(op1)) > 0; - FREE_OP(opline->op1_type, opline->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value), opline->op1.var); ZEND_VM_SMART_BRANCH_JMPNZ(result, 0); } @@ -14206,7 +14301,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_TMPVARCV_ } } - ZEND_VM_TAIL_CALL(zend_add_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_add_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -14244,7 +14341,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_TMPVARCV_ } } - ZEND_VM_TAIL_CALL(zend_sub_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_sub_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -14285,7 +14384,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HAN } } - ZEND_VM_TAIL_CALL(zend_mul_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_mul_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -14312,7 +14413,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HAN } } - ZEND_VM_TAIL_CALL(zend_mod_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_mod_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -14333,7 +14436,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HAND ZEND_VM_NEXT_OPCODE(); } - ZEND_VM_TAIL_CALL(zend_shift_left_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_shift_left_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -14352,7 +14457,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HAND ZEND_VM_NEXT_OPCODE(); } - ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -14395,7 +14502,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVA goto is_smaller_double; } } - ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -14438,7 +14547,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TM goto is_smaller_double; } } - ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -14481,7 +14592,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TM goto is_smaller_double; } } - ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -14528,7 +14641,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVA goto is_smaller_or_equal_double; } } - ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -14575,7 +14690,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUA goto is_smaller_or_equal_double; } } - ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -14622,7 +14739,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUA goto is_smaller_or_equal_double; } } - ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -14640,7 +14759,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_TMPVARC ZEND_VM_NEXT_OPCODE(); } - ZEND_VM_TAIL_CALL(zend_bw_or_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_bw_or_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -14658,7 +14779,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_TMPVAR ZEND_VM_NEXT_OPCODE(); } - ZEND_VM_TAIL_CALL(zend_bw_and_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_bw_and_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -14676,7 +14799,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMPVAR ZEND_VM_NEXT_OPCODE(); } - ZEND_VM_TAIL_CALL(zend_bw_xor_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_bw_xor_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -15100,7 +15225,8 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_NOT_SPEC_TMPVAR ZEND_VM_NEXT_OPCODE(); } - ZEND_VM_TAIL_CALL(zend_bw_not_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_bw_not_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op1_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -15472,18 +15598,18 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HA UNDEF_RESULT(); HANDLE_EXCEPTION(); } else if (new_op_array == ZEND_FAKE_OP_ARRAY) { - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { ZVAL_TRUE(EX_VAR(opline->result.var)); } } else if (UNEXPECTED(new_op_array == NULL)) { - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { ZVAL_FALSE(EX_VAR(opline->result.var)); } } else if (new_op_array->last == 1 && new_op_array->opcodes[0].opcode == ZEND_RETURN && new_op_array->opcodes[0].op1_type == IS_CONST && EXPECTED(zend_execute_ex == execute_ex)) { - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { const zend_op *op = new_op_array->opcodes; ZVAL_COPY(EX_VAR(opline->result.var), RT_CONSTANT(op, op->op1)); @@ -15494,7 +15620,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HA } else { zval *return_value = NULL; zend_execute_data *call; - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { return_value = EX_VAR(opline->result.var); } @@ -15584,7 +15710,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_FROM_SPEC_TMPVAR_HANDLER zend_generator_yield_from(generator, new_gen); } } else { - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { ZVAL_COPY(EX_VAR(opline->result.var), &new_gen->retval); } ZEND_VM_NEXT_OPCODE(); @@ -15625,7 +15751,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_FROM_SPEC_TMPVAR_HANDLER /* This is the default return value * when the expression is a Generator, it will be overwritten in zend_generator_resume() */ - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { ZVAL_NULL(EX_VAR(opline->result.var)); } @@ -15923,7 +16049,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_HAN } } } - ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -15981,7 +16109,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMP } } } - ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -16039,7 +16169,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMP } } } - ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -16097,7 +16229,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST } } } - ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -16155,7 +16289,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST } } } - ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -16213,7 +16349,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST } } } - ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -16371,9 +16509,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_ zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC); #if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)) - opline = hook->op_array.opcodes; + opline = hook->op_array.slim_opcodes; #else - EX(opline) = hook->op_array.opcodes; + EX(opline) = hook->op_array.slim_opcodes; #endif LOAD_OPLINE_EX(); @@ -16901,10 +17039,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_CONST_HANDLER if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { case_true: - ZEND_VM_SMART_BRANCH_TRUE(); + ZEND_VM_SMART_BRANCH_TRUE_EX(QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } else { case_false: - ZEND_VM_SMART_BRANCH_FALSE(); + ZEND_VM_SMART_BRANCH_FALSE_EX(QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { d1 = (double)Z_LVAL_P(op1); @@ -16937,7 +17075,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_CONST_HANDLER } } } - ZEND_VM_TAIL_CALL(zend_case_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_case_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -17098,7 +17237,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_C } zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -17416,7 +17555,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HA } } } - ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -17474,7 +17615,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JM } } } - ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -17532,7 +17675,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JM } } } - ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -17590,7 +17735,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVA } } } - ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -17648,7 +17795,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVA } } } - ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -17706,7 +17855,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVA } } } - ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -17864,9 +18015,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC); #if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)) - opline = hook->op_array.opcodes; + opline = hook->op_array.slim_opcodes; #else - EX(opline) = hook->op_array.opcodes; + EX(opline) = hook->op_array.slim_opcodes; #endif LOAD_OPLINE_EX(); @@ -18366,10 +18517,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLE if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { case_true: - ZEND_VM_SMART_BRANCH_TRUE(); + ZEND_VM_SMART_BRANCH_TRUE_EX(QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } else { case_false: - ZEND_VM_SMART_BRANCH_FALSE(); + ZEND_VM_SMART_BRANCH_FALSE_EX(QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { d1 = (double)Z_LVAL_P(op1); @@ -18402,7 +18553,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLE } } } - ZEND_VM_TAIL_CALL(zend_case_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_case_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -18564,7 +18716,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_T zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -18880,7 +19032,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_ } } - ZEND_VM_SMART_BRANCH(result, true); + ZEND_VM_SMART_BRANCH_EX(result, true, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->op2.num)); } /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ @@ -18959,9 +19111,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_TYPE_CHECK_SPEC_TM if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { SAVE_OPLINE(); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->op2.num)); } else { - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_EX(result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->op2.num)); } } @@ -19333,9 +19485,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HAN zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC); #if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)) - opline = hook->op_array.opcodes; + opline = hook->op_array.slim_opcodes; #else - EX(opline) = hook->op_array.opcodes; + EX(opline) = hook->op_array.slim_opcodes; #endif LOAD_OPLINE_EX(); @@ -19835,10 +19987,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_CV_HANDLER(ZE if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { case_true: - ZEND_VM_SMART_BRANCH_TRUE(); + ZEND_VM_SMART_BRANCH_TRUE_EX(QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } else { case_false: - ZEND_VM_SMART_BRANCH_FALSE(); + ZEND_VM_SMART_BRANCH_FALSE_EX(QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { d1 = (double)Z_LVAL_P(op1); @@ -19871,7 +20023,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_CV_HANDLER(ZE } } } - ZEND_VM_TAIL_CALL(zend_case_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_case_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -20032,7 +20185,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_C } zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -20657,7 +20810,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HA result = fast_is_identical_function(op1, op2); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -20671,7 +20824,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_TMP_CONST_HAN op2 = RT_CONSTANT(opline, opline->op2); result = fast_is_identical_function(op1, op2); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -20686,7 +20839,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONS result = fast_is_not_identical_function(op1, op2); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -21079,7 +21232,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CONST_HANDLER(Z ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ generator->send_target = EX_VAR(opline->result.var); @@ -21521,7 +21674,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_TMPVAR_HANDLER( ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ generator->send_target = EX_VAR(opline->result.var); @@ -21549,7 +21702,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HAND result = fast_is_identical_function(op1, op2); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -21563,7 +21716,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_TMP_TMP_HANDL op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); result = fast_is_identical_function(op1, op2); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -21578,7 +21731,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_ result = fast_is_not_identical_function(op1, op2); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -21592,7 +21745,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_TMP_VAR_HANDL op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC); result = fast_is_identical_function(op1, op2); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -21977,7 +22130,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER( ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ generator->send_target = EX_VAR(opline->result.var); @@ -22022,7 +22175,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_TMP_CV_HANDLE op2 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); result = fast_is_identical_function(op1, op2); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -22378,7 +22531,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ generator->send_target = EX_VAR(opline->result.var); @@ -22451,7 +22604,7 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_inc_help increment_function(var_ptr); } while (0); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } @@ -22521,7 +22674,7 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_dec_help decrement_function(var_ptr); } while (0); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } @@ -23125,7 +23278,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FETCH_R_SPEC_VA value++; } Z_FE_POS_P(array) = pos + 1; - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { ZVAL_LONG(EX_VAR(opline->result.var), pos); } } else { @@ -23148,7 +23301,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FETCH_R_SPEC_VA p++; } Z_FE_POS_P(array) = pos; - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { if (!p->key) { ZVAL_LONG(EX_VAR(opline->result.var), p->h); } else { @@ -23156,7 +23309,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FETCH_R_SPEC_VA } } } - if (EXPECTED(opline->op2_type == IS_CV)) { + if (EXPECTED(EX_WOP2->op2_type == IS_CV)) { zval *variable_ptr = EX_VAR(opline->op2.var); SAVE_OPLINE(); zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES()); @@ -23206,7 +23359,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FETCH_RW_SPEC_VAR_HANDLER(Z value++; } EG(ht_iterators)[Z_FE_ITER_P(EX_VAR(opline->op1.var))].pos = pos + 1; - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { ZVAL_LONG(EX_VAR(opline->result.var), pos); } } else { @@ -23226,7 +23379,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FETCH_RW_SPEC_VAR_HANDLER(Z p++; } EG(ht_iterators)[Z_FE_ITER_P(EX_VAR(opline->op1.var))].pos = pos; - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { if (!p->key) { ZVAL_LONG(EX_VAR(opline->result.var), p->h); } else { @@ -23286,7 +23439,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FETCH_RW_SPEC_VAR_HANDLER(Z p++; } EG(ht_iterators)[Z_FE_ITER_P(EX_VAR(opline->op1.var))].pos = pos; - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { if (UNEXPECTED(!p->key)) { ZVAL_LONG(EX_VAR(opline->result.var), p->h); } else if (ZSTR_VAL(p->key)[0]) { @@ -23327,7 +23480,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FETCH_RW_SPEC_VAR_HANDLER(Z /* failure in get_current_data */ goto fe_fetch_w_exit; } - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { if (funcs->get_current_key) { funcs->get_current_key(iter, EX_VAR(opline->result.var)); if (UNEXPECTED(EG(exception) != NULL)) { @@ -23358,7 +23511,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FETCH_RW_SPEC_VAR_HANDLER(Z ref = Z_REFVAL_P(value); ZVAL_COPY_VALUE_EX(ref, value, gc, value_type); } - if (EXPECTED(opline->op2_type == IS_CV)) { + if (EXPECTED(EX_WOP2->op2_type == IS_CV)) { zval *variable_ptr = EX_VAR(opline->op2.var); if (EXPECTED(variable_ptr != value)) { zend_reference *ref; @@ -23574,7 +23727,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HA result = fast_is_identical_function(op1, op2); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -23588,7 +23741,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_VAR_CONST_HAN op2 = RT_CONSTANT(opline, opline->op2); result = fast_is_identical_function(op1, op2); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -23603,7 +23756,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONS result = fast_is_not_identical_function(op1, op2); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -23624,7 +23777,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST_H property = RT_CONSTANT(opline, opline->op2); do { - value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1); + value = get_op_data_zval_ptr_r(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1); if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) { @@ -23654,7 +23807,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST_H cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot; if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) { if (UNEXPECTED(Z_ISERROR_P(zptr))) { - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } else { @@ -23679,7 +23832,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST_H } } while (0); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), zptr); } } @@ -23691,7 +23844,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST_H } } while (0); - FREE_OP((opline+1)->op1_type, (opline+1)->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1.var); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); /* assign_obj has two opcodes! */ @@ -23732,7 +23885,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST_H } } - value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1); + value = get_op_data_zval_ptr_r(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1); do { if (IS_CONST != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) { @@ -23746,10 +23899,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST_H zend_binary_op(var_ptr, var_ptr, value OPLINE_CC); } while (0); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } - FREE_OP((opline+1)->op1_type, (opline+1)->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1.var); } else { if (EXPECTED(Z_ISREF_P(container))) { container = Z_REFVAL_P(container); @@ -23788,8 +23941,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST_H dim = RT_CONSTANT(opline, opline->op2); zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC); assign_dim_op_ret_null: - FREE_OP((opline+1)->op1_type, (opline+1)->op1.var); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + FREE_OP(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1.var); + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -23821,7 +23974,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_VAR_CONST_HANDL zend_binary_op(var_ptr, var_ptr, value OPLINE_CC); } while (0); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } @@ -23874,7 +24027,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HAN cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot; if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) { if (UNEXPECTED(Z_ISERROR_P(zptr))) { - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } else { @@ -24156,7 +24309,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_D } else { fast_assign_obj: value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -24213,7 +24366,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_D } } zend_hash_add_new(zobj->properties, name, value); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -24252,7 +24405,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_D } free_and_exit_assign_obj: - if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1)) && value) { ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); } @@ -24310,7 +24463,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_D } else { fast_assign_obj: value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -24367,7 +24520,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_D } } zend_hash_add_new(zobj->properties, name, value); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -24406,7 +24559,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_D } free_and_exit_assign_obj: - if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1)) && value) { ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); } zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); @@ -24464,7 +24617,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_D } else { fast_assign_obj: value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -24521,7 +24674,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_D } } zend_hash_add_new(zobj->properties, name, value); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -24560,7 +24713,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_D } free_and_exit_assign_obj: - if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1)) && value) { ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); } zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); @@ -24618,7 +24771,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_D } else { fast_assign_obj: value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -24675,7 +24828,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_D } } zend_hash_add_new(zobj->properties, name, value); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -24714,7 +24867,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_D } free_and_exit_assign_obj: - if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1)) && value) { ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); } @@ -24794,7 +24947,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_D value = RT_CONSTANT((opline+1), (opline+1)->op1); value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } if (garbage) { @@ -24868,7 +25021,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_D dim = RT_CONSTANT(opline, opline->op2); assign_dim_error: - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -24946,7 +25099,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_D value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC); value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } if (garbage) { @@ -25021,7 +25174,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_D dim = RT_CONSTANT(opline, opline->op2); assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -25099,7 +25252,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_D value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } if (garbage) { @@ -25174,7 +25327,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_D dim = RT_CONSTANT(opline, opline->op2); assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -25252,7 +25405,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_D value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC); value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } if (garbage) { @@ -25326,7 +25479,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_D dim = RT_CONSTANT(opline, opline->op2); assign_dim_error: - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -26386,7 +26539,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CONST_HANDLER(Z ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ generator->send_target = EX_VAR(opline->result.var); @@ -26498,7 +26651,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_ ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); if (UNEXPECTED(ce == NULL)) { ZVAL_UNDEF(EX_VAR(opline->result.var)); - FREE_OP(opline->op2_type, opline->op2.var); + FREE_OP(EX_WOP2->op2_type, opline->op2.var); HANDLE_EXCEPTION(); } CACHE_PTR(opline->extended_value, ce); @@ -26507,7 +26660,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_ ce = zend_fetch_class(NULL, opline->op1.num); if (UNEXPECTED(ce == NULL)) { ZVAL_UNDEF(EX_VAR(opline->result.var)); - FREE_OP(opline->op2_type, opline->op2.var); + FREE_OP(EX_WOP2->op2_type, opline->op2.var); HANDLE_EXCEPTION(); } } else { @@ -26520,18 +26673,18 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_ break; } - constant_zv = _get_zval_ptr_tmpvarcv(opline->op2_type, opline->op2, BP_VAR_R EXECUTE_DATA_CC); + constant_zv = _get_zval_ptr_tmpvarcv(EX_WOP2->op2_type, opline->op2, BP_VAR_R EXECUTE_DATA_CC); if (UNEXPECTED(Z_TYPE_P(constant_zv) != IS_STRING)) { zend_invalid_class_constant_type_error(Z_TYPE_P(constant_zv)); ZVAL_UNDEF(EX_VAR(opline->result.var)); - FREE_OP(opline->op2_type, opline->op2.var); + FREE_OP(EX_WOP2->op2_type, opline->op2.var); HANDLE_EXCEPTION(); } constant_name = Z_STR_P(constant_zv); /* Magic 'class' for constant OP2 is caught at compile-time */ if ((IS_TMP_VAR|IS_VAR|IS_CV) != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) { ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name); - FREE_OP(opline->op2_type, opline->op2.var); + FREE_OP(EX_WOP2->op2_type, opline->op2.var); ZEND_VM_NEXT_OPCODE(); } zv = (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST @@ -26544,14 +26697,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_ if (!zend_verify_const_access(c, scope)) { zend_throw_error(NULL, "Cannot access %s constant %s::%s", zend_visibility_string(ZEND_CLASS_CONST_FLAGS(c)), ZSTR_VAL(ce->name), ZSTR_VAL(constant_name)); ZVAL_UNDEF(EX_VAR(opline->result.var)); - FREE_OP(opline->op2_type, opline->op2.var); + FREE_OP(EX_WOP2->op2_type, opline->op2.var); HANDLE_EXCEPTION(); } if (ce->ce_flags & ZEND_ACC_TRAIT) { zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name)); ZVAL_UNDEF(EX_VAR(opline->result.var)); - FREE_OP(opline->op2_type, opline->op2.var); + FREE_OP(EX_WOP2->op2_type, opline->op2.var); HANDLE_EXCEPTION(); } @@ -26568,7 +26721,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_ if (EG(exception)) { ZVAL_UNDEF(EX_VAR(opline->result.var)); - FREE_OP(opline->op2_type, opline->op2.var); + FREE_OP(EX_WOP2->op2_type, opline->op2.var); HANDLE_EXCEPTION(); } } @@ -26578,14 +26731,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_ if (ce->ce_flags & ZEND_ACC_ENUM && ce->enum_backing_type != IS_UNDEF && ce->type == ZEND_USER_CLASS && !(ce->ce_flags & ZEND_ACC_CONSTANTS_UPDATED)) { if (UNEXPECTED(zend_update_class_constants(ce) == FAILURE)) { ZVAL_UNDEF(EX_VAR(opline->result.var)); - FREE_OP(opline->op2_type, opline->op2.var); + FREE_OP(EX_WOP2->op2_type, opline->op2.var); HANDLE_EXCEPTION(); } } if (Z_TYPE_P(value) == IS_CONSTANT_AST) { if (UNEXPECTED(zend_update_class_constant(c, constant_name, c->ce) != SUCCESS)) { ZVAL_UNDEF(EX_VAR(opline->result.var)); - FREE_OP(opline->op2_type, opline->op2.var); + FREE_OP(EX_WOP2->op2_type, opline->op2.var); HANDLE_EXCEPTION(); } } @@ -26596,14 +26749,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_ zend_throw_error(NULL, "Undefined constant %s::%s", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name)); ZVAL_UNDEF(EX_VAR(opline->result.var)); - FREE_OP(opline->op2_type, opline->op2.var); + FREE_OP(EX_WOP2->op2_type, opline->op2.var); HANDLE_EXCEPTION(); } } while (0); ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), value); - FREE_OP(opline->op2_type, opline->op2.var); + FREE_OP(EX_WOP2->op2_type, opline->op2.var); ZEND_VM_NEXT_OPCODE(); } @@ -26625,7 +26778,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_ property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); do { - value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1); + value = get_op_data_zval_ptr_r(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1); if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) { @@ -26655,7 +26808,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_ cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot; if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) { if (UNEXPECTED(Z_ISERROR_P(zptr))) { - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } else { @@ -26680,7 +26833,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_ } } while (0); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), zptr); } } @@ -26692,7 +26845,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_ } } while (0); - FREE_OP((opline+1)->op1_type, (opline+1)->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1.var); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); /* assign_obj has two opcodes! */ @@ -26733,7 +26886,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_ } } - value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1); + value = get_op_data_zval_ptr_r(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1); do { if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) { @@ -26747,10 +26900,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_ zend_binary_op(var_ptr, var_ptr, value OPLINE_CC); } while (0); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } - FREE_OP((opline+1)->op1_type, (opline+1)->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1.var); } else { if (EXPECTED(Z_ISREF_P(container))) { container = Z_REFVAL_P(container); @@ -26789,8 +26942,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_ dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC); assign_dim_op_ret_null: - FREE_OP((opline+1)->op1_type, (opline+1)->op1.var); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + FREE_OP(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1.var); + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -26823,7 +26976,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_HAND zend_binary_op(var_ptr, var_ptr, value OPLINE_CC); } while (0); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } @@ -26877,7 +27030,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_HA cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot; if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) { if (UNEXPECTED(Z_ISERROR_P(zptr))) { - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } else { @@ -27162,7 +27315,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_ } else { fast_assign_obj: value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -27219,7 +27372,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_ } } zend_hash_add_new(zobj->properties, name, value); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -27258,7 +27411,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_ } free_and_exit_assign_obj: - if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1)) && value) { ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); } @@ -27316,7 +27469,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_ } else { fast_assign_obj: value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -27373,7 +27526,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_ } } zend_hash_add_new(zobj->properties, name, value); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -27412,7 +27565,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_ } free_and_exit_assign_obj: - if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1)) && value) { ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); } zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); @@ -27470,7 +27623,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_ } else { fast_assign_obj: value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -27527,7 +27680,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_ } } zend_hash_add_new(zobj->properties, name, value); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -27566,7 +27719,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_ } free_and_exit_assign_obj: - if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1)) && value) { ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); } zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); @@ -27624,7 +27777,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_ } else { fast_assign_obj: value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -27681,7 +27834,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_ } } zend_hash_add_new(zobj->properties, name, value); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -27720,7 +27873,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_ } free_and_exit_assign_obj: - if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1)) && value) { ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); } @@ -27800,7 +27953,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_ value = RT_CONSTANT((opline+1), (opline+1)->op1); value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } if (garbage) { @@ -27874,7 +28027,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_ dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); assign_dim_error: - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -27952,7 +28105,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_ value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC); value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } if (garbage) { @@ -28027,7 +28180,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_ dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -28105,7 +28258,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_ value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } if (garbage) { @@ -28180,7 +28333,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_ dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -28258,7 +28411,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_ value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC); value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } if (garbage) { @@ -28332,7 +28485,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_ dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); assign_dim_error: - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -28912,7 +29065,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_TMPVAR_HANDLER( ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ generator->send_target = EX_VAR(opline->result.var); @@ -28940,7 +29093,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HAND result = fast_is_identical_function(op1, op2); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -28954,7 +29107,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_VAR_TMP_HANDL op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); result = fast_is_identical_function(op1, op2); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -28969,7 +29122,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_ result = fast_is_not_identical_function(op1, op2); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -29042,7 +29195,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HAND result = fast_is_identical_function(op1, op2); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -29056,7 +29209,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_VAR_VAR_HANDL op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC); result = fast_is_identical_function(op1, op2); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -29071,7 +29224,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_ result = fast_is_not_identical_function(op1, op2); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -29153,12 +29306,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLE UNEXPECTED(!Z_ISREF_P(value_ptr))) { variable_ptr = zend_wrong_assign_to_variable_reference( - variable_ptr, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC); + variable_ptr, value_ptr, &garbage EXECUTE_DATA_CC); } else { zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr); } @@ -29204,7 +29357,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED_ } } - value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1); + value = get_op_data_zval_ptr_r(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1); do { if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) { @@ -29218,10 +29371,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED_ zend_binary_op(var_ptr, var_ptr, value OPLINE_CC); } while (0); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } - FREE_OP((opline+1)->op1_type, (opline+1)->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1.var); } else { if (EXPECTED(Z_ISREF_P(container))) { container = Z_REFVAL_P(container); @@ -29260,8 +29413,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED_ dim = NULL; zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC); assign_dim_op_ret_null: - FREE_OP((opline+1)->op1_type, (opline+1)->op1.var); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + FREE_OP(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1.var); + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -29385,7 +29538,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_ value = RT_CONSTANT((opline+1), (opline+1)->op1); value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } if (garbage) { @@ -29459,7 +29612,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_ dim = NULL; assign_dim_error: - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -29537,7 +29690,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_ value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC); value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } if (garbage) { @@ -29612,7 +29765,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_ dim = NULL; assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -29690,7 +29843,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_ value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } if (garbage) { @@ -29765,7 +29918,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_ dim = NULL; assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -29843,7 +29996,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_ value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC); value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } if (garbage) { @@ -29917,7 +30070,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_ dim = NULL; assign_dim_error: - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -30596,7 +30749,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_VAR_UNUSED_HANDLER(ZE if (constructor == NULL) { /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next * opcode is DO_FCALL in case EXT instructions are used. */ - if (EXPECTED(opline->extended_value == 0 && (opline+1)->opcode == ZEND_DO_FCALL)) { + if (EXPECTED(opline->extended_value == 0 && Z_WOP_FROM_OP(opline+1)->opcode == ZEND_DO_FCALL)) { ZEND_VM_NEXT_OPCODE_EX(1, 2); } @@ -30863,7 +31016,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER( ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ generator->send_target = EX_VAR(opline->result.var); @@ -30963,7 +31116,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_VAR_CV_HANDLE op2 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); result = fast_is_identical_function(op1, op2); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -30984,7 +31137,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV_HAND property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); do { - value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1); + value = get_op_data_zval_ptr_r(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1); if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) { @@ -31014,7 +31167,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV_HAND cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot; if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) { if (UNEXPECTED(Z_ISERROR_P(zptr))) { - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } else { @@ -31039,7 +31192,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV_HAND } } while (0); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), zptr); } } @@ -31051,7 +31204,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV_HAND } } while (0); - FREE_OP((opline+1)->op1_type, (opline+1)->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1.var); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); /* assign_obj has two opcodes! */ @@ -31092,7 +31245,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV_HAND } } - value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1); + value = get_op_data_zval_ptr_r(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1); do { if (IS_CV != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) { @@ -31106,10 +31259,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV_HAND zend_binary_op(var_ptr, var_ptr, value OPLINE_CC); } while (0); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } - FREE_OP((opline+1)->op1_type, (opline+1)->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1.var); } else { if (EXPECTED(Z_ISREF_P(container))) { container = Z_REFVAL_P(container); @@ -31148,8 +31301,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV_HAND dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC); assign_dim_op_ret_null: - FREE_OP((opline+1)->op1_type, (opline+1)->op1.var); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + FREE_OP(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1.var); + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -31181,7 +31334,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_VAR_CV_HANDLER( zend_binary_op(var_ptr, var_ptr, value OPLINE_CC); } while (0); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } @@ -31234,7 +31387,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLE cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot; if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) { if (UNEXPECTED(Z_ISERROR_P(zptr))) { - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } else { @@ -31516,7 +31669,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA } else { fast_assign_obj: value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -31573,7 +31726,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA } } zend_hash_add_new(zobj->properties, name, value); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -31612,7 +31765,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA } free_and_exit_assign_obj: - if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1)) && value) { ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); } @@ -31670,7 +31823,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA } else { fast_assign_obj: value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -31727,7 +31880,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA } } zend_hash_add_new(zobj->properties, name, value); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -31766,7 +31919,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA } free_and_exit_assign_obj: - if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1)) && value) { ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); } zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); @@ -31824,7 +31977,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA } else { fast_assign_obj: value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -31881,7 +32034,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA } } zend_hash_add_new(zobj->properties, name, value); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -31920,7 +32073,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA } free_and_exit_assign_obj: - if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1)) && value) { ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); } zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); @@ -31978,7 +32131,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA } else { fast_assign_obj: value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -32035,7 +32188,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA } } zend_hash_add_new(zobj->properties, name, value); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -32074,7 +32227,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA } free_and_exit_assign_obj: - if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1)) && value) { ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); } @@ -32154,7 +32307,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA value = RT_CONSTANT((opline+1), (opline+1)->op1); value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } if (garbage) { @@ -32228,7 +32381,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); assign_dim_error: - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -32306,7 +32459,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC); value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } if (garbage) { @@ -32381,7 +32534,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -32459,7 +32612,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } if (garbage) { @@ -32534,7 +32687,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -32612,7 +32765,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC); value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } if (garbage) { @@ -32686,7 +32839,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); assign_dim_error: - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -32778,12 +32931,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER UNEXPECTED(!Z_ISREF_P(value_ptr))) { variable_ptr = zend_wrong_assign_to_variable_reference( - variable_ptr, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC); + variable_ptr, value_ptr, &garbage EXECUTE_DATA_CC); } else { zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr); } @@ -33359,7 +33512,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ generator->send_target = EX_VAR(opline->result.var); @@ -33654,7 +33807,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONS property = RT_CONSTANT(opline, opline->op2); do { - value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1); + value = get_op_data_zval_ptr_r(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1); if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) { @@ -33684,7 +33837,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONS cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot; if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) { if (UNEXPECTED(Z_ISERROR_P(zptr))) { - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } else { @@ -33709,7 +33862,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONS } } while (0); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), zptr); } } @@ -33721,7 +33874,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONS } } while (0); - FREE_OP((opline+1)->op1_type, (opline+1)->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1.var); /* assign_obj has two opcodes! */ @@ -33774,7 +33927,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_ cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot; if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) { if (UNEXPECTED(Z_ISERROR_P(zptr))) { - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } else { @@ -33934,9 +34087,9 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC); #if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)) - opline = hook->op_array.opcodes; + opline = hook->op_array.slim_opcodes; #else - EX(opline) = hook->op_array.opcodes; + EX(opline) = hook->op_array.slim_opcodes; #endif LOAD_OPLINE_EX(); @@ -34264,7 +34417,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_O } else { fast_assign_obj: value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -34321,7 +34474,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_O } } zend_hash_add_new(zobj->properties, name, value); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -34360,7 +34513,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_O } free_and_exit_assign_obj: - if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1)) && value) { ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); } @@ -34418,7 +34571,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_O } else { fast_assign_obj: value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -34475,7 +34628,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_O } } zend_hash_add_new(zobj->properties, name, value); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -34514,7 +34667,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_O } free_and_exit_assign_obj: - if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1)) && value) { ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); } zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); @@ -34572,7 +34725,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_O } else { fast_assign_obj: value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -34629,7 +34782,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_O } } zend_hash_add_new(zobj->properties, name, value); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -34668,7 +34821,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_O } free_and_exit_assign_obj: - if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1)) && value) { ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); } zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); @@ -34726,7 +34879,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_O } else { fast_assign_obj: value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -34783,7 +34936,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_O } } zend_hash_add_new(zobj->properties, name, value); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -34822,7 +34975,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_O } free_and_exit_assign_obj: - if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1)) && value) { ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); } @@ -35318,7 +35471,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPE } SAVE_OPLINE(); - zend_quick_get_constant(RT_CONSTANT(opline, opline->op2) + 1, opline->op1.num OPLINE_CC EXECUTE_DATA_CC); + zend_quick_get_constant(RT_CONSTANT(opline, opline->op2) + 1, opline->op1.num, opline->extended_value OPLINE_CC EXECUTE_DATA_CC); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -35673,7 +35826,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CONST_HANDLE ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ generator->send_target = EX_VAR(opline->result.var); @@ -35713,7 +35866,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUS ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); if (UNEXPECTED(ce == NULL)) { ZVAL_UNDEF(EX_VAR(opline->result.var)); - FREE_OP(opline->op2_type, opline->op2.var); + FREE_OP(EX_WOP2->op2_type, opline->op2.var); HANDLE_EXCEPTION(); } CACHE_PTR(opline->extended_value, ce); @@ -35722,7 +35875,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUS ce = zend_fetch_class(NULL, opline->op1.num); if (UNEXPECTED(ce == NULL)) { ZVAL_UNDEF(EX_VAR(opline->result.var)); - FREE_OP(opline->op2_type, opline->op2.var); + FREE_OP(EX_WOP2->op2_type, opline->op2.var); HANDLE_EXCEPTION(); } } else { @@ -35735,18 +35888,18 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUS break; } - constant_zv = _get_zval_ptr_tmpvarcv(opline->op2_type, opline->op2, BP_VAR_R EXECUTE_DATA_CC); + constant_zv = _get_zval_ptr_tmpvarcv(EX_WOP2->op2_type, opline->op2, BP_VAR_R EXECUTE_DATA_CC); if (UNEXPECTED(Z_TYPE_P(constant_zv) != IS_STRING)) { zend_invalid_class_constant_type_error(Z_TYPE_P(constant_zv)); ZVAL_UNDEF(EX_VAR(opline->result.var)); - FREE_OP(opline->op2_type, opline->op2.var); + FREE_OP(EX_WOP2->op2_type, opline->op2.var); HANDLE_EXCEPTION(); } constant_name = Z_STR_P(constant_zv); /* Magic 'class' for constant OP2 is caught at compile-time */ if ((IS_TMP_VAR|IS_VAR|IS_CV) != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) { ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name); - FREE_OP(opline->op2_type, opline->op2.var); + FREE_OP(EX_WOP2->op2_type, opline->op2.var); ZEND_VM_NEXT_OPCODE(); } zv = (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST @@ -35759,14 +35912,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUS if (!zend_verify_const_access(c, scope)) { zend_throw_error(NULL, "Cannot access %s constant %s::%s", zend_visibility_string(ZEND_CLASS_CONST_FLAGS(c)), ZSTR_VAL(ce->name), ZSTR_VAL(constant_name)); ZVAL_UNDEF(EX_VAR(opline->result.var)); - FREE_OP(opline->op2_type, opline->op2.var); + FREE_OP(EX_WOP2->op2_type, opline->op2.var); HANDLE_EXCEPTION(); } if (ce->ce_flags & ZEND_ACC_TRAIT) { zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name)); ZVAL_UNDEF(EX_VAR(opline->result.var)); - FREE_OP(opline->op2_type, opline->op2.var); + FREE_OP(EX_WOP2->op2_type, opline->op2.var); HANDLE_EXCEPTION(); } @@ -35783,7 +35936,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUS if (EG(exception)) { ZVAL_UNDEF(EX_VAR(opline->result.var)); - FREE_OP(opline->op2_type, opline->op2.var); + FREE_OP(EX_WOP2->op2_type, opline->op2.var); HANDLE_EXCEPTION(); } } @@ -35793,14 +35946,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUS if (ce->ce_flags & ZEND_ACC_ENUM && ce->enum_backing_type != IS_UNDEF && ce->type == ZEND_USER_CLASS && !(ce->ce_flags & ZEND_ACC_CONSTANTS_UPDATED)) { if (UNEXPECTED(zend_update_class_constants(ce) == FAILURE)) { ZVAL_UNDEF(EX_VAR(opline->result.var)); - FREE_OP(opline->op2_type, opline->op2.var); + FREE_OP(EX_WOP2->op2_type, opline->op2.var); HANDLE_EXCEPTION(); } } if (Z_TYPE_P(value) == IS_CONSTANT_AST) { if (UNEXPECTED(zend_update_class_constant(c, constant_name, c->ce) != SUCCESS)) { ZVAL_UNDEF(EX_VAR(opline->result.var)); - FREE_OP(opline->op2_type, opline->op2.var); + FREE_OP(EX_WOP2->op2_type, opline->op2.var); HANDLE_EXCEPTION(); } } @@ -35811,14 +35964,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUS zend_throw_error(NULL, "Undefined constant %s::%s", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name)); ZVAL_UNDEF(EX_VAR(opline->result.var)); - FREE_OP(opline->op2_type, opline->op2.var); + FREE_OP(EX_WOP2->op2_type, opline->op2.var); HANDLE_EXCEPTION(); } } while (0); ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), value); - FREE_OP(opline->op2_type, opline->op2.var); + FREE_OP(EX_WOP2->op2_type, opline->op2.var); ZEND_VM_NEXT_OPCODE(); } @@ -35840,7 +35993,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPV property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); do { - value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1); + value = get_op_data_zval_ptr_r(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1); if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) { @@ -35870,7 +36023,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPV cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot; if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) { if (UNEXPECTED(Z_ISERROR_P(zptr))) { - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } else { @@ -35895,7 +36048,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPV } } while (0); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), zptr); } } @@ -35907,7 +36060,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPV } } while (0); - FREE_OP((opline+1)->op1_type, (opline+1)->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1.var); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); /* assign_obj has two opcodes! */ @@ -35960,7 +36113,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot; if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) { if (UNEXPECTED(Z_ISERROR_P(zptr))) { - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } else { @@ -36122,9 +36275,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC); #if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)) - opline = hook->op_array.opcodes; + opline = hook->op_array.slim_opcodes; #else - EX(opline) = hook->op_array.opcodes; + EX(opline) = hook->op_array.slim_opcodes; #endif LOAD_OPLINE_EX(); @@ -36447,7 +36600,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_ } else { fast_assign_obj: value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -36504,7 +36657,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_ } } zend_hash_add_new(zobj->properties, name, value); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -36543,7 +36696,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_ } free_and_exit_assign_obj: - if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1)) && value) { ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); } @@ -36601,7 +36754,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_ } else { fast_assign_obj: value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -36658,7 +36811,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_ } } zend_hash_add_new(zobj->properties, name, value); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -36697,7 +36850,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_ } free_and_exit_assign_obj: - if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1)) && value) { ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); } zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); @@ -36755,7 +36908,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_ } else { fast_assign_obj: value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -36812,7 +36965,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_ } } zend_hash_add_new(zobj->properties, name, value); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -36851,7 +37004,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_ } free_and_exit_assign_obj: - if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1)) && value) { ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); } zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); @@ -36909,7 +37062,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_ } else { fast_assign_obj: value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -36966,7 +37119,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_ } } zend_hash_add_new(zobj->properties, name, value); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -37005,7 +37158,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_ } free_and_exit_assign_obj: - if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1)) && value) { ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); } @@ -37679,7 +37832,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_TMPVAR_HANDL ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ generator->send_target = EX_VAR(opline->result.var); @@ -38061,7 +38214,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_UNUSED_UNUSED_HANDLER if (constructor == NULL) { /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next * opcode is DO_FCALL in case EXT instructions are used. */ - if (EXPECTED(opline->extended_value == 0 && (opline+1)->opcode == ZEND_DO_FCALL)) { + if (EXPECTED(opline->extended_value == 0 && Z_WOP_FROM_OP(opline+1)->opcode == ZEND_DO_FCALL)) { ZEND_VM_NEXT_OPCODE_EX(1, 2); } @@ -38216,7 +38369,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDL ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ generator->send_target = EX_VAR(opline->result.var); @@ -38445,7 +38598,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_ } else #endif { - zend_frameless_function_0 function = (zend_frameless_function_0)ZEND_FLF_HANDLER(opline); + zend_frameless_function_0 function = (zend_frameless_function_0)ZEND_FLF_HANDLER(opline->extended_value); function(EX_VAR(opline->result.var)); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -38465,7 +38618,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_0_SPEC_OBSERVE } else #endif { - zend_frameless_function_0 function = (zend_frameless_function_0)ZEND_FLF_HANDLER(opline); + zend_frameless_function_0 function = (zend_frameless_function_0)ZEND_FLF_HANDLER(opline->extended_value); function(EX_VAR(opline->result.var)); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -38489,7 +38642,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV_H property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); do { - value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1); + value = get_op_data_zval_ptr_r(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1); if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) { @@ -38519,7 +38672,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV_H cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot; if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) { if (UNEXPECTED(Z_ISERROR_P(zptr))) { - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } else { @@ -38544,7 +38697,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV_H } } while (0); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), zptr); } } @@ -38556,7 +38709,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV_H } } while (0); - FREE_OP((opline+1)->op1_type, (opline+1)->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1.var); /* assign_obj has two opcodes! */ @@ -38609,7 +38762,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HAN cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot; if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) { if (UNEXPECTED(Z_ISERROR_P(zptr))) { - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } else { @@ -38769,9 +38922,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HAN zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC); #if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)) - opline = hook->op_array.opcodes; + opline = hook->op_array.slim_opcodes; #else - EX(opline) = hook->op_array.opcodes; + EX(opline) = hook->op_array.slim_opcodes; #endif LOAD_OPLINE_EX(); @@ -39094,7 +39247,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_D } else { fast_assign_obj: value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -39151,7 +39304,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_D } } zend_hash_add_new(zobj->properties, name, value); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -39190,7 +39343,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_D } free_and_exit_assign_obj: - if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1)) && value) { ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); } @@ -39248,7 +39401,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_D } else { fast_assign_obj: value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -39305,7 +39458,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_D } } zend_hash_add_new(zobj->properties, name, value); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -39344,7 +39497,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_D } free_and_exit_assign_obj: - if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1)) && value) { ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); } zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); @@ -39402,7 +39555,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_D } else { fast_assign_obj: value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -39459,7 +39612,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_D } } zend_hash_add_new(zobj->properties, name, value); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -39498,7 +39651,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_D } free_and_exit_assign_obj: - if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1)) && value) { ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); } zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); @@ -39556,7 +39709,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_D } else { fast_assign_obj: value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -39613,7 +39766,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_D } } zend_hash_add_new(zobj->properties, name, value); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -39652,7 +39805,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_D } free_and_exit_assign_obj: - if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1)) && value) { ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); } @@ -40323,7 +40476,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(Z ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ generator->send_target = EX_VAR(opline->result.var); @@ -40364,7 +40517,7 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_inc_help increment_function(var_ptr); } while (0); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } @@ -40433,7 +40586,7 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_dec_help decrement_function(var_ptr); } while (0); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } @@ -41132,18 +41285,18 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLE UNDEF_RESULT(); HANDLE_EXCEPTION(); } else if (new_op_array == ZEND_FAKE_OP_ARRAY) { - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { ZVAL_TRUE(EX_VAR(opline->result.var)); } } else if (UNEXPECTED(new_op_array == NULL)) { - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { ZVAL_FALSE(EX_VAR(opline->result.var)); } } else if (new_op_array->last == 1 && new_op_array->opcodes[0].opcode == ZEND_RETURN && new_op_array->opcodes[0].op1_type == IS_CONST && EXPECTED(zend_execute_ex == execute_ex)) { - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { const zend_op *op = new_op_array->opcodes; ZVAL_COPY(EX_VAR(opline->result.var), RT_CONSTANT(op, op->op1)); @@ -41154,7 +41307,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLE } else { zval *return_value = NULL; zend_execute_data *call; - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { return_value = EX_VAR(opline->result.var); } @@ -41585,7 +41738,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_FROM_SPEC_CV_HANDLER(ZEN zend_generator_yield_from(generator, new_gen); } } else { - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { ZVAL_COPY(EX_VAR(opline->result.var), &new_gen->retval); } ZEND_VM_NEXT_OPCODE(); @@ -41625,7 +41778,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_FROM_SPEC_CV_HANDLER(ZEN /* This is the default return value * when the expression is a Generator, it will be overwritten in zend_generator_resume() */ - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { ZVAL_NULL(EX_VAR(opline->result.var)); } @@ -41788,12 +41941,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BIND_STATIC_SPEC_CV_HANDLER(ZE zend_reference *ref = (zend_reference*)emalloc(sizeof(zend_reference)); GC_SET_REFCOUNT(ref, 2); GC_TYPE_INFO(ref) = GC_REFERENCE; - if (opline->op2_type == IS_UNUSED) { + if (QUICK_OP_FLAGS_OP2_TYPE(opline->result.num) == IS_UNUSED) { ZVAL_COPY_VALUE(&ref->val, value); } else { ZEND_ASSERT(!Z_REFCOUNTED_P(value)); - ZVAL_COPY(&ref->val, get_zval_ptr_deref(opline->op2_type, opline->op2, BP_VAR_R)); - FREE_OP(opline->op2_type, opline->op2.var); + ZVAL_COPY(&ref->val, get_zval_ptr_deref(QUICK_OP_FLAGS_OP2_TYPE(opline->result.num), opline->op2, BP_VAR_R)); + FREE_OP(QUICK_OP_FLAGS_OP2_TYPE(opline->result.num), opline->op2.var); } ref->sources.ptr = NULL; Z_REF_P(value) = ref; @@ -41804,8 +41957,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BIND_STATIC_SPEC_CV_HANDLER(ZE Z_ADDREF_P(value); i_zval_ptr_dtor(variable_ptr); ZVAL_REF(variable_ptr, Z_REF_P(value)); - if (opline->op2_type != IS_UNUSED) { - FREE_OP(opline->op2_type, opline->op2.var); + if (QUICK_OP_FLAGS_OP2_TYPE(opline->result.num) != IS_UNUSED) { + FREE_OP(QUICK_OP_FLAGS_OP2_TYPE(opline->result.num), opline->op2.var); } } } else { @@ -42126,7 +42279,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_CONST_HAN result = fast_is_identical_function(op1, op2); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -42141,7 +42294,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST result = fast_is_not_identical_function(op1, op2); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -42199,7 +42352,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER } } } - ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -42257,7 +42412,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ_HA } } } - ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -42315,7 +42472,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ_H } } } - ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -42373,7 +42532,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HAN } } } - ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -42431,7 +42592,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMP } } } - ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -42489,7 +42652,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMP } } } - ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -42538,7 +42703,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST_HA property = RT_CONSTANT(opline, opline->op2); do { - value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1); + value = get_op_data_zval_ptr_r(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1); if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) { @@ -42568,7 +42733,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST_HA cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot; if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) { if (UNEXPECTED(Z_ISERROR_P(zptr))) { - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } else { @@ -42593,7 +42758,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST_HA } } while (0); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), zptr); } } @@ -42605,7 +42770,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST_HA } } while (0); - FREE_OP((opline+1)->op1_type, (opline+1)->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1.var); /* assign_obj has two opcodes! */ @@ -42646,7 +42811,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST_HA } } - value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1); + value = get_op_data_zval_ptr_r(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1); do { if (IS_CONST != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) { @@ -42660,10 +42825,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST_HA zend_binary_op(var_ptr, var_ptr, value OPLINE_CC); } while (0); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } - FREE_OP((opline+1)->op1_type, (opline+1)->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1.var); } else { if (EXPECTED(Z_ISREF_P(container))) { container = Z_REFVAL_P(container); @@ -42702,8 +42867,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST_HA dim = RT_CONSTANT(opline, opline->op2); zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC); assign_dim_op_ret_null: - FREE_OP((opline+1)->op1_type, (opline+1)->op1.var); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + FREE_OP(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1.var); + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -42735,7 +42900,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_CV_CONST_HANDLE zend_binary_op(var_ptr, var_ptr, value OPLINE_CC); } while (0); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } @@ -42788,7 +42953,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HAND cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot; if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) { if (UNEXPECTED(Z_ISERROR_P(zptr))) { - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } else { @@ -43060,9 +43225,9 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC); #if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)) - opline = hook->op_array.opcodes; + opline = hook->op_array.slim_opcodes; #else - EX(opline) = hook->op_array.opcodes; + EX(opline) = hook->op_array.slim_opcodes; #endif LOAD_OPLINE_EX(); @@ -43390,7 +43555,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DA } else { fast_assign_obj: value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -43447,7 +43612,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DA } } zend_hash_add_new(zobj->properties, name, value); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -43486,7 +43651,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DA } free_and_exit_assign_obj: - if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1)) && value) { ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); } @@ -43544,7 +43709,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DA } else { fast_assign_obj: value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -43601,7 +43766,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DA } } zend_hash_add_new(zobj->properties, name, value); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -43640,7 +43805,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DA } free_and_exit_assign_obj: - if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1)) && value) { ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); } zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); @@ -43698,7 +43863,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DA } else { fast_assign_obj: value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -43755,7 +43920,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DA } } zend_hash_add_new(zobj->properties, name, value); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -43794,7 +43959,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DA } free_and_exit_assign_obj: - if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1)) && value) { ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); } zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); @@ -43852,7 +44017,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DA } else { fast_assign_obj: value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -43909,7 +44074,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DA } } zend_hash_add_new(zobj->properties, name, value); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -43948,7 +44113,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DA } free_and_exit_assign_obj: - if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1)) && value) { ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); } @@ -44028,7 +44193,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DA value = RT_CONSTANT((opline+1), (opline+1)->op1); value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } if (garbage) { @@ -44102,7 +44267,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DA dim = RT_CONSTANT(opline, opline->op2); assign_dim_error: - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -44180,7 +44345,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DA value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC); value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } if (garbage) { @@ -44255,7 +44420,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DA dim = RT_CONSTANT(opline, opline->op2); assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -44333,7 +44498,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DA value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } if (garbage) { @@ -44408,7 +44573,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DA dim = RT_CONSTANT(opline, opline->op2); assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -44486,7 +44651,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DA value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC); value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } if (garbage) { @@ -44560,7 +44725,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DA dim = RT_CONSTANT(opline, opline->op2); assign_dim_error: - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -45535,7 +45700,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST } - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -45686,7 +45851,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZE ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ generator->send_target = EX_VAR(opline->result.var); @@ -45867,7 +46032,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_C op2 = RT_CONSTANT(opline, opline->op2); result = fast_is_identical_function(op1, op2); /* Free is a no-op for const/cv */ - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_EX(result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -45880,7 +46045,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_ op2 = RT_CONSTANT(opline, opline->op2); result = fast_is_identical_function(op1, op2); /* Free is a no-op for const/cv */ - ZEND_VM_SMART_BRANCH(!result, 0); + ZEND_VM_SMART_BRANCH_EX(!result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -46153,7 +46318,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMPVAR_HANDLE } } } - ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -46211,7 +46378,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_H } } } - ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -46269,7 +46438,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_ } } } - ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -46327,7 +46498,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HA } } } - ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -46385,7 +46558,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JM } } } - ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -46443,7 +46618,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JM } } } - ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -46492,7 +46669,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_H property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); do { - value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1); + value = get_op_data_zval_ptr_r(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1); if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) { @@ -46522,7 +46699,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_H cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot; if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) { if (UNEXPECTED(Z_ISERROR_P(zptr))) { - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } else { @@ -46547,7 +46724,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_H } } while (0); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), zptr); } } @@ -46559,7 +46736,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_H } } while (0); - FREE_OP((opline+1)->op1_type, (opline+1)->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1.var); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); /* assign_obj has two opcodes! */ @@ -46600,7 +46777,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_H } } - value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1); + value = get_op_data_zval_ptr_r(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1); do { if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) { @@ -46614,10 +46791,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_H zend_binary_op(var_ptr, var_ptr, value OPLINE_CC); } while (0); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } - FREE_OP((opline+1)->op1_type, (opline+1)->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1.var); } else { if (EXPECTED(Z_ISREF_P(container))) { container = Z_REFVAL_P(container); @@ -46656,8 +46833,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_H dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC); assign_dim_op_ret_null: - FREE_OP((opline+1)->op1_type, (opline+1)->op1.var); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + FREE_OP(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1.var); + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -46690,7 +46867,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_HANDL zend_binary_op(var_ptr, var_ptr, value OPLINE_CC); } while (0); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } @@ -46744,7 +46921,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_HAN cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot; if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) { if (UNEXPECTED(Z_ISERROR_P(zptr))) { - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } else { @@ -47018,9 +47195,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HAN zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC); #if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)) - opline = hook->op_array.opcodes; + opline = hook->op_array.slim_opcodes; #else - EX(opline) = hook->op_array.opcodes; + EX(opline) = hook->op_array.slim_opcodes; #endif LOAD_OPLINE_EX(); @@ -47343,7 +47520,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_D } else { fast_assign_obj: value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -47400,7 +47577,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_D } } zend_hash_add_new(zobj->properties, name, value); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -47439,7 +47616,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_D } free_and_exit_assign_obj: - if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1)) && value) { ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); } @@ -47497,7 +47674,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_D } else { fast_assign_obj: value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -47554,7 +47731,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_D } } zend_hash_add_new(zobj->properties, name, value); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -47593,7 +47770,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_D } free_and_exit_assign_obj: - if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1)) && value) { ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); } zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); @@ -47651,7 +47828,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_D } else { fast_assign_obj: value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -47708,7 +47885,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_D } } zend_hash_add_new(zobj->properties, name, value); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -47747,7 +47924,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_D } free_and_exit_assign_obj: - if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1)) && value) { ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); } zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); @@ -47805,7 +47982,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_D } else { fast_assign_obj: value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -47862,7 +48039,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_D } } zend_hash_add_new(zobj->properties, name, value); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -47901,7 +48078,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_D } free_and_exit_assign_obj: - if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1)) && value) { ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); } @@ -47981,7 +48158,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_D value = RT_CONSTANT((opline+1), (opline+1)->op1); value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } if (garbage) { @@ -48055,7 +48232,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_D dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); assign_dim_error: - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -48133,7 +48310,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_D value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC); value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } if (garbage) { @@ -48208,7 +48385,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_D dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -48286,7 +48463,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_D value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } if (garbage) { @@ -48361,7 +48538,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_D dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -48439,7 +48616,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_D value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC); value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } if (garbage) { @@ -48513,7 +48690,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_D dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); assign_dim_error: - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -49292,7 +49469,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVA zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -49399,7 +49576,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_TMPVAR_HANDLER(Z ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ generator->send_target = EX_VAR(opline->result.var); @@ -49427,7 +49604,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDL result = fast_is_identical_function(op1, op2); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -49442,7 +49619,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_H result = fast_is_not_identical_function(op1, op2); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -49515,7 +49692,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDL result = fast_is_identical_function(op1, op2); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -49530,7 +49707,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_H result = fast_is_not_identical_function(op1, op2); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -49612,12 +49789,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER UNEXPECTED(!Z_ISREF_P(value_ptr))) { variable_ptr = zend_wrong_assign_to_variable_reference( - variable_ptr, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC); + variable_ptr, value_ptr, &garbage EXECUTE_DATA_CC); } else { zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr); } @@ -49734,7 +49911,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED_H } } - value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1); + value = get_op_data_zval_ptr_r(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1); do { if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) { @@ -49748,10 +49925,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED_H zend_binary_op(var_ptr, var_ptr, value OPLINE_CC); } while (0); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } - FREE_OP((opline+1)->op1_type, (opline+1)->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1.var); } else { if (EXPECTED(Z_ISREF_P(container))) { container = Z_REFVAL_P(container); @@ -49790,8 +49967,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED_H dim = NULL; zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC); assign_dim_op_ret_null: - FREE_OP((opline+1)->op1_type, (opline+1)->op1.var); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + FREE_OP(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1.var); + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -50050,7 +50227,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_D value = RT_CONSTANT((opline+1), (opline+1)->op1); value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } if (garbage) { @@ -50124,7 +50301,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_D dim = NULL; assign_dim_error: - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -50202,7 +50379,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_D value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC); value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } if (garbage) { @@ -50277,7 +50454,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_D dim = NULL; assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -50355,7 +50532,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_D value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } if (garbage) { @@ -50430,7 +50607,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_D dim = NULL; assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -50508,7 +50685,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_D value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC); value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } if (garbage) { @@ -50582,7 +50759,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_D dim = NULL; assign_dim_error: - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -51051,16 +51228,16 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_CV_S if (!(0)) { if (Z_TYPE_P(value) > IS_NULL && (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL)) { - ZEND_VM_SMART_BRANCH_TRUE(); + ZEND_VM_SMART_BRANCH_TRUE_EX(QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->op2.num)); } else { - ZEND_VM_SMART_BRANCH_FALSE(); + ZEND_VM_SMART_BRANCH_FALSE_EX(QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->op2.num)); } } else { bool result; SAVE_OPLINE(); result = !i_zend_is_true(value); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->op2.num)); } } @@ -51073,16 +51250,16 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_CV_S if (!(1)) { if (Z_TYPE_P(value) > IS_NULL && (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL)) { - ZEND_VM_SMART_BRANCH_TRUE(); + ZEND_VM_SMART_BRANCH_TRUE_EX(QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->op2.num)); } else { - ZEND_VM_SMART_BRANCH_FALSE(); + ZEND_VM_SMART_BRANCH_FALSE_EX(QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->op2.num)); } } else { bool result; SAVE_OPLINE(); result = !i_zend_is_true(value); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->op2.num)); } } @@ -51126,7 +51303,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUS } } - ZEND_VM_SMART_BRANCH(result, true); + ZEND_VM_SMART_BRANCH_EX(result, true, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->op2.num)); } /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ @@ -51278,7 +51455,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(Z ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ generator->send_target = EX_VAR(opline->result.var); @@ -51324,9 +51501,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_TYPE_CHECK_SPEC_CV if (IS_CV & (IS_TMP_VAR|IS_VAR)) { SAVE_OPLINE(); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->op2.num)); } else { - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_EX(result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->op2.num)); } } @@ -51646,7 +51823,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLE result = fast_is_identical_function(op1, op2); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -51661,7 +51838,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HA result = fast_is_not_identical_function(op1, op2); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -51719,7 +51896,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER(ZE } } } - ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -51777,7 +51956,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ_HANDL } } } - ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -51835,7 +52016,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ_HAND } } } - ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -51893,7 +52076,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLE } } } - ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -51951,7 +52136,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ_H } } } - ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -52009,7 +52196,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ_ } } } - ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); + uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); + ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -52058,7 +52247,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV_HANDL property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); do { - value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1); + value = get_op_data_zval_ptr_r(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1); if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) { @@ -52088,7 +52277,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV_HANDL cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot; if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) { if (UNEXPECTED(Z_ISERROR_P(zptr))) { - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } else { @@ -52113,7 +52302,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV_HANDL } } while (0); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), zptr); } } @@ -52125,7 +52314,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV_HANDL } } while (0); - FREE_OP((opline+1)->op1_type, (opline+1)->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1.var); /* assign_obj has two opcodes! */ @@ -52166,7 +52355,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_CV_CV_HANDL } } - value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1); + value = get_op_data_zval_ptr_r(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1); do { if (IS_CV != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) { @@ -52180,10 +52369,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_CV_CV_HANDL zend_binary_op(var_ptr, var_ptr, value OPLINE_CC); } while (0); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } - FREE_OP((opline+1)->op1_type, (opline+1)->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1.var); } else { if (EXPECTED(Z_ISREF_P(container))) { container = Z_REFVAL_P(container); @@ -52222,8 +52411,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_CV_CV_HANDL dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC); assign_dim_op_ret_null: - FREE_OP((opline+1)->op1_type, (opline+1)->op1.var); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + FREE_OP(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1.var); + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -52255,7 +52444,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_CV_CV_HANDLER(Z zend_binary_op(var_ptr, var_ptr, value OPLINE_CC); } while (0); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } @@ -52308,7 +52497,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot; if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) { if (UNEXPECTED(Z_ISERROR_P(zptr))) { - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } else { @@ -52580,9 +52769,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC); #if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)) - opline = hook->op_array.opcodes; + opline = hook->op_array.slim_opcodes; #else - EX(opline) = hook->op_array.opcodes; + EX(opline) = hook->op_array.slim_opcodes; #endif LOAD_OPLINE_EX(); @@ -52905,7 +53094,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_ } else { fast_assign_obj: value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -52962,7 +53151,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_ } } zend_hash_add_new(zobj->properties, name, value); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -53001,7 +53190,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_ } free_and_exit_assign_obj: - if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1)) && value) { ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); } @@ -53059,7 +53248,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_ } else { fast_assign_obj: value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -53116,7 +53305,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_ } } zend_hash_add_new(zobj->properties, name, value); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -53155,7 +53344,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_ } free_and_exit_assign_obj: - if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1)) && value) { ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); } zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); @@ -53213,7 +53402,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_ } else { fast_assign_obj: value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -53270,7 +53459,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_ } } zend_hash_add_new(zobj->properties, name, value); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -53309,7 +53498,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_ } free_and_exit_assign_obj: - if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1)) && value) { ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); } zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); @@ -53367,7 +53556,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_ } else { fast_assign_obj: value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -53424,7 +53613,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_ } } zend_hash_add_new(zobj->properties, name, value); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } goto exit_assign_obj; @@ -53463,7 +53652,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_ } free_and_exit_assign_obj: - if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1)) && value) { ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); } @@ -53543,7 +53732,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_ value = RT_CONSTANT((opline+1), (opline+1)->op1); value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } if (garbage) { @@ -53617,7 +53806,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_ dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); assign_dim_error: - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -53695,7 +53884,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_ value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC); value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } if (garbage) { @@ -53770,7 +53959,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_ dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -53848,7 +54037,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_ value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } if (garbage) { @@ -53923,7 +54112,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_ dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -54001,7 +54190,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_ value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC); value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } if (garbage) { @@ -54075,7 +54264,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_ dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); assign_dim_error: - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -54167,12 +54356,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER( UNEXPECTED(!Z_ISREF_P(value_ptr))) { variable_ptr = zend_wrong_assign_to_variable_reference( - variable_ptr, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC); + variable_ptr, value_ptr, &garbage EXECUTE_DATA_CC); } else { zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + if (UNEXPECTED((opline->result.var != (uint16_t)-1))) { ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr); } @@ -54947,7 +55136,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_HA } - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -55053,7 +55242,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_ ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } - if (RETURN_VALUE_USED(opline)) { + if ((opline->result.var != (uint16_t)-1)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ generator->send_target = EX_VAR(opline->result.var); @@ -55082,7 +55271,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_C op2 = EX_VAR(opline->op2.var); result = fast_is_identical_function(op1, op2); /* Free is a no-op for const/cv */ - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_EX(result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -55095,7 +55284,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_ op2 = EX_VAR(opline->op2.var); result = fast_is_identical_function(op1, op2); /* Free is a no-op for const/cv */ - ZEND_VM_SMART_BRANCH(!result, 0); + ZEND_VM_SMART_BRANCH_EX(!result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -55103,7 +55292,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NULL_HANDLER(ZEND_OPCODE_HANDL USE_OPLINE SAVE_OPLINE(); - zend_error_noreturn(E_ERROR, "Invalid opcode %d/%d/%d.", OPLINE->opcode, OPLINE->op1_type, OPLINE->op2_type); + zend_error_noreturn(E_ERROR, "Invalid opcode %d/%d/%d.", EX_WOP->opcode, EX_WOP->op1_type, EX_WOP->op2_type); ZEND_VM_NEXT_OPCODE(); /* Never reached */ } @@ -55143,7 +55332,7 @@ ZEND_API void execute_ex(zend_execute_data *ex) char hybrid_jit_red_zone[ZEND_VM_HYBRID_JIT_RED_ZONE_SIZE]; #endif #ifdef ZEND_VM_IP_GLOBAL_REG - const zend_op *orig_opline; + const zend_slim_op *orig_opline; #endif #ifdef ZEND_VM_FP_GLOBAL_REG zend_execute_data *orig_execute_data; @@ -59289,31 +59478,31 @@ ZEND_API void execute_ex(zend_execute_data *ex) zval *return_value; zval observer_retval; - retval_ptr = get_zval_ptr_undef(opline->op1_type, opline->op1, BP_VAR_R); + retval_ptr = get_zval_ptr_undef(QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value), opline->op1, BP_VAR_R); return_value = EX(return_value); if (!return_value) { return_value = &observer_retval; }; - if (opline->op1_type == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) { + if (QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) { SAVE_OPLINE(); retval_ptr = ZVAL_UNDEFINED_OP1(); if (return_value) { ZVAL_NULL(return_value); } } else if (!return_value) { - if (opline->op1_type & (IS_VAR|IS_TMP_VAR)) { + if (QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value) & (IS_VAR|IS_TMP_VAR)) { if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) { SAVE_OPLINE(); rc_dtor_func(Z_COUNTED_P(retval_ptr)); } } } else { - if ((opline->op1_type & (IS_CONST|IS_TMP_VAR))) { + if ((QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value) & (IS_CONST|IS_TMP_VAR))) { ZVAL_COPY_VALUE(return_value, retval_ptr); - if (opline->op1_type == IS_CONST) { + if (QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value) == IS_CONST) { if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) { Z_ADDREF_P(return_value); } } - } else if (opline->op1_type == IS_CV) { + } else if (QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value) == IS_CV) { do { if (Z_OPT_REFCOUNTED_P(retval_ptr)) { if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) { @@ -59338,7 +59527,7 @@ ZEND_API void execute_ex(zend_execute_data *ex) } ZVAL_COPY_VALUE(return_value, retval_ptr); } while (0); - } else /* if (opline->op1_type == IS_VAR) */ { + } else /* if (QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value) == IS_VAR) */ { if (UNEXPECTED(Z_ISREF_P(retval_ptr))) { zend_refcounted *ref = Z_COUNTED_P(retval_ptr); @@ -64334,7 +64523,7 @@ ZEND_API void execute_ex(zend_execute_data *ex) # endif return; #else - opline = (const zend_op*)((uintptr_t)opline & ~ZEND_VM_ENTER_BIT); + opline = (const zend_slim_op*)((uintptr_t)opline & ~ZEND_VM_ENTER_BIT); if (EXPECTED(opline != NULL)) { execute_data = EG(current_execute_data); ZEND_VM_LOOP_INTERRUPT_CHECK(); @@ -68218,7 +68407,7 @@ ZEND_API const void* ZEND_FASTCALL zend_get_opcode_handler_func(const zend_op *o #endif } -ZEND_API const zend_op *zend_get_halt_op(void) +ZEND_API const zend_slim_op *zend_get_halt_op(void) { #if ZEND_VM_KIND == ZEND_VM_KIND_HYBRID return &hybrid_halt_op; @@ -68593,7 +68782,7 @@ ZEND_API int ZEND_FASTCALL zend_vm_call_opcode_handler(zend_execute_data* ex) DCL_OPLINE; int ret; #ifdef ZEND_VM_IP_GLOBAL_REG - const zend_op *orig_opline = opline; + const zend_slim_op *orig_opline = opline; #endif #ifdef ZEND_VM_FP_GLOBAL_REG zend_execute_data *orig_execute_data = execute_data; @@ -68605,7 +68794,8 @@ ZEND_API int ZEND_FASTCALL zend_vm_call_opcode_handler(zend_execute_data* ex) LOAD_OPLINE(); #if defined(ZEND_VM_FP_GLOBAL_REG) && defined(ZEND_VM_IP_GLOBAL_REG) #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID) - handler = (opcode_handler_t)zend_vm_get_opcode_handler_func(zend_user_opcodes[opline->opcode], opline); + zend_op *wide_op = EX_WOP2; + handler = (opcode_handler_t)zend_vm_get_opcode_handler_func(zend_user_opcodes[wide_op->opcode], wide_op); handler(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); if (EXPECTED(opline != &hybrid_halt_op)) { #else @@ -68620,7 +68810,7 @@ ZEND_API int ZEND_FASTCALL zend_vm_call_opcode_handler(zend_execute_data* ex) #else opline = ((opcode_handler_t)OPLINE->handler)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); if (UNEXPECTED(((uintptr_t)opline & ZEND_VM_ENTER_BIT))) { - opline = (const zend_op*)((uintptr_t)opline & ~ZEND_VM_ENTER_BIT); + opline = (const zend_slim_op*)((uintptr_t)opline & ~ZEND_VM_ENTER_BIT); if (EXPECTED(opline)) { /* ZEND_VM_ENTER() or ZEND_VM_LEAVE() */ ret = EG(current_execute_data) != ex ? (int)(EG(current_execute_data)->prev_execute_data != ex) + 1 : 0; diff --git a/Zend/zend_vm_execute.skl b/Zend/zend_vm_execute.skl index 6fecd39346a70..2e9974eb92c7d 100644 --- a/Zend/zend_vm_execute.skl +++ b/Zend/zend_vm_execute.skl @@ -152,7 +152,7 @@ ZEND_API const void* ZEND_FASTCALL zend_get_opcode_handler_func(const zend_op *o #endif } -ZEND_API const zend_op *zend_get_halt_op(void) +ZEND_API const zend_slim_op *zend_get_halt_op(void) { #if ZEND_VM_KIND == ZEND_VM_KIND_HYBRID return &hybrid_halt_op; diff --git a/Zend/zend_vm_gen.php b/Zend/zend_vm_gen.php index 5a4a31b60b8d3..6241714eca35b 100755 --- a/Zend/zend_vm_gen.php +++ b/Zend/zend_vm_gen.php @@ -71,6 +71,7 @@ "ZEND_VM_OP_CONST_FETCH" => 0x90, "ZEND_VM_OP_CACHE_SLOT" => 0xa0, + "ZEND_VM_EXT_FULL_MASK" => 0x0fff0000, "ZEND_VM_EXT_VAR_FETCH" => 1<<16, "ZEND_VM_EXT_ISSET" => 1<<17, "ZEND_VM_EXT_CACHE_SLOT" => 1<<18, @@ -93,6 +94,13 @@ // unused 0x0c000000, "ZEND_VM_NO_CONST_CONST" => 0x40000000, "ZEND_VM_COMMUTATIVE" => 0x80000000, + "ZEND_VM_QUICK_OP_FLAGS_FIELD_NONE" => 0, + "ZEND_VM_QUICK_OP_FLAGS_FIELD_EXT_VALUE" => 0x100000000, + "ZEND_VM_QUICK_OP_FLAGS_FIELD_OP1" => 0x200000000, + "ZEND_VM_QUICK_OP_FLAGS_FIELD_OP2" => 0x300000000, + "ZEND_VM_QUICK_OP_FLAGS_FIELD_RESULT" => 0x400000000, + "ZEND_VM_QUICK_OP_FLAGS_FIELD_OP_DATA_OP2" => 0x500000000, + "ZEND_VM_QUICK_OP_FLAGS_FIELD_MASK" => 0x700000000, ); foreach ($vm_op_flags as $name => $val) { @@ -187,7 +195,7 @@ ); $op1_type = array( - "ANY" => "opline->op1_type", + "ANY" => "RT_OP1_TYPE", "TMP" => "IS_TMP_VAR", "VAR" => "IS_VAR", "CONST" => "IS_CONST", @@ -198,7 +206,7 @@ ); $op2_type = array( - "ANY" => "opline->op2_type", + "ANY" => "RT_OP2_TYPE", "TMP" => "IS_TMP_VAR", "VAR" => "IS_VAR", "CONST" => "IS_CONST", @@ -209,7 +217,7 @@ ); $op1_get_zval_ptr = array( - "ANY" => "get_zval_ptr(opline->op1_type, opline->op1, \\1)", + "ANY" => "get_zval_ptr(RT_OP1_TYPE, opline->op1, \\1)", "TMP" => "_get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC)", "VAR" => "_get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC)", "CONST" => "RT_CONSTANT(opline, opline->op1)", @@ -220,7 +228,7 @@ ); $op2_get_zval_ptr = array( - "ANY" => "get_zval_ptr(opline->op2_type, opline->op2, \\1)", + "ANY" => "get_zval_ptr(RT_OP2_TYPE, opline->op2, \\1)", "TMP" => "_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)", "VAR" => "_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)", "CONST" => "RT_CONSTANT(opline, opline->op2)", @@ -231,7 +239,7 @@ ); $op1_get_zval_ptr_ptr = array( - "ANY" => "get_zval_ptr_ptr(opline->op1_type, opline->op1, \\1)", + "ANY" => "get_zval_ptr_ptr(RT_OP1_TYPE, opline->op1, \\1)", "TMP" => "zend_get_bad_ptr()", "VAR" => "_get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC)", "CONST" => "zend_get_bad_ptr()", @@ -242,7 +250,7 @@ ); $op2_get_zval_ptr_ptr = array( - "ANY" => "get_zval_ptr_ptr(opline->op2_type, opline->op2, \\1)", + "ANY" => "get_zval_ptr_ptr(RT_OP2_TYPE, opline->op2, \\1)", "TMP" => "zend_get_bad_ptr()", "VAR" => "_get_zval_ptr_ptr_var(opline->op2.var EXECUTE_DATA_CC)", "CONST" => "zend_get_bad_ptr()", @@ -253,29 +261,29 @@ ); $op1_get_zval_ptr_deref = array( - "ANY" => "get_zval_ptr_deref(opline->op1_type, opline->op1, \\1)", + "ANY" => "get_zval_ptr_deref(RT_OP1_TYPE, opline->op1, \\1)", "TMP" => "_get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC)", "VAR" => "_get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC)", "CONST" => "RT_CONSTANT(opline, opline->op1)", "UNUSED" => "NULL", "CV" => "_get_zval_ptr_cv_deref_\\1(opline->op1.var EXECUTE_DATA_CC)", "TMPVAR" => "???", - "TMPVARCV" => "_get_zval_ptr_tmpvarcv(opline->op1_type, opline->op1, \\1 EXECUTE_DATA_CC)", + "TMPVARCV" => "_get_zval_ptr_tmpvarcv(RT_OP1_TYPE, opline->op1, \\1 EXECUTE_DATA_CC)", ); $op2_get_zval_ptr_deref = array( - "ANY" => "get_zval_ptr_deref(opline->op2_type, opline->op2, \\1)", + "ANY" => "get_zval_ptr_deref(RT_OP2_TYPE, opline->op2, \\1)", "TMP" => "_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)", "VAR" => "_get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC)", "CONST" => "RT_CONSTANT(opline, opline->op2)", "UNUSED" => "NULL", "CV" => "_get_zval_ptr_cv_deref_\\1(opline->op2.var EXECUTE_DATA_CC)", "TMPVAR" => "???", - "TMPVARCV" => "_get_zval_ptr_tmpvarcv(opline->op2_type, opline->op2, \\1 EXECUTE_DATA_CC)", + "TMPVARCV" => "_get_zval_ptr_tmpvarcv(RT_OP2_TYPE, opline->op2, \\1 EXECUTE_DATA_CC)", ); $op1_get_zval_ptr_undef = array( - "ANY" => "get_zval_ptr_undef(opline->op1_type, opline->op1, \\1)", + "ANY" => "get_zval_ptr_undef(RT_OP1_TYPE, opline->op1, \\1)", "TMP" => "_get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC)", "VAR" => "_get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC)", "CONST" => "RT_CONSTANT(opline, opline->op1)", @@ -286,7 +294,7 @@ ); $op2_get_zval_ptr_undef = array( - "ANY" => "get_zval_ptr_undef(opline->op2_type, opline->op2, \\1)", + "ANY" => "get_zval_ptr_undef(RT_OP2_TYPE, opline->op2, \\1)", "TMP" => "_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)", "VAR" => "_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)", "CONST" => "RT_CONSTANT(opline, opline->op2)", @@ -297,7 +305,7 @@ ); $op1_get_zval_ptr_ptr_undef = array( - "ANY" => "get_zval_ptr_ptr_undef(opline->op1_type, opline->op1, \\1)", + "ANY" => "get_zval_ptr_ptr_undef(RT_OP1_TYPE, opline->op1, \\1)", "TMP" => "zend_get_bad_ptr()", "VAR" => "_get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC)", "CONST" => "zend_get_bad_ptr()", @@ -308,7 +316,7 @@ ); $op2_get_zval_ptr_ptr_undef = array( - "ANY" => "get_zval_ptr_ptr_undef(opline->op2_type, opline->op2, \\1)", + "ANY" => "get_zval_ptr_ptr_undef(RT_OP2_TYPE, opline->op2, \\1)", "TMP" => "zend_get_bad_ptr()", "VAR" => "_get_zval_ptr_ptr_var(opline->op2.var EXECUTE_DATA_CC)", "CONST" => "zend_get_bad_ptr()", @@ -319,7 +327,7 @@ ); $op1_get_obj_zval_ptr = array( - "ANY" => "get_obj_zval_ptr(opline->op1_type, opline->op1, \\1)", + "ANY" => "get_obj_zval_ptr(RT_OP1_TYPE, opline->op1, \\1)", "TMP" => "_get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC)", "VAR" => "_get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC)", "CONST" => "RT_CONSTANT(opline, opline->op1)", @@ -330,7 +338,7 @@ ); $op2_get_obj_zval_ptr = array( - "ANY" => "get_obj_zval_ptr(opline->op2_type, opline->op2, \\1)", + "ANY" => "get_obj_zval_ptr(RT_OP2_TYPE, opline->op2, \\1)", "TMP" => "_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)", "VAR" => "_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)", "CONST" => "RT_CONSTANT(opline, opline->op2)", @@ -341,7 +349,7 @@ ); $op1_get_obj_zval_ptr_undef = array( - "ANY" => "get_obj_zval_ptr_undef(opline->op1_type, opline->op1, \\1)", + "ANY" => "get_obj_zval_ptr_undef(RT_OP1_TYPE, opline->op1, \\1)", "TMP" => "_get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC)", "VAR" => "_get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC)", "CONST" => "RT_CONSTANT(opline, opline->op1)", @@ -352,7 +360,7 @@ ); $op2_get_obj_zval_ptr_undef = array( - "ANY" => "get_obj_zval_ptr_undef(opline->op2_type, opline->op2, \\1)", + "ANY" => "get_obj_zval_ptr_undef(RT_OP2_TYPE, opline->op2, \\1)", "TMP" => "_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)", "VAR" => "_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)", "CONST" => "RT_CONSTANT(opline, opline->op2)", @@ -363,7 +371,7 @@ ); $op1_get_obj_zval_ptr_deref = array( - "ANY" => "get_obj_zval_ptr(opline->op1_type, opline->op1, \\1)", + "ANY" => "get_obj_zval_ptr(RT_OP1_TYPE, opline->op1, \\1)", "TMP" => "_get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC)", "VAR" => "_get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC)", "CONST" => "RT_CONSTANT(opline, opline->op1)", @@ -374,7 +382,7 @@ ); $op2_get_obj_zval_ptr_deref = array( - "ANY" => "get_obj_zval_ptr(opline->op2_type, opline->op2, \\1)", + "ANY" => "get_obj_zval_ptr(RT_OP2_TYPE, opline->op2, \\1)", "TMP" => "_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)", "VAR" => "_get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC)", "CONST" => "RT_CONSTANT(opline, opline->op2)", @@ -385,7 +393,7 @@ ); $op1_get_obj_zval_ptr_ptr = array( - "ANY" => "get_obj_zval_ptr_ptr(opline->op1_type, opline->op1, \\1)", + "ANY" => "get_obj_zval_ptr_ptr(RT_OP1_TYPE, opline->op1, \\1)", "TMP" => "zend_get_bad_ptr()", "VAR" => "_get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC)", "CONST" => "zend_get_bad_ptr()", @@ -396,7 +404,7 @@ ); $op2_get_obj_zval_ptr_ptr = array( - "ANY" => "get_obj_zval_ptr_ptr(opline->op2_type, opline->op2, \\1)", + "ANY" => "get_obj_zval_ptr_ptr(RT_OP2_TYPE, opline->op2, \\1)", "TMP" => "zend_get_bad_ptr()", "VAR" => "_get_zval_ptr_ptr_var(opline->op2.var EXECUTE_DATA_CC)", "CONST" => "zend_get_bad_ptr()", @@ -407,7 +415,7 @@ ); $op1_get_obj_zval_ptr_ptr_undef = array( - "ANY" => "get_obj_zval_ptr_ptr(opline->op1_type, opline->op1, \\1)", + "ANY" => "get_obj_zval_ptr_ptr(RT_OP1_TYPE, opline->op1, \\1)", "TMP" => "zend_get_bad_ptr()", "VAR" => "_get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC)", "CONST" => "zend_get_bad_ptr()", @@ -418,7 +426,7 @@ ); $op2_get_obj_zval_ptr_ptr_undef = array( - "ANY" => "get_obj_zval_ptr_ptr(opline->op2_type, opline->op2, \\1)", + "ANY" => "get_obj_zval_ptr_ptr(RT_OP2_TYPE, opline->op2, \\1)", "TMP" => "zend_get_bad_ptr()", "VAR" => "_get_zval_ptr_ptr_var(opline->op2.var EXECUTE_DATA_CC)", "CONST" => "zend_get_bad_ptr()", @@ -429,29 +437,29 @@ ); $op1_free_op = array( - "ANY" => "FREE_OP(opline->op1_type, opline->op1.var)", + "ANY" => "FREE_OP(RT_OP1_TYPE, opline->op1.var)", "TMP" => "zval_ptr_dtor_nogc(EX_VAR(opline->op1.var))", "VAR" => "zval_ptr_dtor_nogc(EX_VAR(opline->op1.var))", "CONST" => "", "UNUSED" => "", "CV" => "", "TMPVAR" => "zval_ptr_dtor_nogc(EX_VAR(opline->op1.var))", - "TMPVARCV" => "FREE_OP(opline->op1_type, opline->op1.var)", + "TMPVARCV" => "FREE_OP(RT_OP1_TYPE, opline->op1.var)", ); $op2_free_op = array( - "ANY" => "FREE_OP(opline->op2_type, opline->op2.var)", + "ANY" => "FREE_OP(RT_OP2_TYPE, opline->op2.var)", "TMP" => "zval_ptr_dtor_nogc(EX_VAR(opline->op2.var))", "VAR" => "zval_ptr_dtor_nogc(EX_VAR(opline->op2.var))", "CONST" => "", "UNUSED" => "", "CV" => "", "TMPVAR" => "zval_ptr_dtor_nogc(EX_VAR(opline->op2.var))", - "TMPVARCV" => "FREE_OP(opline->op2_type, opline->op2.var)", + "TMPVARCV" => "FREE_OP(RT_OP2_TYPE, opline->op2.var)", ); $op1_free_op_if_var = array( - "ANY" => "if (opline->op1_type == IS_VAR) {zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));}", + "ANY" => "if (RT_OP1_TYPE == IS_VAR) {zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));}", "TMP" => "", "VAR" => "zval_ptr_dtor_nogc(EX_VAR(opline->op1.var))", "CONST" => "", @@ -462,7 +470,7 @@ ); $op2_free_op_if_var = array( - "ANY" => "if (opline->op2_type == IS_VAR) {zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));}", + "ANY" => "if (RT_OP2_TYPE == IS_VAR) {zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));}", "TMP" => "", "VAR" => "zval_ptr_dtor_nogc(EX_VAR(opline->op2.var))", "CONST" => "", @@ -473,7 +481,7 @@ ); $op_data_type = array( - "ANY" => "(opline+1)->op1_type", + "ANY" => "RT_OP_DATA_TYPE", "TMP" => "IS_TMP_VAR", "VAR" => "IS_VAR", "CONST" => "IS_CONST", @@ -484,7 +492,7 @@ ); $op_data_get_zval_ptr = array( - "ANY" => "get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1)", + "ANY" => "get_op_data_zval_ptr_r(RT_OP_DATA_TYPE, (opline+1)->op1)", "TMP" => "_get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC)", "VAR" => "_get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC)", "CONST" => "RT_CONSTANT((opline+1), (opline+1)->op1)", @@ -495,7 +503,7 @@ ); $op_data_get_zval_ptr_undef = array( - "ANY" => "get_op_data_zval_ptr_undef((opline+1)->op1_type, (opline+1)->op1)", + "ANY" => "get_op_data_zval_ptr_undef(RT_OP_DATA_TYPE, (opline+1)->op1)", "TMP" => "_get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC)", "VAR" => "_get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC)", "CONST" => "RT_CONSTANT((opline+1), (opline+1)->op1)", @@ -506,7 +514,7 @@ ); $op_data_get_zval_ptr_deref = array( - "ANY" => "get_op_data_zval_ptr_deref_r((opline+1)->op1_type, (opline+1)->op1)", + "ANY" => "get_op_data_zval_ptr_deref_r(RT_OP_DATA_TYPE, (opline+1)->op1)", "TMP" => "_get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC)", "VAR" => "_get_zval_ptr_var_deref((opline+1)->op1.var EXECUTE_DATA_CC)", "CONST" => "RT_CONSTANT((opline+1), (opline+1)->op1)", @@ -517,7 +525,7 @@ ); $op_data_get_zval_ptr_ptr = array( - "ANY" => "get_zval_ptr_ptr((opline+1)->op1_type, (opline+1)->op1, \\1)", + "ANY" => "get_zval_ptr_ptr(RT_OP_DATA_TYPE, (opline+1)->op1, \\1)", "TMP" => "zend_get_bad_ptr()", "VAR" => "_get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC)", "CONST" => "zend_get_bad_ptr()", @@ -528,7 +536,7 @@ ); $op_data_free_op = array( - "ANY" => "FREE_OP((opline+1)->op1_type, (opline+1)->op1.var)", + "ANY" => "FREE_OP(RT_OP_DATA_TYPE, (opline+1)->op1.var)", "TMP" => "zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var))", "VAR" => "zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var))", "CONST" => "", @@ -684,8 +692,34 @@ function format_condition($condition) { return "(" . $condition . ")"; } +function is_smart_branch($opcode) { + switch ($opcode) { + case 'ZEND_IS_IDENTICAL': + case 'ZEND_IS_NOT_IDENTICAL': + case 'ZEND_IS_EQUAL': + case 'ZEND_IS_NOT_EQUAL': + case 'ZEND_IS_SMALLER': + case 'ZEND_IS_SMALLER_OR_EQUAL': + case 'ZEND_CASE': + case 'ZEND_CASE_STRICT': + case 'ZEND_ISSET_ISEMPTY_CV': + case 'ZEND_ISSET_ISEMPTY_VAR': + case 'ZEND_ISSET_ISEMPTY_DIM_OBJ': + case 'ZEND_ISSET_ISEMPTY_PROP_OBJ': + case 'ZEND_ISSET_ISEMPTY_STATIC_PROP': + case 'ZEND_INSTANCEOF': + case 'ZEND_TYPE_CHECK': + case 'ZEND_DEFINED': + case 'ZEND_IN_ARRAY': + case 'ZEND_ARRAY_KEY_EXISTS': + return true; + default: + return false; + } +} + // Generates code for opcode handler or helper -function gen_code($f, $spec, $kind, $code, $op1, $op2, $name, $extra_spec=null) { +function gen_code($opcode, $f, $spec, $kind, $code, $op1, $op2, $name, $extra_spec=null) { global $op1_type, $op2_type, $op1_get_zval_ptr, $op2_get_zval_ptr, $op1_get_zval_ptr_deref, $op2_get_zval_ptr_deref, $op1_get_zval_ptr_undef, $op2_get_zval_ptr_undef, @@ -704,8 +738,8 @@ function gen_code($f, $spec, $kind, $code, $op1, $op2, $name, $extra_spec=null) // Specializing $specialized_replacements = array( - "/OP1_TYPE/" => $op1_type[$op1], - "/OP2_TYPE/" => $op2_type[$op2], + "/\bOP1_TYPE/" => $op1_type[$op1], + "/\bOP2_TYPE/" => $op2_type[$op2], "/GET_OP1_ZVAL_PTR\(([^)]*)\)/" => $op1_get_zval_ptr[$op1], "/GET_OP2_ZVAL_PTR\(([^)]*)\)/" => $op2_get_zval_ptr[$op2], "/GET_OP1_ZVAL_PTR_DEREF\(([^)]*)\)/" => $op1_get_zval_ptr_deref[$op1], @@ -738,32 +772,70 @@ function gen_code($f, $spec, $kind, $code, $op1, $op2, $name, $extra_spec=null) "/^#(\s*)if\s+0\s*&&.*[^\\\\]$/m" => "#\\1if 0", "/^#(\s*)elif\s+1\s*\\|\\|.*[^\\\\]$/m" => "#\\1elif 1", "/^#(\s*)elif\s+0\s*&&.*[^\\\\]$/m" => "#\\1elif 0", - "/OP_DATA_TYPE/" => $op_data_type[isset($extra_spec['OP_DATA']) ? $extra_spec['OP_DATA'] : "ANY"], + "/\bOP_DATA_TYPE/" => $op_data_type[isset($extra_spec['OP_DATA']) ? $extra_spec['OP_DATA'] : "ANY"], "/GET_OP_DATA_ZVAL_PTR\(([^)]*)\)/" => $op_data_get_zval_ptr[isset($extra_spec['OP_DATA']) ? $extra_spec['OP_DATA'] : "ANY"], "/GET_OP_DATA_ZVAL_PTR_UNDEF\(([^)]*)\)/" => $op_data_get_zval_ptr_undef[isset($extra_spec['OP_DATA']) ? $extra_spec['OP_DATA'] : "ANY"], "/GET_OP_DATA_ZVAL_PTR_DEREF\(([^)]*)\)/" => $op_data_get_zval_ptr_deref[isset($extra_spec['OP_DATA']) ? $extra_spec['OP_DATA'] : "ANY"], "/GET_OP_DATA_ZVAL_PTR_PTR\(([^)]*)\)/" => $op_data_get_zval_ptr_ptr[isset($extra_spec['OP_DATA']) ? $extra_spec['OP_DATA'] : "ANY"], "/FREE_OP_DATA\(\)/" => $op_data_free_op[isset($extra_spec['OP_DATA']) ? $extra_spec['OP_DATA'] : "ANY"], - "/RETURN_VALUE_USED\(opline\)/" => isset($extra_spec['RETVAL']) ? $extra_spec['RETVAL'] : "RETURN_VALUE_USED(opline)", + "/RETURN_VALUE_USED\(EX_WOP2\)/" => isset($extra_spec['RETVAL']) + ? $extra_spec['RETVAL'] + : "(opline->result.var != (uint16_t)-1)", "/arg_num <= MAX_ARG_FLAG_NUM/" => isset($extra_spec['QUICK_ARG']) ? $extra_spec['QUICK_ARG'] : "arg_num <= MAX_ARG_FLAG_NUM", - "/ZEND_VM_SMART_BRANCH\(\s*([^,)]*)\s*,\s*([^)]*)\s*\)/" => isset($extra_spec['SMART_BRANCH']) ? - ($extra_spec['SMART_BRANCH'] == 1 ? - "ZEND_VM_SMART_BRANCH_JMPZ(\\1, \\2)" - : ($extra_spec['SMART_BRANCH'] == 2 ? - "ZEND_VM_SMART_BRANCH_JMPNZ(\\1, \\2)" : "ZEND_VM_SMART_BRANCH_NONE(\\1, \\2)")) - : "ZEND_VM_SMART_BRANCH(\\1, \\2)", - "/ZEND_VM_SMART_BRANCH_TRUE\(\s*\)/" => isset($extra_spec['SMART_BRANCH']) ? - ($extra_spec['SMART_BRANCH'] == 1 ? - "ZEND_VM_SMART_BRANCH_TRUE_JMPZ()" - : ($extra_spec['SMART_BRANCH'] == 2 ? - "ZEND_VM_SMART_BRANCH_TRUE_JMPNZ()" : "ZEND_VM_SMART_BRANCH_TRUE_NONE()")) - : "ZEND_VM_SMART_BRANCH_TRUE()", - "/ZEND_VM_SMART_BRANCH_FALSE\(\s*\)/" => isset($extra_spec['SMART_BRANCH']) ? - ($extra_spec['SMART_BRANCH'] == 1 ? - "ZEND_VM_SMART_BRANCH_FALSE_JMPZ()" - : ($extra_spec['SMART_BRANCH'] == 2 ? - "ZEND_VM_SMART_BRANCH_FALSE_JMPNZ()" : "ZEND_VM_SMART_BRANCH_FALSE_NONE()")) - : "ZEND_VM_SMART_BRANCH_FALSE()", + "/ZEND_VM_SMART_BRANCH\(\s*([^,)]*)\s*,\s*([^)]*)\s*\)/" => (function () use ($opcode, $extra_spec) { + if (isset($extra_spec['SMART_BRANCH'])) { + if ($extra_spec['SMART_BRANCH'] == 1) { + return "ZEND_VM_SMART_BRANCH_JMPZ(\\1, \\2)"; + } + if ($extra_spec['SMART_BRANCH'] == 2) { + return "ZEND_VM_SMART_BRANCH_JMPNZ(\\1, \\2)"; + } + return "ZEND_VM_SMART_BRANCH_NONE(\\1, \\2)"; + } + + $field = $opcode['quick_op_flags_field'] ?? null; + if ($field) { + return "ZEND_VM_SMART_BRANCH_EX(\\1, \\2, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ($field), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ($field))"; + } + + return "ZEND_VM_SMART_BRANCH(\\1, \\2)"; + })(), + "/ZEND_VM_SMART_BRANCH_TRUE\(\s*\)/" => (function () use ($opcode, $extra_spec) { + if (isset($extra_spec['SMART_BRANCH'])) { + if ($extra_spec['SMART_BRANCH'] == 1) { + return "ZEND_VM_SMART_BRANCH_TRUE_JMPZ()"; + } + if ($extra_spec['SMART_BRANCH'] == 2) { + return "ZEND_VM_SMART_BRANCH_TRUE_JMPNZ()"; + } + return "ZEND_VM_SMART_BRANCH_TRUE_NONE()"; + } + + $field = $opcode['quick_op_flags_field'] ?? null; + if ($field) { + return "ZEND_VM_SMART_BRANCH_TRUE_EX(QUICK_OP_FLAGS_SMART_BRANCH_JMPZ($field), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ($field))"; + } + + return "ZEND_VM_SMART_BRANCH_TRUE()"; + })(), + "/ZEND_VM_SMART_BRANCH_FALSE\(\s*\)/" => (function () use ($opcode, $extra_spec) { + if (isset($extra_spec['SMART_BRANCH'])) { + if ($extra_spec['SMART_BRANCH'] == 1) { + return "ZEND_VM_SMART_BRANCH_FALSE_JMPZ()"; + } + if ($extra_spec['SMART_BRANCH'] == 2) { + return "ZEND_VM_SMART_BRANCH_FALSE_JMPNZ()"; + } + return "ZEND_VM_SMART_BRANCH_FALSE_NONE()"; + } + + $field = $opcode['quick_op_flags_field'] ?? null; + if ($field) { + return "ZEND_VM_SMART_BRANCH_FALSE_EX(QUICK_OP_FLAGS_SMART_BRANCH_JMPZ($field), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ($field))"; + } + + return "ZEND_VM_SMART_BRANCH_FALSE()"; + })(), "/opline->extended_value\s*&\s*ZEND_ISEMPTY/" => isset($extra_spec['ISSET']) ? ($extra_spec['ISSET'] == 0 ? "0" : "1") : "\\0", @@ -781,8 +853,33 @@ function gen_code($f, $spec, $kind, $code, $op1, $op2, $name, $extra_spec=null) "/ZEND_OBSERVER_FCALL_END\(\s*([^,]*)\s*,\s*(.*)\s*\)/" => isset($extra_spec['OBSERVER']) ? ($extra_spec['OBSERVER'] == 0 ? "" : "zend_observer_fcall_end(\\1, \\2)") : "", + "/RT_OP1_TYPE/" => (function () use ($opcode) { + $field = $opcode['quick_op_flags_field'] ?? null; + if (!$field) { + return 'EX_WOP2->op1_type'; + } + return "QUICK_OP_FLAGS_OP1_TYPE($field)"; + })(), + "/RT_OP2_TYPE/" => (function () use ($opcode) { + $field = $opcode['quick_op_flags_field'] ?? null; + if (!$field) { + return 'EX_WOP2->op2_type'; + } + return "QUICK_OP_FLAGS_OP2_TYPE($field)"; + })(), + "/RT_OP_DATA_TYPE/" => (function () use ($opcode) { + $field = $opcode['quick_op_flags_field'] ?? null; + if (!$field) { + return '(EX_WOP2+1)->op1_type'; + } + return "QUICK_OP_FLAGS_OP_DATA_TYPE($field)"; + })(), ); - $code = preg_replace(array_keys($specialized_replacements), array_values($specialized_replacements), $code); + + do { + $prevCode = $code; + $code = preg_replace(array_keys($specialized_replacements), array_values($specialized_replacements), $code); + } while ($prevCode !== $code); if (0 && strpos($code, '{') === 0) { $code = "{\n\tfprintf(stderr, \"$name\\n\");\n" . substr($code, 1); @@ -1052,7 +1149,7 @@ function gen_handler($f, $spec, $kind, $name, $op1, $op2, $use, $code, $lineno, case ZEND_VM_KIND_HYBRID: if (is_inline_hybrid_handler($name, $opcode["hot"], $op1, $op2, $extra_spec)) { $out = fopen('php://memory', 'w+'); - gen_code($out, $spec, $kind, $code, $op1, $op2, $name, $extra_spec); + gen_code($opcode, $out, $spec, $kind, $code, $op1, $op2, $name, $extra_spec); rewind($out); $code = "\t\t\tHYBRID_CASE({$spec_name}):\n" @@ -1113,7 +1210,7 @@ function gen_handler($f, $spec, $kind, $name, $op1, $op2, $use, $code, $lineno, } // Generate opcode handler's code - gen_code($f, $spec, $kind, $code, $op1, $op2, $name, $extra_spec); + gen_code($opcode, $f, $spec, $kind, $code, $op1, $op2, $name, $extra_spec); if ($additional_func) { out($f,"static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL {$spec_name}_HANDLER(ZEND_OPCODE_HANDLER_ARGS)\n"); @@ -1176,7 +1273,7 @@ function gen_helper($f, $spec, $kind, $name, $op1, $op2, $param, $code, $lineno, } // Generate helper's code - gen_code($f, $spec, $kind, $code, $op1, $op2, $name, $extra_spec); + gen_code(null, $f, $spec, $kind, $code, $op1, $op2, $name, $extra_spec); } @@ -1545,7 +1642,7 @@ function gen_null_handler($f) { out($f,"\tUSE_OPLINE\n"); out($f,"\n"); out($f,"\tSAVE_OPLINE();\n"); - out($f,"\tzend_error_noreturn(E_ERROR, \"Invalid opcode %d/%d/%d.\", OPLINE->opcode, OPLINE->op1_type, OPLINE->op2_type);\n"); + out($f,"\tzend_error_noreturn(E_ERROR, \"Invalid opcode %d/%d/%d.\", EX_WOP->opcode, EX_WOP->op1_type, EX_WOP->op2_type);\n"); out($f,"\tZEND_VM_NEXT_OPCODE(); /* Never reached */\n"); out($f,"}\n\n"); } @@ -1750,12 +1847,12 @@ function gen_executor_code($f, $spec, $kind, $prolog, &$switch_labels = array()) break; case ZEND_VM_KIND_SWITCH: out($f,"default: ZEND_NULL_LABEL:\n"); - out($f,"\tzend_error_noreturn(E_ERROR, \"Invalid opcode %d/%d/%d.\", OPLINE->opcode, OPLINE->op1_type, OPLINE->op2_type);\n"); + out($f,"\tzend_error_noreturn(E_ERROR, \"Invalid opcode %d/%d/%d.\", EX_WOP->opcode, EX_WOP->op1_type, EX_WOP->op2_type);\n"); out($f,"\tZEND_VM_NEXT_OPCODE(); /* Never reached */\n"); break; case ZEND_VM_KIND_GOTO: out($f,"ZEND_NULL_LABEL:\n"); - out($f,"\tzend_error_noreturn(E_ERROR, \"Invalid opcode %d/%d/%d.\", OPLINE->opcode, OPLINE->op1_type, OPLINE->op2_type);\n"); + out($f,"\tzend_error_noreturn(E_ERROR, \"Invalid opcode %d/%d/%d.\", EX_WOP->opcode, EX_WOP->op1_type, EX_WOP->op2_type);\n"); out($f,"\tZEND_VM_NEXT_OPCODE(); /* Never reached */\n"); break; case ZEND_VM_KIND_HYBRID: @@ -1818,7 +1915,7 @@ function gen_executor($f, $skl, $spec, $kind, $executor_name, $initializer_name) if ($kind == ZEND_VM_KIND_HYBRID) { out($f,"#if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)\n"); out($f,"static const void * const * zend_opcode_handler_funcs;\n"); - out($f,"static zend_op hybrid_halt_op;\n"); + out($f,"static zend_slim_op hybrid_halt_op;\n"); out($f,"#endif\n"); } out($f,"#if (ZEND_VM_KIND != ZEND_VM_KIND_HYBRID) || !ZEND_VM_SPEC\n"); @@ -1873,7 +1970,7 @@ function gen_executor($f, $skl, $spec, $kind, $executor_name, $initializer_name) out($f,"# define ZEND_OPCODE_HANDLER_ARGS_EX\n"); out($f,"# define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX\n"); out($f,"#else\n"); - out($f,"# define ZEND_OPCODE_HANDLER_ARGS zend_execute_data *execute_data, const zend_op *opline\n"); + out($f,"# define ZEND_OPCODE_HANDLER_ARGS zend_execute_data *execute_data, const zend_slim_op *opline\n"); out($f,"# define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU execute_data, opline\n"); out($f,"# define ZEND_OPCODE_HANDLER_ARGS_EX ZEND_OPCODE_HANDLER_ARGS, \n"); out($f,"# define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX ZEND_OPCODE_HANDLER_ARGS_PASSTHRU, \n"); @@ -1902,10 +1999,10 @@ function gen_executor($f, $skl, $spec, $kind, $executor_name, $initializer_name) out($f,"# define ZEND_VM_COLD ZEND_COLD ZEND_OPT_SIZE\n"); } out($f,"#else\n"); - out($f,"# define ZEND_OPCODE_HANDLER_RET const zend_op *\n"); + out($f,"# define ZEND_OPCODE_HANDLER_RET const zend_slim_op *\n"); out($f,"# define ZEND_VM_TAIL_CALL(call) return call\n"); out($f,"# define ZEND_VM_CONTINUE() return opline\n"); - out($f,"# define ZEND_VM_RETURN() return (const zend_op*)ZEND_VM_ENTER_BIT\n"); + out($f,"# define ZEND_VM_RETURN() return (const zend_slim_op*)ZEND_VM_ENTER_BIT\n"); if ($kind == ZEND_VM_KIND_HYBRID) { out($f,"# define ZEND_VM_HOT\n"); } @@ -1924,7 +2021,7 @@ function gen_executor($f, $skl, $spec, $kind, $executor_name, $initializer_name) out($f,"# define SAVE_OPLINE() EX(opline) = opline\n"); out($f,"# define SAVE_OPLINE_EX() SAVE_OPLINE()\n"); out($f,"#else\n"); - out($f,"# define DCL_OPLINE const zend_op *opline;\n"); + out($f,"# define DCL_OPLINE const zend_slim_op *opline;\n"); out($f,"# define OPLINE opline\n"); out($f,"# define USE_OPLINE\n"); out($f,"# define LOAD_OPLINE() opline = EX(opline)\n"); @@ -1945,16 +2042,16 @@ function gen_executor($f, $skl, $spec, $kind, $executor_name, $initializer_name) out($f,"# define ZEND_VM_LEAVE() return 2\n"); out($f,"#else\n"); out($f,"# define ZEND_VM_ENTER_BIT 1ULL\n"); - out($f,"# define ZEND_VM_ENTER_EX() return (zend_op*)((uintptr_t)opline | ZEND_VM_ENTER_BIT)\n"); + out($f,"# define ZEND_VM_ENTER_EX() return (zend_slim_op*)((uintptr_t)opline | ZEND_VM_ENTER_BIT)\n"); out($f,"# define ZEND_VM_ENTER() execute_data = EG(current_execute_data); LOAD_OPLINE(); ZEND_VM_ENTER_EX()\n"); - out($f,"# define ZEND_VM_LEAVE() return (zend_op*)((uintptr_t)opline | ZEND_VM_ENTER_BIT)\n"); + out($f,"# define ZEND_VM_LEAVE() return (zend_slim_op*)((uintptr_t)opline | ZEND_VM_ENTER_BIT)\n"); out($f,"#endif\n"); out($f,"#define ZEND_VM_INTERRUPT() ZEND_VM_TAIL_CALL(zend_interrupt_helper".($spec?"_SPEC":"")."(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));\n"); out($f,"#define ZEND_VM_LOOP_INTERRUPT() zend_interrupt_helper".($spec?"_SPEC":"")."(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);\n"); if ($kind == ZEND_VM_KIND_HYBRID) { - out($f,"#define ZEND_VM_DISPATCH(opcode, opline) ZEND_VM_TAIL_CALL(((opcode_handler_t)zend_vm_get_opcode_handler_func(opcode, opline))(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));\n"); + out($f,"#define ZEND_VM_DISPATCH(opcode, opline) ZEND_VM_TAIL_CALL(((opcode_handler_t)zend_vm_get_opcode_handler_func(opcode, EX_WOP2))(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));\n"); } else { - out($f,"#define ZEND_VM_DISPATCH(opcode, opline) ZEND_VM_TAIL_CALL(((opcode_handler_t)zend_vm_get_opcode_handler(opcode, opline))(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));\n"); + out($f,"#define ZEND_VM_DISPATCH(opcode, opline) ZEND_VM_TAIL_CALL(((opcode_handler_t)zend_vm_get_opcode_handler(opcode, EX_WOP2)))(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));\n"); } out($f,"\n"); out($f,"static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_interrupt_helper".($spec?"_SPEC":"")."(ZEND_OPCODE_HANDLER_ARGS);\n"); @@ -1965,9 +2062,9 @@ function gen_executor($f, $skl, $spec, $kind, $executor_name, $initializer_name) out($f,"\n"); out($f,"#define OPLINE opline\n"); out($f,"#ifdef ZEND_VM_IP_GLOBAL_REG\n"); - out($f,"# define DCL_OPLINE register const zend_op *opline __asm__(ZEND_VM_IP_GLOBAL_REG);\n"); + out($f,"# define DCL_OPLINE register const zend_slim_op *opline __asm__(ZEND_VM_IP_GLOBAL_REG);\n"); out($f,"#else\n"); - out($f,"# define DCL_OPLINE const zend_op *opline;\n"); + out($f,"# define DCL_OPLINE const zend_slim_op *opline;\n"); out($f,"#endif\n"); out($f,"#define USE_OPLINE\n"); out($f,"#define LOAD_OPLINE() opline = EX(opline)\n"); @@ -1991,9 +2088,9 @@ function gen_executor($f, $skl, $spec, $kind, $executor_name, $initializer_name) out($f,"\n"); out($f,"#define OPLINE opline\n"); out($f,"#ifdef ZEND_VM_IP_GLOBAL_REG\n"); - out($f,"# define DCL_OPLINE register const zend_op *opline __asm__(ZEND_VM_IP_GLOBAL_REG);\n"); + out($f,"# define DCL_OPLINE register const zend_slim_op *opline __asm__(ZEND_VM_IP_GLOBAL_REG);\n"); out($f,"#else\n"); - out($f,"# define DCL_OPLINE const zend_op *opline;\n"); + out($f,"# define DCL_OPLINE const zend_slim_op *opline;\n"); out($f,"#endif\n"); out($f,"#define USE_OPLINE\n"); out($f,"#define LOAD_OPLINE() opline = EX(opline)\n"); @@ -2067,7 +2164,7 @@ function gen_executor($f, $skl, $spec, $kind, $executor_name, $initializer_name) out($f,$m[1]."\tchar hybrid_jit_red_zone[ZEND_VM_HYBRID_JIT_RED_ZONE_SIZE];\n"); out($f,"#endif\n"); out($f,"#ifdef ZEND_VM_IP_GLOBAL_REG\n"); - out($f,$m[1]."\tconst zend_op *orig_opline;\n"); + out($f,$m[1]."\tconst zend_slim_op *orig_opline;\n"); out($f,"#endif\n"); out($f,"#ifdef ZEND_VM_FP_GLOBAL_REG\n"); out($f,$m[1]."\tzend_execute_data *orig_execute_data;\n"); @@ -2176,7 +2273,7 @@ function gen_executor($f, $skl, $spec, $kind, $executor_name, $initializer_name) "# endif\n" . $m[1]."return;\n" . "#else\n" . - $m[1]."opline = (const zend_op*)((uintptr_t)opline & ~ZEND_VM_ENTER_BIT);\n". + $m[1]."opline = (const zend_slim_op*)((uintptr_t)opline & ~ZEND_VM_ENTER_BIT);\n". $m[1]."if (EXPECTED(opline != NULL)) {\n" . $m[1]."\texecute_data = EG(current_execute_data);\n". $m[1]."\tZEND_VM_LOOP_INTERRUPT_CHECK();\n". @@ -2367,7 +2464,7 @@ function gen_vm_opcodes_header( $str .= "\n"; $str .= "BEGIN_EXTERN_C()\n\n"; $str .= "ZEND_API const char* ZEND_FASTCALL zend_get_opcode_name(uint8_t opcode);\n"; - $str .= "ZEND_API uint32_t ZEND_FASTCALL zend_get_opcode_flags(uint8_t opcode);\n"; + $str .= "ZEND_API uint64_t ZEND_FASTCALL zend_get_opcode_flags(uint8_t opcode);\n"; $str .= "ZEND_API uint8_t zend_get_opcode_id(const char *name, size_t length);\n\n"; $str .= "END_EXTERN_C()\n\n"; @@ -2388,6 +2485,102 @@ function gen_vm_opcodes_header( return $str; } +const OP_HAS_OP_DATA = [ + 'ZEND_ASSIGN_DIM', + 'ZEND_ASSIGN_DIM_OP', + 'ZEND_ASSIGN_OBJ', + 'ZEND_ASSIGN_OBJ_OP', + 'ZEND_ASSIGN_OBJ_REF', + 'ZEND_ASSIGN_STATIC_PROP', + 'ZEND_ASSIGN_STATIC_PROP_OP', + 'ZEND_ASSIGN_STATIC_PROP_REF', + 'ZEND_DECLARE_ATTRIBUTED_CONST', + 'ZEND_FRAMELESS_ICALL_3', +]; + +function needs_quick_op_flags($opcode) { + if (isset($opcode['op1']['TMPVARCV']) + || isset($opcode['op1']['ANY']) + || isset($opcode['op2']['TMPVARCV']) + || isset($opcode['op2']['ANY']) + || is_smart_branch($opcode['op']) + /* Always set quick flags for ops with op_data, given that we know at least + * op_data->op2 will always be free. */ + || in_array($opcode['op'], OP_HAS_OP_DATA)) { + return true; + } + return false; +} + +function get_quick_op_flags_field($opcode) { + global $vm_op_flags; + + /* Full list of ops we cannot optimize. Warn when we encounter new ones. */ + $unfree = [ + 'ZEND_CAST', + 'ZEND_CATCH', + 'ZEND_DECLARE_ANON_CLASS', + 'ZEND_FETCH_CLASS_CONSTANT', + 'ZEND_FETCH_STATIC_PROP_FUNC_ARG', + 'ZEND_FETCH_STATIC_PROP_IS', + 'ZEND_FETCH_STATIC_PROP_R', + 'ZEND_FETCH_STATIC_PROP_RW', + 'ZEND_FETCH_STATIC_PROP_UNSET', + 'ZEND_FETCH_STATIC_PROP_W', + 'ZEND_FE_FETCH_R', + 'ZEND_FE_FETCH_RW', + 'ZEND_FRAMELESS_ICALL_2', + 'ZEND_INCLUDE_OR_EVAL', + 'ZEND_INIT_DYNAMIC_CALL', + 'ZEND_INIT_FCALL', + 'ZEND_INIT_FCALL_BY_NAME', + 'ZEND_INIT_NS_FCALL_BY_NAME', + 'ZEND_INSTANCEOF', + 'ZEND_IN_ARRAY', + 'ZEND_ISSET_ISEMPTY_DIM_OBJ', + 'ZEND_ISSET_ISEMPTY_PROP_OBJ', + 'ZEND_ISSET_ISEMPTY_STATIC_PROP', + 'ZEND_POST_DEC_STATIC_PROP', + 'ZEND_POST_INC_STATIC_PROP', + 'ZEND_PRE_DEC_STATIC_PROP', + 'ZEND_PRE_INC_STATIC_PROP', + 'ZEND_RETURN_BY_REF', + 'ZEND_TICKS', + ]; + + $has_free_result = [ + 'ZEND_BIND_STATIC', + 'ZEND_JMP_FRAMELESS', + 'ZEND_MATCH', + 'ZEND_SEND_ARRAY', + 'ZEND_SWITCH_LONG', + 'ZEND_SWITCH_STRING', + 'ZEND_UNSET_STATIC_PROP', + ]; + + if (!($opcode['flags'] & ZEND_VM_EXT_FULL_MASK)) { + return 'opline->extended_value'; + } + if ($opcode['op1'] === ['UNUSED' => 0]) { + return 'opline->op1.num'; + } + if ($opcode['op2'] === ['UNUSED' => 0]) { + return 'opline->op2.num'; + } + if (in_array($opcode['op'], $has_free_result)) { + return 'opline->result.num'; + } + if (in_array($opcode['op'], OP_HAS_OP_DATA)) { + return '(opline+1)->op2.num'; + } + + if (!in_array($opcode['op'], $unfree)) { + echo "Warning: {$opcode['op']} does not have a free field for quick op flags\n"; + } + + return null; +} + function gen_vm($def, $skel) { global $definition_file, $skeleton_file, $executor_file, $op_types, $list, $opcodes, $helpers, $params, $opnames, @@ -2483,6 +2676,31 @@ function gen_vm($def, $skel) { $opcodes[$code]["flags"] |= $vm_op_flags["ZEND_VM_COMMUTATIVE"]; } } + if (needs_quick_op_flags($opcodes[$code])) { + $quick_op_flags_field = get_quick_op_flags_field($opcodes[$code]); + $opcodes[$code]['quick_op_flags_field'] = $quick_op_flags_field; + if ($quick_op_flags_field) { + switch ($quick_op_flags_field) { + case 'opline->extended_value': + $opcodes[$code]["flags"] |= $vm_op_flags["ZEND_VM_QUICK_OP_FLAGS_FIELD_EXT_VALUE"]; + break; + case 'opline->op1.num': + $opcodes[$code]["flags"] |= $vm_op_flags["ZEND_VM_QUICK_OP_FLAGS_FIELD_OP1"]; + break; + case 'opline->op2.num': + $opcodes[$code]["flags"] |= $vm_op_flags["ZEND_VM_QUICK_OP_FLAGS_FIELD_OP2"]; + break; + case 'opline->result.num': + $opcodes[$code]["flags"] |= $vm_op_flags["ZEND_VM_QUICK_OP_FLAGS_FIELD_RESULT"]; + break; + case '(opline+1)->op2.num': + $opcodes[$code]["flags"] |= $vm_op_flags["ZEND_VM_QUICK_OP_FLAGS_FIELD_OP_DATA_OP2"]; + break; + default: + die("ERROR ($def:$lineno): Unknown field $quick_op_flags_field.\n"); + } + } + } $opnames[$op] = $code; $handler = $code; $helper = null; @@ -2514,6 +2732,7 @@ function gen_vm($def, $skel) { $hot = !empty($m[1]) ? $m[1] : false; $orig_op_list = $m[2]; $code = $extra_num++; + $quick_op_flags_field = null; foreach (explode('|', $orig_op_list) as $orig_op) { if (!isset($opnames[$orig_op])) { die("ERROR ($def:$lineno): Opcode with name '$orig_op' is not defined.\n"); @@ -2521,6 +2740,12 @@ function gen_vm($def, $skel) { $orig_code = $opnames[$orig_op]; $condition = $m[3]; $opcodes[$orig_code]['type_spec'][$code] = $condition; + if (isset($opcodes[$orig_code]['quick_op_flags_field'])) { + if ($quick_op_flags_field && $quick_op_flags_field !== $opcodes[$orig_code]['quick_op_flags_field']) { + die("ERROR ($def:$lineno): Conflicting quick op flags field ($quick_op_flags_field vs. {$opcodes[$orig_code]['quick_op_flags_field']}).\n"); + } + $quick_op_flags_field = $opcodes[$orig_code]['quick_op_flags_field']; + } } $op = $m[4]; $op1 = parse_operand_spec($def, $lineno, $m[5], $flags1); @@ -2534,7 +2759,7 @@ function gen_vm($def, $skel) { die("ERROR ($def:$lineno): Opcode with name '$code' is already defined.\n"); } $used_extra_spec["TYPE"] = 1; - $opcodes[$code] = array("op"=>$op,"op1"=>$op1,"op2"=>$op2,"code"=>"","flags"=>$flags,"hot"=>$hot,"is_type_spec"=>true); + $opcodes[$code] = array("op"=>$op,"op1"=>$op1,"op2"=>$op2,"code"=>"","flags"=>$flags,"hot"=>$hot,"is_type_spec"=>true,"quick_op_flags_field"=>$quick_op_flags_field); if (isset($m[10])) { $opcodes[$code]["spec"] = parse_spec_rules($def, $lineno, $m[10]); if (isset($opcodes[$code]["spec"]["NO_CONST_CONST"])) { @@ -2679,7 +2904,7 @@ function gen_vm($def, $skel) { } fputs($f, "};\n\n"); - fputs($f,"static uint32_t zend_vm_opcodes_flags[".($max_opcode + 1)."] = {\n"); + fputs($f,"static uint64_t zend_vm_opcodes_flags[".($max_opcode + 1)."] = {\n"); for ($i = 0; $i <= $max_opcode; $i++) { fprintf($f, "\t0x%08x,\n", isset($opcodes[$i]["flags"]) ? $opcodes[$i]["flags"] : 0); } @@ -2692,7 +2917,7 @@ function gen_vm($def, $skel) { fputs($f, "\treturn zend_vm_opcodes_names[opcode];\n"); fputs($f, "}\n"); - fputs($f, "ZEND_API uint32_t ZEND_FASTCALL zend_get_opcode_flags(uint8_t opcode) {\n"); + fputs($f, "ZEND_API uint64_t ZEND_FASTCALL zend_get_opcode_flags(uint8_t opcode) {\n"); fputs($f, "\tif (UNEXPECTED(opcode > ZEND_VM_LAST_OPCODE)) {\n"); fputs($f, "\t\topcode = ZEND_NOP;\n"); fputs($f, "\t}\n"); @@ -2972,7 +3197,7 @@ function gen_vm($def, $skel) { out($f, "\tDCL_OPLINE;\n"); out($f, "\tint ret;\n"); out($f, "#ifdef ZEND_VM_IP_GLOBAL_REG\n"); - out($f, "\tconst zend_op *orig_opline = opline;\n"); + out($f, "\tconst zend_slim_op *orig_opline = opline;\n"); out($f, "#endif\n"); out($f, "#ifdef ZEND_VM_FP_GLOBAL_REG\n"); out($f, "\tzend_execute_data *orig_execute_data = execute_data;\n"); @@ -2985,7 +3210,8 @@ function gen_vm($def, $skel) { out($f,"#if defined(ZEND_VM_FP_GLOBAL_REG) && defined(ZEND_VM_IP_GLOBAL_REG)\n"); if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID) { out($f,"#if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)\n"); - out($f, "\thandler = (opcode_handler_t)zend_vm_get_opcode_handler_func(zend_user_opcodes[opline->opcode], opline);\n"); + out($f, "\tzend_op *wide_op = EX_WOP2;\n"); + out($f, "\thandler = (opcode_handler_t)zend_vm_get_opcode_handler_func(zend_user_opcodes[wide_op->opcode], wide_op);\n"); out($f, "\thandler(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);\n"); out($f, "\tif (EXPECTED(opline != &hybrid_halt_op)) {\n"); out($f,"#else\n"); @@ -3006,7 +3232,7 @@ function gen_vm($def, $skel) { out($f, "\topline = ((opcode_handler_t)OPLINE->handler)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);\n"); out($f, "if (UNEXPECTED(((uintptr_t)opline & ZEND_VM_ENTER_BIT))) {\n"); - out($f, "\t\topline = (const zend_op*)((uintptr_t)opline & ~ZEND_VM_ENTER_BIT);\n"); + out($f, "\t\topline = (const zend_slim_op*)((uintptr_t)opline & ~ZEND_VM_ENTER_BIT);\n"); out($f, "\t\tif (EXPECTED(opline)) {\n"); out($f, "\t\t\t/* ZEND_VM_ENTER() or ZEND_VM_LEAVE() */\n"); out($f, "\t\t\tret = EG(current_execute_data) != ex ? (int)(EG(current_execute_data)->prev_execute_data != ex) + 1 : 0;\n"); diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c index e190e341735b0..172790e442f82 100644 --- a/Zend/zend_vm_opcodes.c +++ b/Zend/zend_vm_opcodes.c @@ -236,85 +236,85 @@ static const char *zend_vm_opcodes_names[211] = { "ZEND_DECLARE_ATTRIBUTED_CONST", }; -static uint32_t zend_vm_opcodes_flags[211] = { - 0x00000000, - 0x00000b0b, - 0x00000b0b, - 0x80000b0b, +static uint64_t zend_vm_opcodes_flags[211] = { + 0x100000000, + 0x100000b0b, + 0x100000b0b, + 0x180000b0b, 0x00000707, - 0x00000b0b, - 0x00000b0b, - 0x00000b0b, + 0x100000b0b, + 0x100000b0b, + 0x100000b0b, 0x40000707, - 0x80000b0b, - 0x80000b0b, - 0x80000b0b, + 0x180000b0b, + 0x180000b0b, + 0x180000b0b, 0x00000707, - 0x0000010b, + 0x10000010b, 0x00000107, 0x80000707, - 0x80000303, - 0x80000303, - 0x80000707, - 0x80000707, - 0x00000b0b, - 0x00000b0b, + 0x180000303, + 0x180000303, + 0x180000707, + 0x180000707, + 0x100000b0b, + 0x100000b0b, 0x00000301, - 0x00006701, - 0x00040751, - 0x00040000, + 0x100006701, + 0x500040751, + 0x500040000, 0x04000701, - 0x04006701, - 0x04000751, - 0x04000000, + 0x504006701, + 0x504000751, + 0x504000000, 0x0b000101, - 0x00000003, - 0x0b040751, - 0x0b040000, - 0x00000001, - 0x00000001, - 0x00000001, - 0x00000001, + 0x100000003, + 0x50b040751, + 0x50b040000, + 0x100000001, + 0x100000001, + 0x100000001, + 0x100000001, 0x00040000, 0x00040000, 0x00040000, 0x00040000, - 0x00000020, - 0x00002007, - 0x00002007, + 0x100000020, + 0x100002007, + 0x100002007, 0x00000000, - 0x00002007, - 0x00002007, - 0x00000705, + 0x100002007, + 0x100002007, + 0x100000705, 0x00000101, 0x00001301, 0x07000003, - 0x00000007, + 0x100000007, 0x00000707, 0x01000701, 0x01000701, 0x01000701, - 0x00000000, - 0x00000001, + 0x100000000, + 0x100000001, 0x01040300, - 0x00000000, + 0x100000000, 0x01040310, - 0x00000003, - 0x00000110, - 0x00000310, + 0x100000003, + 0x100000110, + 0x100000310, 0x00001307, 0x00001301, 0x00001301, 0x0100a173, 0x01040300, - 0x00000005, + 0x100000005, 0x00186703, 0x00106703, 0x08000007, 0x00010107, 0x00000701, 0x00040751, - 0x00002003, + 0x100002003, 0x03000001, 0x00000000, 0x00010107, @@ -335,78 +335,78 @@ static uint32_t zend_vm_opcodes_flags[211] = { 0x00010107, 0x00000701, 0x00040751, - 0x0000070b, + 0x10000070b, 0x00040391, 0x00001301, - 0x00000000, - 0x00000000, - 0x00000000, - 0x00000000, + 0x100000000, + 0x100000000, + 0x100000000, + 0x100000000, 0x01000000, 0x00001301, 0x02042003, - 0x00000007, + 0x100000007, 0x00040771, - 0x00000057, + 0x100000057, 0x0b000003, 0x01040757, 0x01048773, - 0x00030107, + 0x300030107, 0x00020707, 0x00001303, 0x00001301, 0x01000703, - 0x01000000, - 0x00001003, - 0x00000007, - 0x00040103, - 0x09000107, + 0x401000000, + 0x100001003, + 0x100000007, + 0x300040103, + 0x309000107, 0x00000103, - 0x00002003, + 0x100002003, 0x03000001, - 0x00000005, + 0x100000005, 0x01000700, - 0x00000000, - 0x00000000, - 0x00000000, + 0x100000000, + 0x100000000, + 0x100000000, 0x00040751, 0x00040751, 0x00040751, 0x00040751, - 0x00000007, + 0x100000007, 0x00000000, 0x00047305, - 0x00000000, + 0x100000000, 0x00000101, - 0x00001000, - 0x00001003, + 0x100001000, + 0x100001003, 0x00000303, - 0x00000003, + 0x100000003, 0x00000303, 0x00040000, - 0x00000000, + 0x100000000, 0x00060757, - 0x00000000, - 0x00000000, - 0x00002000, - 0x00002003, + 0x100000000, + 0x100000000, + 0x100002000, + 0x100002003, 0x00000101, - 0x00020101, + 0x300020101, 0x00000701, 0x00000101, - 0x00000075, - 0x00000000, - 0x00000000, + 0x100000075, + 0x100000000, + 0x100000000, 0x0b000703, - 0x00000003, - 0x00000020, - 0x00003000, - 0x00000110, - 0x00000000, - 0x00000007, + 0x100000003, + 0x100000020, + 0x100003000, + 0x100000110, + 0x100000000, + 0x100000007, 0x00000105, 0x00040301, - 0x00002003, + 0x100002003, 0x00000707, 0x00000101, 0x00000103, @@ -416,38 +416,38 @@ static uint32_t zend_vm_opcodes_flags[211] = { 0x00047000, 0x00247000, 0x00047000, - 0x00040000, + 0x400040000, 0x00067000, 0x00040b73, 0x00100101, - 0x00100001, + 0x400100001, 0x00000101, 0x00001301, 0x00000101, - 0x0300030b, - 0x0300030b, + 0x40300030b, + 0x40300030b, 0x01000303, 0x00000107, 0x00000107, 0x00000101, 0x00000103, - 0x00000707, - 0x0300030b, - 0x00000301, - 0x0000010b, - 0x00002003, + 0x100000707, + 0x40300030b, + 0x100000301, + 0x10000010b, + 0x100002003, 0x00000101, 0x00000101, 0x00000101, 0x00000101, - 0x00002001, + 0x100002001, 0x01000101, - 0x01000100, - 0x01000000, + 0x301000100, 0x01000000, - 0x01042003, + 0x501000000, + 0x401042003, 0x01001103, - 0x00000303, + 0x100000303, }; ZEND_API const char* ZEND_FASTCALL zend_get_opcode_name(uint8_t opcode) { @@ -456,7 +456,7 @@ ZEND_API const char* ZEND_FASTCALL zend_get_opcode_name(uint8_t opcode) { } return zend_vm_opcodes_names[opcode]; } -ZEND_API uint32_t ZEND_FASTCALL zend_get_opcode_flags(uint8_t opcode) { +ZEND_API uint64_t ZEND_FASTCALL zend_get_opcode_flags(uint8_t opcode) { if (UNEXPECTED(opcode > ZEND_VM_LAST_OPCODE)) { opcode = ZEND_NOP; } diff --git a/Zend/zend_vm_opcodes.h b/Zend/zend_vm_opcodes.h index 29469bb5f7dca..85ea563d0c45d 100644 --- a/Zend/zend_vm_opcodes.h +++ b/Zend/zend_vm_opcodes.h @@ -56,6 +56,7 @@ #define ZEND_VM_OP_CONSTRUCTOR 0x00000080 #define ZEND_VM_OP_CONST_FETCH 0x00000090 #define ZEND_VM_OP_CACHE_SLOT 0x000000a0 +#define ZEND_VM_EXT_FULL_MASK 0x0fff0000 #define ZEND_VM_EXT_VAR_FETCH 0x00010000 #define ZEND_VM_EXT_ISSET 0x00020000 #define ZEND_VM_EXT_CACHE_SLOT 0x00040000 @@ -74,13 +75,20 @@ #define ZEND_VM_EXT_SRC 0x0b000000 #define ZEND_VM_NO_CONST_CONST 0x40000000 #define ZEND_VM_COMMUTATIVE 0x80000000 +#define ZEND_VM_QUICK_OP_FLAGS_FIELD_NONE 0x00000000 +#define ZEND_VM_QUICK_OP_FLAGS_FIELD_EXT_VALUE 0x100000000 +#define ZEND_VM_QUICK_OP_FLAGS_FIELD_OP1 0x200000000 +#define ZEND_VM_QUICK_OP_FLAGS_FIELD_OP2 0x300000000 +#define ZEND_VM_QUICK_OP_FLAGS_FIELD_RESULT 0x400000000 +#define ZEND_VM_QUICK_OP_FLAGS_FIELD_OP_DATA_OP2 0x500000000 +#define ZEND_VM_QUICK_OP_FLAGS_FIELD_MASK 0x700000000 #define ZEND_VM_OP1_FLAGS(flags) (flags & 0xff) #define ZEND_VM_OP2_FLAGS(flags) ((flags >> 8) & 0xff) BEGIN_EXTERN_C() ZEND_API const char* ZEND_FASTCALL zend_get_opcode_name(uint8_t opcode); -ZEND_API uint32_t ZEND_FASTCALL zend_get_opcode_flags(uint8_t opcode); +ZEND_API uint64_t ZEND_FASTCALL zend_get_opcode_flags(uint8_t opcode); ZEND_API uint8_t zend_get_opcode_id(const char *name, size_t length); END_EXTERN_C() diff --git a/ext/opcache/ZendAccelerator.c b/ext/opcache/ZendAccelerator.c index a2b2d0fde8b42..de77c66f5998d 100644 --- a/ext/opcache/ZendAccelerator.c +++ b/ext/opcache/ZendAccelerator.c @@ -1939,7 +1939,7 @@ static zend_op_array *file_cache_compile_file(zend_file_handle *file_handle, int if (!EG(current_execute_data) || !EG(current_execute_data)->opline || !EG(current_execute_data)->func || !ZEND_USER_CODE(EG(current_execute_data)->func->common.type) || - EG(current_execute_data)->opline->opcode != ZEND_INCLUDE_OR_EVAL || + Z_WOP->opcode != ZEND_INCLUDE_OR_EVAL || (EG(current_execute_data)->opline->extended_value != ZEND_INCLUDE_ONCE && EG(current_execute_data)->opline->extended_value != ZEND_REQUIRE_ONCE)) { if (zend_hash_add_empty_element(&EG(included_files), persistent_script->script.filename) != NULL) { @@ -2037,7 +2037,7 @@ zend_op_array *persistent_compile_file(zend_file_handle *file_handle, int type) (EG(current_execute_data) && EG(current_execute_data)->func && ZEND_USER_CODE(EG(current_execute_data)->func->common.type) && - ZCG(cache_opline) == EG(current_execute_data)->opline))) { + ZCG(cache_opline) == Z_WOP))) { persistent_script = ZCG(cache_persistent_script); if (ZSTR_LEN(ZCG(key))) { @@ -2225,7 +2225,7 @@ zend_op_array *persistent_compile_file(zend_file_handle *file_handle, int type) !EG(current_execute_data)->func || !ZEND_USER_CODE(EG(current_execute_data)->func->common.type) || !EG(current_execute_data)->opline || - EG(current_execute_data)->opline->opcode != ZEND_INCLUDE_OR_EVAL || + Z_WOP->opcode != ZEND_INCLUDE_OR_EVAL || (EG(current_execute_data)->opline->extended_value != ZEND_INCLUDE_ONCE && EG(current_execute_data)->opline->extended_value != ZEND_REQUIRE_ONCE)) { if (zend_hash_add_empty_element(&EG(included_files), persistent_script->script.filename) != NULL) { @@ -2524,7 +2524,7 @@ static zend_result persistent_stream_open_function(zend_file_handle *handle) (EG(current_execute_data) && EG(current_execute_data)->func && ZEND_USER_CODE(EG(current_execute_data)->func->common.type) && - ZCG(cache_opline) == EG(current_execute_data)->opline)) { + ZCG(cache_opline) == Z_WOP)) { /* we are in include_once or FastCGI request */ handle->opened_path = zend_string_copy(ZCG(cache_persistent_script)->script.filename); @@ -2547,7 +2547,7 @@ static zend_string* persistent_zend_resolve_path(zend_string *filename) (EG(current_execute_data) && EG(current_execute_data)->func && ZEND_USER_CODE(EG(current_execute_data)->func->common.type) && - EG(current_execute_data)->opline->opcode == ZEND_INCLUDE_OR_EVAL && + Z_WOP->opcode == ZEND_INCLUDE_OR_EVAL && (EG(current_execute_data)->opline->extended_value == ZEND_INCLUDE_ONCE || EG(current_execute_data)->opline->extended_value == ZEND_REQUIRE_ONCE))) { @@ -2563,7 +2563,7 @@ static zend_string* persistent_zend_resolve_path(zend_string *filename) if (bucket != NULL) { zend_persistent_script *persistent_script = (zend_persistent_script *)bucket->data; if (!persistent_script->corrupted) { - ZCG(cache_opline) = EG(current_execute_data) ? EG(current_execute_data)->opline : NULL; + ZCG(cache_opline) = EG(current_execute_data) ? Z_WOP : NULL; ZCG(cache_persistent_script) = persistent_script; return zend_string_copy(persistent_script->script.filename); } @@ -2596,7 +2596,7 @@ static zend_string* persistent_zend_resolve_path(zend_string *filename) } else { ZSTR_LEN(ZCG(key)) = 0; } - ZCG(cache_opline) = EG(current_execute_data) ? EG(current_execute_data)->opline : NULL; + ZCG(cache_opline) = EG(current_execute_data) ? Z_WOP : NULL; ZCG(cache_persistent_script) = persistent_script; return resolved_path; } @@ -4691,20 +4691,12 @@ static zend_result accel_preload(const char *config, bool in_child) /* Store all functions and classes in a single pseudo-file */ CG(compiled_filename) = ZSTR_INIT_LITERAL("$PRELOAD$", 0); -#if ZEND_USE_ABS_CONST_ADDR - init_op_array(&script->script.main_op_array, ZEND_USER_FUNCTION, 1); -#else init_op_array(&script->script.main_op_array, ZEND_USER_FUNCTION, 2); -#endif script->script.main_op_array.fn_flags |= ZEND_ACC_DONE_PASS_TWO; script->script.main_op_array.last = 1; script->script.main_op_array.last_literal = 1; script->script.main_op_array.T = ZEND_OBSERVER_ENABLED; -#if ZEND_USE_ABS_CONST_ADDR - script->script.main_op_array.literals = (zval*)emalloc(sizeof(zval)); -#else script->script.main_op_array.literals = (zval*)(script->script.main_op_array.opcodes + 1); -#endif ZVAL_NULL(script->script.main_op_array.literals); memset(script->script.main_op_array.opcodes, 0, sizeof(zend_op)); script->script.main_op_array.opcodes[0].opcode = ZEND_RETURN; diff --git a/ext/opcache/jit/zend_jit_internal.h b/ext/opcache/jit/zend_jit_internal.h index 3623689f05aae..352cf1f1b29f2 100644 --- a/ext/opcache/jit/zend_jit_internal.h +++ b/ext/opcache/jit/zend_jit_internal.h @@ -71,17 +71,10 @@ typedef uintptr_t zend_jit_addr; (jit->ra[Z_SSA_VAR(addr)].flags & ZREG_LOAD) : \ 0) -#if ZEND_USE_ABS_CONST_ADDR -# define OP_ADDR(opline, type, op) \ - (((opline)->type == IS_CONST) ? \ - ZEND_ADDR_CONST_ZVAL((opline)->op.zv) : \ - ZEND_ADDR_MEM_ZVAL(ZREG_FP, (opline)->op.var)) -#else # define OP_ADDR(opline, type, op) \ (((opline)->type == IS_CONST) ? \ ZEND_ADDR_CONST_ZVAL(RT_CONSTANT(opline, (opline)->op)) : \ ZEND_ADDR_MEM_ZVAL(ZREG_FP, (opline)->op.var)) -#endif #define OP_REG_ADDR(opline, ssa_op, type, op, _ssa_op) \ ((ctx.ra && (ssa_op)->_ssa_op >= 0 && ctx.ra[(ssa_op)->_ssa_op].ref) ? \ diff --git a/ext/opcache/jit/zend_jit_vm_helpers.c b/ext/opcache/jit/zend_jit_vm_helpers.c index 4348fbd53ad48..c223d07a66447 100644 --- a/ext/opcache/jit/zend_jit_vm_helpers.c +++ b/ext/opcache/jit/zend_jit_vm_helpers.c @@ -35,13 +35,13 @@ # pragma GCC diagnostic ignored "-Wvolatile-register-var" # if defined(__x86_64__) register zend_execute_data* volatile execute_data __asm__("%r14"); -register const zend_op* volatile opline __asm__("%r15"); +register const zend_slim_op* volatile opline __asm__("%r15"); # elif defined(i386) register zend_execute_data* volatile execute_data __asm__("%esi"); -register const zend_op* volatile opline __asm__("%edi"); +register const zend_slim_op* volatile opline __asm__("%edi"); # elif defined(__aarch64__) register zend_execute_data* volatile execute_data __asm__("x27"); -register const zend_op* volatile opline __asm__("x28"); +register const zend_slim_op* volatile opline __asm__("x28"); # endif # pragma GCC diagnostic warning "-Wvolatile-register-var" #endif diff --git a/ext/opcache/zend_file_cache.c b/ext/opcache/zend_file_cache.c index fee90e42b574f..68457d368fa53 100644 --- a/ext/opcache/zend_file_cache.c +++ b/ext/opcache/zend_file_cache.c @@ -508,6 +508,7 @@ static void zend_file_cache_serialize_op_array(zend_op_array *op_arra SERIALIZE_PTR(op_array->static_variables); SERIALIZE_PTR(op_array->literals); SERIALIZE_PTR(op_array->opcodes); + SERIALIZE_PTR(op_array->slim_opcodes); SERIALIZE_PTR(op_array->arg_info); SERIALIZE_PTR(op_array->vars); SERIALIZE_STR(op_array->function_name); @@ -549,12 +550,11 @@ static void zend_file_cache_serialize_op_array(zend_op_array *op_arra { zend_op *opline, *end; -#if !ZEND_USE_ABS_CONST_ADDR zval *literals = op_array->literals; UNSERIALIZE_PTR(literals); -#endif SERIALIZE_PTR(op_array->opcodes); + SERIALIZE_PTR(op_array->slim_opcodes); opline = op_array->opcodes; UNSERIALIZE_PTR(opline); end = opline + op_array->last; @@ -565,56 +565,6 @@ static void zend_file_cache_serialize_op_array(zend_op_array *op_arra zval *literal = RT_CONSTANT(opline, opline->op1); SERIALIZE_ATTRIBUTES(Z_PTR_P(literal)); } - -#if ZEND_USE_ABS_CONST_ADDR - if (opline->op1_type == IS_CONST) { - SERIALIZE_PTR(opline->op1.zv); - } - if (opline->op2_type == IS_CONST) { - SERIALIZE_PTR(opline->op2.zv); - } -#else - if (opline->op1_type == IS_CONST) { - opline->op1.constant = RT_CONSTANT(opline, opline->op1) - literals; - } - if (opline->op2_type == IS_CONST) { - opline->op2.constant = RT_CONSTANT(opline, opline->op2) - literals; - } -#endif -#if ZEND_USE_ABS_JMP_ADDR - switch (opline->opcode) { - case ZEND_JMP: - case ZEND_FAST_CALL: - SERIALIZE_PTR(opline->op1.jmp_addr); - break; - case ZEND_JMPZ: - case ZEND_JMPNZ: - case ZEND_JMPZ_EX: - case ZEND_JMPNZ_EX: - case ZEND_JMP_SET: - case ZEND_COALESCE: - case ZEND_FE_RESET_R: - case ZEND_FE_RESET_RW: - case ZEND_ASSERT_CHECK: - case ZEND_JMP_NULL: - case ZEND_BIND_INIT_STATIC_OR_JMP: - case ZEND_JMP_FRAMELESS: - SERIALIZE_PTR(opline->op2.jmp_addr); - break; - case ZEND_CATCH: - if (!(opline->extended_value & ZEND_LAST_CATCH)) { - SERIALIZE_PTR(opline->op2.jmp_addr); - } - break; - case ZEND_FE_FETCH_R: - case ZEND_FE_FETCH_RW: - case ZEND_SWITCH_LONG: - case ZEND_SWITCH_STRING: - case ZEND_MATCH: - /* relative extended_value don't have to be changed */ - break; - } -#endif zend_serialize_opcode_handler(opline); opline++; } @@ -1415,6 +1365,7 @@ static void zend_file_cache_unserialize_op_array(zend_op_array *op_arr UNSERIALIZE_PTR(op_array->static_variables); UNSERIALIZE_PTR(op_array->literals); UNSERIALIZE_PTR(op_array->opcodes); + UNSERIALIZE_PTR(op_array->slim_opcodes); UNSERIALIZE_PTR(op_array->arg_info); UNSERIALIZE_PTR(op_array->vars); UNSERIALIZE_STR(op_array->function_name); @@ -1454,58 +1405,10 @@ static void zend_file_cache_unserialize_op_array(zend_op_array *op_arr zend_op *opline, *end; UNSERIALIZE_PTR(op_array->opcodes); + UNSERIALIZE_PTR(op_array->slim_opcodes); opline = op_array->opcodes; end = opline + op_array->last; while (opline < end) { -#if ZEND_USE_ABS_CONST_ADDR - if (opline->op1_type == IS_CONST) { - UNSERIALIZE_PTR(opline->op1.zv); - } - if (opline->op2_type == IS_CONST) { - UNSERIALIZE_PTR(opline->op2.zv); - } -#else - if (opline->op1_type == IS_CONST) { - ZEND_PASS_TWO_UPDATE_CONSTANT(op_array, opline, opline->op1); - } - if (opline->op2_type == IS_CONST) { - ZEND_PASS_TWO_UPDATE_CONSTANT(op_array, opline, opline->op2); - } -#endif -#if ZEND_USE_ABS_JMP_ADDR - switch (opline->opcode) { - case ZEND_JMP: - case ZEND_FAST_CALL: - UNSERIALIZE_PTR(opline->op1.jmp_addr); - break; - case ZEND_JMPZ: - case ZEND_JMPNZ: - case ZEND_JMPZ_EX: - case ZEND_JMPNZ_EX: - case ZEND_JMP_SET: - case ZEND_COALESCE: - case ZEND_FE_RESET_R: - case ZEND_FE_RESET_RW: - case ZEND_ASSERT_CHECK: - case ZEND_JMP_NULL: - case ZEND_BIND_INIT_STATIC_OR_JMP: - case ZEND_JMP_FRAMELESS: - UNSERIALIZE_PTR(opline->op2.jmp_addr); - break; - case ZEND_CATCH: - if (!(opline->extended_value & ZEND_LAST_CATCH)) { - UNSERIALIZE_PTR(opline->op2.jmp_addr); - } - break; - case ZEND_FE_FETCH_R: - case ZEND_FE_FETCH_RW: - case ZEND_SWITCH_LONG: - case ZEND_SWITCH_STRING: - /* relative extended_value don't have to be changed */ - break; - } -#endif - if (opline->opcode == ZEND_OP_DATA && (opline-1)->opcode == ZEND_DECLARE_ATTRIBUTED_CONST ) { diff --git a/ext/opcache/zend_persist.c b/ext/opcache/zend_persist.c index 202cd73c90422..97c3847511569 100644 --- a/ext/opcache/zend_persist.c +++ b/ext/opcache/zend_persist.c @@ -437,6 +437,8 @@ static void zend_persist_op_array_ex(zend_op_array *op_array, zend_persistent_sc persist_ptr = zend_shared_alloc_get_xlat_entry(op_array->opcodes); if (persist_ptr) { op_array->opcodes = persist_ptr; + op_array->slim_opcodes = zend_shared_alloc_get_xlat_entry(op_array->slim_opcodes); + ZEND_ASSERT(op_array->slim_opcodes != NULL); if (op_array->static_variables) { op_array->static_variables = zend_shared_alloc_get_xlat_entry(op_array->static_variables); ZEND_ASSERT(op_array->static_variables != NULL); @@ -519,101 +521,49 @@ static void zend_persist_op_array_ex(zend_op_array *op_array, zend_persistent_sc GC_TYPE_INFO(op_array->static_variables) = GC_ARRAY | ((IS_ARRAY_IMMUTABLE|GC_NOT_COLLECTABLE) << GC_FLAGS_SHIFT); } - if (op_array->literals) { - zval *p, *end; + { + zend_op *new_opcodes = zend_shared_memdup_put(op_array->opcodes, ZEND_MM_ALIGNED_SIZE_EX(sizeof(zend_op) * op_array->last, 16)); + zend_slim_op *new_slim_opcodes = zend_shared_memdup_put(op_array->slim_opcodes, ZEND_MM_ALIGNED_SIZE_EX(sizeof(zend_slim_op) * op_array->last, 16)); + + if (op_array->literals) { + zval *p, *end; + + orig_literals = op_array->literals; + p = zend_shared_memdup_put(op_array->literals, sizeof(zval) * op_array->last_literal); + end = p + op_array->last_literal; + op_array->literals = p; + while (p < end) { + zend_persist_zval(p); + p++; + } - orig_literals = op_array->literals; -#if ZEND_USE_ABS_CONST_ADDR - p = zend_shared_memdup_put_free(op_array->literals, sizeof(zval) * op_array->last_literal); -#else - p = zend_shared_memdup_put(op_array->literals, sizeof(zval) * op_array->last_literal); -#endif - end = p + op_array->last_literal; - op_array->literals = p; - while (p < end) { - zend_persist_zval(p); - p++; + /* Make sure distance between literals + ops stay the same. */ + ZEND_ASSERT((uintptr_t)orig_literals - (uintptr_t)op_array->opcodes == (uintptr_t)op_array->literals - (uintptr_t)new_opcodes); + ZEND_ASSERT((uintptr_t)orig_literals - (uintptr_t)op_array->slim_opcodes == (uintptr_t)op_array->literals - (uintptr_t)new_slim_opcodes); } - } - { - zend_op *new_opcodes = zend_shared_memdup_put(op_array->opcodes, sizeof(zend_op) * op_array->last); zend_op *opline = new_opcodes; + zend_slim_op *slim_op = new_slim_opcodes; zend_op *end = new_opcodes + op_array->last; int offset = 0; - for (; opline < end ; opline++, offset++) { -#if ZEND_USE_ABS_CONST_ADDR - if (opline->op1_type == IS_CONST) { - opline->op1.zv = (zval*)((char*)opline->op1.zv + ((char*)op_array->literals - (char*)orig_literals)); - if (opline->opcode == ZEND_SEND_VAL - || opline->opcode == ZEND_SEND_VAL_EX - || opline->opcode == ZEND_QM_ASSIGN) { - /* Update handlers to eliminate REFCOUNTED check */ - zend_vm_set_opcode_handler_ex(opline, 1 << Z_TYPE_P(opline->op1.zv), 0, 0); - } - } - if (opline->op2_type == IS_CONST) { - opline->op2.zv = (zval*)((char*)opline->op2.zv + ((char*)op_array->literals - (char*)orig_literals)); - } -#else + for (; opline < end ; opline++, offset++, slim_op++) { if (opline->op1_type == IS_CONST) { - opline->op1.constant = - (char*)(op_array->literals + - ((zval*)((char*)(op_array->opcodes + (opline - new_opcodes)) + - (int32_t)opline->op1.constant) - orig_literals)) - - (char*)opline; if (opline->opcode == ZEND_SEND_VAL || opline->opcode == ZEND_SEND_VAL_EX || opline->opcode == ZEND_QM_ASSIGN) { + uint8_t prev_op1_type = opline->op1_type; zend_vm_set_opcode_handler_ex(opline, 0, 0, 0); + slim_op->handler = opline->handler; + + /* Check if operands were swapped. */ + if (opline->op1_type != prev_op1_type) { + znode_op tmp = slim_op->op1; + slim_op->op1 = slim_op->op2; + slim_op->op2 = tmp; + } } } - if (opline->op2_type == IS_CONST) { - opline->op2.constant = - (char*)(op_array->literals + - ((zval*)((char*)(op_array->opcodes + (opline - new_opcodes)) + - (int32_t)opline->op2.constant) - orig_literals)) - - (char*)opline; - } -#endif -#if ZEND_USE_ABS_JMP_ADDR - if (op_array->fn_flags & ZEND_ACC_DONE_PASS_TWO) { - /* fix jumps to point to new array */ - switch (opline->opcode) { - case ZEND_JMP: - case ZEND_FAST_CALL: - opline->op1.jmp_addr = &new_opcodes[opline->op1.jmp_addr - op_array->opcodes]; - break; - case ZEND_JMPZ: - case ZEND_JMPNZ: - case ZEND_JMPZ_EX: - case ZEND_JMPNZ_EX: - case ZEND_JMP_SET: - case ZEND_COALESCE: - case ZEND_FE_RESET_R: - case ZEND_FE_RESET_RW: - case ZEND_ASSERT_CHECK: - case ZEND_JMP_NULL: - case ZEND_BIND_INIT_STATIC_OR_JMP: - case ZEND_JMP_FRAMELESS: - opline->op2.jmp_addr = &new_opcodes[opline->op2.jmp_addr - op_array->opcodes]; - break; - case ZEND_CATCH: - if (!(opline->extended_value & ZEND_LAST_CATCH)) { - opline->op2.jmp_addr = &new_opcodes[opline->op2.jmp_addr - op_array->opcodes]; - } - break; - case ZEND_FE_FETCH_R: - case ZEND_FE_FETCH_RW: - case ZEND_SWITCH_LONG: - case ZEND_SWITCH_STRING: - case ZEND_MATCH: - /* relative extended_value don't have to be changed */ - break; - } - } -#endif if (opline->opcode == ZEND_OP_DATA && (opline-1)->opcode == ZEND_DECLARE_ATTRIBUTED_CONST) { zval *literal = RT_CONSTANT(opline, opline->op1); HashTable *attributes = Z_PTR_P(literal); @@ -624,6 +574,7 @@ static void zend_persist_op_array_ex(zend_op_array *op_array, zend_persistent_sc efree(op_array->opcodes); op_array->opcodes = new_opcodes; + op_array->slim_opcodes = new_slim_opcodes; } if (op_array->filename) { diff --git a/ext/opcache/zend_persist_calc.c b/ext/opcache/zend_persist_calc.c index 639d7d5446705..731b3dc584369 100644 --- a/ext/opcache/zend_persist_calc.c +++ b/ext/opcache/zend_persist_calc.c @@ -264,7 +264,8 @@ static void zend_persist_op_array_calc_ex(zend_op_array *op_array) } zend_shared_alloc_register_xlat_entry(op_array->opcodes, op_array->opcodes); - ADD_SIZE(sizeof(zend_op) * op_array->last); + ADD_SIZE(ZEND_MM_ALIGNED_SIZE_EX(sizeof(zend_op) * op_array->last, 16)); + ADD_SIZE(ZEND_MM_ALIGNED_SIZE_EX(sizeof(zend_slim_op) * op_array->last, 16)); /* ZEND_ACC_PTR_OPS and ZEND_ACC_OVERRIDE use the same value */ if ((op_array->fn_flags & ZEND_ACC_PTR_OPS) && !op_array->function_name) { diff --git a/ext/reflection/php_reflection.c b/ext/reflection/php_reflection.c index 8ef0269481cf7..13096a7f5f762 100644 --- a/ext/reflection/php_reflection.c +++ b/ext/reflection/php_reflection.c @@ -2378,7 +2378,7 @@ ZEND_METHOD(ReflectionGenerator, getExecutingLine) REFLECTION_CHECK_VALID_GENERATOR(ex) - ZVAL_LONG(return_value, ex->opline->lineno); + ZVAL_LONG(return_value, Z_WOP_FROM_EX(ex)->lineno); } /* }}} */ @@ -7577,7 +7577,7 @@ ZEND_METHOD(ReflectionFiber, getExecutingLine) prev_execute_data = prev_execute_data->prev_execute_data; } if (prev_execute_data && prev_execute_data->func && ZEND_USER_CODE(prev_execute_data->func->common.type)) { - RETURN_LONG(prev_execute_data->opline->lineno); + RETURN_LONG(Z_WOP_FROM_EX(prev_execute_data)->lineno); } RETURN_NULL(); } diff --git a/ext/zend_test/observer.c b/ext/zend_test/observer.c index d2a91d16840e0..a3344286dae8f 100644 --- a/ext/zend_test/observer.c +++ b/ext/zend_test/observer.c @@ -71,7 +71,7 @@ static void observer_show_opcode(zend_execute_data *execute_data) static inline void assert_observer_opline(zend_execute_data *execute_data) { ZEND_ASSERT(!ZEND_USER_CODE(EX(func)->type) || (EX(opline) >= EX(func)->op_array.opcodes && EX(opline) < EX(func)->op_array.opcodes + EX(func)->op_array.last) || - (EX(opline) >= EG(exception_op) && EX(opline) < EG(exception_op) + 3)); + (EX(opline) >= EG(exception_slim_op) && EX(opline) < EG(exception_slim_op) + 3)); } static void observer_begin(zend_execute_data *execute_data) diff --git a/main/main.c b/main/main.c index 18c8e2dfac7ec..cbc58ea346b60 100644 --- a/main/main.c +++ b/main/main.c @@ -1040,7 +1040,7 @@ PHPAPI ZEND_COLD void php_verror(const char *docref, const char *params, int typ EG(current_execute_data)->func && ZEND_USER_CODE(EG(current_execute_data)->func->common.type) && EG(current_execute_data)->opline && - EG(current_execute_data)->opline->opcode == ZEND_INCLUDE_OR_EVAL + Z_WOP->opcode == ZEND_INCLUDE_OR_EVAL ) { switch (EG(current_execute_data)->opline->extended_value) { case ZEND_EVAL: diff --git a/sapi/phpdbg/phpdbg_utils.c b/sapi/phpdbg/phpdbg_utils.c index 329ee9a8830e3..89965bfda21c7 100644 --- a/sapi/phpdbg/phpdbg_utils.c +++ b/sapi/phpdbg/phpdbg_utils.c @@ -615,7 +615,7 @@ PHPDBG_API bool phpdbg_check_caught_ex(zend_execute_data *execute_data, zend_obj uint32_t op_num, i; zend_op_array *op_array = &execute_data->func->op_array; - if (execute_data->opline >= EG(exception_op) && execute_data->opline < EG(exception_op) + 3 && EG(opline_before_exception)) { + if (execute_data->opline >= EG(exception_slim_op) && execute_data->opline < EG(exception_slim_op) + 3 && EG(opline_before_exception)) { op = EG(opline_before_exception); } else { op = execute_data->opline; From 6cd333e2774981f849ea4e0fe354bfdcafce8b00 Mon Sep 17 00:00:00 2001 From: Ilija Tovilo Date: Mon, 9 Jun 2025 12:44:20 +0200 Subject: [PATCH 03/19] Reduce diff --- Zend/zend_vm_def.h | 114 +++++++++++++++++++++---------------------- Zend/zend_vm_gen.php | 2 +- 2 files changed, 58 insertions(+), 58 deletions(-) diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 71f434b2356ca..e12919de4f5f7 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -1082,7 +1082,7 @@ ZEND_VM_C_LABEL(assign_op_object): cache_slot = (OP2_TYPE == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot; if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) { if (UNEXPECTED(Z_ISERROR_P(zptr))) { - if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } else { @@ -1107,7 +1107,7 @@ ZEND_VM_C_LABEL(assign_op_object): } } while (0); - if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(EX_VAR(opline->result.var), zptr); } } @@ -1173,7 +1173,7 @@ ZEND_VM_HANDLER(29, ZEND_ASSIGN_STATIC_PROP_OP, ANY, ANY, OP) } } while (0); - if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(EX_VAR(opline->result.var), prop); } @@ -1229,7 +1229,7 @@ ZEND_VM_C_LABEL(assign_dim_op_new_array): zend_binary_op(var_ptr, var_ptr, value OPLINE_CC); } while (0); - if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } FREE_OP_DATA(); @@ -1272,7 +1272,7 @@ ZEND_VM_C_LABEL(assign_dim_op_new_array): zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC); ZEND_VM_C_LABEL(assign_dim_op_ret_null): FREE_OP_DATA(); - if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -1305,7 +1305,7 @@ ZEND_VM_HANDLER(26, ZEND_ASSIGN_OP, VAR|CV, CONST|TMPVAR|CV, OP) zend_binary_op(var_ptr, var_ptr, value OPLINE_CC); } while (0); - if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } @@ -1359,7 +1359,7 @@ ZEND_VM_C_LABEL(pre_incdec_object): cache_slot = (OP2_TYPE == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot; if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) { if (UNEXPECTED(Z_ISERROR_P(zptr))) { - if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } else { @@ -1545,7 +1545,7 @@ ZEND_VM_HELPER(zend_pre_inc_helper, VAR|CV, ANY) increment_function(var_ptr); } while (0); - if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } @@ -1562,7 +1562,7 @@ ZEND_VM_HOT_HANDLER(34, ZEND_PRE_INC, VAR|CV, ANY, SPEC(RETVAL)) if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) { fast_long_increment_function(var_ptr); - if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr); } ZEND_VM_NEXT_OPCODE(); @@ -1597,7 +1597,7 @@ ZEND_VM_HELPER(zend_pre_dec_helper, VAR|CV, ANY) decrement_function(var_ptr); } while (0); - if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(EX_VAR(opline->result.var), var_ptr); } @@ -1614,7 +1614,7 @@ ZEND_VM_HOT_HANDLER(35, ZEND_PRE_DEC, VAR|CV, ANY, SPEC(RETVAL)) if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) { fast_long_decrement_function(var_ptr); - if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr); } ZEND_VM_NEXT_OPCODE(); @@ -2543,7 +2543,7 @@ ZEND_VM_C_LABEL(assign_obj_simple): } else { ZEND_VM_C_LABEL(fast_assign_obj): value = zend_assign_to_variable_ex(property_val, value, OP_DATA_TYPE, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } ZEND_VM_C_GOTO(exit_assign_obj); @@ -2600,7 +2600,7 @@ ZEND_VM_C_LABEL(fast_assign_obj): } } zend_hash_add_new(zobj->properties, name, value); - if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } ZEND_VM_C_GOTO(exit_assign_obj); @@ -2639,7 +2639,7 @@ ZEND_VM_C_LABEL(fast_assign_obj): } ZEND_VM_C_LABEL(free_and_exit_assign_obj): - if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2)) && value) { + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); } FREE_OP_DATA(); @@ -2679,7 +2679,7 @@ ZEND_VM_HANDLER(25, ZEND_ASSIGN_STATIC_PROP, ANY, ANY, CACHE_SLOT, SPEC(OP_DATA= value = zend_assign_to_variable_ex(prop, value, OP_DATA_TYPE, EX_USES_STRICT_TYPES(), &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } @@ -2756,7 +2756,7 @@ ZEND_VM_C_LABEL(try_assign_dim_array): value = GET_OP_DATA_ZVAL_PTR(BP_VAR_R); value = zend_assign_to_variable_ex(variable_ptr, value, OP_DATA_TYPE, EX_USES_STRICT_TYPES(), &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } if (garbage) { @@ -2831,7 +2831,7 @@ ZEND_VM_C_LABEL(try_assign_dim_array): dim = GET_OP2_ZVAL_PTR(BP_VAR_R); ZEND_VM_C_LABEL(assign_dim_error): FREE_OP_DATA(); - if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_NULL(EX_VAR(opline->result.var)); } } @@ -2854,11 +2854,11 @@ ZEND_VM_HANDLER(22, ZEND_ASSIGN, VAR|CV, CONST|TMP|VAR|CV, SPEC(RETVAL)) value = GET_OP2_ZVAL_PTR(BP_VAR_R); variable_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_W); - if (!ZEND_VM_SPEC || UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { + if (!ZEND_VM_SPEC || UNEXPECTED(RETURN_VALUE_USED(opline))) { zend_refcounted *garbage = NULL; value = zend_assign_to_variable_ex(variable_ptr, value, OP2_TYPE, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } if (garbage) { @@ -2899,7 +2899,7 @@ ZEND_VM_HANDLER(30, ZEND_ASSIGN_REF, VAR|CV, VAR|CV, SRC) zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr); } @@ -2985,7 +2985,7 @@ ZEND_VM_HANDLER(33, ZEND_ASSIGN_STATIC_PROP_REF, ANY, ANY, CACHE_SLOT|SRC) zend_assign_to_variable_reference(prop, value_ptr, &garbage); } - if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(EX_VAR(opline->result.var), prop); } @@ -4153,7 +4153,7 @@ ZEND_VM_HOT_HANDLER(129, ZEND_DO_ICALL, ANY, ANY, SPEC(RETVAL,OBSERVER)) bool should_throw = zend_internal_call_should_throw(fbc, call); #endif - ret = RETURN_VALUE_USED(EX_WOP2) ? EX_VAR(opline->result.var) : &retval; + ret = RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : &retval; ZVAL_NULL(ret); ZEND_OBSERVER_FCALL_BEGIN(call); @@ -4187,7 +4187,7 @@ ZEND_VM_HOT_HANDLER(129, ZEND_DO_ICALL, ANY, ANY, SPEC(RETVAL,OBSERVER)) EG(vm_stack_top) = (zval*)call; } - if (!RETURN_VALUE_USED(EX_WOP2)) { + if (!RETURN_VALUE_USED(opline)) { i_zval_ptr_dtor(ret); } @@ -4211,7 +4211,7 @@ ZEND_VM_HOT_HANDLER(130, ZEND_DO_UCALL, ANY, ANY, SPEC(RETVAL,OBSERVER)) EX(call) = call->prev_execute_data; ret = NULL; - if (RETURN_VALUE_USED(EX_WOP2)) { + if (RETURN_VALUE_USED(opline)) { ret = EX_VAR(opline->result.var); } @@ -4236,7 +4236,7 @@ ZEND_VM_HOT_HANDLER(131, ZEND_DO_FCALL_BY_NAME, ANY, ANY, SPEC(RETVAL,OBSERVER)) SAVE_OPLINE(); EX(call) = call->prev_execute_data; - const uint32_t no_discard = RETURN_VALUE_USED(EX_WOP2) ? 0 : ZEND_ACC_NODISCARD; + const uint32_t no_discard = RETURN_VALUE_USED(opline) ? 0 : ZEND_ACC_NODISCARD; if (UNEXPECTED(fbc->common.fn_flags & (ZEND_ACC_DEPRECATED|no_discard))) { if (fbc->common.fn_flags & ZEND_ACC_DEPRECATED) { @@ -4247,7 +4247,7 @@ ZEND_VM_HOT_HANDLER(131, ZEND_DO_FCALL_BY_NAME, ANY, ANY, SPEC(RETVAL,OBSERVER)) } if (UNEXPECTED(EG(exception) != NULL)) { UNDEF_RESULT(); - if (!RETURN_VALUE_USED(EX_WOP2)) { + if (!RETURN_VALUE_USED(opline)) { ret = &retval; ZVAL_UNDEF(ret); } @@ -4257,7 +4257,7 @@ ZEND_VM_HOT_HANDLER(131, ZEND_DO_FCALL_BY_NAME, ANY, ANY, SPEC(RETVAL,OBSERVER)) if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) { ret = NULL; - if (RETURN_VALUE_USED(EX_WOP2)) { + if (RETURN_VALUE_USED(opline)) { ret = EX_VAR(opline->result.var); } @@ -4282,7 +4282,7 @@ ZEND_VM_HOT_HANDLER(131, ZEND_DO_FCALL_BY_NAME, ANY, ANY, SPEC(RETVAL,OBSERVER)) bool should_throw = zend_internal_call_should_throw(fbc, call); #endif - ret = RETURN_VALUE_USED(EX_WOP2) ? EX_VAR(opline->result.var) : &retval; + ret = RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : &retval; ZVAL_NULL(ret); ZEND_OBSERVER_FCALL_BEGIN(call); @@ -4323,7 +4323,7 @@ ZEND_VM_C_LABEL(fcall_by_name_end): EG(vm_stack_top) = (zval*)call; } - if (!RETURN_VALUE_USED(EX_WOP2)) { + if (!RETURN_VALUE_USED(opline)) { i_zval_ptr_dtor(ret); } } @@ -4347,7 +4347,7 @@ ZEND_VM_HOT_HANDLER(60, ZEND_DO_FCALL, ANY, ANY, SPEC(RETVAL,OBSERVER)) SAVE_OPLINE(); EX(call) = call->prev_execute_data; - const uint32_t no_discard = RETURN_VALUE_USED(EX_WOP2) ? 0 : ZEND_ACC_NODISCARD; + const uint32_t no_discard = RETURN_VALUE_USED(opline) ? 0 : ZEND_ACC_NODISCARD; if (UNEXPECTED(fbc->common.fn_flags & (ZEND_ACC_DEPRECATED|no_discard))) { if (fbc->common.fn_flags & ZEND_ACC_DEPRECATED) { @@ -4361,7 +4361,7 @@ ZEND_VM_HOT_HANDLER(60, ZEND_DO_FCALL, ANY, ANY, SPEC(RETVAL,OBSERVER)) OBJ_RELEASE(ZEND_CLOSURE_OBJECT(call->func)); } UNDEF_RESULT(); - if (!RETURN_VALUE_USED(EX_WOP2)) { + if (!RETURN_VALUE_USED(opline)) { ret = &retval; ZVAL_UNDEF(ret); } @@ -4371,7 +4371,7 @@ ZEND_VM_HOT_HANDLER(60, ZEND_DO_FCALL, ANY, ANY, SPEC(RETVAL,OBSERVER)) if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) { ret = NULL; - if (RETURN_VALUE_USED(EX_WOP2)) { + if (RETURN_VALUE_USED(opline)) { ret = EX_VAR(opline->result.var); } @@ -4405,7 +4405,7 @@ ZEND_VM_HOT_HANDLER(60, ZEND_DO_FCALL, ANY, ANY, SPEC(RETVAL,OBSERVER)) bool should_throw = zend_internal_call_should_throw(fbc, call); #endif - ret = RETURN_VALUE_USED(EX_WOP2) ? EX_VAR(opline->result.var) : &retval; + ret = RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : &retval; ZVAL_NULL(ret); ZEND_OBSERVER_FCALL_BEGIN(call); @@ -4444,7 +4444,7 @@ ZEND_VM_C_LABEL(fcall_end): zend_free_extra_named_params(call->extra_named_params); } - if (!RETURN_VALUE_USED(EX_WOP2)) { + if (!RETURN_VALUE_USED(opline)) { i_zval_ptr_dtor(ret); } } @@ -4879,7 +4879,7 @@ ZEND_VM_HANDLER(107, ZEND_CATCH, CONST, JMP_ADDR, LAST_CATCH|CACHE_SLOT) exception = EG(exception); EG(exception) = NULL; - if (RETURN_VALUE_USED(EX_WOP2)) { + if (RETURN_VALUE_USED(opline)) { /* Always perform a strict assignment. There is a reasonable expectation that if you * write "catch (Exception $e)" then $e will actually be instanceof Exception. As such, * we should not permit coercion to string here. */ @@ -6566,18 +6566,18 @@ ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMPVAR|CV, ANY, EVAL, SPEC(OBSER UNDEF_RESULT(); HANDLE_EXCEPTION(); } else if (new_op_array == ZEND_FAKE_OP_ARRAY) { - if (RETURN_VALUE_USED(EX_WOP2)) { + if (RETURN_VALUE_USED(opline)) { ZVAL_TRUE(EX_VAR(opline->result.var)); } } else if (UNEXPECTED(new_op_array == NULL)) { - if (RETURN_VALUE_USED(EX_WOP2)) { + if (RETURN_VALUE_USED(opline)) { ZVAL_FALSE(EX_VAR(opline->result.var)); } } else if (new_op_array->last == 1 && new_op_array->opcodes[0].opcode == ZEND_RETURN && new_op_array->opcodes[0].op1_type == IS_CONST && EXPECTED(zend_execute_ex == execute_ex)) { - if (RETURN_VALUE_USED(EX_WOP2)) { + if (RETURN_VALUE_USED(opline)) { const zend_op *op = new_op_array->opcodes; ZVAL_COPY(EX_VAR(opline->result.var), RT_CONSTANT(op, op->op1)); @@ -6588,7 +6588,7 @@ ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMPVAR|CV, ANY, EVAL, SPEC(OBSER } else { zval *return_value = NULL; zend_execute_data *call; - if (RETURN_VALUE_USED(EX_WOP2)) { + if (RETURN_VALUE_USED(opline)) { return_value = EX_VAR(opline->result.var); } @@ -7098,7 +7098,7 @@ ZEND_VM_HELPER(zend_fe_fetch_object_helper, ANY, ANY) p++; } EG(ht_iterators)[Z_FE_ITER_P(array)].pos = pos; - if (RETURN_VALUE_USED(EX_WOP2)) { + if (RETURN_VALUE_USED(opline)) { if (UNEXPECTED(!p->key)) { ZVAL_LONG(EX_VAR(opline->result.var), p->h); } else if (ZSTR_VAL(p->key)[0]) { @@ -7141,7 +7141,7 @@ ZEND_VM_C_LABEL(fe_fetch_r_exit): /* failure in get_current_data */ ZEND_VM_C_GOTO(fe_fetch_r_exit); } - if (RETURN_VALUE_USED(EX_WOP2)) { + if (RETURN_VALUE_USED(opline)) { if (funcs->get_current_key) { funcs->get_current_key(iter, EX_VAR(opline->result.var)); if (UNEXPECTED(EG(exception) != NULL)) { @@ -7202,7 +7202,7 @@ ZEND_VM_HOT_HANDLER(78, ZEND_FE_FETCH_R, VAR, ANY, JMP_ADDR) value++; } Z_FE_POS_P(array) = pos + 1; - if (RETURN_VALUE_USED(EX_WOP2)) { + if (RETURN_VALUE_USED(opline)) { ZVAL_LONG(EX_VAR(opline->result.var), pos); } } else { @@ -7225,7 +7225,7 @@ ZEND_VM_HOT_HANDLER(78, ZEND_FE_FETCH_R, VAR, ANY, JMP_ADDR) p++; } Z_FE_POS_P(array) = pos; - if (RETURN_VALUE_USED(EX_WOP2)) { + if (RETURN_VALUE_USED(opline)) { if (!p->key) { ZVAL_LONG(EX_VAR(opline->result.var), p->h); } else { @@ -7283,7 +7283,7 @@ ZEND_VM_HANDLER(126, ZEND_FE_FETCH_RW, VAR, ANY, JMP_ADDR) value++; } EG(ht_iterators)[Z_FE_ITER_P(EX_VAR(opline->op1.var))].pos = pos + 1; - if (RETURN_VALUE_USED(EX_WOP2)) { + if (RETURN_VALUE_USED(opline)) { ZVAL_LONG(EX_VAR(opline->result.var), pos); } } else { @@ -7303,7 +7303,7 @@ ZEND_VM_HANDLER(126, ZEND_FE_FETCH_RW, VAR, ANY, JMP_ADDR) p++; } EG(ht_iterators)[Z_FE_ITER_P(EX_VAR(opline->op1.var))].pos = pos; - if (RETURN_VALUE_USED(EX_WOP2)) { + if (RETURN_VALUE_USED(opline)) { if (!p->key) { ZVAL_LONG(EX_VAR(opline->result.var), p->h); } else { @@ -7363,7 +7363,7 @@ ZEND_VM_HANDLER(126, ZEND_FE_FETCH_RW, VAR, ANY, JMP_ADDR) p++; } EG(ht_iterators)[Z_FE_ITER_P(EX_VAR(opline->op1.var))].pos = pos; - if (RETURN_VALUE_USED(EX_WOP2)) { + if (RETURN_VALUE_USED(opline)) { if (UNEXPECTED(!p->key)) { ZVAL_LONG(EX_VAR(opline->result.var), p->h); } else if (ZSTR_VAL(p->key)[0]) { @@ -7404,7 +7404,7 @@ ZEND_VM_HANDLER(126, ZEND_FE_FETCH_RW, VAR, ANY, JMP_ADDR) /* failure in get_current_data */ ZEND_VM_C_GOTO(fe_fetch_w_exit); } - if (RETURN_VALUE_USED(EX_WOP2)) { + if (RETURN_VALUE_USED(opline)) { if (funcs->get_current_key) { funcs->get_current_key(iter, EX_VAR(opline->result.var)); if (UNEXPECTED(EG(exception) != NULL)) { @@ -8513,7 +8513,7 @@ ZEND_VM_HANDLER(160, ZEND_YIELD, CONST|TMP|VAR|CV|UNUSED, CONST|TMPVAR|CV|UNUSED ZVAL_LONG(&generator->key, generator->largest_used_integer_key); } - if (RETURN_VALUE_USED(EX_WOP2)) { + if (RETURN_VALUE_USED(opline)) { /* If the return value of yield is used set the send * target and initialize it to NULL */ generator->send_target = EX_VAR(opline->result.var); @@ -8576,7 +8576,7 @@ ZEND_VM_C_LABEL(yield_from_try_again): zend_generator_yield_from(generator, new_gen); } } else { - if (RETURN_VALUE_USED(EX_WOP2)) { + if (RETURN_VALUE_USED(opline)) { ZVAL_COPY(EX_VAR(opline->result.var), &new_gen->retval); } ZEND_VM_NEXT_OPCODE(); @@ -8617,7 +8617,7 @@ ZEND_VM_C_LABEL(yield_from_try_again): /* This is the default return value * when the expression is a Generator, it will be overwritten in zend_generator_resume() */ - if (RETURN_VALUE_USED(EX_WOP2)) { + if (RETURN_VALUE_USED(opline)) { ZVAL_NULL(EX_VAR(opline->result.var)); } @@ -8893,7 +8893,7 @@ ZEND_VM_HANDLER(151, ZEND_ASSERT_CHECK, ANY, JMP_ADDR) if (EG(assertions) <= 0) { zend_slim_op *target = OP_JMP_ADDR(opline, opline->op2); - if (RETURN_VALUE_USED(EX_WOP2)) { + if (RETURN_VALUE_USED(opline)) { ZVAL_TRUE(EX_VAR(opline->result.var)); } ZEND_VM_JMP_EX(target, 0); @@ -10223,7 +10223,7 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_PRE_INC, (res_info == MAY_BE_LONG && op1_info var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW); Z_LVAL_P(var_ptr)++; - if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr)); } ZEND_VM_NEXT_OPCODE(); @@ -10236,7 +10236,7 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_PRE_INC, (op1_info == MAY_BE_LONG), ZEND_PRE_ var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW); fast_long_increment_function(var_ptr); - if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr); } ZEND_VM_NEXT_OPCODE(); @@ -10249,7 +10249,7 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_PRE_DEC, (res_info == MAY_BE_LONG && op1_info var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW); Z_LVAL_P(var_ptr)--; - if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr)); } ZEND_VM_NEXT_OPCODE(); @@ -10262,7 +10262,7 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_PRE_DEC, (op1_info == MAY_BE_LONG), ZEND_PRE_ var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW); fast_long_decrement_function(var_ptr); - if (UNEXPECTED(RETURN_VALUE_USED(EX_WOP2))) { + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr); } ZEND_VM_NEXT_OPCODE(); @@ -10492,7 +10492,7 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_FE_FETCH_R, op->op2_type == IS_CV && (op1_inf value++; } Z_FE_POS_P(array) = pos + 1; - if (RETURN_VALUE_USED(EX_WOP2)) { + if (RETURN_VALUE_USED(opline)) { ZVAL_LONG(EX_VAR(opline->result.var), pos); } } else { @@ -10515,7 +10515,7 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_FE_FETCH_R, op->op2_type == IS_CV && (op1_inf p++; } Z_FE_POS_P(array) = pos; - if (RETURN_VALUE_USED(EX_WOP2)) { + if (RETURN_VALUE_USED(opline)) { if (!p->key) { ZVAL_LONG(EX_VAR(opline->result.var), p->h); } else { diff --git a/Zend/zend_vm_gen.php b/Zend/zend_vm_gen.php index 6241714eca35b..5411fd4fae42b 100755 --- a/Zend/zend_vm_gen.php +++ b/Zend/zend_vm_gen.php @@ -778,7 +778,7 @@ function gen_code($opcode, $f, $spec, $kind, $code, $op1, $op2, $name, $extra_sp "/GET_OP_DATA_ZVAL_PTR_DEREF\(([^)]*)\)/" => $op_data_get_zval_ptr_deref[isset($extra_spec['OP_DATA']) ? $extra_spec['OP_DATA'] : "ANY"], "/GET_OP_DATA_ZVAL_PTR_PTR\(([^)]*)\)/" => $op_data_get_zval_ptr_ptr[isset($extra_spec['OP_DATA']) ? $extra_spec['OP_DATA'] : "ANY"], "/FREE_OP_DATA\(\)/" => $op_data_free_op[isset($extra_spec['OP_DATA']) ? $extra_spec['OP_DATA'] : "ANY"], - "/RETURN_VALUE_USED\(EX_WOP2\)/" => isset($extra_spec['RETVAL']) + "/RETURN_VALUE_USED\(opline\)/" => isset($extra_spec['RETVAL']) ? $extra_spec['RETVAL'] : "(opline->result.var != (uint16_t)-1)", "/arg_num <= MAX_ARG_FLAG_NUM/" => isset($extra_spec['QUICK_ARG']) ? $extra_spec['QUICK_ARG'] : "arg_num <= MAX_ARG_FLAG_NUM", From 09846ed23b1ec11408da68b3ef34a50b15a509ef Mon Sep 17 00:00:00 2001 From: Ilija Tovilo Date: Mon, 9 Jun 2025 15:40:44 +0200 Subject: [PATCH 04/19] Fix missing extended_value hint --- Zend/zend_vm_def.h | 2 +- Zend/zend_vm_opcodes.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index e12919de4f5f7..5c3602cfcd1e6 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -9193,7 +9193,7 @@ ZEND_VM_HANDLER(183, ZEND_BIND_STATIC, CV, ANY, REF) ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -ZEND_VM_HANDLER(203, ZEND_BIND_INIT_STATIC_OR_JMP, CV, JMP_ADDR) +ZEND_VM_HANDLER(203, ZEND_BIND_INIT_STATIC_OR_JMP, CV, JMP_ADDR, NUM) { USE_OPLINE HashTable *ht; diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c index 172790e442f82..b660d2d4498ab 100644 --- a/Zend/zend_vm_opcodes.c +++ b/Zend/zend_vm_opcodes.c @@ -440,7 +440,7 @@ static uint64_t zend_vm_opcodes_flags[211] = { 0x00000101, 0x00000101, 0x00000101, - 0x100002001, + 0x01002001, 0x01000101, 0x301000100, 0x01000000, From ad14f327354308dd69511ba2fe66e7a361fe9849 Mon Sep 17 00:00:00 2001 From: Ilija Tovilo Date: Mon, 9 Jun 2025 15:47:52 +0200 Subject: [PATCH 05/19] Fix zend_setup_quick_op_flags() for opcache --- Zend/Optimizer/zend_optimizer.c | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/Zend/Optimizer/zend_optimizer.c b/Zend/Optimizer/zend_optimizer.c index 3c629f27ea68c..01dd9efc86d3e 100644 --- a/Zend/Optimizer/zend_optimizer.c +++ b/Zend/Optimizer/zend_optimizer.c @@ -1342,6 +1342,11 @@ static void zend_redo_pass_two(zend_op_array *op_array) zend_setup_quick_op_flags(opline, slim_op); + // FIXME: Ugly workaround, we break op_data->extended_value, repeat for previous opcode + if (opline->opcode == ZEND_OP_DATA) { + zend_setup_quick_op_flags(opline-1, slim_op-1); + } + opline++; slim_op++; } @@ -1473,6 +1478,11 @@ static void zend_redo_pass_two_ex(zend_op_array *op_array, zend_ssa *ssa) zend_setup_quick_op_flags(opline, slim_op); + // FIXME: Ugly workaround, we break op_data->extended_value, repeat for previous opcode + if (opline->opcode == ZEND_OP_DATA) { + zend_setup_quick_op_flags(opline-1, slim_op-1); + } + opline++; slim_op++; } From 657770e9da26e068d90296e731037082e3055e1e Mon Sep 17 00:00:00 2001 From: Ilija Tovilo Date: Mon, 9 Jun 2025 15:48:14 +0200 Subject: [PATCH 06/19] Fix extended_value hint for JMP_NULL --- Zend/zend_vm_def.h | 2 +- Zend/zend_vm_gen.php | 2 ++ Zend/zend_vm_opcodes.c | 2 +- 3 files changed, 4 insertions(+), 2 deletions(-) diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 5c3602cfcd1e6..589aa26c150f7 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -7834,7 +7834,7 @@ ZEND_VM_COLD_CONST_HANDLER(169, ZEND_COALESCE, CONST|TMP|VAR|CV, JMP_ADDR) ZEND_VM_NEXT_OPCODE(); } -ZEND_VM_HOT_NOCONST_HANDLER(198, ZEND_JMP_NULL, CONST|TMP|VAR|CV, JMP_ADDR) +ZEND_VM_HOT_NOCONST_HANDLER(198, ZEND_JMP_NULL, CONST|TMP|VAR|CV, JMP_ADDR, NUM) { USE_OPLINE zval *val, *result; diff --git a/Zend/zend_vm_gen.php b/Zend/zend_vm_gen.php index 5411fd4fae42b..67d493b96c457 100755 --- a/Zend/zend_vm_gen.php +++ b/Zend/zend_vm_gen.php @@ -2517,6 +2517,7 @@ function get_quick_op_flags_field($opcode) { /* Full list of ops we cannot optimize. Warn when we encounter new ones. */ $unfree = [ + 'ZEND_BIND_INIT_STATIC_OR_JMP', 'ZEND_CAST', 'ZEND_CATCH', 'ZEND_DECLARE_ANON_CLASS', @@ -2540,6 +2541,7 @@ function get_quick_op_flags_field($opcode) { 'ZEND_ISSET_ISEMPTY_DIM_OBJ', 'ZEND_ISSET_ISEMPTY_PROP_OBJ', 'ZEND_ISSET_ISEMPTY_STATIC_PROP', + 'ZEND_JMP_NULL', 'ZEND_POST_DEC_STATIC_PROP', 'ZEND_POST_INC_STATIC_PROP', 'ZEND_PRE_DEC_STATIC_PROP', diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c index b660d2d4498ab..c94b52989c315 100644 --- a/Zend/zend_vm_opcodes.c +++ b/Zend/zend_vm_opcodes.c @@ -435,7 +435,7 @@ static uint64_t zend_vm_opcodes_flags[211] = { 0x40300030b, 0x100000301, 0x10000010b, - 0x100002003, + 0x01002003, 0x00000101, 0x00000101, 0x00000101, From 52eb34171d3dfc35f5fb582c16857741650b139b Mon Sep 17 00:00:00 2001 From: Ilija Tovilo Date: Mon, 9 Jun 2025 15:57:55 +0200 Subject: [PATCH 07/19] Fix opcache tests --- ext/opcache/tests/match/005.phpt | 8 ++++---- ext/opcache/tests/opt/gh14873.phpt | 14 +++++++------- ext/opcache/tests/opt/inference_frameless.phpt | 2 +- ext/opcache/tests/opt/nullsafe_001.phpt | 6 +++--- ext/opcache/tests/opt/nullsafe_002.phpt | 2 +- 5 files changed, 16 insertions(+), 16 deletions(-) diff --git a/ext/opcache/tests/match/005.phpt b/ext/opcache/tests/match/005.phpt index 5726336d53922..266ef1c4f471f 100644 --- a/ext/opcache/tests/match/005.phpt +++ b/ext/opcache/tests/match/005.phpt @@ -27,13 +27,13 @@ $_main: ; (after optimizer) ; %s 0000 ASSIGN CV0($text) string("Bienvenue chez nous") -0001 T2 = FRAMELESS_ICALL_2(preg_match) string("/Welcome/") CV0($text) +0001 T2 = FRAMELESS_ICALL_2(preg_match) %d string("/Welcome/") CV0($text) 0002 JMPNZ T2 0010 -0003 T2 = FRAMELESS_ICALL_2(preg_match) string("/Hello/") CV0($text) +0003 T2 = FRAMELESS_ICALL_2(preg_match) %d string("/Hello/") CV0($text) 0004 JMPNZ T2 0010 -0005 T2 = FRAMELESS_ICALL_2(preg_match) string("/Bienvenue/") CV0($text) +0005 T2 = FRAMELESS_ICALL_2(preg_match) %d string("/Bienvenue/") CV0($text) 0006 JMPNZ T2 0012 -0007 T2 = FRAMELESS_ICALL_2(preg_match) string("/Bonjour/") CV0($text) +0007 T2 = FRAMELESS_ICALL_2(preg_match) %d string("/Bonjour/") CV0($text) 0008 JMPNZ T2 0012 0009 JMP 0014 0010 T2 = QM_ASSIGN string("en") diff --git a/ext/opcache/tests/opt/gh14873.phpt b/ext/opcache/tests/opt/gh14873.phpt index d442128d023c8..ba7c2239138f3 100644 --- a/ext/opcache/tests/opt/gh14873.phpt +++ b/ext/opcache/tests/opt/gh14873.phpt @@ -108,7 +108,7 @@ testTrim1: ; (after optimizer) ; %s 0000 CV0($value) = RECV 1 -0001 T1 = FRAMELESS_ICALL_1(trim) CV0($value) +0001 T1 = FRAMELESS_ICALL_1(trim) %d CV0($value) 0002 ASSIGN CV0($value) T1 0003 RETURN CV0($value) @@ -117,7 +117,7 @@ testMin2First: ; (after optimizer) ; %s 0000 CV0($value) = RECV 1 -0001 T1 = FRAMELESS_ICALL_2(min) CV0($value) int(100) +0001 T1 = FRAMELESS_ICALL_2(min) %d CV0($value) int(100) 0002 CV0($value) = QM_ASSIGN T1 0003 VERIFY_RETURN_TYPE CV0($value) 0004 RETURN CV0($value) @@ -127,7 +127,7 @@ testMin2Second: ; (after optimizer) ; %s 0000 CV0($value) = RECV 1 -0001 T1 = FRAMELESS_ICALL_2(min) int(100) CV0($value) +0001 T1 = FRAMELESS_ICALL_2(min) %d int(100) CV0($value) 0002 CV0($value) = QM_ASSIGN T1 0003 VERIFY_RETURN_TYPE CV0($value) 0004 RETURN CV0($value) @@ -138,7 +138,7 @@ testMin2_TMP: ; %s 0000 CV0($value) = RECV 1 0001 T1 = ADD CV0($value) int(1) -0002 CV0($value) = FRAMELESS_ICALL_2(min) T1 int(100) +0002 CV0($value) = FRAMELESS_ICALL_2(min) %d T1 int(100) 0003 VERIFY_RETURN_TYPE CV0($value) 0004 RETURN CV0($value) @@ -147,7 +147,7 @@ testStrstr3First: ; (after optimizer) ; %s 0000 CV0($value) = RECV 1 -0001 T1 = FRAMELESS_ICALL_3(strstr) CV0($value) string("needle") +0001 T1 = FRAMELESS_ICALL_3(strstr) %d CV0($value) string("needle") 0002 OP_DATA bool(false) 0003 ASSIGN CV0($value) T1 0004 VERIFY_RETURN_TYPE CV0($value) @@ -160,7 +160,7 @@ testStrstr3Second: ; (after optimizer) ; %s 0000 CV0($value) = RECV 1 -0001 T1 = FRAMELESS_ICALL_3(strstr) string("needles") CV0($value) +0001 T1 = FRAMELESS_ICALL_3(strstr) %d string("needles") CV0($value) 0002 OP_DATA bool(false) 0003 ASSIGN CV0($value) T1 0004 VERIFY_RETURN_TYPE CV0($value) @@ -173,7 +173,7 @@ testStrstr3Third: ; (after optimizer) ; %s 0000 CV0($value) = RECV 1 -0001 T1 = FRAMELESS_ICALL_3(strstr) string("needles") string("needle") +0001 T1 = FRAMELESS_ICALL_3(strstr) %d string("needles") string("needle") 0002 OP_DATA CV0($value) 0003 CV0($value) = QM_ASSIGN T1 0004 VERIFY_RETURN_TYPE CV0($value) diff --git a/ext/opcache/tests/opt/inference_frameless.phpt b/ext/opcache/tests/opt/inference_frameless.phpt index 3462053393ff8..0ed05b761948b 100644 --- a/ext/opcache/tests/opt/inference_frameless.phpt +++ b/ext/opcache/tests/opt/inference_frameless.phpt @@ -26,6 +26,6 @@ _strpos: ; (after optimizer) ; %sinference_frameless.php:2-4 0000 CV0($str) = RECV 1 -0001 T1 = FRAMELESS_ICALL_3(strpos) CV0($str) string("o") +0001 T1 = FRAMELESS_ICALL_3(strpos) %d CV0($str) string("o") 0002 OP_DATA int(1) 0003 RETURN T1 diff --git a/ext/opcache/tests/opt/nullsafe_001.phpt b/ext/opcache/tests/opt/nullsafe_001.phpt index 171ac7190af9d..7efe0bbc24fe3 100644 --- a/ext/opcache/tests/opt/nullsafe_001.phpt +++ b/ext/opcache/tests/opt/nullsafe_001.phpt @@ -53,17 +53,17 @@ test2: ; %s 0000 CV0($obj) = RECV 1 0001 INIT_FCALL 1 %d string("var_dump") -0002 T1 = JMP_NULL CV0($obj) 0004 +0002 T1 = JMP_NULL %d CV0($obj) 0004 0003 T1 = FETCH_OBJ_R CV0($obj) string("foo") 0004 SEND_VAL T1 1 0005 DO_ICALL 0006 INIT_FCALL 1 %d string("var_dump") -0007 T1 = JMP_NULL CV0($obj) 0009 +0007 T1 = JMP_NULL %d CV0($obj) 0009 0008 T1 = ISSET_ISEMPTY_PROP_OBJ (isset) CV0($obj) string("foo") 0009 SEND_VAL T1 1 0010 DO_ICALL 0011 INIT_FCALL 1 %d string("var_dump") -0012 T1 = JMP_NULL CV0($obj) 0014 +0012 T1 = JMP_NULL %d CV0($obj) 0014 0013 T1 = ISSET_ISEMPTY_PROP_OBJ (empty) CV0($obj) string("foo") 0014 SEND_VAL T1 1 0015 DO_ICALL diff --git a/ext/opcache/tests/opt/nullsafe_002.phpt b/ext/opcache/tests/opt/nullsafe_002.phpt index a8d9f1482c6e1..7721b65c667c5 100644 --- a/ext/opcache/tests/opt/nullsafe_002.phpt +++ b/ext/opcache/tests/opt/nullsafe_002.phpt @@ -42,7 +42,7 @@ BB0: ; children=(BB1, BB2) 0000 #1.CV0($test) [null, object (instanceof Test)] = RECV 1 0001 INIT_FCALL 1 %d string("var_dump") -0002 #2.T1 [null] = JMP_NULL #1.CV0($test) [null, object (instanceof Test)] BB2 +0002 #2.T1 [null] = JMP_NULL %d #1.CV0($test) [null, object (instanceof Test)] BB2 BB1: ; follow lines=[3-3] From 63f6325a3d6195454157b52f9e1be3c5f5ac234e Mon Sep 17 00:00:00 2001 From: Ilija Tovilo Date: Mon, 9 Jun 2025 16:18:33 +0200 Subject: [PATCH 08/19] Add op_data to FRAMELESS_ICALL2 This is added solely for quick op flags. --- Zend/Optimizer/dfa_pass.c | 4 +-- Zend/Optimizer/sccp.c | 4 +-- Zend/zend_compile.c | 12 ++++++--- Zend/zend_vm_def.h | 2 +- Zend/zend_vm_execute.h | 36 ++++++++++++------------- Zend/zend_vm_gen.php | 2 +- Zend/zend_vm_opcodes.c | 2 +- ext/opcache/tests/match/005.phpt | 42 ++++++++++++++++-------------- ext/opcache/tests/opt/gh14873.phpt | 29 +++++++++++++-------- 9 files changed, 75 insertions(+), 58 deletions(-) diff --git a/Zend/Optimizer/dfa_pass.c b/Zend/Optimizer/dfa_pass.c index b9817017ab965..f67bcd052ae4a 100644 --- a/Zend/Optimizer/dfa_pass.c +++ b/Zend/Optimizer/dfa_pass.c @@ -415,10 +415,10 @@ int zend_dfa_optimize_calls(zend_op_array *op_array, zend_ssa *ssa) && zend_string_equals_literal_ci(call_info->callee_func->common.function_name, "in_array")) { bool strict = 0; - bool has_opdata = op->opcode == ZEND_FRAMELESS_ICALL_3; + bool has_opdata = op->opcode == ZEND_FRAMELESS_ICALL_2 || op->opcode == ZEND_FRAMELESS_ICALL_3; ZEND_ASSERT(!call_info->is_prototype); - if (has_opdata) { + if (has_opdata && (op + 1)->op1_type == IS_CONST) { if (zend_is_true(CT_CONSTANT_EX(op_array, (op + 1)->op1.constant))) { strict = 1; } diff --git a/Zend/Optimizer/sccp.c b/Zend/Optimizer/sccp.c index 16b077a9a543a..a755d3523d239 100644 --- a/Zend/Optimizer/sccp.c +++ b/Zend/Optimizer/sccp.c @@ -2206,7 +2206,7 @@ static int try_remove_definition(sccp_ctx *ctx, int var_num, zend_ssa_var *var, if (opline->opcode == ZEND_DO_ICALL) { removed_ops = remove_call(ctx, opline, ssa_op) - 1; } else { - bool has_op_data = opline->opcode == ZEND_FRAMELESS_ICALL_3; + bool has_op_data = opline->opcode == ZEND_FRAMELESS_ICALL_2 || opline->opcode == ZEND_FRAMELESS_ICALL_3; zend_ssa_remove_instr(ssa, opline, ssa_op); removed_ops++; if (has_op_data) { @@ -2248,7 +2248,7 @@ static int try_remove_definition(sccp_ctx *ctx, int var_num, zend_ssa_var *var, if (opline->opcode == ZEND_DO_ICALL) { removed_ops = remove_call(ctx, opline, ssa_op); } else { - bool has_op_data = opline->opcode == ZEND_FRAMELESS_ICALL_3; + bool has_op_data = opline->opcode == ZEND_FRAMELESS_ICALL_2 || opline->opcode == ZEND_FRAMELESS_ICALL_3; zend_ssa_remove_instr(ssa, opline, ssa_op); removed_ops++; if (has_op_data) { diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index ab03e43b95f19..cbf209d3b5b7d 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -4690,9 +4690,15 @@ static uint32_t zend_compile_frameless_icall_ex(znode *result, zend_ast_list *ar } if (num_args >= 2) { SET_NODE(opline->op2, &arg_zvs[1]); - } - if (num_args >= 3) { - zend_emit_op_data(&arg_zvs[2]); + if (num_args >= 3) { + zend_emit_op_data(&arg_zvs[2]); + } else { + /* We emit a dummy op_data for FRAMELESS_ICALL2 to allocate space for quick op flags. */ + znode dummy; + dummy.op_type = IS_UNUSED; + dummy.u.op.var = (uint16_t)-1; + zend_emit_op_data(&dummy); + } } return opnum; } diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 589aa26c150f7..bdd87cb360f13 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -9848,7 +9848,7 @@ ZEND_VM_HANDLER(206, ZEND_FRAMELESS_ICALL_2, ANY, ANY, NUM, SPEC(OBSERVER)) ZVAL_UNDEF(EX_VAR(opline->op1.var)); } FREE_OP2(); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE_EX(1, 2); } ZEND_VM_HANDLER(207, ZEND_FRAMELESS_ICALL_3, ANY, ANY, NUM, SPEC(OBSERVER)) diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index ad29cb7aeb81c..6aec146ca5d42 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -3821,11 +3821,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_2_SPEC_HANDLER zval *result = EX_VAR(opline->result.var); ZVAL_NULL(result); - zval *arg1 = get_zval_ptr_deref(EX_WOP2->op1_type, opline->op1, BP_VAR_R); - zval *arg2 = get_zval_ptr_deref(EX_WOP2->op2_type, opline->op2, BP_VAR_R); + zval *arg1 = get_zval_ptr_deref(QUICK_OP_FLAGS_OP1_TYPE((opline+1)->op2.num), opline->op1, BP_VAR_R); + zval *arg2 = get_zval_ptr_deref(QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num), opline->op2, BP_VAR_R); if (EG(exception)) { - FREE_OP(EX_WOP2->op1_type, opline->op1.var); - FREE_OP(EX_WOP2->op2_type, opline->op2.var); + FREE_OP(QUICK_OP_FLAGS_OP1_TYPE((opline+1)->op2.num), opline->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num), opline->op2.var); HANDLE_EXCEPTION(); } @@ -3839,13 +3839,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_2_SPEC_HANDLER function(result, arg1, arg2); } - FREE_OP(EX_WOP2->op1_type, opline->op1.var); - /* Set OP1 to UNDEF in case FREE_OP(EX_WOP2->op2_type, opline->op2.var) throws. */ - if (EX_WOP2->op1_type & (IS_VAR|IS_TMP_VAR)) { + FREE_OP(QUICK_OP_FLAGS_OP1_TYPE((opline+1)->op2.num), opline->op1.var); + /* Set OP1 to UNDEF in case FREE_OP(QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num), opline->op2.var) throws. */ + if (QUICK_OP_FLAGS_OP1_TYPE((opline+1)->op2.num) & (IS_VAR|IS_TMP_VAR)) { ZVAL_UNDEF(EX_VAR(opline->op1.var)); } - FREE_OP(EX_WOP2->op2_type, opline->op2.var); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + FREE_OP(QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num), opline->op2.var); + ZEND_VM_NEXT_OPCODE_EX(1, 2); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -3855,11 +3855,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVE zval *result = EX_VAR(opline->result.var); ZVAL_NULL(result); - zval *arg1 = get_zval_ptr_deref(EX_WOP2->op1_type, opline->op1, BP_VAR_R); - zval *arg2 = get_zval_ptr_deref(EX_WOP2->op2_type, opline->op2, BP_VAR_R); + zval *arg1 = get_zval_ptr_deref(QUICK_OP_FLAGS_OP1_TYPE((opline+1)->op2.num), opline->op1, BP_VAR_R); + zval *arg2 = get_zval_ptr_deref(QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num), opline->op2, BP_VAR_R); if (EG(exception)) { - FREE_OP(EX_WOP2->op1_type, opline->op1.var); - FREE_OP(EX_WOP2->op2_type, opline->op2.var); + FREE_OP(QUICK_OP_FLAGS_OP1_TYPE((opline+1)->op2.num), opline->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num), opline->op2.var); HANDLE_EXCEPTION(); } @@ -3873,13 +3873,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVE function(result, arg1, arg2); } - FREE_OP(EX_WOP2->op1_type, opline->op1.var); - /* Set OP1 to UNDEF in case FREE_OP(EX_WOP2->op2_type, opline->op2.var) throws. */ - if (EX_WOP2->op1_type & (IS_VAR|IS_TMP_VAR)) { + FREE_OP(QUICK_OP_FLAGS_OP1_TYPE((opline+1)->op2.num), opline->op1.var); + /* Set OP1 to UNDEF in case FREE_OP(QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num), opline->op2.var) throws. */ + if (QUICK_OP_FLAGS_OP1_TYPE((opline+1)->op2.num) & (IS_VAR|IS_TMP_VAR)) { ZVAL_UNDEF(EX_VAR(opline->op1.var)); } - FREE_OP(EX_WOP2->op2_type, opline->op2.var); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + FREE_OP(QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num), opline->op2.var); + ZEND_VM_NEXT_OPCODE_EX(1, 2); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_3_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) diff --git a/Zend/zend_vm_gen.php b/Zend/zend_vm_gen.php index 67d493b96c457..2f4264e91ee74 100755 --- a/Zend/zend_vm_gen.php +++ b/Zend/zend_vm_gen.php @@ -2495,6 +2495,7 @@ function gen_vm_opcodes_header( 'ZEND_ASSIGN_STATIC_PROP_OP', 'ZEND_ASSIGN_STATIC_PROP_REF', 'ZEND_DECLARE_ATTRIBUTED_CONST', + 'ZEND_FRAMELESS_ICALL_2', 'ZEND_FRAMELESS_ICALL_3', ]; @@ -2530,7 +2531,6 @@ function get_quick_op_flags_field($opcode) { 'ZEND_FETCH_STATIC_PROP_W', 'ZEND_FE_FETCH_R', 'ZEND_FE_FETCH_RW', - 'ZEND_FRAMELESS_ICALL_2', 'ZEND_INCLUDE_OR_EVAL', 'ZEND_INIT_DYNAMIC_CALL', 'ZEND_INIT_FCALL', diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c index c94b52989c315..63ade044d2323 100644 --- a/Zend/zend_vm_opcodes.c +++ b/Zend/zend_vm_opcodes.c @@ -443,7 +443,7 @@ static uint64_t zend_vm_opcodes_flags[211] = { 0x01002001, 0x01000101, 0x301000100, - 0x01000000, + 0x501000000, 0x501000000, 0x401042003, 0x01001103, diff --git a/ext/opcache/tests/match/005.phpt b/ext/opcache/tests/match/005.phpt index 266ef1c4f471f..fb2aabab00a63 100644 --- a/ext/opcache/tests/match/005.phpt +++ b/ext/opcache/tests/match/005.phpt @@ -23,27 +23,31 @@ var_dump($result); ?> --EXPECTF-- $_main: - ; (lines=20, args=0, vars=2, tmps=1) + ; (lines=24, args=0, vars=2, tmps=%d) ; (after optimizer) ; %s 0000 ASSIGN CV0($text) string("Bienvenue chez nous") 0001 T2 = FRAMELESS_ICALL_2(preg_match) %d string("/Welcome/") CV0($text) -0002 JMPNZ T2 0010 -0003 T2 = FRAMELESS_ICALL_2(preg_match) %d string("/Hello/") CV0($text) -0004 JMPNZ T2 0010 -0005 T2 = FRAMELESS_ICALL_2(preg_match) %d string("/Bienvenue/") CV0($text) -0006 JMPNZ T2 0012 -0007 T2 = FRAMELESS_ICALL_2(preg_match) %d string("/Bonjour/") CV0($text) -0008 JMPNZ T2 0012 -0009 JMP 0014 -0010 T2 = QM_ASSIGN string("en") -0011 JMP 0015 -0012 T2 = QM_ASSIGN string("fr") -0013 JMP 0015 -0014 T2 = QM_ASSIGN string("other") -0015 ASSIGN CV1($result) T2 -0016 INIT_FCALL 1 %d string("var_dump") -0017 SEND_VAR CV1($result) 1 -0018 DO_ICALL -0019 RETURN int(1) +0002 OP_DATA +0003 JMPNZ T2 0014 +0004 T2 = FRAMELESS_ICALL_2(preg_match) %d string("/Hello/") CV0($text) +0005 OP_DATA +0006 JMPNZ T2 0014 +0007 T2 = FRAMELESS_ICALL_2(preg_match) %d string("/Bienvenue/") CV0($text) +0008 OP_DATA +0009 JMPNZ T2 0016 +0010 T2 = FRAMELESS_ICALL_2(preg_match) %d string("/Bonjour/") CV0($text) +0011 OP_DATA +0012 JMPNZ T2 0016 +0013 JMP 0018 +0014 T2 = QM_ASSIGN string("en") +0015 JMP 0019 +0016 T2 = QM_ASSIGN string("fr") +0017 JMP 0019 +0018 T2 = QM_ASSIGN string("other") +0019 ASSIGN CV1($result) T2 +0020 INIT_FCALL 1 96 string("var_dump") +0021 SEND_VAR CV1($result) 1 +0022 DO_ICALL +0023 RETURN int(1) string(2) "fr" diff --git a/ext/opcache/tests/opt/gh14873.phpt b/ext/opcache/tests/opt/gh14873.phpt index ba7c2239138f3..42d1f0f84a89e 100644 --- a/ext/opcache/tests/opt/gh14873.phpt +++ b/ext/opcache/tests/opt/gh14873.phpt @@ -113,34 +113,41 @@ testTrim1: 0003 RETURN CV0($value) testMin2First: - ; (lines=5, args=1, vars=1, tmps=%d) + ; (lines=6, args=1, vars=1, tmps=%d) ; (after optimizer) ; %s 0000 CV0($value) = RECV 1 0001 T1 = FRAMELESS_ICALL_2(min) %d CV0($value) int(100) -0002 CV0($value) = QM_ASSIGN T1 -0003 VERIFY_RETURN_TYPE CV0($value) -0004 RETURN CV0($value) +0002 OP_DATA +0003 CV0($value) = QM_ASSIGN T1 +0004 VERIFY_RETURN_TYPE CV0($value) +0005 RETURN CV0($value) +LIVE RANGES: + 1: 0002 - 0003 (tmp/var) testMin2Second: - ; (lines=5, args=1, vars=1, tmps=%d) + ; (lines=6, args=1, vars=1, tmps=%d) ; (after optimizer) ; %s 0000 CV0($value) = RECV 1 0001 T1 = FRAMELESS_ICALL_2(min) %d int(100) CV0($value) -0002 CV0($value) = QM_ASSIGN T1 -0003 VERIFY_RETURN_TYPE CV0($value) -0004 RETURN CV0($value) +0002 OP_DATA +0003 CV0($value) = QM_ASSIGN T1 +0004 VERIFY_RETURN_TYPE CV0($value) +0005 RETURN CV0($value) +LIVE RANGES: + 1: 0002 - 0003 (tmp/var) testMin2_TMP: - ; (lines=5, args=1, vars=1, tmps=%d) + ; (lines=6, args=1, vars=1, tmps=%d) ; (after optimizer) ; %s 0000 CV0($value) = RECV 1 0001 T1 = ADD CV0($value) int(1) 0002 CV0($value) = FRAMELESS_ICALL_2(min) %d T1 int(100) -0003 VERIFY_RETURN_TYPE CV0($value) -0004 RETURN CV0($value) +0003 OP_DATA +0004 VERIFY_RETURN_TYPE CV0($value) +0005 RETURN CV0($value) testStrstr3First: ; (lines=6, args=1, vars=1, tmps=%d) From 1d89a9384d4b04c8e2de5eb0b433d8d696da41a1 Mon Sep 17 00:00:00 2001 From: Ilija Tovilo Date: Sun, 8 Jun 2025 01:38:36 +0200 Subject: [PATCH 09/19] Switch from == to & for op type comp This should generate better assembly when combined with the QUICK_OP_FLAGS_x_TYPE() macros. --- Zend/zend_execute.c | 98 ++++++++++++++++++++++----------------------- 1 file changed, 49 insertions(+), 49 deletions(-) diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c index 7eb35b483bcc8..b0903342f556f 100644 --- a/Zend/zend_execute.c +++ b/Zend/zend_execute.c @@ -399,14 +399,14 @@ static zend_always_inline zval *_get_zval_ptr_cv_BP_VAR_W(uint32_t var EXECUTE_D static zend_always_inline zval *_get_zval_ptr_tmpvarcv(int op_type, znode_op node, int type EXECUTE_DATA_DC) { if (op_type & (IS_TMP_VAR|IS_VAR)) { - if (op_type == IS_TMP_VAR) { + if (op_type & IS_TMP_VAR) { return _get_zval_ptr_tmp(node.var EXECUTE_DATA_CC); } else { - ZEND_ASSERT(op_type == IS_VAR); + ZEND_ASSERT(op_type & IS_VAR); return _get_zval_ptr_var_deref(node.var EXECUTE_DATA_CC); } } else { - ZEND_ASSERT(op_type == IS_CV); + ZEND_ASSERT(op_type & IS_CV); return _get_zval_ptr_cv_deref(node.var, type EXECUTE_DATA_CC); } } @@ -414,16 +414,16 @@ static zend_always_inline zval *_get_zval_ptr_tmpvarcv(int op_type, znode_op nod static zend_always_inline zval *_get_zval_ptr(int op_type, znode_op node, int type EXECUTE_DATA_DC OPLINE_DC) { if (op_type & (IS_TMP_VAR|IS_VAR)) { - if (!ZEND_DEBUG || op_type == IS_VAR) { + if (!ZEND_DEBUG || (op_type & IS_VAR)) { return _get_zval_ptr_var(node.var EXECUTE_DATA_CC); } else { - ZEND_ASSERT(op_type == IS_TMP_VAR); + ZEND_ASSERT(op_type & IS_TMP_VAR); return _get_zval_ptr_tmp(node.var EXECUTE_DATA_CC); } } else { - if (op_type == IS_CONST) { + if (op_type & IS_CONST) { return RT_CONSTANT(opline, node); - } else if (op_type == IS_CV) { + } else if (op_type & IS_CV) { return _get_zval_ptr_cv(node.var, type EXECUTE_DATA_CC); } else { return NULL; @@ -434,16 +434,16 @@ static zend_always_inline zval *_get_zval_ptr(int op_type, znode_op node, int ty static zend_always_inline zval *_get_op_data_zval_ptr_r(int op_type, znode_op node EXECUTE_DATA_DC OPLINE_DC) { if (op_type & (IS_TMP_VAR|IS_VAR)) { - if (!ZEND_DEBUG || op_type == IS_VAR) { + if (!ZEND_DEBUG || (op_type & IS_VAR)) { return _get_zval_ptr_var(node.var EXECUTE_DATA_CC); } else { - ZEND_ASSERT(op_type == IS_TMP_VAR); + ZEND_ASSERT(op_type & IS_TMP_VAR); return _get_zval_ptr_tmp(node.var EXECUTE_DATA_CC); } } else { - if (op_type == IS_CONST) { + if (op_type & IS_CONST) { return RT_CONSTANT(opline + 1, node); - } else if (op_type == IS_CV) { + } else if (op_type & IS_CV) { return _get_zval_ptr_cv_BP_VAR_R(node.var EXECUTE_DATA_CC); } else { return NULL; @@ -454,16 +454,16 @@ static zend_always_inline zval *_get_op_data_zval_ptr_r(int op_type, znode_op no static zend_always_inline ZEND_ATTRIBUTE_UNUSED zval *_get_zval_ptr_deref(int op_type, znode_op node, int type EXECUTE_DATA_DC OPLINE_DC) { if (op_type & (IS_TMP_VAR|IS_VAR)) { - if (op_type == IS_TMP_VAR) { + if (op_type & IS_TMP_VAR) { return _get_zval_ptr_tmp(node.var EXECUTE_DATA_CC); } else { - ZEND_ASSERT(op_type == IS_VAR); + ZEND_ASSERT(op_type & IS_VAR); return _get_zval_ptr_var_deref(node.var EXECUTE_DATA_CC); } } else { - if (op_type == IS_CONST) { + if (op_type & IS_CONST) { return RT_CONSTANT(opline, node); - } else if (op_type == IS_CV) { + } else if (op_type & IS_CV) { return _get_zval_ptr_cv_deref(node.var, type EXECUTE_DATA_CC); } else { return NULL; @@ -474,16 +474,16 @@ static zend_always_inline ZEND_ATTRIBUTE_UNUSED zval *_get_zval_ptr_deref(int op static zend_always_inline ZEND_ATTRIBUTE_UNUSED zval *_get_op_data_zval_ptr_deref_r(int op_type, znode_op node EXECUTE_DATA_DC OPLINE_DC) { if (op_type & (IS_TMP_VAR|IS_VAR)) { - if (op_type == IS_TMP_VAR) { + if (op_type & IS_TMP_VAR) { return _get_zval_ptr_tmp(node.var EXECUTE_DATA_CC); } else { - ZEND_ASSERT(op_type == IS_VAR); + ZEND_ASSERT(op_type & IS_VAR); return _get_zval_ptr_var_deref(node.var EXECUTE_DATA_CC); } } else { - if (op_type == IS_CONST) { + if (op_type & IS_CONST) { return RT_CONSTANT(opline + 1, node); - } else if (op_type == IS_CV) { + } else if (op_type & IS_CV) { return _get_zval_ptr_cv_deref_BP_VAR_R(node.var EXECUTE_DATA_CC); } else { return NULL; @@ -494,16 +494,16 @@ static zend_always_inline ZEND_ATTRIBUTE_UNUSED zval *_get_op_data_zval_ptr_dere static zend_always_inline zval *_get_zval_ptr_undef(int op_type, znode_op node, int type EXECUTE_DATA_DC OPLINE_DC) { if (op_type & (IS_TMP_VAR|IS_VAR)) { - if (!ZEND_DEBUG || op_type == IS_VAR) { + if (!ZEND_DEBUG || (op_type & IS_VAR)) { return _get_zval_ptr_var(node.var EXECUTE_DATA_CC); } else { - ZEND_ASSERT(op_type == IS_TMP_VAR); + ZEND_ASSERT(op_type & IS_TMP_VAR); return _get_zval_ptr_tmp(node.var EXECUTE_DATA_CC); } } else { - if (op_type == IS_CONST) { + if (op_type & IS_CONST) { return RT_CONSTANT(opline, node); - } else if (op_type == IS_CV) { + } else if (op_type & IS_CV) { return EX_VAR(node.var); } else { return NULL; @@ -523,10 +523,10 @@ static zend_always_inline zval *_get_zval_ptr_ptr_var(uint32_t var EXECUTE_DATA_ static inline zval *_get_zval_ptr_ptr(int op_type, znode_op node, int type EXECUTE_DATA_DC) { - if (op_type == IS_CV) { + if (op_type & IS_CV) { return _get_zval_ptr_cv(node.var, type EXECUTE_DATA_CC); - } else /* if (op_type == IS_VAR) */ { - ZEND_ASSERT(op_type == IS_VAR); + } else /* if (op_type & IS_VAR) */ { + ZEND_ASSERT(op_type & IS_VAR); return _get_zval_ptr_ptr_var(node.var EXECUTE_DATA_CC); } } @@ -2799,7 +2799,7 @@ static zend_always_inline zval *zend_fetch_dimension_address_inner(HashTable *ht } str_index: if (type != BP_VAR_W) { - retval = zend_hash_find_ex(ht, offset_key, ZEND_CONST_COND(dim_type == IS_CONST, 0)); + retval = zend_hash_find_ex(ht, offset_key, ZEND_CONST_COND(dim_type & IS_CONST, 0)); if (!retval) { switch (type) { case BP_VAR_R: @@ -2920,9 +2920,9 @@ static zend_always_inline void zend_fetch_dimension_address(zval *result, zval * } else if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { zend_object *obj = Z_OBJ_P(container); GC_ADDREF(obj); - if (ZEND_CONST_COND(dim_type == IS_CV, dim != NULL) && UNEXPECTED(Z_TYPE_P(dim) == IS_UNDEF)) { + if (ZEND_CONST_COND(dim_type & IS_CV, dim != NULL) && UNEXPECTED(Z_TYPE_P(dim) == IS_UNDEF)) { dim = ZVAL_UNDEFINED_OP2(); - } else if (dim_type == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + } else if ((dim_type & IS_CONST) && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { dim++; } retval = obj->handlers->read_dimension(obj, dim, type, result); @@ -2980,7 +2980,7 @@ static zend_always_inline void zend_fetch_dimension_address(zval *result, zval * } return_null: /* for read-mode only */ - if (ZEND_CONST_COND(dim_type == IS_CV, dim != NULL) && UNEXPECTED(Z_TYPE_P(dim) == IS_UNDEF)) { + if (ZEND_CONST_COND(dim_type & IS_CV, dim != NULL) && UNEXPECTED(Z_TYPE_P(dim) == IS_UNDEF)) { ZVAL_UNDEFINED_OP2(); } ZVAL_NULL(result); @@ -3125,10 +3125,10 @@ static zend_always_inline void zend_fetch_dimension_address_read(zval *result, z zend_object *obj = Z_OBJ_P(container); GC_ADDREF(obj); - if (ZEND_CONST_COND(dim_type == IS_CV, 1) && UNEXPECTED(Z_TYPE_P(dim) == IS_UNDEF)) { + if (ZEND_CONST_COND(dim_type & IS_CV, 1) && UNEXPECTED(Z_TYPE_P(dim) == IS_UNDEF)) { dim = ZVAL_UNDEFINED_OP2(); } - if (dim_type == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + if ((dim_type & IS_CONST) && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { dim++; } retval = obj->handlers->read_dimension(obj, dim, type, result); @@ -3150,7 +3150,7 @@ static zend_always_inline void zend_fetch_dimension_address_read(zval *result, z if (type != BP_VAR_IS && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { container = ZVAL_UNDEFINED_OP1(); } - if (ZEND_CONST_COND(dim_type == IS_CV, 1) && UNEXPECTED(Z_TYPE_P(dim) == IS_UNDEF)) { + if (ZEND_CONST_COND(dim_type & IS_CV, 1) && UNEXPECTED(Z_TYPE_P(dim) == IS_UNDEF)) { ZVAL_UNDEFINED_OP2(); } if (!is_list && type != BP_VAR_IS) { @@ -3211,7 +3211,7 @@ static zend_never_inline zval* ZEND_FASTCALL zend_find_array_dim_slow(HashTable zend_use_resource_as_offset(offset); hval = Z_RES_HANDLE_P(offset); goto num_idx; - } else if (/*OP2_TYPE == IS_CV &&*/ Z_TYPE_P(offset) == IS_UNDEF) { + } else if (/*OP2_TYPE & IS_CV &&*/ Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); goto str_idx; } else { @@ -3222,7 +3222,7 @@ static zend_never_inline zval* ZEND_FASTCALL zend_find_array_dim_slow(HashTable static zend_never_inline bool ZEND_FASTCALL zend_isset_dim_slow(zval *container, zval *offset EXECUTE_DATA_DC) { - if (/*OP2_TYPE == IS_CV &&*/ UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) { + if (/*OP2_TYPE & IS_CV &&*/ UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) { offset = ZVAL_UNDEFINED_OP2(); } @@ -3261,7 +3261,7 @@ static zend_never_inline bool ZEND_FASTCALL zend_isset_dim_slow(zval *container, static zend_never_inline bool ZEND_FASTCALL zend_isempty_dim_slow(zval *container, zval *offset EXECUTE_DATA_DC) { - if (/*OP2_TYPE == IS_CV &&*/ UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) { + if (/*OP2_TYPE & IS_CV &&*/ UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) { offset = ZVAL_UNDEFINED_OP2(); } @@ -3441,7 +3441,7 @@ static zend_always_inline void zend_fetch_property_address(zval *result, zval *c break; } - if (container_op_type == IS_CV + if ((container_op_type & IS_CV) && type != BP_VAR_W && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { ZVAL_UNDEFINED_OP1(); @@ -3460,7 +3460,7 @@ static zend_always_inline void zend_fetch_property_address(zval *result, zval *c } zobj = Z_OBJ_P(container); - if (prop_op_type == IS_CONST && + if ((prop_op_type & IS_CONST) && EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) { uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); if (prop_info_p) { @@ -3514,7 +3514,7 @@ static zend_always_inline void zend_fetch_property_address(zval *result, zval *c return; } } - } else if (prop_op_type == IS_CONST) { + } else if (prop_op_type & IS_CONST) { /* CE mismatch, make cache slot consistent */ cache_slot[0] = cache_slot[1] = cache_slot[2] = NULL; } @@ -3522,7 +3522,7 @@ static zend_always_inline void zend_fetch_property_address(zval *result, zval *c /* Pointer on property callback is required */ ZEND_ASSERT(zobj->handlers->get_property_ptr_ptr != NULL); - if (prop_op_type == IS_CONST) { + if (prop_op_type & IS_CONST) { name = Z_STR_P(prop_ptr); } else { name = zval_get_tmp_string(prop_ptr, &tmp_name); @@ -3569,7 +3569,7 @@ static zend_always_inline void zend_assign_to_property_reference(zval *container { zend_op *wop = EX_WOP; zval variable, *variable_ptr = &variable; - void **cache_addr = (prop_op_type == IS_CONST) ? CACHE_ADDR(wop->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL; + void **cache_addr = (prop_op_type & IS_CONST) ? CACHE_ADDR(wop->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL; zend_refcounted *garbage = NULL; zend_property_info *prop_info = NULL; @@ -3578,7 +3578,7 @@ static zend_always_inline void zend_assign_to_property_reference(zval *container if (EXPECTED(Z_TYPE_P(variable_ptr) == IS_INDIRECT)) { variable_ptr = Z_INDIRECT_P(variable_ptr); - if (/*OP_DATA_TYPE == IS_VAR &&*/ + if (/*OP_DATA_TYPE & IS_VAR &&*/ (wop->extended_value & ZEND_RETURNS_FUNCTION) && UNEXPECTED(!Z_ISREF_P(value_ptr))) { @@ -3638,7 +3638,7 @@ static zend_never_inline zval* zend_fetch_static_property_address_ex(zend_proper zend_op *wop = EX_WOP; uint8_t op1_type = wop->op1_type, op2_type = wop->op2_type; - if (EXPECTED(op2_type == IS_CONST)) { + if (EXPECTED(op2_type & IS_CONST)) { zval *class_name = RT_CONSTANT(opline, opline->op2); ZEND_ASSERT(op1_type != IS_CONST || CACHED_PTR(cache_slot) == NULL); @@ -3663,14 +3663,14 @@ static zend_never_inline zval* zend_fetch_static_property_address_ex(zend_proper } else { ce = Z_CE_P(EX_VAR(wop->op2.var)); } - if (EXPECTED(op1_type == IS_CONST) && EXPECTED(CACHED_PTR(cache_slot) == ce)) { + if (EXPECTED(op1_type & IS_CONST) && EXPECTED(CACHED_PTR(cache_slot) == ce)) { result = CACHED_PTR(cache_slot + sizeof(void *)); *prop_info = CACHED_PTR(cache_slot + sizeof(void *) * 2); return result; } } - if (EXPECTED(op1_type == IS_CONST)) { + if (EXPECTED(op1_type & IS_CONST)) { name = Z_STR_P(RT_CONSTANT(opline, opline->op1)); result = zend_std_get_static_property_with_info(ce, name, fetch_type, &property_info); } else { @@ -3680,7 +3680,7 @@ static zend_never_inline zval* zend_fetch_static_property_address_ex(zend_proper name = Z_STR_P(varname); tmp_name = NULL; } else { - if (op1_type == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) { + if ((op1_type & IS_CV) && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) { zval_undefined_cv(wop->op1.var EXECUTE_DATA_CC); } name = zval_get_tmp_string(varname, &tmp_name); @@ -3698,7 +3698,7 @@ static zend_never_inline zval* zend_fetch_static_property_address_ex(zend_proper *prop_info = property_info; - if (EXPECTED(op1_type == IS_CONST) + if (EXPECTED(op1_type & IS_CONST) && EXPECTED(!(property_info->ce->ce_flags & ZEND_ACC_TRAIT))) { CACHE_POLYMORPHIC_PTR(cache_slot, ce, result); CACHE_PTR(cache_slot + sizeof(void *) * 2, property_info); @@ -3712,8 +3712,8 @@ static zend_always_inline zval* zend_fetch_static_property_address(zend_property zval *result; zend_property_info *property_info; - if (op1_type == IS_CONST - && (op2_type == IS_CONST + if ((op1_type & IS_CONST) + && ((op2_type & IS_CONST) || (op2_type == IS_UNUSED && ((opline->op2.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF || (opline->op2.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT))) From b2c5f2f7f360a74f601f5f196421701db6b9cd8c Mon Sep 17 00:00:00 2001 From: Ilija Tovilo Date: Mon, 9 Jun 2025 18:07:32 +0200 Subject: [PATCH 10/19] Revert helper changes --- Zend/zend_vm_def.h | 146 ++++++-------- Zend/zend_vm_execute.h | 439 +++++++++++++---------------------------- 2 files changed, 190 insertions(+), 395 deletions(-) diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index bdd87cb360f13..b94f714084f8e 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -23,7 +23,7 @@ * php zend_vm_gen.php */ -ZEND_VM_HELPER(zend_add_helper, ANY, ANY, zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) +ZEND_VM_HELPER(zend_add_helper, ANY, ANY, zval *op_1, zval *op_2) { USE_OPLINE @@ -35,10 +35,10 @@ ZEND_VM_HELPER(zend_add_helper, ANY, ANY, zval *op_1, zval *op_2, uint8_t op1_ty op_2 = ZVAL_UNDEFINED_OP2(); } add_function(EX_VAR(opline->result.var), op_1, op_2); - if (op1_type & (IS_TMP_VAR|IS_VAR)) { + if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (op2_type & (IS_TMP_VAR|IS_VAR)) { + if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -79,12 +79,10 @@ ZEND_VM_C_LABEL(add_double): } } - uint8_t op1_type = RT_OP1_TYPE; - uint8_t op2_type = RT_OP2_TYPE; - ZEND_VM_DISPATCH_TO_HELPER(zend_add_helper, op_1, op1, op_2, op2, op1_type, op1_type, op2_type, op2_type); + ZEND_VM_DISPATCH_TO_HELPER(zend_add_helper, op_1, op1, op_2, op2); } -ZEND_VM_HELPER(zend_sub_helper, ANY, ANY, zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) +ZEND_VM_HELPER(zend_sub_helper, ANY, ANY, zval *op_1, zval *op_2) { USE_OPLINE @@ -96,10 +94,10 @@ ZEND_VM_HELPER(zend_sub_helper, ANY, ANY, zval *op_1, zval *op_2, uint8_t op1_ty op_2 = ZVAL_UNDEFINED_OP2(); } sub_function(EX_VAR(opline->result.var), op_1, op_2); - if (op1_type & (IS_TMP_VAR|IS_VAR)) { + if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (op2_type & (IS_TMP_VAR|IS_VAR)) { + if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -140,12 +138,10 @@ ZEND_VM_C_LABEL(sub_double): } } - uint8_t op1_type = RT_OP1_TYPE; - uint8_t op2_type = RT_OP2_TYPE; - ZEND_VM_DISPATCH_TO_HELPER(zend_sub_helper, op_1, op1, op_2, op2, op1_type, op1_type, op2_type, op2_type); + ZEND_VM_DISPATCH_TO_HELPER(zend_sub_helper, op_1, op1, op_2, op2); } -ZEND_VM_HELPER(zend_mul_helper, ANY, ANY, zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) +ZEND_VM_HELPER(zend_mul_helper, ANY, ANY, zval *op_1, zval *op_2) { USE_OPLINE @@ -157,10 +153,10 @@ ZEND_VM_HELPER(zend_mul_helper, ANY, ANY, zval *op_1, zval *op_2, uint8_t op1_ty op_2 = ZVAL_UNDEFINED_OP2(); } mul_function(EX_VAR(opline->result.var), op_1, op_2); - if (op1_type & (IS_TMP_VAR|IS_VAR)) { + if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (op2_type & (IS_TMP_VAR|IS_VAR)) { + if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -204,9 +200,7 @@ ZEND_VM_C_LABEL(mul_double): } } - uint8_t op1_type = RT_OP1_TYPE; - uint8_t op2_type = RT_OP2_TYPE; - ZEND_VM_DISPATCH_TO_HELPER(zend_mul_helper, op_1, op1, op_2, op2, op1_type, op1_type, op2_type, op2_type); + ZEND_VM_DISPATCH_TO_HELPER(zend_mul_helper, op_1, op1, op_2, op2); } ZEND_VM_COLD_CONSTCONST_HANDLER(4, ZEND_DIV, CONST|TMPVAR|CV, CONST|TMPVAR|CV) @@ -233,7 +227,7 @@ ZEND_VM_COLD_HELPER(zend_mod_by_zero_helper, ANY, ANY) HANDLE_EXCEPTION(); } -ZEND_VM_HELPER(zend_mod_helper, ANY, ANY, zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) +ZEND_VM_HELPER(zend_mod_helper, ANY, ANY, zval *op_1, zval *op_2) { USE_OPLINE @@ -245,10 +239,10 @@ ZEND_VM_HELPER(zend_mod_helper, ANY, ANY, zval *op_1, zval *op_2, uint8_t op1_ty op_2 = ZVAL_UNDEFINED_OP2(); } mod_function(EX_VAR(opline->result.var), op_1, op_2); - if (op1_type & (IS_TMP_VAR|IS_VAR)) { + if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (op2_type & (IS_TMP_VAR|IS_VAR)) { + if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -278,12 +272,10 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(5, ZEND_MOD, CONST|TMPVARCV, CONST|TMPVARCV) } } - uint8_t op1_type = RT_OP1_TYPE; - uint8_t op2_type = RT_OP2_TYPE; - ZEND_VM_DISPATCH_TO_HELPER(zend_mod_helper, op_1, op1, op_2, op2, op1_type, op1_type, op2_type, op2_type); + ZEND_VM_DISPATCH_TO_HELPER(zend_mod_helper, op_1, op1, op_2, op2); } -ZEND_VM_HELPER(zend_shift_left_helper, ANY, ANY, zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) +ZEND_VM_HELPER(zend_shift_left_helper, ANY, ANY, zval *op_1, zval *op_2) { USE_OPLINE @@ -295,10 +287,10 @@ ZEND_VM_HELPER(zend_shift_left_helper, ANY, ANY, zval *op_1, zval *op_2, uint8_t op_2 = ZVAL_UNDEFINED_OP2(); } shift_left_function(EX_VAR(opline->result.var), op_1, op_2); - if (op1_type & (IS_TMP_VAR|IS_VAR)) { + if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (op2_type & (IS_TMP_VAR|IS_VAR)) { + if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -322,12 +314,10 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(6, ZEND_SL, CONST|TMPVARCV, CONST|TMPVARCV) ZEND_VM_NEXT_OPCODE(); } - uint8_t op1_type = RT_OP1_TYPE; - uint8_t op2_type = RT_OP2_TYPE; - ZEND_VM_DISPATCH_TO_HELPER(zend_shift_left_helper, op_1, op1, op_2, op2, op1_type, op1_type, op2_type, op2_type); + ZEND_VM_DISPATCH_TO_HELPER(zend_shift_left_helper, op_1, op1, op_2, op2); } -ZEND_VM_HELPER(zend_shift_right_helper, ANY, ANY, zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) +ZEND_VM_HELPER(zend_shift_right_helper, ANY, ANY, zval *op_1, zval *op_2) { USE_OPLINE @@ -339,10 +329,10 @@ ZEND_VM_HELPER(zend_shift_right_helper, ANY, ANY, zval *op_1, zval *op_2, uint8_ op_2 = ZVAL_UNDEFINED_OP2(); } shift_right_function(EX_VAR(opline->result.var), op_1, op_2); - if (op1_type & (IS_TMP_VAR|IS_VAR)) { + if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (op2_type & (IS_TMP_VAR|IS_VAR)) { + if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -364,9 +354,7 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(7, ZEND_SR, CONST|TMPVARCV, CONST|TMPVARCV) ZEND_VM_NEXT_OPCODE(); } - uint8_t op1_type = RT_OP1_TYPE; - uint8_t op2_type = RT_OP2_TYPE; - ZEND_VM_DISPATCH_TO_HELPER(zend_shift_right_helper, op_1, op1, op_2, op2, op1_type, op1_type, op2_type, op2_type); + ZEND_VM_DISPATCH_TO_HELPER(zend_shift_right_helper, op_1, op1, op_2, op2); } ZEND_VM_COLD_CONSTCONST_HANDLER(12, ZEND_POW, CONST|TMPVAR|CV, CONST|TMPVAR|CV) @@ -504,7 +492,7 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(17, ZEND_IS_NOT_IDENTICAL, CONST|TMP|VAR|CV, CON ZEND_VM_SMART_BRANCH(result, 1); } -ZEND_VM_HELPER(zend_is_equal_helper, ANY, ANY, zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) +ZEND_VM_HELPER(zend_is_equal_helper, ANY, ANY, zval *op_1, zval *op_2) { int ret; USE_OPLINE @@ -517,10 +505,10 @@ ZEND_VM_HELPER(zend_is_equal_helper, ANY, ANY, zval *op_1, zval *op_2, uint8_t o op_2 = ZVAL_UNDEFINED_OP2(); } ret = zend_compare(op_1, op_2); - if (op1_type & (IS_TMP_VAR|IS_VAR)) { + if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (op2_type & (IS_TMP_VAR|IS_VAR)) { + if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_SMART_BRANCH(ret == 0, 1); @@ -581,12 +569,10 @@ ZEND_VM_C_LABEL(is_equal_double): } } } - uint8_t op1_type = RT_OP1_TYPE; - uint8_t op2_type = RT_OP2_TYPE; - ZEND_VM_DISPATCH_TO_HELPER(zend_is_equal_helper, op_1, op1, op_2, op2, op1_type, op1_type, op2_type, op2_type); + ZEND_VM_DISPATCH_TO_HELPER(zend_is_equal_helper, op_1, op1, op_2, op2); } -ZEND_VM_HELPER(zend_is_not_equal_helper, ANY, ANY, zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) +ZEND_VM_HELPER(zend_is_not_equal_helper, ANY, ANY, zval *op_1, zval *op_2) { int ret; USE_OPLINE @@ -599,10 +585,10 @@ ZEND_VM_HELPER(zend_is_not_equal_helper, ANY, ANY, zval *op_1, zval *op_2, uint8 op_2 = ZVAL_UNDEFINED_OP2(); } ret = zend_compare(op_1, op_2); - if (op1_type & (IS_TMP_VAR|IS_VAR)) { + if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (op2_type & (IS_TMP_VAR|IS_VAR)) { + if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_SMART_BRANCH(ret != 0, 1); @@ -663,12 +649,10 @@ ZEND_VM_C_LABEL(is_not_equal_double): } } } - uint8_t op1_type = RT_OP1_TYPE; - uint8_t op2_type = RT_OP2_TYPE; - ZEND_VM_DISPATCH_TO_HELPER(zend_is_not_equal_helper, op_1, op1, op_2, op2, op1_type, op1_type, op2_type, op2_type); + ZEND_VM_DISPATCH_TO_HELPER(zend_is_not_equal_helper, op_1, op1, op_2, op2); } -ZEND_VM_HELPER(zend_is_smaller_helper, ANY, ANY, zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) +ZEND_VM_HELPER(zend_is_smaller_helper, ANY, ANY, zval *op_1, zval *op_2) { int ret; USE_OPLINE @@ -681,10 +665,10 @@ ZEND_VM_HELPER(zend_is_smaller_helper, ANY, ANY, zval *op_1, zval *op_2, uint8_t op_2 = ZVAL_UNDEFINED_OP2(); } ret = zend_compare(op_1, op_2); - if (op1_type & (IS_TMP_VAR|IS_VAR)) { + if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (op2_type & (IS_TMP_VAR|IS_VAR)) { + if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_SMART_BRANCH(ret < 0, 1); @@ -730,12 +714,10 @@ ZEND_VM_C_LABEL(is_smaller_double): ZEND_VM_C_GOTO(is_smaller_double); } } - uint8_t op1_type = RT_OP1_TYPE; - uint8_t op2_type = RT_OP2_TYPE; - ZEND_VM_DISPATCH_TO_HELPER(zend_is_smaller_helper, op_1, op1, op_2, op2, op1_type, op1_type, op2_type, op2_type); + ZEND_VM_DISPATCH_TO_HELPER(zend_is_smaller_helper, op_1, op1, op_2, op2); } -ZEND_VM_HELPER(zend_is_smaller_or_equal_helper, ANY, ANY, zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) +ZEND_VM_HELPER(zend_is_smaller_or_equal_helper, ANY, ANY, zval *op_1, zval *op_2) { int ret; USE_OPLINE @@ -748,10 +730,10 @@ ZEND_VM_HELPER(zend_is_smaller_or_equal_helper, ANY, ANY, zval *op_1, zval *op_2 op_2 = ZVAL_UNDEFINED_OP2(); } ret = zend_compare(op_1, op_2); - if (op1_type & (IS_TMP_VAR|IS_VAR)) { + if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (op2_type & (IS_TMP_VAR|IS_VAR)) { + if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_SMART_BRANCH(ret <= 0, 1); @@ -801,9 +783,7 @@ ZEND_VM_C_LABEL(is_smaller_or_equal_double): ZEND_VM_C_GOTO(is_smaller_or_equal_double); } } - uint8_t op1_type = RT_OP1_TYPE; - uint8_t op2_type = RT_OP2_TYPE; - ZEND_VM_DISPATCH_TO_HELPER(zend_is_smaller_or_equal_helper, op_1, op1, op_2, op2, op1_type, op1_type, op2_type, op2_type); + ZEND_VM_DISPATCH_TO_HELPER(zend_is_smaller_or_equal_helper, op_1, op1, op_2, op2); } ZEND_VM_COLD_CONSTCONST_HANDLER(170, ZEND_SPACESHIP, CONST|TMPVAR|CV, CONST|TMPVAR|CV) @@ -820,7 +800,7 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(170, ZEND_SPACESHIP, CONST|TMPVAR|CV, CONST|TMPV ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -ZEND_VM_HELPER(zend_bw_or_helper, ANY, ANY, zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) +ZEND_VM_HELPER(zend_bw_or_helper, ANY, ANY, zval *op_1, zval *op_2) { USE_OPLINE @@ -832,10 +812,10 @@ ZEND_VM_HELPER(zend_bw_or_helper, ANY, ANY, zval *op_1, zval *op_2, uint8_t op1_ op_2 = ZVAL_UNDEFINED_OP2(); } bitwise_or_function(EX_VAR(opline->result.var), op_1, op_2); - if (op1_type & (IS_TMP_VAR|IS_VAR)) { + if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (op2_type & (IS_TMP_VAR|IS_VAR)) { + if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -856,12 +836,10 @@ ZEND_VM_HOT_NOCONSTCONST_HANDLER(9, ZEND_BW_OR, CONST|TMPVARCV, CONST|TMPVARCV, ZEND_VM_NEXT_OPCODE(); } - uint8_t op1_type = RT_OP1_TYPE; - uint8_t op2_type = RT_OP2_TYPE; - ZEND_VM_DISPATCH_TO_HELPER(zend_bw_or_helper, op_1, op1, op_2, op2, op1_type, op1_type, op2_type, op2_type); + ZEND_VM_DISPATCH_TO_HELPER(zend_bw_or_helper, op_1, op1, op_2, op2); } -ZEND_VM_HELPER(zend_bw_and_helper, ANY, ANY, zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) +ZEND_VM_HELPER(zend_bw_and_helper, ANY, ANY, zval *op_1, zval *op_2) { USE_OPLINE @@ -873,10 +851,10 @@ ZEND_VM_HELPER(zend_bw_and_helper, ANY, ANY, zval *op_1, zval *op_2, uint8_t op1 op_2 = ZVAL_UNDEFINED_OP2(); } bitwise_and_function(EX_VAR(opline->result.var), op_1, op_2); - if (op1_type & (IS_TMP_VAR|IS_VAR)) { + if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (op2_type & (IS_TMP_VAR|IS_VAR)) { + if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -897,12 +875,10 @@ ZEND_VM_HOT_NOCONSTCONST_HANDLER(10, ZEND_BW_AND, CONST|TMPVARCV, CONST|TMPVARCV ZEND_VM_NEXT_OPCODE(); } - uint8_t op1_type = RT_OP1_TYPE; - uint8_t op2_type = RT_OP2_TYPE; - ZEND_VM_DISPATCH_TO_HELPER(zend_bw_and_helper, op_1, op1, op_2, op2, op1_type, op1_type, op2_type, op2_type); + ZEND_VM_DISPATCH_TO_HELPER(zend_bw_and_helper, op_1, op1, op_2, op2); } -ZEND_VM_HELPER(zend_bw_xor_helper, ANY, ANY, zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) +ZEND_VM_HELPER(zend_bw_xor_helper, ANY, ANY, zval *op_1, zval *op_2) { USE_OPLINE @@ -914,10 +890,10 @@ ZEND_VM_HELPER(zend_bw_xor_helper, ANY, ANY, zval *op_1, zval *op_2, uint8_t op1 op_2 = ZVAL_UNDEFINED_OP2(); } bitwise_xor_function(EX_VAR(opline->result.var), op_1, op_2); - if (op1_type & (IS_TMP_VAR|IS_VAR)) { + if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (op2_type & (IS_TMP_VAR|IS_VAR)) { + if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -938,9 +914,7 @@ ZEND_VM_HOT_NOCONSTCONST_HANDLER(11, ZEND_BW_XOR, CONST|TMPVARCV, CONST|TMPVARCV ZEND_VM_NEXT_OPCODE(); } - uint8_t op1_type = RT_OP1_TYPE; - uint8_t op2_type = RT_OP2_TYPE; - ZEND_VM_DISPATCH_TO_HELPER(zend_bw_xor_helper, op_1, op1, op_2, op2, op1_type, op1_type, op2_type, op2_type); + ZEND_VM_DISPATCH_TO_HELPER(zend_bw_xor_helper, op_1, op1, op_2, op2); } ZEND_VM_COLD_CONSTCONST_HANDLER(15, ZEND_BOOL_XOR, CONST|TMPVAR|CV, CONST|TMPVAR|CV, SPEC(COMMUTATIVE)) @@ -957,7 +931,7 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(15, ZEND_BOOL_XOR, CONST|TMPVAR|CV, CONST|TMPVAR ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -ZEND_VM_HELPER(zend_bw_not_helper, ANY, ANY, zval *op_1, uint8_t op1_type) +ZEND_VM_HELPER(zend_bw_not_helper, ANY, ANY, zval *op_1) { USE_OPLINE @@ -966,9 +940,7 @@ ZEND_VM_HELPER(zend_bw_not_helper, ANY, ANY, zval *op_1, uint8_t op1_type) op_1 = ZVAL_UNDEFINED_OP1(); } bitwise_not_function(EX_VAR(opline->result.var), op_1); - if (op1_type & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_nogc(op_1); - } + FREE_OP1(); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -983,8 +955,7 @@ ZEND_VM_HOT_NOCONST_HANDLER(13, ZEND_BW_NOT, CONST|TMPVARCV, UNUSED) ZEND_VM_NEXT_OPCODE(); } - uint8_t op1_type = RT_OP1_TYPE; - ZEND_VM_DISPATCH_TO_HELPER(zend_bw_not_helper, op_1, op1, op1_type, op1_type); + ZEND_VM_DISPATCH_TO_HELPER(zend_bw_not_helper, op_1, op1); } ZEND_VM_COLD_CONST_HANDLER(14, ZEND_BOOL_NOT, CONST|TMPVAR|CV, UNUSED) @@ -5894,7 +5865,7 @@ ZEND_VM_COLD_CONST_HANDLER(52, ZEND_BOOL, CONST|TMPVAR|CV, ANY) ZEND_VM_NEXT_OPCODE(); } -ZEND_VM_HELPER(zend_case_helper, ANY, ANY, zval *op_1, zval *op_2, uint8_t op2_type) +ZEND_VM_HELPER(zend_case_helper, ANY, ANY, zval *op_1, zval *op_2) { int ret; USE_OPLINE @@ -5907,7 +5878,7 @@ ZEND_VM_HELPER(zend_case_helper, ANY, ANY, zval *op_1, zval *op_2, uint8_t op2_t op_2 = ZVAL_UNDEFINED_OP2(); } ret = zend_compare(op_1, op_2); - if (op2_type & (IS_TMP_VAR|IS_VAR)) { + if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_SMART_BRANCH(ret == 0, 1); @@ -5961,8 +5932,7 @@ ZEND_VM_C_LABEL(case_double): } } } - uint8_t op2_type = RT_OP2_TYPE; - ZEND_VM_DISPATCH_TO_HELPER(zend_case_helper, op_1, op1, op_2, op2, op2_type, op2_type); + ZEND_VM_DISPATCH_TO_HELPER(zend_case_helper, op_1, op1, op_2, op2); } ZEND_VM_HANDLER(68, ZEND_NEW, UNUSED|CLASS_FETCH|CONST|VAR, UNUSED|CACHE_SLOT, NUM) diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 6aec146ca5d42..a6c12edb5eba6 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -448,7 +448,7 @@ typedef ZEND_OPCODE_HANDLER_RET (ZEND_FASTCALL *opcode_handler_t) (ZEND_OPCODE_H static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_interrupt_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS); static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS); -static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_add_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_add_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2) { USE_OPLINE @@ -460,16 +460,16 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_add_helper_S op_2 = ZVAL_UNDEFINED_OP2(); } add_function(EX_VAR(opline->result.var), op_1, op_2); - if (op1_type & (IS_TMP_VAR|IS_VAR)) { + if (EX_WOP2->op1_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (op2_type & (IS_TMP_VAR|IS_VAR)) { + if (EX_WOP2->op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_sub_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_sub_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2) { USE_OPLINE @@ -481,16 +481,16 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_sub_helper_S op_2 = ZVAL_UNDEFINED_OP2(); } sub_function(EX_VAR(opline->result.var), op_1, op_2); - if (op1_type & (IS_TMP_VAR|IS_VAR)) { + if (EX_WOP2->op1_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (op2_type & (IS_TMP_VAR|IS_VAR)) { + if (EX_WOP2->op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_mul_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_mul_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2) { USE_OPLINE @@ -502,10 +502,10 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_mul_helper_S op_2 = ZVAL_UNDEFINED_OP2(); } mul_function(EX_VAR(opline->result.var), op_1, op_2); - if (op1_type & (IS_TMP_VAR|IS_VAR)) { + if (EX_WOP2->op1_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (op2_type & (IS_TMP_VAR|IS_VAR)) { + if (EX_WOP2->op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -521,7 +521,7 @@ static zend_never_inline ZEND_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_mo HANDLE_EXCEPTION(); } -static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_mod_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_mod_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2) { USE_OPLINE @@ -533,16 +533,16 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_mod_helper_S op_2 = ZVAL_UNDEFINED_OP2(); } mod_function(EX_VAR(opline->result.var), op_1, op_2); - if (op1_type & (IS_TMP_VAR|IS_VAR)) { + if (EX_WOP2->op1_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (op2_type & (IS_TMP_VAR|IS_VAR)) { + if (EX_WOP2->op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_shift_left_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_shift_left_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2) { USE_OPLINE @@ -554,16 +554,16 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_shift_left_h op_2 = ZVAL_UNDEFINED_OP2(); } shift_left_function(EX_VAR(opline->result.var), op_1, op_2); - if (op1_type & (IS_TMP_VAR|IS_VAR)) { + if (EX_WOP2->op1_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (op2_type & (IS_TMP_VAR|IS_VAR)) { + if (EX_WOP2->op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_shift_right_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_shift_right_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2) { USE_OPLINE @@ -575,16 +575,16 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_shift_right_ op_2 = ZVAL_UNDEFINED_OP2(); } shift_right_function(EX_VAR(opline->result.var), op_1, op_2); - if (op1_type & (IS_TMP_VAR|IS_VAR)) { + if (EX_WOP2->op1_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (op2_type & (IS_TMP_VAR|IS_VAR)) { + if (EX_WOP2->op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2) { int ret; USE_OPLINE @@ -597,16 +597,16 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_equal_hel op_2 = ZVAL_UNDEFINED_OP2(); } ret = zend_compare(op_1, op_2); - if (op1_type & (IS_TMP_VAR|IS_VAR)) { + if (EX_WOP2->op1_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (op2_type & (IS_TMP_VAR|IS_VAR)) { + if (EX_WOP2->op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_SMART_BRANCH(ret == 0, 1); } -static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2) { int ret; USE_OPLINE @@ -619,16 +619,16 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_not_equal op_2 = ZVAL_UNDEFINED_OP2(); } ret = zend_compare(op_1, op_2); - if (op1_type & (IS_TMP_VAR|IS_VAR)) { + if (EX_WOP2->op1_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (op2_type & (IS_TMP_VAR|IS_VAR)) { + if (EX_WOP2->op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_SMART_BRANCH(ret != 0, 1); } -static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2) { int ret; USE_OPLINE @@ -641,16 +641,16 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_smaller_h op_2 = ZVAL_UNDEFINED_OP2(); } ret = zend_compare(op_1, op_2); - if (op1_type & (IS_TMP_VAR|IS_VAR)) { + if (EX_WOP2->op1_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (op2_type & (IS_TMP_VAR|IS_VAR)) { + if (EX_WOP2->op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_SMART_BRANCH(ret < 0, 1); } -static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2) { int ret; USE_OPLINE @@ -663,16 +663,16 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_smaller_o op_2 = ZVAL_UNDEFINED_OP2(); } ret = zend_compare(op_1, op_2); - if (op1_type & (IS_TMP_VAR|IS_VAR)) { + if (EX_WOP2->op1_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (op2_type & (IS_TMP_VAR|IS_VAR)) { + if (EX_WOP2->op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_SMART_BRANCH(ret <= 0, 1); } -static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_or_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_or_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2) { USE_OPLINE @@ -684,16 +684,16 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_or_helper op_2 = ZVAL_UNDEFINED_OP2(); } bitwise_or_function(EX_VAR(opline->result.var), op_1, op_2); - if (op1_type & (IS_TMP_VAR|IS_VAR)) { + if (EX_WOP2->op1_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (op2_type & (IS_TMP_VAR|IS_VAR)) { + if (EX_WOP2->op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_and_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_and_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2) { USE_OPLINE @@ -705,16 +705,16 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_and_helpe op_2 = ZVAL_UNDEFINED_OP2(); } bitwise_and_function(EX_VAR(opline->result.var), op_1, op_2); - if (op1_type & (IS_TMP_VAR|IS_VAR)) { + if (EX_WOP2->op1_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (op2_type & (IS_TMP_VAR|IS_VAR)) { + if (EX_WOP2->op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_xor_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2, uint8_t op1_type, uint8_t op2_type) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_xor_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2) { USE_OPLINE @@ -726,16 +726,16 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_xor_helpe op_2 = ZVAL_UNDEFINED_OP2(); } bitwise_xor_function(EX_VAR(opline->result.var), op_1, op_2); - if (op1_type & (IS_TMP_VAR|IS_VAR)) { + if (EX_WOP2->op1_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (op2_type & (IS_TMP_VAR|IS_VAR)) { + if (EX_WOP2->op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_not_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, uint8_t op1_type) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_not_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1) { USE_OPLINE @@ -744,9 +744,7 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_not_helpe op_1 = ZVAL_UNDEFINED_OP1(); } bitwise_not_function(EX_VAR(opline->result.var), op_1); - if (op1_type & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_nogc(op_1); - } + FREE_OP(EX_WOP2->op1_type, opline->op1.var); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -2779,7 +2777,7 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_verify_recv_ ZEND_VM_NEXT_OPCODE(); } -static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_case_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2, uint8_t op2_type) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_case_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2) { int ret; USE_OPLINE @@ -2792,7 +2790,7 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_case_helper_ op_2 = ZVAL_UNDEFINED_OP2(); } ret = zend_compare(op_1, op_2); - if (op2_type & (IS_TMP_VAR|IS_VAR)) { + if (EX_WOP2->op2_type & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_SMART_BRANCH(ret == 0, 1); @@ -6074,9 +6072,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_CONST_CO } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_add_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_add_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -6114,9 +6110,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_CONST_CO } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_sub_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_sub_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -6157,9 +6151,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_SPEC_CONST_CO } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_mul_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_mul_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -6200,9 +6192,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_CONST_CO } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_mod_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_mod_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -6223,9 +6213,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_CONST_CON ZEND_VM_NEXT_OPCODE(); } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_shift_left_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_shift_left_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -6244,9 +6232,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_CONST_CON ZEND_VM_NEXT_OPCODE(); } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -6348,9 +6334,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CON } } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -6408,9 +6392,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC } } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -6453,9 +6435,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_C goto is_smaller_double; } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -6502,9 +6482,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQU goto is_smaller_or_equal_double; } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -6536,9 +6514,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_CONST_ ZEND_VM_NEXT_OPCODE(); } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_bw_or_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_bw_or_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -6556,9 +6532,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_CONST ZEND_VM_NEXT_OPCODE(); } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_bw_and_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_bw_and_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -6576,9 +6550,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_CONST ZEND_VM_NEXT_OPCODE(); } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_bw_xor_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_bw_xor_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -8361,9 +8333,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_CONST_TMP } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_add_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_add_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -8401,9 +8371,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_CONST_TMP } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_sub_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_sub_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -8430,9 +8398,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_CONST_TMPVARCV_HANDLE } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_mod_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_mod_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -8453,9 +8419,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_CONST_TMPVARCV_HANDLER ZEND_VM_NEXT_OPCODE(); } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_shift_left_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_shift_left_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -8474,9 +8438,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_CONST_TMPVARCV_HANDLER ZEND_VM_NEXT_OPCODE(); } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -8519,9 +8481,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV goto is_smaller_double; } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -8564,9 +8524,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CO goto is_smaller_double; } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -8609,9 +8567,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CO goto is_smaller_double; } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -8658,9 +8614,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST goto is_smaller_or_equal_double; } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -8707,9 +8661,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUA goto is_smaller_or_equal_double; } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -8756,9 +8708,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUA goto is_smaller_or_equal_double; } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -10529,8 +10479,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_NOT_SPEC_CONST ZEND_VM_NEXT_OPCODE(); } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_bw_not_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op1_type)); + ZEND_VM_TAIL_CALL(zend_bw_not_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1)); } static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -13173,9 +13122,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_TMPVARCV_ } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_add_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_add_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -13213,9 +13160,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_TMPVARCV_ } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_sub_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_sub_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -13256,9 +13201,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_SPEC_TMPVARCV_CONST_HANDLE } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_mul_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_mul_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -13285,9 +13228,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_TMPVARCV_CONST_HANDLE } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_mod_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_mod_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -13308,9 +13249,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_TMPVARCV_CONST_HANDLER ZEND_VM_NEXT_OPCODE(); } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_shift_left_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_shift_left_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -13329,9 +13268,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_TMPVARCV_CONST_HANDLER ZEND_VM_NEXT_OPCODE(); } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -13374,9 +13311,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST goto is_smaller_double; } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -13419,9 +13354,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TM goto is_smaller_double; } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -13464,9 +13397,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TM goto is_smaller_double; } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -13513,9 +13444,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVA goto is_smaller_or_equal_double; } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -13562,9 +13491,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUA goto is_smaller_or_equal_double; } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -13611,9 +13538,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUA goto is_smaller_or_equal_double; } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -13631,9 +13556,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_TMPVARC ZEND_VM_NEXT_OPCODE(); } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_bw_or_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_bw_or_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -13651,9 +13574,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_TMPVAR ZEND_VM_NEXT_OPCODE(); } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_bw_and_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_bw_and_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -13671,9 +13592,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMPVAR ZEND_VM_NEXT_OPCODE(); } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_bw_xor_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_bw_xor_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -14301,9 +14220,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_TMPVARCV_ } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_add_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_add_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -14341,9 +14258,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_TMPVARCV_ } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_sub_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_sub_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -14384,9 +14299,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HAN } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_mul_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_mul_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -14413,9 +14326,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HAN } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_mod_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_mod_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -14436,9 +14347,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HAND ZEND_VM_NEXT_OPCODE(); } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_shift_left_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_shift_left_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -14457,9 +14366,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HAND ZEND_VM_NEXT_OPCODE(); } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -14502,9 +14409,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVA goto is_smaller_double; } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -14547,9 +14452,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TM goto is_smaller_double; } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -14592,9 +14495,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TM goto is_smaller_double; } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -14641,9 +14542,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVA goto is_smaller_or_equal_double; } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -14690,9 +14589,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUA goto is_smaller_or_equal_double; } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -14739,9 +14636,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUA goto is_smaller_or_equal_double; } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -14759,9 +14654,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_TMPVARC ZEND_VM_NEXT_OPCODE(); } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_bw_or_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_bw_or_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -14779,9 +14672,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_TMPVAR ZEND_VM_NEXT_OPCODE(); } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_bw_and_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_bw_and_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -14799,9 +14690,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMPVAR ZEND_VM_NEXT_OPCODE(); } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_bw_xor_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_bw_xor_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -15225,8 +15114,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_NOT_SPEC_TMPVAR ZEND_VM_NEXT_OPCODE(); } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_bw_not_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op1_type)); + ZEND_VM_TAIL_CALL(zend_bw_not_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -16049,9 +15937,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_HAN } } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -16109,9 +15995,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMP } } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -16169,9 +16053,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMP } } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -16229,9 +16111,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST } } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -16289,9 +16169,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST } } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -16349,9 +16227,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST } } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -17075,8 +16951,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_CONST_HANDLER } } } - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_case_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op2_type)); + ZEND_VM_TAIL_CALL(zend_case_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -17555,9 +17430,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HA } } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -17615,9 +17488,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JM } } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -17675,9 +17546,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JM } } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -17735,9 +17604,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVA } } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -17795,9 +17662,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVA } } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -17855,9 +17720,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVA } } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -18553,8 +18416,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLE } } } - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_case_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op2_type)); + ZEND_VM_TAIL_CALL(zend_case_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -20023,8 +19885,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_CV_HANDLER(ZE } } } - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_case_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op2_type)); + ZEND_VM_TAIL_CALL(zend_case_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -42352,9 +42213,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER } } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -42412,9 +42271,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ_HA } } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -42472,9 +42329,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ_H } } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -42532,9 +42387,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HAN } } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -42592,9 +42445,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMP } } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -42652,9 +42503,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMP } } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -46318,9 +46167,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMPVAR_HANDLE } } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -46378,9 +46225,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_H } } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -46438,9 +46283,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_ } } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -46498,9 +46341,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HA } } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -46558,9 +46399,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JM } } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -46618,9 +46457,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JM } } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -51896,9 +51733,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER(ZE } } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -51956,9 +51791,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ_HANDL } } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -52016,9 +51849,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ_HAND } } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -52076,9 +51907,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLE } } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -52136,9 +51965,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ_H } } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -52196,9 +52023,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ_ } } } - uint8_t op1_type = QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value); - uint8_t op2_type = QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value); - ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) From 198f8c5a5c7c2ec44018a294cd062512bbc72986 Mon Sep 17 00:00:00 2001 From: Ilija Tovilo Date: Mon, 9 Jun 2025 18:57:30 +0200 Subject: [PATCH 11/19] Use quick op flags in helpers --- Zend/zend_vm_def.h | 38 ++++++++++++------------ Zend/zend_vm_execute.h | 66 +++++++++++++++++++++--------------------- Zend/zend_vm_gen.php | 38 ++++++++++++++++++++---- 3 files changed, 85 insertions(+), 57 deletions(-) diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index b94f714084f8e..f483e5b6bf6a0 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -23,7 +23,7 @@ * php zend_vm_gen.php */ -ZEND_VM_HELPER(zend_add_helper, ANY, ANY, zval *op_1, zval *op_2) +ZEND_VM_HELPER(zend_add_helper, ANY, ANY, OPTIONS(quick_op_flags_field=opline->extended_value), zval *op_1, zval *op_2) { USE_OPLINE @@ -82,7 +82,7 @@ ZEND_VM_C_LABEL(add_double): ZEND_VM_DISPATCH_TO_HELPER(zend_add_helper, op_1, op1, op_2, op2); } -ZEND_VM_HELPER(zend_sub_helper, ANY, ANY, zval *op_1, zval *op_2) +ZEND_VM_HELPER(zend_sub_helper, ANY, ANY, OPTIONS(quick_op_flags_field=opline->extended_value), zval *op_1, zval *op_2) { USE_OPLINE @@ -141,7 +141,7 @@ ZEND_VM_C_LABEL(sub_double): ZEND_VM_DISPATCH_TO_HELPER(zend_sub_helper, op_1, op1, op_2, op2); } -ZEND_VM_HELPER(zend_mul_helper, ANY, ANY, zval *op_1, zval *op_2) +ZEND_VM_HELPER(zend_mul_helper, ANY, ANY, OPTIONS(quick_op_flags_field=opline->extended_value), zval *op_1, zval *op_2) { USE_OPLINE @@ -227,7 +227,7 @@ ZEND_VM_COLD_HELPER(zend_mod_by_zero_helper, ANY, ANY) HANDLE_EXCEPTION(); } -ZEND_VM_HELPER(zend_mod_helper, ANY, ANY, zval *op_1, zval *op_2) +ZEND_VM_HELPER(zend_mod_helper, ANY, ANY, OPTIONS(quick_op_flags_field=opline->extended_value), zval *op_1, zval *op_2) { USE_OPLINE @@ -275,7 +275,7 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(5, ZEND_MOD, CONST|TMPVARCV, CONST|TMPVARCV) ZEND_VM_DISPATCH_TO_HELPER(zend_mod_helper, op_1, op1, op_2, op2); } -ZEND_VM_HELPER(zend_shift_left_helper, ANY, ANY, zval *op_1, zval *op_2) +ZEND_VM_HELPER(zend_shift_left_helper, ANY, ANY, OPTIONS(quick_op_flags_field=opline->extended_value), zval *op_1, zval *op_2) { USE_OPLINE @@ -317,7 +317,7 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(6, ZEND_SL, CONST|TMPVARCV, CONST|TMPVARCV) ZEND_VM_DISPATCH_TO_HELPER(zend_shift_left_helper, op_1, op1, op_2, op2); } -ZEND_VM_HELPER(zend_shift_right_helper, ANY, ANY, zval *op_1, zval *op_2) +ZEND_VM_HELPER(zend_shift_right_helper, ANY, ANY, OPTIONS(quick_op_flags_field=opline->extended_value), zval *op_1, zval *op_2) { USE_OPLINE @@ -492,7 +492,7 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(17, ZEND_IS_NOT_IDENTICAL, CONST|TMP|VAR|CV, CON ZEND_VM_SMART_BRANCH(result, 1); } -ZEND_VM_HELPER(zend_is_equal_helper, ANY, ANY, zval *op_1, zval *op_2) +ZEND_VM_HELPER(zend_is_equal_helper, ANY, ANY, OPTIONS(quick_op_flags_field=opline->extended_value), zval *op_1, zval *op_2) { int ret; USE_OPLINE @@ -572,7 +572,7 @@ ZEND_VM_C_LABEL(is_equal_double): ZEND_VM_DISPATCH_TO_HELPER(zend_is_equal_helper, op_1, op1, op_2, op2); } -ZEND_VM_HELPER(zend_is_not_equal_helper, ANY, ANY, zval *op_1, zval *op_2) +ZEND_VM_HELPER(zend_is_not_equal_helper, ANY, ANY, OPTIONS(quick_op_flags_field=opline->extended_value), zval *op_1, zval *op_2) { int ret; USE_OPLINE @@ -652,7 +652,7 @@ ZEND_VM_C_LABEL(is_not_equal_double): ZEND_VM_DISPATCH_TO_HELPER(zend_is_not_equal_helper, op_1, op1, op_2, op2); } -ZEND_VM_HELPER(zend_is_smaller_helper, ANY, ANY, zval *op_1, zval *op_2) +ZEND_VM_HELPER(zend_is_smaller_helper, ANY, ANY, OPTIONS(quick_op_flags_field=opline->extended_value), zval *op_1, zval *op_2) { int ret; USE_OPLINE @@ -717,7 +717,7 @@ ZEND_VM_C_LABEL(is_smaller_double): ZEND_VM_DISPATCH_TO_HELPER(zend_is_smaller_helper, op_1, op1, op_2, op2); } -ZEND_VM_HELPER(zend_is_smaller_or_equal_helper, ANY, ANY, zval *op_1, zval *op_2) +ZEND_VM_HELPER(zend_is_smaller_or_equal_helper, ANY, ANY, OPTIONS(quick_op_flags_field=opline->extended_value), zval *op_1, zval *op_2) { int ret; USE_OPLINE @@ -800,7 +800,7 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(170, ZEND_SPACESHIP, CONST|TMPVAR|CV, CONST|TMPV ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -ZEND_VM_HELPER(zend_bw_or_helper, ANY, ANY, zval *op_1, zval *op_2) +ZEND_VM_HELPER(zend_bw_or_helper, ANY, ANY, OPTIONS(quick_op_flags_field=opline->extended_value), zval *op_1, zval *op_2) { USE_OPLINE @@ -839,7 +839,7 @@ ZEND_VM_HOT_NOCONSTCONST_HANDLER(9, ZEND_BW_OR, CONST|TMPVARCV, CONST|TMPVARCV, ZEND_VM_DISPATCH_TO_HELPER(zend_bw_or_helper, op_1, op1, op_2, op2); } -ZEND_VM_HELPER(zend_bw_and_helper, ANY, ANY, zval *op_1, zval *op_2) +ZEND_VM_HELPER(zend_bw_and_helper, ANY, ANY, OPTIONS(quick_op_flags_field=opline->extended_value), zval *op_1, zval *op_2) { USE_OPLINE @@ -878,7 +878,7 @@ ZEND_VM_HOT_NOCONSTCONST_HANDLER(10, ZEND_BW_AND, CONST|TMPVARCV, CONST|TMPVARCV ZEND_VM_DISPATCH_TO_HELPER(zend_bw_and_helper, op_1, op1, op_2, op2); } -ZEND_VM_HELPER(zend_bw_xor_helper, ANY, ANY, zval *op_1, zval *op_2) +ZEND_VM_HELPER(zend_bw_xor_helper, ANY, ANY, OPTIONS(quick_op_flags_field=opline->extended_value), zval *op_1, zval *op_2) { USE_OPLINE @@ -931,7 +931,7 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(15, ZEND_BOOL_XOR, CONST|TMPVAR|CV, CONST|TMPVAR ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -ZEND_VM_HELPER(zend_bw_not_helper, ANY, ANY, zval *op_1) +ZEND_VM_HELPER(zend_bw_not_helper, ANY, ANY, OPTIONS(quick_op_flags_field=opline->extended_value), zval *op_1) { USE_OPLINE @@ -1491,7 +1491,7 @@ ZEND_VM_HANDLER(41, ZEND_POST_DEC_STATIC_PROP, ANY, ANY, CACHE_SLOT) ZEND_VM_DISPATCH_TO_HANDLER(ZEND_POST_INC_STATIC_PROP); } -ZEND_VM_HELPER(zend_pre_inc_helper, VAR|CV, ANY) +ZEND_VM_HELPER(zend_pre_inc_helper, VAR|CV, ANY, OPTIONS(quick_op_flags_field=opline->extended_value)) { USE_OPLINE zval *var_ptr; @@ -1542,7 +1542,7 @@ ZEND_VM_HOT_HANDLER(34, ZEND_PRE_INC, VAR|CV, ANY, SPEC(RETVAL)) ZEND_VM_DISPATCH_TO_HELPER(zend_pre_inc_helper); } -ZEND_VM_HELPER(zend_pre_dec_helper, VAR|CV, ANY) +ZEND_VM_HELPER(zend_pre_dec_helper, VAR|CV, ANY, OPTIONS(quick_op_flags_field=opline->extended_value)) { USE_OPLINE zval *var_ptr; @@ -1594,7 +1594,7 @@ ZEND_VM_HOT_HANDLER(35, ZEND_PRE_DEC, VAR|CV, ANY, SPEC(RETVAL)) ZEND_VM_DISPATCH_TO_HELPER(zend_pre_dec_helper); } -ZEND_VM_HELPER(zend_post_inc_helper, VAR|CV, ANY) +ZEND_VM_HELPER(zend_post_inc_helper, VAR|CV, ANY, OPTIONS(quick_op_flags_field=opline->extended_value)) { USE_OPLINE zval *var_ptr; @@ -1642,7 +1642,7 @@ ZEND_VM_HOT_HANDLER(36, ZEND_POST_INC, VAR|CV, ANY) ZEND_VM_DISPATCH_TO_HELPER(zend_post_inc_helper); } -ZEND_VM_HELPER(zend_post_dec_helper, VAR|CV, ANY) +ZEND_VM_HELPER(zend_post_dec_helper, VAR|CV, ANY, OPTIONS(quick_op_flags_field=opline->extended_value)) { USE_OPLINE zval *var_ptr; @@ -5865,7 +5865,7 @@ ZEND_VM_COLD_CONST_HANDLER(52, ZEND_BOOL, CONST|TMPVAR|CV, ANY) ZEND_VM_NEXT_OPCODE(); } -ZEND_VM_HELPER(zend_case_helper, ANY, ANY, zval *op_1, zval *op_2) +ZEND_VM_HELPER(zend_case_helper, ANY, ANY, OPTIONS(quick_op_flags_field=opline->extended_value), zval *op_1, zval *op_2) { int ret; USE_OPLINE diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index a6c12edb5eba6..8cc6d4677d646 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -460,10 +460,10 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_add_helper_S op_2 = ZVAL_UNDEFINED_OP2(); } add_function(EX_VAR(opline->result.var), op_1, op_2); - if (EX_WOP2->op1_type & (IS_TMP_VAR|IS_VAR)) { + if (QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value) & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (EX_WOP2->op2_type & (IS_TMP_VAR|IS_VAR)) { + if (QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value) & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -481,10 +481,10 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_sub_helper_S op_2 = ZVAL_UNDEFINED_OP2(); } sub_function(EX_VAR(opline->result.var), op_1, op_2); - if (EX_WOP2->op1_type & (IS_TMP_VAR|IS_VAR)) { + if (QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value) & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (EX_WOP2->op2_type & (IS_TMP_VAR|IS_VAR)) { + if (QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value) & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -502,10 +502,10 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_mul_helper_S op_2 = ZVAL_UNDEFINED_OP2(); } mul_function(EX_VAR(opline->result.var), op_1, op_2); - if (EX_WOP2->op1_type & (IS_TMP_VAR|IS_VAR)) { + if (QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value) & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (EX_WOP2->op2_type & (IS_TMP_VAR|IS_VAR)) { + if (QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value) & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -533,10 +533,10 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_mod_helper_S op_2 = ZVAL_UNDEFINED_OP2(); } mod_function(EX_VAR(opline->result.var), op_1, op_2); - if (EX_WOP2->op1_type & (IS_TMP_VAR|IS_VAR)) { + if (QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value) & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (EX_WOP2->op2_type & (IS_TMP_VAR|IS_VAR)) { + if (QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value) & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -554,10 +554,10 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_shift_left_h op_2 = ZVAL_UNDEFINED_OP2(); } shift_left_function(EX_VAR(opline->result.var), op_1, op_2); - if (EX_WOP2->op1_type & (IS_TMP_VAR|IS_VAR)) { + if (QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value) & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (EX_WOP2->op2_type & (IS_TMP_VAR|IS_VAR)) { + if (QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value) & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -575,10 +575,10 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_shift_right_ op_2 = ZVAL_UNDEFINED_OP2(); } shift_right_function(EX_VAR(opline->result.var), op_1, op_2); - if (EX_WOP2->op1_type & (IS_TMP_VAR|IS_VAR)) { + if (QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value) & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (EX_WOP2->op2_type & (IS_TMP_VAR|IS_VAR)) { + if (QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value) & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -597,13 +597,13 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_equal_hel op_2 = ZVAL_UNDEFINED_OP2(); } ret = zend_compare(op_1, op_2); - if (EX_WOP2->op1_type & (IS_TMP_VAR|IS_VAR)) { + if (QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value) & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (EX_WOP2->op2_type & (IS_TMP_VAR|IS_VAR)) { + if (QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value) & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } - ZEND_VM_SMART_BRANCH(ret == 0, 1); + ZEND_VM_SMART_BRANCH_EX(ret == 0, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2) @@ -619,13 +619,13 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_not_equal op_2 = ZVAL_UNDEFINED_OP2(); } ret = zend_compare(op_1, op_2); - if (EX_WOP2->op1_type & (IS_TMP_VAR|IS_VAR)) { + if (QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value) & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (EX_WOP2->op2_type & (IS_TMP_VAR|IS_VAR)) { + if (QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value) & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } - ZEND_VM_SMART_BRANCH(ret != 0, 1); + ZEND_VM_SMART_BRANCH_EX(ret != 0, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_smaller_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2) @@ -641,13 +641,13 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_smaller_h op_2 = ZVAL_UNDEFINED_OP2(); } ret = zend_compare(op_1, op_2); - if (EX_WOP2->op1_type & (IS_TMP_VAR|IS_VAR)) { + if (QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value) & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (EX_WOP2->op2_type & (IS_TMP_VAR|IS_VAR)) { + if (QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value) & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } - ZEND_VM_SMART_BRANCH(ret < 0, 1); + ZEND_VM_SMART_BRANCH_EX(ret < 0, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_smaller_or_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2) @@ -663,13 +663,13 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_smaller_o op_2 = ZVAL_UNDEFINED_OP2(); } ret = zend_compare(op_1, op_2); - if (EX_WOP2->op1_type & (IS_TMP_VAR|IS_VAR)) { + if (QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value) & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (EX_WOP2->op2_type & (IS_TMP_VAR|IS_VAR)) { + if (QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value) & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } - ZEND_VM_SMART_BRANCH(ret <= 0, 1); + ZEND_VM_SMART_BRANCH_EX(ret <= 0, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_or_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX zval *op_1, zval *op_2) @@ -684,10 +684,10 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_or_helper op_2 = ZVAL_UNDEFINED_OP2(); } bitwise_or_function(EX_VAR(opline->result.var), op_1, op_2); - if (EX_WOP2->op1_type & (IS_TMP_VAR|IS_VAR)) { + if (QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value) & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (EX_WOP2->op2_type & (IS_TMP_VAR|IS_VAR)) { + if (QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value) & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -705,10 +705,10 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_and_helpe op_2 = ZVAL_UNDEFINED_OP2(); } bitwise_and_function(EX_VAR(opline->result.var), op_1, op_2); - if (EX_WOP2->op1_type & (IS_TMP_VAR|IS_VAR)) { + if (QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value) & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (EX_WOP2->op2_type & (IS_TMP_VAR|IS_VAR)) { + if (QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value) & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -726,10 +726,10 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_xor_helpe op_2 = ZVAL_UNDEFINED_OP2(); } bitwise_xor_function(EX_VAR(opline->result.var), op_1, op_2); - if (EX_WOP2->op1_type & (IS_TMP_VAR|IS_VAR)) { + if (QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value) & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_1); } - if (EX_WOP2->op2_type & (IS_TMP_VAR|IS_VAR)) { + if (QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value) & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -744,7 +744,7 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_not_helpe op_1 = ZVAL_UNDEFINED_OP1(); } bitwise_not_function(EX_VAR(opline->result.var), op_1); - FREE_OP(EX_WOP2->op1_type, opline->op1.var); + FREE_OP(QUICK_OP_FLAGS_OP1_TYPE(opline->extended_value), opline->op1.var); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -2790,10 +2790,10 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_case_helper_ op_2 = ZVAL_UNDEFINED_OP2(); } ret = zend_compare(op_1, op_2); - if (EX_WOP2->op2_type & (IS_TMP_VAR|IS_VAR)) { + if (QUICK_OP_FLAGS_OP2_TYPE(opline->extended_value) & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_nogc(op_2); } - ZEND_VM_SMART_BRANCH(ret == 0, 1); + ZEND_VM_SMART_BRANCH_EX(ret == 0, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->extended_value), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->extended_value)); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) diff --git a/Zend/zend_vm_gen.php b/Zend/zend_vm_gen.php index 2f4264e91ee74..7d9a37b869876 100755 --- a/Zend/zend_vm_gen.php +++ b/Zend/zend_vm_gen.php @@ -929,7 +929,9 @@ function($matches) use ($spec, $prefix, $op1, $op2, $extra_spec) { "/ZEND_VM_DISPATCH_TO_HANDLER\(\s*([A-Z_]*)\s*\)/m", "/ZEND_VM_DISPATCH_TO_HELPER\(\s*([A-Za-z_]*)\s*(,[^)]*)?\)/m", ), - function($matches) use ($spec, $prefix, $op1, $op2, $extra_spec, $name) { + function($matches) use ($spec, $prefix, $op1, $op2, $extra_spec, $name, $opcode) { + global $helpers; + if (strncasecmp($matches[0], "EXECUTE_DATA", strlen("EXECUTE_DATA")) == 0) { return "execute_data"; } else if (strncasecmp($matches[0], "ZEND_VM_DISPATCH_TO_HANDLER", strlen("ZEND_VM_DISPATCH_TO_HANDLER")) == 0) { @@ -946,6 +948,15 @@ function($matches) use ($spec, $prefix, $op1, $op2, $extra_spec, $name) { return "ZEND_VM_TAIL_CALL(" . opcode_name($handler, $spec, $op1, $op2, $extra_spec) . $inline . "_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU))"; } else { // ZEND_VM_DISPATCH_TO_HELPER + + /* Validate quick_op_flags_field compatibility. */ + if (isset($helpers[$matches[1]])) { + $helper = $helpers[$matches[1]]; + if (isset($helper['quick_op_flags_field']) + && $helper['quick_op_flags_field'] !== ($opcode['quick_op_flags_field'] ?? null)) { + die("ERROR: quick_op_flags_field of opcode {$opcode['op']} ({$opcode['quick_op_flags_field']}) is not compatible with {$matches[1]} ({$helper['quick_op_flags_field']}).\n"); + } + } if (isset($matches[2])) { // extra args $args = substr(preg_replace("/,\s*[A-Za-z0-9_]*\s*,\s*([^,)\s]*)\s*/", ", $1", $matches[2]), 2); @@ -1223,7 +1234,7 @@ function gen_handler($f, $spec, $kind, $name, $op1, $op2, $use, $code, $lineno, // Generates helper function gen_helper($f, $spec, $kind, $name, $op1, $op2, $param, $code, $lineno, $inline, $cold = false, $hot = false, $extra_spec = null) { - global $definition_file, $prefix; + global $definition_file, $prefix, $helpers; if ($kind == ZEND_VM_KIND_HYBRID && !$hot) { return; @@ -1233,6 +1244,8 @@ function gen_helper($f, $spec, $kind, $name, $op1, $op2, $param, $code, $lineno, return; } + $helper = $helpers[$name]; + if (ZEND_VM_LINES) { out($f, "#line $lineno \"$definition_file\"\n"); } @@ -1273,7 +1286,7 @@ function gen_helper($f, $spec, $kind, $name, $op1, $op2, $param, $code, $lineno, } // Generate helper's code - gen_code(null, $f, $spec, $kind, $code, $op1, $op2, $name, $extra_spec); + gen_code($helper, $f, $spec, $kind, $code, $op1, $op2, $name, $extra_spec); } @@ -2787,6 +2800,7 @@ function gen_vm($def, $skel) { \s*([A-Z_|]+)\s*, \s*([A-Z_|]+)\s* (?:,\s*SPEC\(([A-Z_|=,]+)\)\s*)? + (?:,\s*OPTIONS\(([^\)]+)\)\s*)? (?:,\s*([^)]*)\s*)? \) $/x", @@ -2800,11 +2814,25 @@ function gen_vm($def, $skel) { $helper = $m[2]; $op1 = parse_operand_spec($def, $lineno, $m[3], $flags1); $op2 = parse_operand_spec($def, $lineno, $m[4], $flags2); - $param = isset($m[6]) ? $m[6] : null; + $options = isset($m[6]) ? $m[6] : null; + $param = isset($m[7]) ? $m[7] : null; if (isset($helpers[$helper])) { die("ERROR ($def:$lineno): Helper with name '$helper' is already defined.\n"); } + $quick_op_flags_field = null; + if ($options) { + $options = explode(',', $options); + foreach ($options as $option) { + [$option_name, $option_value] = explode('=', $option); + if ($option_name === 'quick_op_flags_field') { + $quick_op_flags_field = $option_value; + } else { + die("ERROR ($def:$lineno): Unknown helper option '$option_name'.\n"); + } + } + } + // Store parameters if ((ZEND_VM_KIND == ZEND_VM_KIND_GOTO || ZEND_VM_KIND == ZEND_VM_KIND_SWITCH @@ -2818,7 +2846,7 @@ function gen_vm($def, $skel) { } } - $helpers[$helper] = array("op1"=>$op1,"op2"=>$op2,"param"=>$param,"code"=>"","inline"=>$inline,"cold"=>$cold,"hot"=>$hot); + $helpers[$helper] = array("op1"=>$op1,"op2"=>$op2,"param"=>$param,"code"=>"","inline"=>$inline,"cold"=>$cold,"hot"=>$hot,"quick_op_flags_field"=>$quick_op_flags_field); if (!empty($m[5])) { $helpers[$helper]["spec"] = parse_spec_rules($def, $lineno, $m[5]); From 16d7a4d0779c9504c87266d714bf95a57340b9d2 Mon Sep 17 00:00:00 2001 From: Ilija Tovilo Date: Tue, 10 Jun 2025 20:05:04 +0200 Subject: [PATCH 12/19] Attempt to optimize static vars --- Zend/zend_compile.c | 29 +++++++++++++++++++----- Zend/zend_execute.c | 44 ++++++++++++++++++++----------------- Zend/zend_vm_def.h | 44 ++++++++++++++----------------------- Zend/zend_vm_execute.h | 50 +++++++++++++++++------------------------- Zend/zend_vm_gen.php | 44 +++++++++++++++++++++++++------------ Zend/zend_vm_opcodes.c | 22 +++++++++---------- 6 files changed, 126 insertions(+), 107 deletions(-) diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index cbf209d3b5b7d..4e73cb89ad293 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -2483,6 +2483,11 @@ static zend_op *zend_delayed_compile_end(uint32_t offset) /* {{{ */ } CG(delayed_oplines_stack).top = offset; + + if (opline && opline->opcode == ZEND_OP_DATA) { + opline--; + } + return opline; } /* }}} */ @@ -3199,11 +3204,21 @@ static zend_op *zend_compile_static_prop(znode *result, zend_ast *ast, uint32_t zend_compile_expr(&prop_node, prop_ast); + znode unused_node; + unused_node.op_type = IS_UNUSED; + unused_node.u.op.num = (uint16_t)-1; + + uint32_t opnum = get_next_op_number(); if (delayed) { opline = zend_delayed_emit_op(result, ZEND_FETCH_STATIC_PROP_R, &prop_node, NULL); + zend_delayed_emit_op(NULL, ZEND_OP_DATA, &unused_node, NULL); + opline = (zend_op*)zend_stack_top(&CG(delayed_oplines_stack)) - 1; } else { opline = zend_emit_op(result, ZEND_FETCH_STATIC_PROP_R, &prop_node, NULL); + zend_emit_op_data(&unused_node); + opline = CG(active_op_array)->opcodes + opnum; } + if (opline->op1_type == IS_CONST) { convert_to_string(CT_CONSTANT(opline->op1)); opline->extended_value = zend_alloc_cache_slots(3); @@ -3224,6 +3239,9 @@ static zend_op *zend_compile_static_prop(znode *result, zend_ast *ast, uint32_t } zend_adjust_for_fetch_type(opline, result, type); + + + return opline; } /* }}} */ @@ -3466,7 +3484,7 @@ static void zend_compile_assign(znode *result, zend_ast *ast) /* {{{ */ opline->result_type = IS_TMP_VAR; result->op_type = IS_TMP_VAR; - zend_emit_op_data(&expr_node); + SET_NODE((opline+1)->op1, &expr_node); return; case ZEND_AST_DIM: offset = zend_delayed_compile_begin(); @@ -3581,7 +3599,7 @@ static void zend_compile_assign_ref(znode *result, zend_ast *ast) /* {{{ */ opline->opcode = ZEND_ASSIGN_STATIC_PROP_REF; opline->extended_value &= ~ZEND_FETCH_REF; opline->extended_value |= flags; - zend_emit_op_data(&source_node); + SET_NODE((opline+1)->op1, &source_node); *result = target_node; } else { opline = zend_emit_op(result, ZEND_ASSIGN_REF, &target_node, &source_node); @@ -3635,8 +3653,8 @@ static void zend_compile_compound_assign(znode *result, zend_ast *ast) /* {{{ */ opline->result_type = IS_TMP_VAR; result->op_type = IS_TMP_VAR; - opline = zend_emit_op_data(&expr_node); - opline->extended_value = cache_slot; + SET_NODE((opline+1)->op1, &expr_node); + (opline+1)->extended_value = cache_slot; return; case ZEND_AST_DIM: offset = zend_delayed_compile_begin(); @@ -10495,10 +10513,11 @@ static void zend_compile_assign_coalesce(znode *result, zend_ast *ast) /* {{{ */ zend_emit_op_tmp(&assign_node, ZEND_ASSIGN, &var_node_w, &default_node); break; case ZEND_AST_STATIC_PROP: + opline--; opline->opcode = ZEND_ASSIGN_STATIC_PROP; opline->result_type = IS_TMP_VAR; var_node_w.op_type = IS_TMP_VAR; - zend_emit_op_data(&default_node); + SET_NODE((opline+1)->op1, &default_node); assign_node = var_node_w; break; case ZEND_AST_DIM: diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c index b0903342f556f..a3460da0b891f 100644 --- a/Zend/zend_execute.c +++ b/Zend/zend_execute.c @@ -3629,15 +3629,12 @@ static zend_never_inline void zend_assign_to_property_reference_var_var(zval *co OPLINE_CC EXECUTE_DATA_CC); } -static zend_never_inline zval* zend_fetch_static_property_address_ex(zend_property_info **prop_info, uint32_t cache_slot, int fetch_type OPLINE_DC EXECUTE_DATA_DC) { +static zend_never_inline zval* zend_fetch_static_property_address_ex(zend_property_info **prop_info, uint32_t cache_slot, int fetch_type, uint8_t op1_type, uint32_t op1, uint8_t op2_type, uint32_t op2 OPLINE_DC EXECUTE_DATA_DC) { zval *result; zend_string *name; zend_class_entry *ce; zend_property_info *property_info; - zend_op *wop = EX_WOP; - uint8_t op1_type = wop->op1_type, op2_type = wop->op2_type; - if (EXPECTED(op2_type & IS_CONST)) { zval *class_name = RT_CONSTANT(opline, opline->op2); @@ -3646,7 +3643,7 @@ static zend_never_inline zval* zend_fetch_static_property_address_ex(zend_proper if (EXPECTED((ce = CACHED_PTR(cache_slot)) == NULL)) { ce = zend_fetch_class_by_name(Z_STR_P(class_name), Z_STR_P(class_name + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); if (UNEXPECTED(ce == NULL)) { - FREE_OP(op1_type, wop->op1.var); + FREE_OP(op1_type, op1); return NULL; } if (UNEXPECTED(op1_type != IS_CONST)) { @@ -3655,13 +3652,13 @@ static zend_never_inline zval* zend_fetch_static_property_address_ex(zend_proper } } else { if (EXPECTED(op2_type == IS_UNUSED)) { - ce = zend_fetch_class(NULL, wop->op2.num); + ce = zend_fetch_class(NULL, op2); if (UNEXPECTED(ce == NULL)) { - FREE_OP(op1_type, wop->op1.var); + FREE_OP(op1_type, op1); return NULL; } } else { - ce = Z_CE_P(EX_VAR(wop->op2.var)); + ce = Z_CE_P(EX_VAR(op2)); } if (EXPECTED(op1_type & IS_CONST) && EXPECTED(CACHED_PTR(cache_slot) == ce)) { result = CACHED_PTR(cache_slot + sizeof(void *)); @@ -3675,13 +3672,15 @@ static zend_never_inline zval* zend_fetch_static_property_address_ex(zend_proper result = zend_std_get_static_property_with_info(ce, name, fetch_type, &property_info); } else { zend_string *tmp_name; - zval *varname = get_zval_ptr_undef(wop->op1_type, wop->op1, BP_VAR_R); + znode_op op1_znode; + op1_znode.var = op1; + zval *varname = get_zval_ptr_undef(op1_type, op1_znode, BP_VAR_R); if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) { name = Z_STR_P(varname); tmp_name = NULL; } else { if ((op1_type & IS_CV) && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) { - zval_undefined_cv(wop->op1.var EXECUTE_DATA_CC); + zval_undefined_cv(op1 EXECUTE_DATA_CC); } name = zval_get_tmp_string(varname, &tmp_name); } @@ -3689,7 +3688,7 @@ static zend_never_inline zval* zend_fetch_static_property_address_ex(zend_proper zend_tmp_string_release(tmp_name); - FREE_OP(op1_type, wop->op1.var); + FREE_OP(op1_type, op1); } if (UNEXPECTED(result == NULL)) { @@ -3708,7 +3707,7 @@ static zend_never_inline zval* zend_fetch_static_property_address_ex(zend_proper } -static zend_always_inline zval* zend_fetch_static_property_address(zend_property_info **prop_info, uint32_t cache_slot, int fetch_type, int flags, uint8_t op1_type, uint8_t op2_type OPLINE_DC EXECUTE_DATA_DC) { +static zend_always_inline zval* zend_fetch_static_property_address(zend_property_info **prop_info, uint32_t cache_slot, int fetch_type, int flags, uint8_t op1_type, uint32_t op1, uint8_t op2_type, uint32_t op2 OPLINE_DC EXECUTE_DATA_DC) { zval *result; zend_property_info *property_info; @@ -3730,7 +3729,7 @@ static zend_always_inline zval* zend_fetch_static_property_address(zend_property return NULL; } } else { - result = zend_fetch_static_property_address_ex(&property_info, cache_slot, fetch_type OPLINE_CC EXECUTE_DATA_CC); + result = zend_fetch_static_property_address_ex(&property_info, cache_slot, fetch_type, op1_type, op1, op2_type, op2 OPLINE_CC EXECUTE_DATA_CC); if (UNEXPECTED(!result)) { return NULL; } @@ -3771,7 +3770,7 @@ ZEND_API zval* ZEND_FASTCALL zend_fetch_static_property(zend_execute_data *ex, i if (fetch_type == BP_VAR_W) { flags = wop->extended_value & ZEND_FETCH_OBJ_FLAGS; } - result = zend_fetch_static_property_address_ex(&property_info, cache_slot, fetch_type OPLINE_CC EXECUTE_DATA_CC); + result = zend_fetch_static_property_address_ex(&property_info, cache_slot, fetch_type, wop->op1_type, wop->op1.var, wop->op2_type, wop->op2.var OPLINE_CC EXECUTE_DATA_CC); if (EXPECTED(result)) { if (flags && ZEND_TYPE_IS_SET(property_info->type)) { zend_handle_fetch_obj_flags(NULL, result, NULL, property_info, flags); @@ -5717,31 +5716,36 @@ static zend_always_inline zend_execute_data *_zend_vm_stack_push_call_frame(uint } while (UNEXPECTED(prev_handler == opline->handler)); \ OPLINE = opline; \ ZEND_VM_CONTINUE() -#define ZEND_VM_SMART_BRANCH_EX(_result, _check, _check_jmpz, _check_jmpnz) do { \ +#define ZEND_VM_SMART_BRANCH_EX_OFFSET(_result, _check, _check_jmpz, _check_jmpnz, _offset) do { \ if ((_check) && UNEXPECTED(EG(exception))) { \ OPLINE = EX(opline); \ } else if (EXPECTED(_check_jmpz)) { \ if (_result) { \ - ZEND_VM_SET_NEXT_OPCODE(opline + 2); \ + ZEND_VM_SET_NEXT_OPCODE(opline + _offset + 1); \ } else { \ - ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline + 1, (opline+1)->op2)); \ + ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline + _offset, (opline+_offset)->op2)); \ } \ } else if (EXPECTED(_check_jmpnz)) { \ if (!(_result)) { \ - ZEND_VM_SET_NEXT_OPCODE(opline + 2); \ + ZEND_VM_SET_NEXT_OPCODE(opline + _offset + 1); \ } else { \ - ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline + 1, (opline+1)->op2)); \ + ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline + _offset, (opline+_offset)->op2)); \ } \ } else { \ ZVAL_BOOL(EX_VAR(opline->result.var), _result); \ - ZEND_VM_SET_NEXT_OPCODE(opline + 1); \ + ZEND_VM_SET_NEXT_OPCODE(opline + _offset); \ } \ ZEND_VM_CONTINUE(); \ } while (0) +#define ZEND_VM_SMART_BRANCH_EX(_result, _check, _check_jmpz, _check_jmpnz) ZEND_VM_SMART_BRANCH_EX_OFFSET(_result, _check, _check_jmpz, _check_jmpnz, 1) #define ZEND_VM_SMART_BRANCH(_result, _check) do { \ zend_op *wop = EX_WOP2; \ ZEND_VM_SMART_BRANCH_EX(_result, _check, wop->result_type == (IS_SMART_BRANCH_JMPZ|IS_TMP_VAR), wop->result_type == (IS_SMART_BRANCH_JMPNZ|IS_TMP_VAR)); \ } while (0) +#define ZEND_VM_SMART_BRANCH_OFFSET(_result, _check, _offset) do { \ + zend_op *wop = EX_WOP2; \ + ZEND_VM_SMART_BRANCH_EX_OFFSET(_result, _check, wop->result_type == (IS_SMART_BRANCH_JMPZ|IS_TMP_VAR), wop->result_type == (IS_SMART_BRANCH_JMPNZ|IS_TMP_VAR), _offset); \ + } while (0) #define ZEND_VM_SMART_BRANCH_JMPZ(_result, _check) do { \ if ((_check) && UNEXPECTED(EG(exception))) { \ OPLINE = EX(opline); \ diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index f483e5b6bf6a0..9b522f0e2d460 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -1109,7 +1109,7 @@ ZEND_VM_HANDLER(29, ZEND_ASSIGN_STATIC_PROP_OP, ANY, ANY, OP) SAVE_OPLINE(); - prop = zend_fetch_static_property_address(&prop_info, (opline+1)->extended_value, BP_VAR_RW, 0, OP1_TYPE, OP2_TYPE OPLINE_CC EXECUTE_DATA_CC); + prop = zend_fetch_static_property_address(&prop_info, (opline+1)->extended_value, BP_VAR_RW, 0, OP1_TYPE, opline->op1.var, OP2_TYPE, opline->op2.var OPLINE_CC EXECUTE_DATA_CC); if (UNEXPECTED(!prop)) { UNDEF_RESULT(); FREE_OP_DATA(); @@ -1432,7 +1432,7 @@ ZEND_VM_HANDLER(38, ZEND_PRE_INC_STATIC_PROP, ANY, ANY, CACHE_SLOT) SAVE_OPLINE(); - prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_RW, 0, OP1_TYPE, OP2_TYPE OPLINE_CC EXECUTE_DATA_CC); + prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_RW, 0, OP1_TYPE, opline->op1.var, OP2_TYPE, opline->op2.var OPLINE_CC EXECUTE_DATA_CC); if (UNEXPECTED(!prop)) { UNDEF_RESULT(); HANDLE_EXCEPTION(); @@ -1448,7 +1448,7 @@ ZEND_VM_HANDLER(38, ZEND_PRE_INC_STATIC_PROP, ANY, ANY, CACHE_SLOT) zend_pre_incdec_property_zval(prop, ZEND_TYPE_IS_SET(prop_info->type) ? prop_info : NULL OPLINE_CC EXECUTE_DATA_CC); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE_EX(1, 2); } /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ @@ -1466,7 +1466,7 @@ ZEND_VM_HANDLER(40, ZEND_POST_INC_STATIC_PROP, ANY, ANY, CACHE_SLOT) SAVE_OPLINE(); - prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_RW, 0, OP1_TYPE, OP2_TYPE OPLINE_CC EXECUTE_DATA_CC); + prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_RW, 0, OP1_TYPE, opline->op1.var, OP2_TYPE, opline->op2.var OPLINE_CC EXECUTE_DATA_CC); if (UNEXPECTED(!prop)) { UNDEF_RESULT(); HANDLE_EXCEPTION(); @@ -1482,7 +1482,7 @@ ZEND_VM_HANDLER(40, ZEND_POST_INC_STATIC_PROP, ANY, ANY, CACHE_SLOT) zend_post_incdec_property_zval(prop, ZEND_TYPE_IS_SET(prop_info->type) ? prop_info : NULL OPLINE_CC EXECUTE_DATA_CC); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE_EX(1, 2); } /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ @@ -1854,7 +1854,7 @@ ZEND_VM_HANDLER(89, ZEND_FETCH_IS, CONST|TMPVAR|CV, UNUSED, VAR_FETCH) } /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ -ZEND_VM_INLINE_HELPER(zend_fetch_static_prop_helper, ANY, ANY, int type, uint8_t op1_type, uint8_t op2_type) +ZEND_VM_INLINE_HELPER(zend_fetch_static_prop_helper, ANY, ANY, OPTIONS(quick_op_flags_field=op_data), int type) { USE_OPLINE zval *prop; @@ -1864,7 +1864,7 @@ ZEND_VM_INLINE_HELPER(zend_fetch_static_prop_helper, ANY, ANY, int type, uint8_t prop = zend_fetch_static_property_address( &prop_info, opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS, type, - type == BP_VAR_W ? opline->extended_value : 0, op1_type, op2_type OPLINE_CC EXECUTE_DATA_CC); + type == BP_VAR_W ? opline->extended_value : 0, OP1_TYPE, opline->op1.var, OP2_TYPE, opline->op2.var OPLINE_CC EXECUTE_DATA_CC); if (UNEXPECTED(!prop)) { ZEND_ASSERT(EG(exception) || (type == BP_VAR_IS)); prop = &EG(uninitialized_zval); @@ -1885,31 +1885,25 @@ ZEND_VM_C_LABEL(copy_deref): } else { ZVAL_INDIRECT(EX_VAR(opline->result.var), prop); } - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE_EX(1, 2); } /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ ZEND_VM_HANDLER(173, ZEND_FETCH_STATIC_PROP_R, ANY, CLASS_FETCH, CACHE_SLOT) { - uint8_t op1_type = OP1_TYPE; - uint8_t op2_type = OP2_TYPE; - ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper, type, BP_VAR_R, op1_type, op1_type, op2_type, op2_type); + ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper, type, BP_VAR_R); } /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ ZEND_VM_HANDLER(174, ZEND_FETCH_STATIC_PROP_W, ANY, CLASS_FETCH, FETCH_REF|DIM_WRITE|CACHE_SLOT) { - uint8_t op1_type = OP1_TYPE; - uint8_t op2_type = OP2_TYPE; - ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper, type, BP_VAR_W, op1_type, op1_type, op2_type, op2_type); + ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper, type, BP_VAR_W); } /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ ZEND_VM_HANDLER(175, ZEND_FETCH_STATIC_PROP_RW, ANY, CLASS_FETCH, CACHE_SLOT) { - uint8_t op1_type = OP1_TYPE; - uint8_t op2_type = OP2_TYPE; - ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper, type, BP_VAR_RW, op1_type, op1_type, op2_type, op2_type); + ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper, type, BP_VAR_RW); } /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ @@ -1925,17 +1919,13 @@ ZEND_VM_HANDLER(177, ZEND_FETCH_STATIC_PROP_FUNC_ARG, ANY, CLASS_FETCH, FETCH_RE /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ ZEND_VM_HANDLER(178, ZEND_FETCH_STATIC_PROP_UNSET, ANY, CLASS_FETCH, CACHE_SLOT) { - uint8_t op1_type = OP1_TYPE; - uint8_t op2_type = OP2_TYPE; - ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper, type, BP_VAR_UNSET, op1_type, op1_type, op2_type, op2_type); + ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper, type, BP_VAR_UNSET); } /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ ZEND_VM_HANDLER(176, ZEND_FETCH_STATIC_PROP_IS, ANY, CLASS_FETCH, CACHE_SLOT) { - uint8_t op1_type = OP1_TYPE; - uint8_t op2_type = OP2_TYPE; - ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper, type, BP_VAR_IS, op1_type, op1_type, op2_type, op2_type); + ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper, type, BP_VAR_IS); } ZEND_VM_COLD_CONSTCONST_HANDLER(81, ZEND_FETCH_DIM_R, CONST|TMPVAR|CV, CONST|TMPVAR|CV) @@ -2634,7 +2624,7 @@ ZEND_VM_HANDLER(25, ZEND_ASSIGN_STATIC_PROP, ANY, ANY, CACHE_SLOT, SPEC(OP_DATA= SAVE_OPLINE(); - prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_W, 0, OP1_TYPE, OP2_TYPE OPLINE_CC EXECUTE_DATA_CC); + prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_W, 0, OP1_TYPE, opline->op1.var, OP2_TYPE, opline->op2.var OPLINE_CC EXECUTE_DATA_CC); if (UNEXPECTED(!prop)) { FREE_OP_DATA(); UNDEF_RESULT(); @@ -2929,7 +2919,7 @@ ZEND_VM_HANDLER(33, ZEND_ASSIGN_STATIC_PROP_REF, ANY, ANY, CACHE_SLOT|SRC) SAVE_OPLINE(); - prop = zend_fetch_static_property_address(&prop_info, opline->extended_value & ~ZEND_RETURNS_FUNCTION, BP_VAR_W, 0, OP1_TYPE, OP2_TYPE OPLINE_CC EXECUTE_DATA_CC); + prop = zend_fetch_static_property_address(&prop_info, opline->extended_value & ~ZEND_RETURNS_FUNCTION, BP_VAR_W, 0, OP1_TYPE, opline->op1.var, OP2_TYPE, opline->op2.var OPLINE_CC EXECUTE_DATA_CC); if (UNEXPECTED(!prop)) { FREE_OP_DATA(); UNDEF_RESULT(); @@ -7497,7 +7487,7 @@ ZEND_VM_HANDLER(180, ZEND_ISSET_ISEMPTY_STATIC_PROP, ANY, CLASS_FETCH, ISSET|CAC SAVE_OPLINE(); - value = zend_fetch_static_property_address(NULL, opline->extended_value & ~ZEND_ISEMPTY, BP_VAR_IS, 0, OP1_TYPE, OP2_TYPE OPLINE_CC EXECUTE_DATA_CC); + value = zend_fetch_static_property_address(NULL, opline->extended_value & ~ZEND_ISEMPTY, BP_VAR_IS, 0, OP1_TYPE, opline->op1.var, OP2_TYPE, opline->op2.var OPLINE_CC EXECUTE_DATA_CC); if (!(opline->extended_value & ZEND_ISEMPTY)) { result = value != NULL && Z_TYPE_P(value) > IS_NULL && @@ -7506,7 +7496,7 @@ ZEND_VM_HANDLER(180, ZEND_ISSET_ISEMPTY_STATIC_PROP, ANY, CLASS_FETCH, ISSET|CAC result = value == NULL || !i_zend_is_true(value); } - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_OFFSET(result, 1, 2); } ZEND_VM_COLD_CONSTCONST_HANDLER(115, ZEND_ISSET_ISEMPTY_DIM_OBJ, CONST|TMPVAR|CV, CONST|TMPVAR|CV, ISSET) diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 8cc6d4677d646..fe1dcf11b856b 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -780,7 +780,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_OP_SPEC_HAN SAVE_OPLINE(); - prop = zend_fetch_static_property_address(&prop_info, (opline+1)->extended_value, BP_VAR_RW, 0, QUICK_OP_FLAGS_OP1_TYPE((opline+1)->op2.num), QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num) OPLINE_CC EXECUTE_DATA_CC); + prop = zend_fetch_static_property_address(&prop_info, (opline+1)->extended_value, BP_VAR_RW, 0, QUICK_OP_FLAGS_OP1_TYPE((opline+1)->op2.num), opline->op1.var, QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num), opline->op2.var OPLINE_CC EXECUTE_DATA_CC); if (UNEXPECTED(!prop)) { UNDEF_RESULT(); FREE_OP(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1.var); @@ -832,7 +832,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_STATIC_PROP_SPEC_HANDL SAVE_OPLINE(); - prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_RW, 0, EX_WOP2->op1_type, EX_WOP2->op2_type OPLINE_CC EXECUTE_DATA_CC); + prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_RW, 0, QUICK_OP_FLAGS_OP1_TYPE((opline+1)->op2.num), opline->op1.var, QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num), opline->op2.var OPLINE_CC EXECUTE_DATA_CC); if (UNEXPECTED(!prop)) { UNDEF_RESULT(); HANDLE_EXCEPTION(); @@ -848,7 +848,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_STATIC_PROP_SPEC_HANDL zend_pre_incdec_property_zval(prop, ZEND_TYPE_IS_SET(prop_info->type) ? prop_info : NULL OPLINE_CC EXECUTE_DATA_CC); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE_EX(1, 2); } /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ @@ -860,7 +860,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_STATIC_PROP_SPEC_HAND SAVE_OPLINE(); - prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_RW, 0, EX_WOP2->op1_type, EX_WOP2->op2_type OPLINE_CC EXECUTE_DATA_CC); + prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_RW, 0, QUICK_OP_FLAGS_OP1_TYPE((opline+1)->op2.num), opline->op1.var, QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num), opline->op2.var OPLINE_CC EXECUTE_DATA_CC); if (UNEXPECTED(!prop)) { UNDEF_RESULT(); HANDLE_EXCEPTION(); @@ -876,11 +876,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_STATIC_PROP_SPEC_HAND zend_post_incdec_property_zval(prop, ZEND_TYPE_IS_SET(prop_info->type) ? prop_info : NULL OPLINE_CC EXECUTE_DATA_CC); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE_EX(1, 2); } /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ -static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_fetch_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX int type, uint8_t op1_type, uint8_t op2_type) +static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_fetch_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX int type) { USE_OPLINE zval *prop; @@ -890,7 +890,7 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_fetch_static_prop_helper_ prop = zend_fetch_static_property_address( &prop_info, opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS, type, - type == BP_VAR_W ? opline->extended_value : 0, op1_type, op2_type OPLINE_CC EXECUTE_DATA_CC); + type == BP_VAR_W ? opline->extended_value : 0, QUICK_OP_FLAGS_OP1_TYPE((opline+1)->op2.num), opline->op1.var, QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num), opline->op2.var OPLINE_CC EXECUTE_DATA_CC); if (UNEXPECTED(!prop)) { ZEND_ASSERT(EG(exception) || (type == BP_VAR_IS)); prop = &EG(uninitialized_zval); @@ -911,31 +911,25 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_fetch_static_prop_helper_ } else { ZVAL_INDIRECT(EX_VAR(opline->result.var), prop); } - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE_EX(1, 2); } /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_STATIC_PROP_R_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - uint8_t op1_type = EX_WOP2->op1_type; - uint8_t op2_type = EX_WOP2->op2_type; - ZEND_VM_TAIL_CALL(zend_fetch_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_R, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_fetch_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_R)); } /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_STATIC_PROP_W_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - uint8_t op1_type = EX_WOP2->op1_type; - uint8_t op2_type = EX_WOP2->op2_type; - ZEND_VM_TAIL_CALL(zend_fetch_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_W, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_fetch_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_W)); } /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_STATIC_PROP_RW_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - uint8_t op1_type = EX_WOP2->op1_type; - uint8_t op2_type = EX_WOP2->op2_type; - ZEND_VM_TAIL_CALL(zend_fetch_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_RW, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_fetch_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_RW)); } /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ @@ -951,17 +945,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPE /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_STATIC_PROP_UNSET_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - uint8_t op1_type = EX_WOP2->op1_type; - uint8_t op2_type = EX_WOP2->op2_type; - ZEND_VM_TAIL_CALL(zend_fetch_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_UNSET, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_fetch_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_UNSET)); } /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_STATIC_PROP_IS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - uint8_t op1_type = EX_WOP2->op1_type; - uint8_t op2_type = EX_WOP2->op2_type; - ZEND_VM_TAIL_CALL(zend_fetch_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_IS, op1_type, op2_type)); + ZEND_VM_TAIL_CALL(zend_fetch_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_IS)); } static zend_never_inline ZEND_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS) @@ -997,7 +987,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DAT SAVE_OPLINE(); - prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_W, 0, QUICK_OP_FLAGS_OP1_TYPE((opline+1)->op2.num), QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num) OPLINE_CC EXECUTE_DATA_CC); + prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_W, 0, QUICK_OP_FLAGS_OP1_TYPE((opline+1)->op2.num), opline->op1.var, QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num), opline->op2.var OPLINE_CC EXECUTE_DATA_CC); if (UNEXPECTED(!prop)) { UNDEF_RESULT(); @@ -1034,7 +1024,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DAT SAVE_OPLINE(); - prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_W, 0, QUICK_OP_FLAGS_OP1_TYPE((opline+1)->op2.num), QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num) OPLINE_CC EXECUTE_DATA_CC); + prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_W, 0, QUICK_OP_FLAGS_OP1_TYPE((opline+1)->op2.num), opline->op1.var, QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num), opline->op2.var OPLINE_CC EXECUTE_DATA_CC); if (UNEXPECTED(!prop)) { zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); UNDEF_RESULT(); @@ -1071,7 +1061,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DAT SAVE_OPLINE(); - prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_W, 0, QUICK_OP_FLAGS_OP1_TYPE((opline+1)->op2.num), QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num) OPLINE_CC EXECUTE_DATA_CC); + prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_W, 0, QUICK_OP_FLAGS_OP1_TYPE((opline+1)->op2.num), opline->op1.var, QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num), opline->op2.var OPLINE_CC EXECUTE_DATA_CC); if (UNEXPECTED(!prop)) { zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); UNDEF_RESULT(); @@ -1108,7 +1098,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DAT SAVE_OPLINE(); - prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_W, 0, QUICK_OP_FLAGS_OP1_TYPE((opline+1)->op2.num), QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num) OPLINE_CC EXECUTE_DATA_CC); + prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_W, 0, QUICK_OP_FLAGS_OP1_TYPE((opline+1)->op2.num), opline->op1.var, QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num), opline->op2.var OPLINE_CC EXECUTE_DATA_CC); if (UNEXPECTED(!prop)) { UNDEF_RESULT(); @@ -1145,7 +1135,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_REF_SPEC_HA SAVE_OPLINE(); - prop = zend_fetch_static_property_address(&prop_info, opline->extended_value & ~ZEND_RETURNS_FUNCTION, BP_VAR_W, 0, QUICK_OP_FLAGS_OP1_TYPE((opline+1)->op2.num), QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num) OPLINE_CC EXECUTE_DATA_CC); + prop = zend_fetch_static_property_address(&prop_info, opline->extended_value & ~ZEND_RETURNS_FUNCTION, BP_VAR_W, 0, QUICK_OP_FLAGS_OP1_TYPE((opline+1)->op2.num), opline->op1.var, QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num), opline->op2.var OPLINE_CC EXECUTE_DATA_CC); if (UNEXPECTED(!prop)) { FREE_OP(QUICK_OP_FLAGS_OP_DATA_TYPE((opline+1)->op2.num), (opline+1)->op1.var); UNDEF_RESULT(); @@ -3108,7 +3098,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC SAVE_OPLINE(); - value = zend_fetch_static_property_address(NULL, opline->extended_value & ~ZEND_ISEMPTY, BP_VAR_IS, 0, EX_WOP2->op1_type, EX_WOP2->op2_type OPLINE_CC EXECUTE_DATA_CC); + value = zend_fetch_static_property_address(NULL, opline->extended_value & ~ZEND_ISEMPTY, BP_VAR_IS, 0, QUICK_OP_FLAGS_OP1_TYPE((opline+1)->op2.num), opline->op1.var, QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num), opline->op2.var OPLINE_CC EXECUTE_DATA_CC); if (!(opline->extended_value & ZEND_ISEMPTY)) { result = value != NULL && Z_TYPE_P(value) > IS_NULL && @@ -3117,7 +3107,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC result = value == NULL || !i_zend_is_true(value); } - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BEGIN_SILENCE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) diff --git a/Zend/zend_vm_gen.php b/Zend/zend_vm_gen.php index 7d9a37b869876..7bb7c525dbc18 100755 --- a/Zend/zend_vm_gen.php +++ b/Zend/zend_vm_gen.php @@ -800,6 +800,15 @@ function gen_code($opcode, $f, $spec, $kind, $code, $op1, $op2, $name, $extra_sp return "ZEND_VM_SMART_BRANCH(\\1, \\2)"; })(), + "/ZEND_VM_SMART_BRANCH_OFFSET\(\s*([^,)]*)\s*,\s*([^)]*)\s*\,\s*([^)]*)\s*\)/" => (function () use ($opcode, $extra_spec) { + /* Currently not used for any SMART_BRANCH specialized handlers. */ + $field = $opcode['quick_op_flags_field'] ?? null; + if ($field) { + return "ZEND_VM_SMART_BRANCH_EX_OFFSET(\\1, \\2, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ($field), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ($field), \\3)"; + } + + return "ZEND_VM_SMART_BRANCH_OFFSET(\\1, \\2, \\3)"; + })(), "/ZEND_VM_SMART_BRANCH_TRUE\(\s*\)/" => (function () use ($opcode, $extra_spec) { if (isset($extra_spec['SMART_BRANCH'])) { if ($extra_spec['SMART_BRANCH'] == 1) { @@ -2510,6 +2519,18 @@ function gen_vm_opcodes_header( 'ZEND_DECLARE_ATTRIBUTED_CONST', 'ZEND_FRAMELESS_ICALL_2', 'ZEND_FRAMELESS_ICALL_3', + + 'ZEND_FETCH_STATIC_PROP_FUNC_ARG', + 'ZEND_FETCH_STATIC_PROP_IS', + 'ZEND_FETCH_STATIC_PROP_R', + 'ZEND_FETCH_STATIC_PROP_RW', + 'ZEND_FETCH_STATIC_PROP_UNSET', + 'ZEND_FETCH_STATIC_PROP_W', + 'ZEND_ISSET_ISEMPTY_STATIC_PROP', + 'ZEND_POST_DEC_STATIC_PROP', + 'ZEND_POST_INC_STATIC_PROP', + 'ZEND_PRE_DEC_STATIC_PROP', + 'ZEND_PRE_INC_STATIC_PROP', ]; function needs_quick_op_flags($opcode) { @@ -2536,12 +2557,6 @@ function get_quick_op_flags_field($opcode) { 'ZEND_CATCH', 'ZEND_DECLARE_ANON_CLASS', 'ZEND_FETCH_CLASS_CONSTANT', - 'ZEND_FETCH_STATIC_PROP_FUNC_ARG', - 'ZEND_FETCH_STATIC_PROP_IS', - 'ZEND_FETCH_STATIC_PROP_R', - 'ZEND_FETCH_STATIC_PROP_RW', - 'ZEND_FETCH_STATIC_PROP_UNSET', - 'ZEND_FETCH_STATIC_PROP_W', 'ZEND_FE_FETCH_R', 'ZEND_FE_FETCH_RW', 'ZEND_INCLUDE_OR_EVAL', @@ -2549,18 +2564,15 @@ function get_quick_op_flags_field($opcode) { 'ZEND_INIT_FCALL', 'ZEND_INIT_FCALL_BY_NAME', 'ZEND_INIT_NS_FCALL_BY_NAME', + 'ZEND_JMP_NULL', + 'ZEND_RETURN_BY_REF', + 'ZEND_TICKS', + + // Trying to improve 'ZEND_INSTANCEOF', 'ZEND_IN_ARRAY', 'ZEND_ISSET_ISEMPTY_DIM_OBJ', 'ZEND_ISSET_ISEMPTY_PROP_OBJ', - 'ZEND_ISSET_ISEMPTY_STATIC_PROP', - 'ZEND_JMP_NULL', - 'ZEND_POST_DEC_STATIC_PROP', - 'ZEND_POST_INC_STATIC_PROP', - 'ZEND_PRE_DEC_STATIC_PROP', - 'ZEND_PRE_INC_STATIC_PROP', - 'ZEND_RETURN_BY_REF', - 'ZEND_TICKS', ]; $has_free_result = [ @@ -2826,6 +2838,10 @@ function gen_vm($def, $skel) { foreach ($options as $option) { [$option_name, $option_value] = explode('=', $option); if ($option_name === 'quick_op_flags_field') { + // FIXME: Can't set this through OPTIONS() because it contains a ). + if ($option_value === 'op_data') { + $option_value = '(opline+1)->op2.num'; + } $quick_op_flags_field = $option_value; } else { die("ERROR ($def:$lineno): Unknown helper option '$option_name'.\n"); diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c index 63ade044d2323..07ff18c892e30 100644 --- a/Zend/zend_vm_opcodes.c +++ b/Zend/zend_vm_opcodes.c @@ -275,10 +275,10 @@ static uint64_t zend_vm_opcodes_flags[211] = { 0x100000001, 0x100000001, 0x100000001, - 0x00040000, - 0x00040000, - 0x00040000, - 0x00040000, + 0x500040000, + 0x500040000, + 0x500040000, + 0x500040000, 0x100000020, 0x100002007, 0x100002007, @@ -410,14 +410,14 @@ static uint64_t zend_vm_opcodes_flags[211] = { 0x00000707, 0x00000101, 0x00000103, - 0x00047000, - 0x00647000, - 0x00047000, - 0x00047000, - 0x00247000, - 0x00047000, + 0x500047000, + 0x500647000, + 0x500047000, + 0x500047000, + 0x500247000, + 0x500047000, 0x400040000, - 0x00067000, + 0x500067000, 0x00040b73, 0x00100101, 0x400100001, From b0a8192fd82f9e4ddd35397ac4e0914f9e2aed32 Mon Sep 17 00:00:00 2001 From: Ilija Tovilo Date: Tue, 10 Jun 2025 22:45:09 +0200 Subject: [PATCH 13/19] Implement op_data + quick flags for ZEND_FE_FETCH_R[W] --- Zend/zend_compile.c | 6 ++++-- Zend/zend_vm_def.h | 12 ++++++------ Zend/zend_vm_execute.h | 18 +++++++++--------- Zend/zend_vm_gen.php | 4 ++-- Zend/zend_vm_opcodes.c | 4 ++-- 5 files changed, 23 insertions(+), 21 deletions(-) diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index 4e73cb89ad293..55f9101771dbb 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -6123,12 +6123,14 @@ static void zend_compile_foreach(zend_ast *ast) /* {{{ */ } opnum_reset = get_next_op_number(); - opline = zend_emit_op(&reset_node, by_ref ? ZEND_FE_RESET_RW : ZEND_FE_RESET_R, &expr_node, NULL); + zend_emit_op(&reset_node, by_ref ? ZEND_FE_RESET_RW : ZEND_FE_RESET_R, &expr_node, NULL); zend_begin_loop(ZEND_FE_FREE, &reset_node, 0); opnum_fetch = get_next_op_number(); - opline = zend_emit_op(NULL, by_ref ? ZEND_FE_FETCH_RW : ZEND_FE_FETCH_R, &reset_node, NULL); + zend_emit_op(NULL, by_ref ? ZEND_FE_FETCH_RW : ZEND_FE_FETCH_R, &reset_node, NULL); + zend_emit_op_data(NULL); + opline = CG(active_op_array)->opcodes + opnum_fetch; if (is_this_fetch(value_ast)) { zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this"); diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 9b522f0e2d460..6d9c115bf2dd9 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -7012,7 +7012,7 @@ ZEND_VM_COLD_CONST_HANDLER(125, ZEND_FE_RESET_RW, CONST|TMP|VAR|CV, JMP_ADDR) } } -ZEND_VM_HELPER(zend_fe_fetch_object_helper, ANY, ANY) +ZEND_VM_HELPER(zend_fe_fetch_object_helper, ANY, ANY, OPTIONS(quick_op_flags_field=op_data)) { USE_OPLINE zval *array; @@ -7127,7 +7127,7 @@ ZEND_VM_C_LABEL(fe_fetch_r_exit): GC_ADDREF(gc); } } - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE_EX(1, 2); } ZEND_VM_HOT_HANDLER(78, ZEND_FE_FETCH_R, VAR, ANY, JMP_ADDR) @@ -7197,7 +7197,7 @@ ZEND_VM_HOT_HANDLER(78, ZEND_FE_FETCH_R, VAR, ANY, JMP_ADDR) zval *variable_ptr = EX_VAR(opline->op2.var); SAVE_OPLINE(); zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES()); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE_EX(1, 2); } else { zval *res = EX_VAR(opline->op2.var); zend_refcounted *gc = Z_COUNTED_P(value); @@ -7206,7 +7206,7 @@ ZEND_VM_HOT_HANDLER(78, ZEND_FE_FETCH_R, VAR, ANY, JMP_ADDR) if (Z_TYPE_INFO_REFCOUNTED(value_type)) { GC_ADDREF(gc); } - ZEND_VM_NEXT_OPCODE(); + ZEND_VM_NEXT_OPCODE_EX(0, 2); } } @@ -7409,7 +7409,7 @@ ZEND_VM_C_LABEL(fe_fetch_w_exit): Z_ADDREF_P(value); ZVAL_REF(EX_VAR(opline->op2.var), Z_REF_P(value)); } - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE_EX(1, 2); } ZEND_VM_HOT_HANDLER(154, ZEND_ISSET_ISEMPTY_CV, CV, UNUSED, ISSET, SPEC(ISSET)) @@ -10486,7 +10486,7 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_FE_FETCH_R, op->op2_type == IS_CV && (op1_inf variable_ptr = EX_VAR(opline->op2.var); zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES()); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE_EX(1, 2); } ZEND_VM_DEFINE_OP(137, ZEND_OP_DATA); diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index fe1dcf11b856b..8038db0bb3e0f 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -3075,7 +3075,7 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fe_fetch_obj value_type = Z_TYPE_INFO_P(value); } - if (EXPECTED(EX_WOP2->op2_type == IS_CV)) { + if (EXPECTED(QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num) == IS_CV)) { zval *variable_ptr = EX_VAR(opline->op2.var); zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES()); } else { @@ -3087,7 +3087,7 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fe_fetch_obj GC_ADDREF(gc); } } - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE_EX(1, 2); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -23160,11 +23160,11 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FETCH_R_SPEC_VA } } } - if (EXPECTED(EX_WOP2->op2_type == IS_CV)) { + if (EXPECTED(QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num) == IS_CV)) { zval *variable_ptr = EX_VAR(opline->op2.var); SAVE_OPLINE(); zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES()); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE_EX(1, 2); } else { zval *res = EX_VAR(opline->op2.var); zend_refcounted *gc = Z_COUNTED_P(value); @@ -23173,7 +23173,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FETCH_R_SPEC_VA if (Z_TYPE_INFO_REFCOUNTED(value_type)) { GC_ADDREF(gc); } - ZEND_VM_NEXT_OPCODE(); + ZEND_VM_NEXT_OPCODE_EX(0, 2); } } @@ -23362,7 +23362,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FETCH_RW_SPEC_VAR_HANDLER(Z ref = Z_REFVAL_P(value); ZVAL_COPY_VALUE_EX(ref, value, gc, value_type); } - if (EXPECTED(EX_WOP2->op2_type == IS_CV)) { + if (EXPECTED(QUICK_OP_FLAGS_OP2_TYPE((opline+1)->op2.num) == IS_CV)) { zval *variable_ptr = EX_VAR(opline->op2.var); if (EXPECTED(variable_ptr != value)) { zend_reference *ref; @@ -23376,7 +23376,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FETCH_RW_SPEC_VAR_HANDLER(Z Z_ADDREF_P(value); ZVAL_REF(EX_VAR(opline->op2.var), Z_REF_P(value)); } - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE_EX(1, 2); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_SET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -33443,7 +33443,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FETCH_R_SIMPLE_ variable_ptr = EX_VAR(opline->op2.var); zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES()); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE_EX(1, 2); } @@ -33511,7 +33511,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FETCH_R_SIMPLE_ variable_ptr = EX_VAR(opline->op2.var); zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES()); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE_EX(1, 2); } diff --git a/Zend/zend_vm_gen.php b/Zend/zend_vm_gen.php index 7bb7c525dbc18..060f0214ecd1c 100755 --- a/Zend/zend_vm_gen.php +++ b/Zend/zend_vm_gen.php @@ -2526,6 +2526,8 @@ function gen_vm_opcodes_header( 'ZEND_FETCH_STATIC_PROP_RW', 'ZEND_FETCH_STATIC_PROP_UNSET', 'ZEND_FETCH_STATIC_PROP_W', + 'ZEND_FE_FETCH_R', + 'ZEND_FE_FETCH_RW', 'ZEND_ISSET_ISEMPTY_STATIC_PROP', 'ZEND_POST_DEC_STATIC_PROP', 'ZEND_POST_INC_STATIC_PROP', @@ -2557,8 +2559,6 @@ function get_quick_op_flags_field($opcode) { 'ZEND_CATCH', 'ZEND_DECLARE_ANON_CLASS', 'ZEND_FETCH_CLASS_CONSTANT', - 'ZEND_FE_FETCH_R', - 'ZEND_FE_FETCH_RW', 'ZEND_INCLUDE_OR_EVAL', 'ZEND_INIT_DYNAMIC_CALL', 'ZEND_INIT_FCALL', diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c index 07ff18c892e30..b3e7fc8d53de5 100644 --- a/Zend/zend_vm_opcodes.c +++ b/Zend/zend_vm_opcodes.c @@ -315,7 +315,7 @@ static uint64_t zend_vm_opcodes_flags[211] = { 0x00000701, 0x00040751, 0x100002003, - 0x03000001, + 0x503000001, 0x00000000, 0x00010107, 0x00000707, @@ -363,7 +363,7 @@ static uint64_t zend_vm_opcodes_flags[211] = { 0x309000107, 0x00000103, 0x100002003, - 0x03000001, + 0x503000001, 0x100000005, 0x01000700, 0x100000000, From 57b634524c23656975e655ee6cdcd2efd9bbd3bc Mon Sep 17 00:00:00 2001 From: Ilija Tovilo Date: Tue, 10 Jun 2025 23:59:08 +0200 Subject: [PATCH 14/19] Avoid wop for pre/post inc/dec and isset --- Zend/zend_compile.c | 2 + Zend/zend_execute.c | 31 +- Zend/zend_vm_def.h | 52 +- Zend/zend_vm_execute.h | 1058 +++++++++++----- Zend/zend_vm_gen.php | 4 +- Zend/zend_vm_handlers.h | 2638 ++++++++++++++++++++------------------- Zend/zend_vm_opcodes.c | 4 +- 7 files changed, 2125 insertions(+), 1664 deletions(-) diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index 55f9101771dbb..83534196ed4a7 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -10747,11 +10747,13 @@ static void zend_compile_isset_or_empty(znode *result, zend_ast *ast) /* {{{ */ case ZEND_AST_DIM: opline = zend_compile_dim(result, var_ast, BP_VAR_IS, /* by_ref */ false); opline->opcode = ZEND_ISSET_ISEMPTY_DIM_OBJ; + zend_emit_op_data(NULL); break; case ZEND_AST_PROP: case ZEND_AST_NULLSAFE_PROP: opline = zend_compile_prop(result, var_ast, BP_VAR_IS, 0); opline->opcode = ZEND_ISSET_ISEMPTY_PROP_OBJ; + zend_emit_op_data(NULL); break; case ZEND_AST_STATIC_PROP: opline = zend_compile_static_prop(result, var_ast, BP_VAR_IS, 0, 0); diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c index a3460da0b891f..90ddbb06a6e5f 100644 --- a/Zend/zend_execute.c +++ b/Zend/zend_execute.c @@ -2265,13 +2265,10 @@ static void zend_incdec_typed_prop(zend_property_info *prop_info, zval *var_ptr, } } -static void zend_pre_incdec_property_zval(zval *prop, zend_property_info *prop_info OPLINE_DC EXECUTE_DATA_DC) +static void zend_pre_incdec_property_zval(zval *prop, zend_property_info *prop_info, bool is_inc, uint32_t result OPLINE_DC EXECUTE_DATA_DC) { - // FIXME: If this may be inlined, fetch wop only if needed. - zend_op *wop = EX_WOP; - if (EXPECTED(Z_TYPE_P(prop) == IS_LONG)) { - if (ZEND_IS_INCREMENT(wop->opcode)) { + if (is_inc) { fast_long_increment_function(prop); } else { fast_long_decrement_function(prop); @@ -2294,26 +2291,24 @@ static void zend_pre_incdec_property_zval(zval *prop, zend_property_info *prop_i if (prop_info) { zend_incdec_typed_prop(prop_info, prop, NULL OPLINE_CC EXECUTE_DATA_CC); - } else if (ZEND_IS_INCREMENT(wop->opcode)) { + } else if (is_inc) { increment_function(prop); } else { decrement_function(prop); } } while (0); } - if (UNEXPECTED(RETURN_VALUE_USED(wop))) { - ZVAL_COPY(EX_VAR(wop->result.var), prop); + // FIXME: How do we promote -1 to 32-bit? + if (UNEXPECTED(result != (uint16_t)-1)) { + ZVAL_COPY(EX_VAR(result), prop); } } -static void zend_post_incdec_property_zval(zval *prop, zend_property_info *prop_info OPLINE_DC EXECUTE_DATA_DC) +static void zend_post_incdec_property_zval(zval *prop, zend_property_info *prop_info, bool is_inc, uint32_t result OPLINE_DC EXECUTE_DATA_DC) { - // FIXME: If this may be inlined, fetch wop only if needed. - zend_op *wop = EX_WOP; - if (EXPECTED(Z_TYPE_P(prop) == IS_LONG)) { - ZVAL_LONG(EX_VAR(wop->result.var), Z_LVAL_P(prop)); - if (ZEND_IS_INCREMENT(wop->opcode)) { + ZVAL_LONG(EX_VAR(result), Z_LVAL_P(prop)); + if (is_inc) { fast_long_increment_function(prop); } else { fast_long_decrement_function(prop); @@ -2328,16 +2323,16 @@ static void zend_post_incdec_property_zval(zval *prop, zend_property_info *prop_ zend_reference *ref = Z_REF_P(prop); prop = Z_REFVAL_P(prop); if (ZEND_REF_HAS_TYPE_SOURCES(ref)) { - zend_incdec_typed_ref(ref, EX_VAR(wop->result.var) OPLINE_CC EXECUTE_DATA_CC); + zend_incdec_typed_ref(ref, EX_VAR(result) OPLINE_CC EXECUTE_DATA_CC); return; } } if (prop_info) { - zend_incdec_typed_prop(prop_info, prop, EX_VAR(wop->result.var) OPLINE_CC EXECUTE_DATA_CC); + zend_incdec_typed_prop(prop_info, prop, EX_VAR(result) OPLINE_CC EXECUTE_DATA_CC); } else { - ZVAL_COPY(EX_VAR(wop->result.var), prop); - if (ZEND_IS_INCREMENT(wop->opcode)) { + ZVAL_COPY(EX_VAR(result), prop); + if (is_inc) { increment_function(prop); } else { decrement_function(prop); diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 6d9c115bf2dd9..c44107386a575 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -1285,7 +1285,7 @@ ZEND_VM_HANDLER(26, ZEND_ASSIGN_OP, VAR|CV, CONST|TMPVAR|CV, OP) ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -ZEND_VM_HANDLER(132, ZEND_PRE_INC_OBJ, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, CACHE_SLOT) +ZEND_VM_HELPER(zend_pre_incdec_obj_helper, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, bool is_inc) { USE_OPLINE zval *object; @@ -1335,7 +1335,7 @@ ZEND_VM_C_LABEL(pre_incdec_object): } } else { prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2); - zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC); + zend_pre_incdec_property_zval(zptr, prop_info, is_inc, opline->result.var OPLINE_CC EXECUTE_DATA_CC); } } else { zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC); @@ -1350,12 +1350,17 @@ ZEND_VM_C_LABEL(pre_incdec_object): ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +ZEND_VM_HANDLER(132, ZEND_PRE_INC_OBJ, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, CACHE_SLOT) +{ + ZEND_VM_DISPATCH_TO_HELPER(zend_pre_incdec_obj_helper, is_inc, true); +} + ZEND_VM_HANDLER(133, ZEND_PRE_DEC_OBJ, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, CACHE_SLOT) { - ZEND_VM_DISPATCH_TO_HANDLER(ZEND_PRE_INC_OBJ); + ZEND_VM_DISPATCH_TO_HELPER(zend_pre_incdec_obj_helper, is_inc, false); } -ZEND_VM_HANDLER(134, ZEND_POST_INC_OBJ, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, CACHE_SLOT) +ZEND_VM_HELPER(zend_post_incdec_obj_helper, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, bool is_inc) { USE_OPLINE zval *object; @@ -1403,7 +1408,7 @@ ZEND_VM_C_LABEL(post_incdec_object): ZVAL_NULL(EX_VAR(opline->result.var)); } else { prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2); - zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC); + zend_post_incdec_property_zval(zptr, prop_info, is_inc, opline->result.var OPLINE_CC EXECUTE_DATA_CC); } } else { zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC); @@ -1418,13 +1423,18 @@ ZEND_VM_C_LABEL(post_incdec_object): ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +ZEND_VM_HANDLER(134, ZEND_POST_INC_OBJ, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, CACHE_SLOT) +{ + ZEND_VM_DISPATCH_TO_HELPER(zend_post_incdec_obj_helper, is_inc, true); +} + ZEND_VM_HANDLER(135, ZEND_POST_DEC_OBJ, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, CACHE_SLOT) { - ZEND_VM_DISPATCH_TO_HANDLER(ZEND_POST_INC_OBJ); + ZEND_VM_DISPATCH_TO_HELPER(zend_post_incdec_obj_helper, is_inc, false); } /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ -ZEND_VM_HANDLER(38, ZEND_PRE_INC_STATIC_PROP, ANY, ANY, CACHE_SLOT) +ZEND_VM_HELPER(zend_pre_incdec_static_prop_helper, ANY, ANY, OPTIONS(quick_op_flags_field=op_data), bool is_inc) { USE_OPLINE zval *prop; @@ -1446,19 +1456,25 @@ ZEND_VM_HANDLER(38, ZEND_PRE_INC_STATIC_PROP, ANY, ANY, CACHE_SLOT) } zend_pre_incdec_property_zval(prop, - ZEND_TYPE_IS_SET(prop_info->type) ? prop_info : NULL OPLINE_CC EXECUTE_DATA_CC); + ZEND_TYPE_IS_SET(prop_info->type) ? prop_info : NULL, is_inc, opline->result.var OPLINE_CC EXECUTE_DATA_CC); ZEND_VM_NEXT_OPCODE_EX(1, 2); } +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +ZEND_VM_HANDLER(38, ZEND_PRE_INC_STATIC_PROP, ANY, ANY, CACHE_SLOT) +{ + ZEND_VM_DISPATCH_TO_HELPER(zend_pre_incdec_static_prop_helper, is_inc, true); +} + /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ ZEND_VM_HANDLER(39, ZEND_PRE_DEC_STATIC_PROP, ANY, ANY, CACHE_SLOT) { - ZEND_VM_DISPATCH_TO_HANDLER(ZEND_PRE_INC_STATIC_PROP); + ZEND_VM_DISPATCH_TO_HELPER(zend_pre_incdec_static_prop_helper, is_inc, false); } /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ -ZEND_VM_HANDLER(40, ZEND_POST_INC_STATIC_PROP, ANY, ANY, CACHE_SLOT) +ZEND_VM_HELPER(zend_post_incdec_static_prop_helper, ANY, ANY, OPTIONS(quick_op_flags_field=op_data), bool is_inc) { USE_OPLINE zval *prop; @@ -1480,15 +1496,21 @@ ZEND_VM_HANDLER(40, ZEND_POST_INC_STATIC_PROP, ANY, ANY, CACHE_SLOT) } zend_post_incdec_property_zval(prop, - ZEND_TYPE_IS_SET(prop_info->type) ? prop_info : NULL OPLINE_CC EXECUTE_DATA_CC); + ZEND_TYPE_IS_SET(prop_info->type) ? prop_info : NULL, is_inc, opline->result.var OPLINE_CC EXECUTE_DATA_CC); ZEND_VM_NEXT_OPCODE_EX(1, 2); } +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +ZEND_VM_HANDLER(40, ZEND_POST_INC_STATIC_PROP, ANY, ANY, CACHE_SLOT) +{ + ZEND_VM_DISPATCH_TO_HELPER(zend_post_incdec_static_prop_helper, is_inc, true); +} + /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ ZEND_VM_HANDLER(41, ZEND_POST_DEC_STATIC_PROP, ANY, ANY, CACHE_SLOT) { - ZEND_VM_DISPATCH_TO_HANDLER(ZEND_POST_INC_STATIC_PROP); + ZEND_VM_DISPATCH_TO_HELPER(zend_post_incdec_static_prop_helper, is_inc, false); } ZEND_VM_HELPER(zend_pre_inc_helper, VAR|CV, ANY, OPTIONS(quick_op_flags_field=opline->extended_value)) @@ -7550,7 +7572,7 @@ ZEND_VM_C_LABEL(num_index_prop): if (OP1_TYPE & (IS_CONST|IS_CV)) { /* avoid exception check */ FREE_OP2(); - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_OFFSET(result, 0, 2); } } else { result = (value == NULL || !i_zend_is_true(value)); @@ -7575,7 +7597,7 @@ ZEND_VM_C_LABEL(num_index_prop): ZEND_VM_C_LABEL(isset_dim_obj_exit): FREE_OP2(); FREE_OP1(); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_OFFSET(result, 1, 2); } ZEND_VM_COLD_CONST_HANDLER(148, ZEND_ISSET_ISEMPTY_PROP_OBJ, CONST|TMPVAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, ISSET|CACHE_SLOT) @@ -7625,7 +7647,7 @@ ZEND_VM_COLD_CONST_HANDLER(148, ZEND_ISSET_ISEMPTY_PROP_OBJ, CONST|TMPVAR|UNUSED ZEND_VM_C_LABEL(isset_object_finish): FREE_OP2(); FREE_OP1(); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_OFFSET(result, 1, 2); } ZEND_VM_HANDLER(194, ZEND_ARRAY_KEY_EXISTS, CV|TMPVAR|CONST, CV|TMPVAR|CONST) diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 8038db0bb3e0f..059ee67c25b81 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -824,7 +824,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_OP_SPEC_HAN ZEND_VM_NEXT_OPCODE_EX(1, 2); } -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX bool is_inc) { USE_OPLINE zval *prop; @@ -846,13 +846,25 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_STATIC_PROP_SPEC_HANDL } zend_pre_incdec_property_zval(prop, - ZEND_TYPE_IS_SET(prop_info->type) ? prop_info : NULL OPLINE_CC EXECUTE_DATA_CC); + ZEND_TYPE_IS_SET(prop_info->type) ? prop_info : NULL, is_inc, opline->result.var OPLINE_CC EXECUTE_DATA_CC); ZEND_VM_NEXT_OPCODE_EX(1, 2); } /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_TAIL_CALL(zend_pre_incdec_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX true)); +} + +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_TAIL_CALL(zend_pre_incdec_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX false)); +} + +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX bool is_inc) { USE_OPLINE zval *prop; @@ -874,12 +886,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_STATIC_PROP_SPEC_HAND } zend_post_incdec_property_zval(prop, - ZEND_TYPE_IS_SET(prop_info->type) ? prop_info : NULL OPLINE_CC EXECUTE_DATA_CC); + ZEND_TYPE_IS_SET(prop_info->type) ? prop_info : NULL, is_inc, opline->result.var OPLINE_CC EXECUTE_DATA_CC); ZEND_VM_NEXT_OPCODE_EX(1, 2); } /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_TAIL_CALL(zend_post_incdec_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX true)); +} + +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_TAIL_CALL(zend_post_incdec_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX false)); +} + static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_fetch_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX int type) { USE_OPLINE @@ -7792,7 +7815,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM if (IS_CONST & (IS_CONST|IS_CV)) { /* avoid exception check */ - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } } else { result = (value == NULL || !i_zend_is_true(value)); @@ -7817,7 +7840,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM isset_dim_obj_exit: - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -7867,7 +7890,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PRO isset_object_finish: - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -10227,7 +10250,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CON if (IS_CONST & (IS_CONST|IS_CV)) { /* avoid exception check */ zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } } else { result = (value == NULL || !i_zend_is_true(value)); @@ -10252,7 +10275,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CON isset_dim_obj_exit: zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -10302,7 +10325,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PRO isset_object_finish: zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -12818,7 +12841,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CON if (IS_CONST & (IS_CONST|IS_CV)) { /* avoid exception check */ - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } } else { result = (value == NULL || !i_zend_is_true(value)); @@ -12843,7 +12866,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CON isset_dim_obj_exit: - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -12893,7 +12916,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PRO isset_object_finish: - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -16995,7 +17018,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP if ((IS_TMP_VAR|IS_VAR) & (IS_CONST|IS_CV)) { /* avoid exception check */ - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } } else { result = (value == NULL || !i_zend_is_true(value)); @@ -17020,7 +17043,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP isset_dim_obj_exit: zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -17070,7 +17093,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TM isset_object_finish: zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -18460,7 +18483,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP if ((IS_TMP_VAR|IS_VAR) & (IS_CONST|IS_CV)) { /* avoid exception check */ zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } } else { result = (value == NULL || !i_zend_is_true(value)); @@ -18485,7 +18508,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP isset_dim_obj_exit: zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -18535,7 +18558,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TM isset_object_finish: zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -19929,7 +19952,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP if ((IS_TMP_VAR|IS_VAR) & (IS_CONST|IS_CV)) { /* avoid exception check */ - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } } else { result = (value == NULL || !i_zend_is_true(value)); @@ -19954,7 +19977,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP isset_dim_obj_exit: zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -20004,7 +20027,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TM isset_object_finish: zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -23833,7 +23856,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_VAR_CONST_HANDL ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_obj_helper_SPEC_VAR_CONST(ZEND_OPCODE_HANDLER_ARGS_EX bool is_inc) { USE_OPLINE zval *object; @@ -23883,7 +23906,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HAN } } else { prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2); - zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC); + zend_pre_incdec_property_zval(zptr, prop_info, is_inc, opline->result.var OPLINE_CC EXECUTE_DATA_CC); } } else { zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC); @@ -23897,7 +23920,17 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HAN ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_TAIL_CALL(zend_pre_incdec_obj_helper_SPEC_VAR_CONST(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX true)); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_TAIL_CALL(zend_pre_incdec_obj_helper_SPEC_VAR_CONST(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX false)); +} + +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_obj_helper_SPEC_VAR_CONST(ZEND_OPCODE_HANDLER_ARGS_EX bool is_inc) { USE_OPLINE zval *object; @@ -23945,7 +23978,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_CONST_HA ZVAL_NULL(EX_VAR(opline->result.var)); } else { prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2); - zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC); + zend_post_incdec_property_zval(zptr, prop_info, is_inc, opline->result.var OPLINE_CC EXECUTE_DATA_CC); } } else { zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC); @@ -23959,6 +23992,17 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_CONST_HA ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_TAIL_CALL(zend_post_incdec_obj_helper_SPEC_VAR_CONST(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX true)); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_TAIL_CALL(zend_post_incdec_obj_helper_SPEC_VAR_CONST(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX false)); +} + +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -26836,7 +26880,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_HAND ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_obj_helper_SPEC_VAR_TMPVAR(ZEND_OPCODE_HANDLER_ARGS_EX bool is_inc) { USE_OPLINE zval *object; @@ -26886,7 +26930,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_HA } } else { prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2); - zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC); + zend_pre_incdec_property_zval(zptr, prop_info, is_inc, opline->result.var OPLINE_CC EXECUTE_DATA_CC); } } else { zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC); @@ -26901,7 +26945,17 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_HA ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_TAIL_CALL(zend_pre_incdec_obj_helper_SPEC_VAR_TMPVAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX true)); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_TAIL_CALL(zend_pre_incdec_obj_helper_SPEC_VAR_TMPVAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX false)); +} + +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_obj_helper_SPEC_VAR_TMPVAR(ZEND_OPCODE_HANDLER_ARGS_EX bool is_inc) { USE_OPLINE zval *object; @@ -26949,7 +27003,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_H ZVAL_NULL(EX_VAR(opline->result.var)); } else { prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2); - zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC); + zend_post_incdec_property_zval(zptr, prop_info, is_inc, opline->result.var OPLINE_CC EXECUTE_DATA_CC); } } else { zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC); @@ -26964,6 +27018,17 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_H ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_TAIL_CALL(zend_post_incdec_obj_helper_SPEC_VAR_TMPVAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX true)); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_TAIL_CALL(zend_post_incdec_obj_helper_SPEC_VAR_TMPVAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX false)); +} + +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -31193,7 +31258,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_VAR_CV_HANDLER( ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_obj_helper_SPEC_VAR_CV(ZEND_OPCODE_HANDLER_ARGS_EX bool is_inc) { USE_OPLINE zval *object; @@ -31243,7 +31308,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLE } } else { prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2); - zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC); + zend_pre_incdec_property_zval(zptr, prop_info, is_inc, opline->result.var OPLINE_CC EXECUTE_DATA_CC); } } else { zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC); @@ -31257,7 +31322,17 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLE ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_TAIL_CALL(zend_pre_incdec_obj_helper_SPEC_VAR_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX true)); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_TAIL_CALL(zend_pre_incdec_obj_helper_SPEC_VAR_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX false)); +} + +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_obj_helper_SPEC_VAR_CV(ZEND_OPCODE_HANDLER_ARGS_EX bool is_inc) { USE_OPLINE zval *object; @@ -31305,7 +31380,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_CV_HANDL ZVAL_NULL(EX_VAR(opline->result.var)); } else { prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2); - zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC); + zend_post_incdec_property_zval(zptr, prop_info, is_inc, opline->result.var OPLINE_CC EXECUTE_DATA_CC); } } else { zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC); @@ -31319,6 +31394,17 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_CV_HANDL ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_TAIL_CALL(zend_post_incdec_obj_helper_SPEC_VAR_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX true)); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_TAIL_CALL(zend_post_incdec_obj_helper_SPEC_VAR_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX false)); +} + +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -33733,7 +33819,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONS } /* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */ -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_obj_helper_SPEC_UNUSED_CONST(ZEND_OPCODE_HANDLER_ARGS_EX bool is_inc) { USE_OPLINE zval *object; @@ -33783,7 +33869,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_ } } else { prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2); - zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC); + zend_pre_incdec_property_zval(zptr, prop_info, is_inc, opline->result.var OPLINE_CC EXECUTE_DATA_CC); } } else { zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC); @@ -33797,7 +33883,17 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_TAIL_CALL(zend_pre_incdec_obj_helper_SPEC_UNUSED_CONST(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX true)); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_TAIL_CALL(zend_pre_incdec_obj_helper_SPEC_UNUSED_CONST(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX false)); +} + +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_obj_helper_SPEC_UNUSED_CONST(ZEND_OPCODE_HANDLER_ARGS_EX bool is_inc) { USE_OPLINE zval *object; @@ -33845,7 +33941,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST ZVAL_NULL(EX_VAR(opline->result.var)); } else { prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2); - zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC); + zend_post_incdec_property_zval(zptr, prop_info, is_inc, opline->result.var OPLINE_CC EXECUTE_DATA_CC); } } else { zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC); @@ -33859,6 +33955,17 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_TAIL_CALL(zend_post_incdec_obj_helper_SPEC_UNUSED_CONST(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX true)); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_TAIL_CALL(zend_post_incdec_obj_helper_SPEC_UNUSED_CONST(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX false)); +} + +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static zend_always_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -35571,7 +35678,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UN isset_object_finish: - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -35919,7 +36026,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPV } /* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */ -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_obj_helper_SPEC_UNUSED_TMPVAR(ZEND_OPCODE_HANDLER_ARGS_EX bool is_inc) { USE_OPLINE zval *object; @@ -35969,7 +36076,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR } } else { prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2); - zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC); + zend_pre_incdec_property_zval(zptr, prop_info, is_inc, opline->result.var OPLINE_CC EXECUTE_DATA_CC); } } else { zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC); @@ -35984,7 +36091,17 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_TAIL_CALL(zend_pre_incdec_obj_helper_SPEC_UNUSED_TMPVAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX true)); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_TAIL_CALL(zend_pre_incdec_obj_helper_SPEC_UNUSED_TMPVAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX false)); +} + +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_obj_helper_SPEC_UNUSED_TMPVAR(ZEND_OPCODE_HANDLER_ARGS_EX bool is_inc) { USE_OPLINE zval *object; @@ -36032,7 +36149,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVA ZVAL_NULL(EX_VAR(opline->result.var)); } else { prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2); - zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC); + zend_post_incdec_property_zval(zptr, prop_info, is_inc, opline->result.var OPLINE_CC EXECUTE_DATA_CC); } } else { zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC); @@ -36047,6 +36164,17 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVA ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_TAIL_CALL(zend_post_incdec_obj_helper_SPEC_UNUSED_TMPVAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX true)); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_TAIL_CALL(zend_post_incdec_obj_helper_SPEC_UNUSED_TMPVAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX false)); +} + +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -37576,7 +37704,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UN isset_object_finish: zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -38568,7 +38696,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV_H } /* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */ -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_obj_helper_SPEC_UNUSED_CV(ZEND_OPCODE_HANDLER_ARGS_EX bool is_inc) { USE_OPLINE zval *object; @@ -38618,7 +38746,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HAN } } else { prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2); - zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC); + zend_pre_incdec_property_zval(zptr, prop_info, is_inc, opline->result.var OPLINE_CC EXECUTE_DATA_CC); } } else { zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC); @@ -38632,7 +38760,17 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HAN ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_TAIL_CALL(zend_pre_incdec_obj_helper_SPEC_UNUSED_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX true)); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_TAIL_CALL(zend_pre_incdec_obj_helper_SPEC_UNUSED_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX false)); +} + +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_obj_helper_SPEC_UNUSED_CV(ZEND_OPCODE_HANDLER_ARGS_EX bool is_inc) { USE_OPLINE zval *object; @@ -38680,7 +38818,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_HA ZVAL_NULL(EX_VAR(opline->result.var)); } else { prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2); - zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC); + zend_post_incdec_property_zval(zptr, prop_info, is_inc, opline->result.var OPLINE_CC EXECUTE_DATA_CC); } } else { zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC); @@ -38694,6 +38832,17 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_HA ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_TAIL_CALL(zend_post_incdec_obj_helper_SPEC_UNUSED_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX true)); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_TAIL_CALL(zend_post_incdec_obj_helper_SPEC_UNUSED_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX false)); +} + +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -40221,7 +40370,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UN isset_object_finish: - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -42747,7 +42896,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_CV_CONST_HANDLE ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_obj_helper_SPEC_CV_CONST(ZEND_OPCODE_HANDLER_ARGS_EX bool is_inc) { USE_OPLINE zval *object; @@ -42797,7 +42946,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HAND } } else { prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2); - zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC); + zend_pre_incdec_property_zval(zptr, prop_info, is_inc, opline->result.var OPLINE_CC EXECUTE_DATA_CC); } } else { zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC); @@ -42811,7 +42960,17 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HAND ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_TAIL_CALL(zend_pre_incdec_obj_helper_SPEC_CV_CONST(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX true)); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_TAIL_CALL(zend_pre_incdec_obj_helper_SPEC_CV_CONST(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX false)); +} + +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_obj_helper_SPEC_CV_CONST(ZEND_OPCODE_HANDLER_ARGS_EX bool is_inc) { USE_OPLINE zval *object; @@ -42859,7 +43018,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_CONST_HAN ZVAL_NULL(EX_VAR(opline->result.var)); } else { prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2); - zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC); + zend_post_incdec_property_zval(zptr, prop_info, is_inc, opline->result.var OPLINE_CC EXECUTE_DATA_CC); } } else { zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC); @@ -42873,6 +43032,17 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_CONST_HAN ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_TAIL_CALL(zend_post_incdec_obj_helper_SPEC_CV_CONST(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX true)); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_TAIL_CALL(zend_post_incdec_obj_helper_SPEC_CV_CONST(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX false)); +} + +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -45432,7 +45602,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_ if (IS_CV & (IS_CONST|IS_CV)) { /* avoid exception check */ - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } } else { result = (value == NULL || !i_zend_is_true(value)); @@ -45457,7 +45627,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_ isset_dim_obj_exit: - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -45507,7 +45677,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV isset_object_finish: - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -46703,7 +46873,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_HANDL ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_obj_helper_SPEC_CV_TMPVAR(ZEND_OPCODE_HANDLER_ARGS_EX bool is_inc) { USE_OPLINE zval *object; @@ -46753,7 +46923,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_HAN } } else { prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2); - zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC); + zend_pre_incdec_property_zval(zptr, prop_info, is_inc, opline->result.var OPLINE_CC EXECUTE_DATA_CC); } } else { zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC); @@ -46768,7 +46938,17 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_HAN ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_TAIL_CALL(zend_pre_incdec_obj_helper_SPEC_CV_TMPVAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX true)); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_TAIL_CALL(zend_pre_incdec_obj_helper_SPEC_CV_TMPVAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX false)); +} + +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_obj_helper_SPEC_CV_TMPVAR(ZEND_OPCODE_HANDLER_ARGS_EX bool is_inc) { USE_OPLINE zval *object; @@ -46816,7 +46996,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_HA ZVAL_NULL(EX_VAR(opline->result.var)); } else { prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2); - zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC); + zend_post_incdec_property_zval(zptr, prop_info, is_inc, opline->result.var OPLINE_CC EXECUTE_DATA_CC); } } else { zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC); @@ -46831,6 +47011,17 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_HA ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_TAIL_CALL(zend_post_incdec_obj_helper_SPEC_CV_TMPVAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX true)); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_TAIL_CALL(zend_post_incdec_obj_helper_SPEC_CV_TMPVAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX false)); +} + +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -49188,7 +49379,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_ if (IS_CV & (IS_CONST|IS_CV)) { /* avoid exception check */ zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } } else { result = (value == NULL || !i_zend_is_true(value)); @@ -49213,7 +49404,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_ isset_dim_obj_exit: zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -49263,7 +49454,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV isset_object_finish: zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -52267,7 +52458,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_CV_CV_HANDLER(Z ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_obj_helper_SPEC_CV_CV(ZEND_OPCODE_HANDLER_ARGS_EX bool is_inc) { USE_OPLINE zval *object; @@ -52317,7 +52508,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER } } else { prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2); - zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC); + zend_pre_incdec_property_zval(zptr, prop_info, is_inc, opline->result.var OPLINE_CC EXECUTE_DATA_CC); } } else { zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC); @@ -52331,7 +52522,17 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_TAIL_CALL(zend_pre_incdec_obj_helper_SPEC_CV_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX true)); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_TAIL_CALL(zend_pre_incdec_obj_helper_SPEC_CV_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX false)); +} + +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_obj_helper_SPEC_CV_CV(ZEND_OPCODE_HANDLER_ARGS_EX bool is_inc) { USE_OPLINE zval *object; @@ -52379,7 +52580,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_CV_HANDLE ZVAL_NULL(EX_VAR(opline->result.var)); } else { prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2); - zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC); + zend_post_incdec_property_zval(zptr, prop_info, is_inc, opline->result.var OPLINE_CC EXECUTE_DATA_CC); } } else { zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC); @@ -52393,6 +52594,17 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_CV_HANDLE ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_TAIL_CALL(zend_post_incdec_obj_helper_SPEC_CV_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX true)); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_TAIL_CALL(zend_post_incdec_obj_helper_SPEC_CV_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX false)); +} + +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -54844,7 +55056,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_ if (IS_CV & (IS_CONST|IS_CV)) { /* avoid exception check */ - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } } else { result = (value == NULL || !i_zend_is_true(value)); @@ -54869,7 +55081,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_ isset_dim_obj_exit: - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -54919,7 +55131,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV isset_object_finish: - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -56421,7 +56633,9 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_POST_DEC_SPEC_CV_LABEL, (void*)&&ZEND_PRE_INC_STATIC_PROP_SPEC_LABEL, + (void*)&&ZEND_PRE_DEC_STATIC_PROP_SPEC_LABEL, (void*)&&ZEND_POST_INC_STATIC_PROP_SPEC_LABEL, + (void*)&&ZEND_POST_DEC_STATIC_PROP_SPEC_LABEL, (void*)&&ZEND_JMP_SPEC_LABEL, (void*)&&ZEND_JMPZ_SPEC_CONST_LABEL, (void*)&&ZEND_JMPZ_SPEC_TMPVAR_LABEL, @@ -57400,6 +57614,31 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_PRE_DEC_OBJ_SPEC_VAR_CONST_LABEL, + (void*)&&ZEND_PRE_DEC_OBJ_SPEC_VAR_TMPVAR_LABEL, + (void*)&&ZEND_PRE_DEC_OBJ_SPEC_VAR_TMPVAR_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_PRE_DEC_OBJ_SPEC_VAR_CV_LABEL, + (void*)&&ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CONST_LABEL, + (void*)&&ZEND_PRE_DEC_OBJ_SPEC_UNUSED_TMPVAR_LABEL, + (void*)&&ZEND_PRE_DEC_OBJ_SPEC_UNUSED_TMPVAR_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CV_LABEL, + (void*)&&ZEND_PRE_DEC_OBJ_SPEC_CV_CONST_LABEL, + (void*)&&ZEND_PRE_DEC_OBJ_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_PRE_DEC_OBJ_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_PRE_DEC_OBJ_SPEC_CV_CV_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_POST_INC_OBJ_SPEC_VAR_CONST_LABEL, (void*)&&ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_LABEL, (void*)&&ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_LABEL, @@ -57415,6 +57654,31 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_POST_INC_OBJ_SPEC_CV_CV_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_POST_DEC_OBJ_SPEC_VAR_CONST_LABEL, + (void*)&&ZEND_POST_DEC_OBJ_SPEC_VAR_TMPVAR_LABEL, + (void*)&&ZEND_POST_DEC_OBJ_SPEC_VAR_TMPVAR_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_POST_DEC_OBJ_SPEC_VAR_CV_LABEL, + (void*)&&ZEND_POST_DEC_OBJ_SPEC_UNUSED_CONST_LABEL, + (void*)&&ZEND_POST_DEC_OBJ_SPEC_UNUSED_TMPVAR_LABEL, + (void*)&&ZEND_POST_DEC_OBJ_SPEC_UNUSED_TMPVAR_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_POST_DEC_OBJ_SPEC_UNUSED_CV_LABEL, + (void*)&&ZEND_POST_DEC_OBJ_SPEC_CV_CONST_LABEL, + (void*)&&ZEND_POST_DEC_OBJ_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_POST_DEC_OBJ_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_POST_DEC_OBJ_SPEC_CV_CV_LABEL, (void*)&&ZEND_ECHO_SPEC_CONST_LABEL, (void*)&&ZEND_ECHO_SPEC_TMPVAR_LABEL, (void*)&&ZEND_ECHO_SPEC_TMPVAR_LABEL, @@ -58712,11 +58976,21 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_PRE_INC_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_PRE_INC_STATIC_PROP_SPEC) HYBRID_BREAK(); + HYBRID_CASE(ZEND_PRE_DEC_STATIC_PROP_SPEC): + VM_TRACE(ZEND_PRE_DEC_STATIC_PROP_SPEC) + ZEND_PRE_DEC_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_PRE_DEC_STATIC_PROP_SPEC) + HYBRID_BREAK(); HYBRID_CASE(ZEND_POST_INC_STATIC_PROP_SPEC): VM_TRACE(ZEND_POST_INC_STATIC_PROP_SPEC) ZEND_POST_INC_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_POST_INC_STATIC_PROP_SPEC) HYBRID_BREAK(); + HYBRID_CASE(ZEND_POST_DEC_STATIC_PROP_SPEC): + VM_TRACE(ZEND_POST_DEC_STATIC_PROP_SPEC) + ZEND_POST_DEC_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_POST_DEC_STATIC_PROP_SPEC) + HYBRID_BREAK(); HYBRID_CASE(ZEND_FETCH_STATIC_PROP_R_SPEC): VM_TRACE(ZEND_FETCH_STATIC_PROP_R_SPEC) ZEND_FETCH_STATIC_PROP_R_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -61788,11 +62062,21 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_VAR_CONST) HYBRID_BREAK(); + HYBRID_CASE(ZEND_PRE_DEC_OBJ_SPEC_VAR_CONST): + VM_TRACE(ZEND_PRE_DEC_OBJ_SPEC_VAR_CONST) + ZEND_PRE_DEC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_PRE_DEC_OBJ_SPEC_VAR_CONST) + HYBRID_BREAK(); HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_VAR_CONST): VM_TRACE(ZEND_POST_INC_OBJ_SPEC_VAR_CONST) ZEND_POST_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_VAR_CONST) HYBRID_BREAK(); + HYBRID_CASE(ZEND_POST_DEC_OBJ_SPEC_VAR_CONST): + VM_TRACE(ZEND_POST_DEC_OBJ_SPEC_VAR_CONST) + ZEND_POST_DEC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_POST_DEC_OBJ_SPEC_VAR_CONST) + HYBRID_BREAK(); HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_VAR_CONST): VM_TRACE(ZEND_FETCH_DIM_W_SPEC_VAR_CONST) ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -61993,11 +62277,21 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) HYBRID_BREAK(); + HYBRID_CASE(ZEND_PRE_DEC_OBJ_SPEC_VAR_TMPVAR): + VM_TRACE(ZEND_PRE_DEC_OBJ_SPEC_VAR_TMPVAR) + ZEND_PRE_DEC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_PRE_DEC_OBJ_SPEC_VAR_TMPVAR) + HYBRID_BREAK(); HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR): VM_TRACE(ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) HYBRID_BREAK(); + HYBRID_CASE(ZEND_POST_DEC_OBJ_SPEC_VAR_TMPVAR): + VM_TRACE(ZEND_POST_DEC_OBJ_SPEC_VAR_TMPVAR) + ZEND_POST_DEC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_POST_DEC_OBJ_SPEC_VAR_TMPVAR) + HYBRID_BREAK(); HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR): VM_TRACE(ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -62333,11 +62627,21 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_VAR_CV) HYBRID_BREAK(); + HYBRID_CASE(ZEND_PRE_DEC_OBJ_SPEC_VAR_CV): + VM_TRACE(ZEND_PRE_DEC_OBJ_SPEC_VAR_CV) + ZEND_PRE_DEC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_PRE_DEC_OBJ_SPEC_VAR_CV) + HYBRID_BREAK(); HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_VAR_CV): VM_TRACE(ZEND_POST_INC_OBJ_SPEC_VAR_CV) ZEND_POST_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_VAR_CV) HYBRID_BREAK(); + HYBRID_CASE(ZEND_POST_DEC_OBJ_SPEC_VAR_CV): + VM_TRACE(ZEND_POST_DEC_OBJ_SPEC_VAR_CV) + ZEND_POST_DEC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_POST_DEC_OBJ_SPEC_VAR_CV) + HYBRID_BREAK(); HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_VAR_CV): VM_TRACE(ZEND_FETCH_DIM_W_SPEC_VAR_CV) ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -62508,11 +62812,21 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST) HYBRID_BREAK(); + HYBRID_CASE(ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CONST): + VM_TRACE(ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CONST) + ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CONST) + HYBRID_BREAK(); HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST): VM_TRACE(ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST) ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST) HYBRID_BREAK(); + HYBRID_CASE(ZEND_POST_DEC_OBJ_SPEC_UNUSED_CONST): + VM_TRACE(ZEND_POST_DEC_OBJ_SPEC_UNUSED_CONST) + ZEND_POST_DEC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_POST_DEC_OBJ_SPEC_UNUSED_CONST) + HYBRID_BREAK(); HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST): VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST) ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -62643,11 +62957,21 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) HYBRID_BREAK(); + HYBRID_CASE(ZEND_PRE_DEC_OBJ_SPEC_UNUSED_TMPVAR): + VM_TRACE(ZEND_PRE_DEC_OBJ_SPEC_UNUSED_TMPVAR) + ZEND_PRE_DEC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_PRE_DEC_OBJ_SPEC_UNUSED_TMPVAR) + HYBRID_BREAK(); HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR): VM_TRACE(ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) HYBRID_BREAK(); + HYBRID_CASE(ZEND_POST_DEC_OBJ_SPEC_UNUSED_TMPVAR): + VM_TRACE(ZEND_POST_DEC_OBJ_SPEC_UNUSED_TMPVAR) + ZEND_POST_DEC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_POST_DEC_OBJ_SPEC_UNUSED_TMPVAR) + HYBRID_BREAK(); HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR): VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -62858,11 +63182,21 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV) HYBRID_BREAK(); + HYBRID_CASE(ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CV): + VM_TRACE(ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CV) + ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CV) + HYBRID_BREAK(); HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_UNUSED_CV): VM_TRACE(ZEND_POST_INC_OBJ_SPEC_UNUSED_CV) ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_UNUSED_CV) HYBRID_BREAK(); + HYBRID_CASE(ZEND_POST_DEC_OBJ_SPEC_UNUSED_CV): + VM_TRACE(ZEND_POST_DEC_OBJ_SPEC_UNUSED_CV) + ZEND_POST_DEC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_POST_DEC_OBJ_SPEC_UNUSED_CV) + HYBRID_BREAK(); HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV): VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV) ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -63342,11 +63676,21 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_CV_CONST) HYBRID_BREAK(); + HYBRID_CASE(ZEND_PRE_DEC_OBJ_SPEC_CV_CONST): + VM_TRACE(ZEND_PRE_DEC_OBJ_SPEC_CV_CONST) + ZEND_PRE_DEC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_PRE_DEC_OBJ_SPEC_CV_CONST) + HYBRID_BREAK(); HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_CV_CONST): VM_TRACE(ZEND_POST_INC_OBJ_SPEC_CV_CONST) ZEND_POST_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_CV_CONST) HYBRID_BREAK(); + HYBRID_CASE(ZEND_POST_DEC_OBJ_SPEC_CV_CONST): + VM_TRACE(ZEND_POST_DEC_OBJ_SPEC_CV_CONST) + ZEND_POST_DEC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_POST_DEC_OBJ_SPEC_CV_CONST) + HYBRID_BREAK(); HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CV_CONST): VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CV_CONST) ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -63642,11 +63986,21 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) HYBRID_BREAK(); + HYBRID_CASE(ZEND_PRE_DEC_OBJ_SPEC_CV_TMPVAR): + VM_TRACE(ZEND_PRE_DEC_OBJ_SPEC_CV_TMPVAR) + ZEND_PRE_DEC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_PRE_DEC_OBJ_SPEC_CV_TMPVAR) + HYBRID_BREAK(); HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR): VM_TRACE(ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) HYBRID_BREAK(); + HYBRID_CASE(ZEND_POST_DEC_OBJ_SPEC_CV_TMPVAR): + VM_TRACE(ZEND_POST_DEC_OBJ_SPEC_CV_TMPVAR) + ZEND_POST_DEC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_POST_DEC_OBJ_SPEC_CV_TMPVAR) + HYBRID_BREAK(); HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR): VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -64127,11 +64481,21 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_CV_CV) HYBRID_BREAK(); + HYBRID_CASE(ZEND_PRE_DEC_OBJ_SPEC_CV_CV): + VM_TRACE(ZEND_PRE_DEC_OBJ_SPEC_CV_CV) + ZEND_PRE_DEC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_PRE_DEC_OBJ_SPEC_CV_CV) + HYBRID_BREAK(); HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_CV_CV): VM_TRACE(ZEND_POST_INC_OBJ_SPEC_CV_CV) ZEND_POST_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_CV_CV) HYBRID_BREAK(); + HYBRID_CASE(ZEND_POST_DEC_OBJ_SPEC_CV_CV): + VM_TRACE(ZEND_POST_DEC_OBJ_SPEC_CV_CV) + ZEND_POST_DEC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_POST_DEC_OBJ_SPEC_CV_CV) + HYBRID_BREAK(); HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CV_CV): VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CV_CV) ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -65649,7 +66013,9 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_POST_DEC_SPEC_CV_HANDLER, ZEND_PRE_INC_STATIC_PROP_SPEC_HANDLER, + ZEND_PRE_DEC_STATIC_PROP_SPEC_HANDLER, ZEND_POST_INC_STATIC_PROP_SPEC_HANDLER, + ZEND_POST_DEC_STATIC_PROP_SPEC_HANDLER, ZEND_JMP_SPEC_HANDLER, ZEND_JMPZ_SPEC_CONST_HANDLER, ZEND_JMPZ_SPEC_TMPVAR_HANDLER, @@ -66628,6 +66994,31 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, + ZEND_PRE_DEC_OBJ_SPEC_VAR_CONST_HANDLER, + ZEND_PRE_DEC_OBJ_SPEC_VAR_TMPVAR_HANDLER, + ZEND_PRE_DEC_OBJ_SPEC_VAR_TMPVAR_HANDLER, + ZEND_NULL_HANDLER, + ZEND_PRE_DEC_OBJ_SPEC_VAR_CV_HANDLER, + ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CONST_HANDLER, + ZEND_PRE_DEC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER, + ZEND_PRE_DEC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER, + ZEND_NULL_HANDLER, + ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CV_HANDLER, + ZEND_PRE_DEC_OBJ_SPEC_CV_CONST_HANDLER, + ZEND_PRE_DEC_OBJ_SPEC_CV_TMPVAR_HANDLER, + ZEND_PRE_DEC_OBJ_SPEC_CV_TMPVAR_HANDLER, + ZEND_NULL_HANDLER, + ZEND_PRE_DEC_OBJ_SPEC_CV_CV_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, ZEND_POST_INC_OBJ_SPEC_VAR_CONST_HANDLER, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER, @@ -66643,6 +67034,31 @@ void zend_vm_init(void) ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_POST_INC_OBJ_SPEC_CV_CV_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_POST_DEC_OBJ_SPEC_VAR_CONST_HANDLER, + ZEND_POST_DEC_OBJ_SPEC_VAR_TMPVAR_HANDLER, + ZEND_POST_DEC_OBJ_SPEC_VAR_TMPVAR_HANDLER, + ZEND_NULL_HANDLER, + ZEND_POST_DEC_OBJ_SPEC_VAR_CV_HANDLER, + ZEND_POST_DEC_OBJ_SPEC_UNUSED_CONST_HANDLER, + ZEND_POST_DEC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER, + ZEND_POST_DEC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER, + ZEND_NULL_HANDLER, + ZEND_POST_DEC_OBJ_SPEC_UNUSED_CV_HANDLER, + ZEND_POST_DEC_OBJ_SPEC_CV_CONST_HANDLER, + ZEND_POST_DEC_OBJ_SPEC_CV_TMPVAR_HANDLER, + ZEND_POST_DEC_OBJ_SPEC_CV_TMPVAR_HANDLER, + ZEND_NULL_HANDLER, + ZEND_POST_DEC_OBJ_SPEC_CV_CV_HANDLER, ZEND_ECHO_SPEC_CONST_HANDLER, ZEND_ECHO_SPEC_TMPVAR_HANDLER, ZEND_ECHO_SPEC_TMPVAR_HANDLER, @@ -67930,223 +68346,223 @@ void zend_vm_init(void) 1243 | SPEC_RULE_OP1, 1248 | SPEC_RULE_OP1, 1253, - 1253, - 1254, 1254, 1255, - 1256 | SPEC_RULE_OP1, - 1261 | SPEC_RULE_OP1, - 3493, - 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, - 1297 | SPEC_RULE_OP1, - 1302 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1327 | SPEC_RULE_OP2, - 1332 | SPEC_RULE_OP2, - 1337 | SPEC_RULE_OP2, - 1342, - 1343, + 1256, + 1257, + 1258 | SPEC_RULE_OP1, + 1263 | SPEC_RULE_OP1, + 3545, + 1268 | SPEC_RULE_OP1, + 1273 | SPEC_RULE_OP1, + 1278 | SPEC_RULE_OP2, + 1283, + 1284 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, + 1294 | SPEC_RULE_OP1, + 1299 | SPEC_RULE_OP1, + 1304 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1329 | SPEC_RULE_OP2, + 1334 | SPEC_RULE_OP2, + 1339 | SPEC_RULE_OP2, 1344, - 1345 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, - 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, - 3493, - 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, + 1345, + 1346, + 1347 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, + 1351, + 1352 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, + 1362, + 1363, + 1364 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1389 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, + 1439 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1464 | SPEC_RULE_OP1, + 1469, + 1470, + 1471 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1496 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1521 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, + 1531 | SPEC_RULE_OP1, + 1536 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1561 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1586 | SPEC_RULE_OP1, + 1591, + 3545, + 1592 | SPEC_RULE_OP1, + 1597 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1622 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1647 | SPEC_RULE_OP1, + 1652 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1677 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1702 | SPEC_RULE_OP1, + 1707 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1732 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1757 | SPEC_RULE_OP1, + 1762 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1787 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1812 | SPEC_RULE_OP1, + 1817 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1842 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1867 | SPEC_RULE_OP1, + 1872 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1897 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1922 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1947, + 1948 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, 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, - 2158 | SPEC_RULE_OP1, - 2163, - 2164 | SPEC_RULE_OP1, - 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, - 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, + 1961, + 1962, + 1963 | SPEC_RULE_OP2, + 1968, + 1969 | SPEC_RULE_OP1, + 1974 | SPEC_RULE_OP2, + 1979 | SPEC_RULE_OP1, + 1984 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, + 1994 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2019 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2044 | SPEC_RULE_OP1, + 2049 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2074 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, + 2124 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2149 | SPEC_RULE_OP2, + 2154, + 2155 | SPEC_RULE_OP1, + 2160 | SPEC_RULE_OP1, + 2165, + 2166 | SPEC_RULE_OP1, + 2171 | SPEC_RULE_OP1, + 2176 | SPEC_RULE_OP1, + 2181, + 2182, + 2183 | SPEC_RULE_OP2, + 2188 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, + 2192 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, + 2196 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, + 2200 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2225 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2250 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2275 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2300 | SPEC_RULE_OP1, + 2305, + 2306 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2331, + 2332 | SPEC_RULE_OP1, + 2337, + 2338, + 2339, + 2340, 2341, - 2342 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2367 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, + 2342, + 2343, + 2344 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2369, + 2370, + 2371, + 2372 | SPEC_RULE_OP1, 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, + 2378 | SPEC_RULE_ISSET, + 2380 | SPEC_RULE_OP2, + 2385, + 2386 | SPEC_RULE_OP1, + 2391 | SPEC_RULE_OBSERVER, + 2393, + 2394 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2419 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, 2429, 2430, 2431, - 2432 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2457, - 2458, - 2459, - 2460 | SPEC_RULE_OP2, - 2465, - 2466 | SPEC_RULE_OP1, + 2432, + 2433 | SPEC_RULE_OP1, + 2438, + 2439, + 2440 | SPEC_RULE_OP1, + 2445 | SPEC_RULE_OP1 | 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_OP1 | SPEC_RULE_OP2, - 2552 | SPEC_RULE_OP1, - 2557 | SPEC_RULE_OP1, - 2562, - 2563, - 2564, - 2565, - 2566, - 2567 | SPEC_RULE_OBSERVER, - 2569 | SPEC_RULE_OBSERVER, - 2571 | SPEC_RULE_OBSERVER, - 2573 | SPEC_RULE_OBSERVER, - 2575, - 2576, - 2577, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, - 3493, + 2476, + 2477, + 2478, + 2479, + 2480, + 2481, + 2482, + 2483, + 2484 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2509, + 2510, + 2511, + 2512 | SPEC_RULE_OP2, + 2517, + 2518 | SPEC_RULE_OP1, + 2523 | SPEC_RULE_OP1, + 2528 | SPEC_RULE_OP1, + 2533 | SPEC_RULE_OP1, + 2538 | SPEC_RULE_OP1, + 2543, + 2544 | SPEC_RULE_OP1, + 2549 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2574 | SPEC_RULE_OP1, + 2579 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2604 | SPEC_RULE_OP1, + 2609 | SPEC_RULE_OP1, + 2614, + 2615, + 2616, + 2617, + 2618, + 2619 | SPEC_RULE_OBSERVER, + 2621 | SPEC_RULE_OBSERVER, + 2623 | SPEC_RULE_OBSERVER, + 2625 | SPEC_RULE_OBSERVER, + 2627, + 2628, + 2629, + 3545, + 3545, + 3545, + 3545, + 3545, + 3545, + 3545, + 3545, + 3545, + 3545, + 3545, + 3545, + 3545, + 3545, + 3545, + 3545, + 3545, + 3545, + 3545, + 3545, + 3545, + 3545, + 3545, + 3545, + 3545, + 3545, + 3545, + 3545, + 3545, + 3545, + 3545, + 3545, + 3545, + 3545, + 3545, + 3545, + 3545, + 3545, + 3545, + 3545, + 3545, + 3545, + 3545, + 3545, + 3545, }; #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID) zend_opcode_handler_funcs = labels; @@ -68319,7 +68735,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 = 2586 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2638 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -68327,7 +68743,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 = 2611 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2663 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -68335,7 +68751,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 = 2636 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2688 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -68346,17 +68762,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 = 2661 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2713 | 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 = 2686 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2738 | 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 = 2711 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2763 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_MUL: @@ -68367,17 +68783,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 = 2736 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2788 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } else if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2761 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2813 | 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 = 2786 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2838 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_IDENTICAL: @@ -68388,16 +68804,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 = 2811 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2863 | 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 = 2886 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2938 | 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 = 3111 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3163 | 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 = 3117 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3169 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_IDENTICAL: @@ -68408,16 +68824,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 = 2961 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3013 | 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 = 3036 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3088 | 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 = 3114 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3166 | 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 = 3122 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3174 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_EQUAL: @@ -68428,12 +68844,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 = 2811 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2863 | 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 = 2886 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2938 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_EQUAL: @@ -68444,12 +68860,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 = 2961 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3013 | 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 = 3036 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3088 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_SMALLER: @@ -68457,12 +68873,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 = 3127 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3179 | 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 = 3202 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3254 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_IS_SMALLER_OR_EQUAL: @@ -68470,79 +68886,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 = 3277 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3329 | 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 = 3352 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3404 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_QM_ASSIGN: if (op1_info == MAY_BE_LONG) { - spec = 3439 | SPEC_RULE_OP1; + spec = 3491 | SPEC_RULE_OP1; } else if (op1_info == MAY_BE_DOUBLE) { - spec = 3444 | SPEC_RULE_OP1; + spec = 3496 | 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 = 3449 | SPEC_RULE_OP1; + spec = 3501 | SPEC_RULE_OP1; } break; case ZEND_PRE_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3427 | SPEC_RULE_RETVAL; + spec = 3479 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3429 | SPEC_RULE_RETVAL; + spec = 3481 | SPEC_RULE_RETVAL; } break; case ZEND_PRE_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3431 | SPEC_RULE_RETVAL; + spec = 3483 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3433 | SPEC_RULE_RETVAL; + spec = 3485 | SPEC_RULE_RETVAL; } break; case ZEND_POST_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3435; + spec = 3487; } else if (op1_info == MAY_BE_LONG) { - spec = 3436; + spec = 3488; } break; case ZEND_POST_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3437; + spec = 3489; } else if (op1_info == MAY_BE_LONG) { - spec = 3438; + spec = 3490; } break; case ZEND_JMP: if (OP_JMP_ADDR(op, op->op1) > op) { - spec = 2585; + spec = 2637; } break; case ZEND_INIT_FCALL: if (Z_EXTRA_P(RT_CONSTANT(op, op->op2)) != 0) { - spec = 2578; + spec = 2630; } break; case ZEND_RECV: if (op->op2.num == MAY_BE_ANY) { - spec = 2579; + spec = 2631; } 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 = 3489; + spec = 3541; } 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 = 3484 | SPEC_RULE_OP1; + spec = 3536 | 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 = 3491 | SPEC_RULE_RETVAL; + spec = 3543 | SPEC_RULE_RETVAL; } break; case ZEND_FETCH_DIM_R: @@ -68550,22 +68966,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 = 3454 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 3506 | 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 = 3490; + spec = 3542; } break; case ZEND_SEND_VAR: if (op->op2_type == IS_UNUSED && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3479 | SPEC_RULE_OP1; + spec = 3531 | SPEC_RULE_OP1; } break; case ZEND_COUNT: if ((op1_info & (MAY_BE_ANY|MAY_BE_UNDEF|MAY_BE_REF)) == MAY_BE_ARRAY) { - spec = 2580 | SPEC_RULE_OP1; + spec = 2632 | SPEC_RULE_OP1; } break; case ZEND_BW_OR: diff --git a/Zend/zend_vm_gen.php b/Zend/zend_vm_gen.php index 060f0214ecd1c..1c4efa1901cc6 100755 --- a/Zend/zend_vm_gen.php +++ b/Zend/zend_vm_gen.php @@ -2528,6 +2528,8 @@ function gen_vm_opcodes_header( 'ZEND_FETCH_STATIC_PROP_W', 'ZEND_FE_FETCH_R', 'ZEND_FE_FETCH_RW', + 'ZEND_ISSET_ISEMPTY_DIM_OBJ', + 'ZEND_ISSET_ISEMPTY_PROP_OBJ', 'ZEND_ISSET_ISEMPTY_STATIC_PROP', 'ZEND_POST_DEC_STATIC_PROP', 'ZEND_POST_INC_STATIC_PROP', @@ -2571,8 +2573,6 @@ function get_quick_op_flags_field($opcode) { // Trying to improve 'ZEND_INSTANCEOF', 'ZEND_IN_ARRAY', - 'ZEND_ISSET_ISEMPTY_DIM_OBJ', - 'ZEND_ISSET_ISEMPTY_PROP_OBJ', ]; $has_free_result = [ diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h index 40321dcb91e66..c4dd76d7143bf 100644 --- a/Zend/zend_vm_handlers.h +++ b/Zend/zend_vm_handlers.h @@ -565,1316 +565,1342 @@ _(1250, ZEND_POST_DEC_SPEC_VAR) \ _(1252, ZEND_POST_DEC_SPEC_CV) \ _(1253, ZEND_PRE_INC_STATIC_PROP_SPEC) \ - _(1254, ZEND_POST_INC_STATIC_PROP_SPEC) \ - _(1255, ZEND_JMP_SPEC) \ - _(1256, ZEND_JMPZ_SPEC_CONST) \ - _(1257, ZEND_JMPZ_SPEC_TMPVAR) \ - _(1258, ZEND_JMPZ_SPEC_TMPVAR) \ - _(1260, ZEND_JMPZ_SPEC_CV) \ - _(1261, ZEND_JMPNZ_SPEC_CONST) \ - _(1262, ZEND_JMPNZ_SPEC_TMPVAR) \ - _(1263, ZEND_JMPNZ_SPEC_TMPVAR) \ - _(1265, ZEND_JMPNZ_SPEC_CV) \ - _(1266, ZEND_JMPZ_EX_SPEC_CONST) \ - _(1267, ZEND_JMPZ_EX_SPEC_TMPVAR) \ - _(1268, ZEND_JMPZ_EX_SPEC_TMPVAR) \ - _(1270, ZEND_JMPZ_EX_SPEC_CV) \ - _(1271, ZEND_JMPNZ_EX_SPEC_CONST) \ - _(1272, ZEND_JMPNZ_EX_SPEC_TMPVAR) \ - _(1273, ZEND_JMPNZ_EX_SPEC_TMPVAR) \ - _(1275, ZEND_JMPNZ_EX_SPEC_CV) \ - _(1276, ZEND_CASE_SPEC_TMPVAR_CONST) \ - _(1277, ZEND_CASE_SPEC_TMPVAR_TMPVAR) \ - _(1278, ZEND_CASE_SPEC_TMPVAR_TMPVAR) \ - _(1280, ZEND_CASE_SPEC_TMPVAR_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) \ - _(1294, ZEND_CAST_SPEC_VAR) \ - _(1296, ZEND_CAST_SPEC_CV) \ - _(1297, ZEND_BOOL_SPEC_CONST) \ - _(1298, ZEND_BOOL_SPEC_TMPVAR) \ - _(1299, ZEND_BOOL_SPEC_TMPVAR) \ - _(1301, ZEND_BOOL_SPEC_CV) \ - _(1302, ZEND_FAST_CONCAT_SPEC_CONST_CONST) \ - _(1303, ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR) \ - _(1304, ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR) \ - _(1306, ZEND_FAST_CONCAT_SPEC_CONST_CV) \ - _(1307, ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST) \ - _(1308, ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR) \ - _(1309, ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR) \ - _(1311, ZEND_FAST_CONCAT_SPEC_TMPVAR_CV) \ - _(1312, ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST) \ - _(1313, ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR) \ - _(1314, ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR) \ - _(1316, ZEND_FAST_CONCAT_SPEC_TMPVAR_CV) \ - _(1322, ZEND_FAST_CONCAT_SPEC_CV_CONST) \ - _(1323, ZEND_FAST_CONCAT_SPEC_CV_TMPVAR) \ - _(1324, ZEND_FAST_CONCAT_SPEC_CV_TMPVAR) \ - _(1326, ZEND_FAST_CONCAT_SPEC_CV_CV) \ - _(1327, ZEND_ROPE_INIT_SPEC_UNUSED_CONST) \ - _(1328, ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR) \ - _(1329, ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR) \ - _(1331, ZEND_ROPE_INIT_SPEC_UNUSED_CV) \ - _(1332, ZEND_ROPE_ADD_SPEC_TMP_CONST) \ - _(1333, ZEND_ROPE_ADD_SPEC_TMP_TMPVAR) \ - _(1334, ZEND_ROPE_ADD_SPEC_TMP_TMPVAR) \ - _(1336, ZEND_ROPE_ADD_SPEC_TMP_CV) \ - _(1337, ZEND_ROPE_END_SPEC_TMP_CONST) \ - _(1338, ZEND_ROPE_END_SPEC_TMP_TMPVAR) \ - _(1339, ZEND_ROPE_END_SPEC_TMP_TMPVAR) \ - _(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) \ + _(1254, ZEND_PRE_DEC_STATIC_PROP_SPEC) \ + _(1255, ZEND_POST_INC_STATIC_PROP_SPEC) \ + _(1256, ZEND_POST_DEC_STATIC_PROP_SPEC) \ + _(1257, ZEND_JMP_SPEC) \ + _(1258, ZEND_JMPZ_SPEC_CONST) \ + _(1259, ZEND_JMPZ_SPEC_TMPVAR) \ + _(1260, ZEND_JMPZ_SPEC_TMPVAR) \ + _(1262, ZEND_JMPZ_SPEC_CV) \ + _(1263, ZEND_JMPNZ_SPEC_CONST) \ + _(1264, ZEND_JMPNZ_SPEC_TMPVAR) \ + _(1265, ZEND_JMPNZ_SPEC_TMPVAR) \ + _(1267, ZEND_JMPNZ_SPEC_CV) \ + _(1268, ZEND_JMPZ_EX_SPEC_CONST) \ + _(1269, ZEND_JMPZ_EX_SPEC_TMPVAR) \ + _(1270, ZEND_JMPZ_EX_SPEC_TMPVAR) \ + _(1272, ZEND_JMPZ_EX_SPEC_CV) \ + _(1273, ZEND_JMPNZ_EX_SPEC_CONST) \ + _(1274, ZEND_JMPNZ_EX_SPEC_TMPVAR) \ + _(1275, ZEND_JMPNZ_EX_SPEC_TMPVAR) \ + _(1277, ZEND_JMPNZ_EX_SPEC_CV) \ + _(1278, ZEND_CASE_SPEC_TMPVAR_CONST) \ + _(1279, ZEND_CASE_SPEC_TMPVAR_TMPVAR) \ + _(1280, ZEND_CASE_SPEC_TMPVAR_TMPVAR) \ + _(1282, ZEND_CASE_SPEC_TMPVAR_CV) \ + _(1283, ZEND_CHECK_VAR_SPEC_CV_UNUSED) \ + _(1284, ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST) \ + _(1285, ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST) \ + _(1290, ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED) \ + _(1291, ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK) \ + _(1294, ZEND_CAST_SPEC_CONST) \ + _(1295, ZEND_CAST_SPEC_TMP) \ + _(1296, ZEND_CAST_SPEC_VAR) \ + _(1298, ZEND_CAST_SPEC_CV) \ + _(1299, ZEND_BOOL_SPEC_CONST) \ + _(1300, ZEND_BOOL_SPEC_TMPVAR) \ + _(1301, ZEND_BOOL_SPEC_TMPVAR) \ + _(1303, ZEND_BOOL_SPEC_CV) \ + _(1304, ZEND_FAST_CONCAT_SPEC_CONST_CONST) \ + _(1305, ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR) \ + _(1306, ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR) \ + _(1308, ZEND_FAST_CONCAT_SPEC_CONST_CV) \ + _(1309, ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST) \ + _(1310, ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR) \ + _(1311, ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR) \ + _(1313, ZEND_FAST_CONCAT_SPEC_TMPVAR_CV) \ + _(1314, ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST) \ + _(1315, ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR) \ + _(1316, ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR) \ + _(1318, ZEND_FAST_CONCAT_SPEC_TMPVAR_CV) \ + _(1324, ZEND_FAST_CONCAT_SPEC_CV_CONST) \ + _(1325, ZEND_FAST_CONCAT_SPEC_CV_TMPVAR) \ + _(1326, ZEND_FAST_CONCAT_SPEC_CV_TMPVAR) \ + _(1328, ZEND_FAST_CONCAT_SPEC_CV_CV) \ + _(1329, ZEND_ROPE_INIT_SPEC_UNUSED_CONST) \ + _(1330, ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR) \ + _(1331, ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR) \ + _(1333, ZEND_ROPE_INIT_SPEC_UNUSED_CV) \ + _(1334, ZEND_ROPE_ADD_SPEC_TMP_CONST) \ + _(1335, ZEND_ROPE_ADD_SPEC_TMP_TMPVAR) \ + _(1336, ZEND_ROPE_ADD_SPEC_TMP_TMPVAR) \ + _(1338, ZEND_ROPE_ADD_SPEC_TMP_CV) \ + _(1339, ZEND_ROPE_END_SPEC_TMP_CONST) \ + _(1340, ZEND_ROPE_END_SPEC_TMP_TMPVAR) \ + _(1341, ZEND_ROPE_END_SPEC_TMP_TMPVAR) \ + _(1343, ZEND_ROPE_END_SPEC_TMP_CV) \ + _(1344, ZEND_BEGIN_SILENCE_SPEC) \ + _(1345, ZEND_END_SILENCE_SPEC_TMP) \ + _(1346, ZEND_INIT_FCALL_BY_NAME_SPEC_CONST) \ + _(1347, ZEND_DO_FCALL_SPEC_RETVAL_UNUSED) \ + _(1348, ZEND_DO_FCALL_SPEC_RETVAL_USED) \ + _(1349, ZEND_DO_FCALL_SPEC_OBSERVER) \ + _(1350, ZEND_DO_FCALL_SPEC_OBSERVER) \ + _(1351, ZEND_INIT_FCALL_SPEC_CONST) \ + _(1352, ZEND_RETURN_SPEC_CONST) \ _(1353, ZEND_RETURN_SPEC_OBSERVER) \ - _(1354, ZEND_RETURN_SPEC_VAR) \ + _(1354, ZEND_RETURN_SPEC_TMP) \ _(1355, 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) \ - _(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_TMPVAR) \ - _(1471, ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR) \ - _(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_TMPVAR) \ - _(1476, ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR) \ - _(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_TMPVAR) \ - _(1481, ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR) \ - _(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_TMPVAR) \ - _(1486, ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR) \ - _(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_TMPVAR) \ - _(1491, ZEND_INIT_ARRAY_SPEC_CV_TMPVAR) \ - _(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_TMPVAR) \ - _(1496, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR) \ - _(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_TMPVAR) \ - _(1501, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR) \ - _(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_TMPVAR) \ - _(1506, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR) \ - _(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_TMPVAR) \ - _(1516, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR) \ - _(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_TMPVAR) \ + _(1356, ZEND_RETURN_SPEC_VAR) \ + _(1357, ZEND_RETURN_SPEC_OBSERVER) \ + _(1360, ZEND_RETURN_SPEC_CV) \ + _(1361, ZEND_RETURN_SPEC_OBSERVER) \ + _(1362, ZEND_RECV_SPEC_UNUSED) \ + _(1363, ZEND_RECV_INIT_SPEC_CONST) \ + _(1364, ZEND_SEND_VAL_SPEC_CONST_CONST) \ + _(1367, ZEND_SEND_VAL_SPEC_CONST_UNUSED) \ + _(1369, ZEND_SEND_VAL_SPEC_TMPVAR_CONST) \ + _(1372, ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED) \ + _(1374, ZEND_SEND_VAL_SPEC_TMPVAR_CONST) \ + _(1377, ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED) \ + _(1409, ZEND_SEND_VAR_EX_SPEC_VAR_CONST) \ + _(1410, ZEND_SEND_VAR_EX_SPEC_VAR_CONST) \ + _(1415, ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED) \ + _(1416, ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK) \ + _(1429, ZEND_SEND_VAR_EX_SPEC_CV_CONST) \ + _(1430, ZEND_SEND_VAR_EX_SPEC_CV_CONST) \ + _(1435, ZEND_SEND_VAR_EX_SPEC_CV_UNUSED) \ + _(1436, ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK) \ + _(1449, ZEND_SEND_REF_SPEC_VAR_CONST) \ + _(1452, ZEND_SEND_REF_SPEC_VAR_UNUSED) \ + _(1459, ZEND_SEND_REF_SPEC_CV_CONST) \ + _(1462, ZEND_SEND_REF_SPEC_CV_UNUSED) \ + _(1464, ZEND_NEW_SPEC_CONST_UNUSED) \ + _(1466, ZEND_NEW_SPEC_VAR_UNUSED) \ + _(1467, ZEND_NEW_SPEC_UNUSED_UNUSED) \ + _(1469, ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST) \ + _(1470, ZEND_FREE_SPEC_TMPVAR) \ + _(1471, ZEND_INIT_ARRAY_SPEC_CONST_CONST) \ + _(1472, ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR) \ + _(1473, ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR) \ + _(1474, ZEND_INIT_ARRAY_SPEC_CONST_UNUSED) \ + _(1475, ZEND_INIT_ARRAY_SPEC_CONST_CV) \ + _(1476, ZEND_INIT_ARRAY_SPEC_TMP_CONST) \ + _(1477, ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR) \ + _(1478, ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR) \ + _(1479, ZEND_INIT_ARRAY_SPEC_TMP_UNUSED) \ + _(1480, ZEND_INIT_ARRAY_SPEC_TMP_CV) \ + _(1481, ZEND_INIT_ARRAY_SPEC_VAR_CONST) \ + _(1482, ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR) \ + _(1483, ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR) \ + _(1484, ZEND_INIT_ARRAY_SPEC_VAR_UNUSED) \ + _(1485, ZEND_INIT_ARRAY_SPEC_VAR_CV) \ + _(1486, ZEND_INIT_ARRAY_SPEC_UNUSED_CONST) \ + _(1487, ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR) \ + _(1488, ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR) \ + _(1489, ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED) \ + _(1490, ZEND_INIT_ARRAY_SPEC_UNUSED_CV) \ + _(1491, ZEND_INIT_ARRAY_SPEC_CV_CONST) \ + _(1492, ZEND_INIT_ARRAY_SPEC_CV_TMPVAR) \ + _(1493, ZEND_INIT_ARRAY_SPEC_CV_TMPVAR) \ + _(1494, ZEND_INIT_ARRAY_SPEC_CV_UNUSED) \ + _(1495, ZEND_INIT_ARRAY_SPEC_CV_CV) \ + _(1496, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST) \ + _(1497, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR) \ + _(1498, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR) \ + _(1499, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED) \ + _(1500, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV) \ + _(1501, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST) \ + _(1502, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR) \ + _(1503, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR) \ + _(1504, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED) \ + _(1505, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV) \ + _(1506, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST) \ + _(1507, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR) \ + _(1508, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR) \ + _(1509, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED) \ + _(1510, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV) \ + _(1516, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST) \ + _(1517, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR) \ + _(1518, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR) \ + _(1519, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED) \ + _(1520, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV) \ + _(1521, ZEND_INCLUDE_OR_EVAL_SPEC_CONST) \ _(1522, ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER) \ _(1523, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR) \ _(1524, 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_TMPVAR) \ - _(1546, ZEND_UNSET_DIM_SPEC_VAR_TMPVAR) \ - _(1548, ZEND_UNSET_DIM_SPEC_VAR_CV) \ - _(1554, ZEND_UNSET_DIM_SPEC_CV_CONST) \ - _(1555, ZEND_UNSET_DIM_SPEC_CV_TMPVAR) \ - _(1556, ZEND_UNSET_DIM_SPEC_CV_TMPVAR) \ - _(1558, ZEND_UNSET_DIM_SPEC_CV_CV) \ - _(1569, ZEND_UNSET_OBJ_SPEC_VAR_CONST) \ - _(1570, ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR) \ - _(1571, ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR) \ - _(1573, ZEND_UNSET_OBJ_SPEC_VAR_CV) \ - _(1574, ZEND_UNSET_OBJ_SPEC_UNUSED_CONST) \ - _(1575, ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR) \ - _(1576, ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR) \ - _(1578, ZEND_UNSET_OBJ_SPEC_UNUSED_CV) \ - _(1579, ZEND_UNSET_OBJ_SPEC_CV_CONST) \ - _(1580, ZEND_UNSET_OBJ_SPEC_CV_TMPVAR) \ - _(1581, ZEND_UNSET_OBJ_SPEC_CV_TMPVAR) \ - _(1583, ZEND_UNSET_OBJ_SPEC_CV_CV) \ - _(1584, ZEND_FE_RESET_R_SPEC_CONST) \ - _(1585, ZEND_FE_RESET_R_SPEC_TMP) \ - _(1586, ZEND_FE_RESET_R_SPEC_VAR) \ - _(1588, ZEND_FE_RESET_R_SPEC_CV) \ - _(1589, ZEND_FE_FETCH_R_SPEC_VAR) \ - _(1590, ZEND_FETCH_R_SPEC_CONST_UNUSED) \ - _(1591, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \ - _(1592, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \ - _(1594, ZEND_FETCH_R_SPEC_CV_UNUSED) \ - _(1595, ZEND_FETCH_DIM_R_SPEC_CONST_CONST) \ - _(1596, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \ - _(1597, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \ - _(1599, ZEND_FETCH_DIM_R_SPEC_CONST_CV) \ - _(1600, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \ - _(1601, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ - _(1602, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ - _(1604, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \ - _(1605, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \ - _(1606, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ - _(1607, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ - _(1609, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \ - _(1615, ZEND_FETCH_DIM_R_SPEC_CV_CONST) \ - _(1616, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \ - _(1617, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \ - _(1619, ZEND_FETCH_DIM_R_SPEC_CV_CV) \ - _(1620, ZEND_FETCH_OBJ_R_SPEC_CONST_CONST) \ - _(1621, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \ - _(1622, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \ - _(1624, ZEND_FETCH_OBJ_R_SPEC_CONST_CV) \ - _(1625, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \ - _(1626, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ - _(1627, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ - _(1629, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \ - _(1630, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \ - _(1631, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ - _(1632, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ - _(1634, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \ - _(1635, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST) \ - _(1636, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \ - _(1637, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \ - _(1639, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV) \ - _(1640, ZEND_FETCH_OBJ_R_SPEC_CV_CONST) \ - _(1641, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \ - _(1642, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \ - _(1644, ZEND_FETCH_OBJ_R_SPEC_CV_CV) \ - _(1645, ZEND_FETCH_W_SPEC_CONST_UNUSED) \ - _(1646, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \ - _(1647, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \ - _(1649, ZEND_FETCH_W_SPEC_CV_UNUSED) \ - _(1660, ZEND_FETCH_DIM_W_SPEC_VAR_CONST) \ - _(1661, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \ - _(1662, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \ - _(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_TMPVAR) \ - _(1672, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \ - _(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_TMPVAR) \ - _(1687, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \ - _(1689, ZEND_FETCH_OBJ_W_SPEC_VAR_CV) \ - _(1690, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST) \ - _(1691, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \ - _(1692, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \ - _(1694, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV) \ - _(1695, ZEND_FETCH_OBJ_W_SPEC_CV_CONST) \ - _(1696, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \ - _(1697, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \ - _(1699, ZEND_FETCH_OBJ_W_SPEC_CV_CV) \ - _(1700, ZEND_FETCH_RW_SPEC_CONST_UNUSED) \ - _(1701, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \ - _(1702, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \ - _(1704, ZEND_FETCH_RW_SPEC_CV_UNUSED) \ - _(1715, ZEND_FETCH_DIM_RW_SPEC_VAR_CONST) \ - _(1716, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \ - _(1717, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \ - _(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_TMPVAR) \ - _(1727, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \ - _(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_TMPVAR) \ - _(1742, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \ - _(1744, ZEND_FETCH_OBJ_RW_SPEC_VAR_CV) \ - _(1745, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST) \ - _(1746, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \ - _(1747, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \ - _(1749, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV) \ - _(1750, ZEND_FETCH_OBJ_RW_SPEC_CV_CONST) \ - _(1751, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \ - _(1752, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \ - _(1754, ZEND_FETCH_OBJ_RW_SPEC_CV_CV) \ - _(1755, ZEND_FETCH_IS_SPEC_CONST_UNUSED) \ - _(1756, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \ - _(1757, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \ - _(1759, ZEND_FETCH_IS_SPEC_CV_UNUSED) \ - _(1760, ZEND_FETCH_DIM_IS_SPEC_CONST_CONST) \ - _(1761, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \ - _(1762, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \ - _(1764, ZEND_FETCH_DIM_IS_SPEC_CONST_CV) \ - _(1765, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \ - _(1766, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ - _(1767, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ - _(1769, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \ - _(1770, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \ - _(1771, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ - _(1772, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ - _(1774, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \ - _(1780, ZEND_FETCH_DIM_IS_SPEC_CV_CONST) \ - _(1781, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \ - _(1782, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \ - _(1784, ZEND_FETCH_DIM_IS_SPEC_CV_CV) \ - _(1785, ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST) \ - _(1786, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \ - _(1787, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \ - _(1789, ZEND_FETCH_OBJ_IS_SPEC_CONST_CV) \ - _(1790, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \ - _(1791, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ - _(1792, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ - _(1794, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \ - _(1795, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \ - _(1796, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ - _(1797, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ - _(1799, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \ - _(1800, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST) \ - _(1801, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \ - _(1802, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \ - _(1804, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV) \ - _(1805, ZEND_FETCH_OBJ_IS_SPEC_CV_CONST) \ - _(1806, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \ - _(1807, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \ - _(1809, ZEND_FETCH_OBJ_IS_SPEC_CV_CV) \ - _(1810, ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED) \ - _(1811, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \ - _(1812, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_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_TMPVAR) \ - _(1817, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \ - _(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_TMPVAR) \ - _(1822, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \ - _(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_TMPVAR) \ - _(1827, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \ - _(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_TMPVAR) \ - _(1837, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \ - _(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_TMPVAR) \ - _(1842, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \ - _(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_TMPVAR) \ - _(1847, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \ - _(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_TMPVAR) \ - _(1852, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \ - _(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_TMPVAR) \ - _(1857, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \ - _(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_TMPVAR) \ - _(1862, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \ - _(1864, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV) \ - _(1865, ZEND_FETCH_UNSET_SPEC_CONST_UNUSED) \ - _(1866, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \ - _(1867, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \ - _(1869, ZEND_FETCH_UNSET_SPEC_CV_UNUSED) \ - _(1880, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST) \ - _(1881, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \ - _(1882, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \ - _(1884, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV) \ - _(1890, ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST) \ - _(1891, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \ - _(1892, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \ - _(1894, ZEND_FETCH_DIM_UNSET_SPEC_CV_CV) \ - _(1905, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST) \ - _(1906, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \ - _(1907, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \ - _(1909, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV) \ - _(1910, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST) \ - _(1911, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \ - _(1912, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \ - _(1914, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV) \ - _(1915, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST) \ - _(1916, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \ - _(1917, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \ - _(1919, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV) \ - _(1920, ZEND_FETCH_LIST_R_SPEC_CONST_CONST) \ - _(1921, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \ - _(1922, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \ - _(1924, ZEND_FETCH_LIST_R_SPEC_CONST_CV) \ - _(1925, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ - _(1926, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1927, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1929, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ - _(1930, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ - _(1931, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1932, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1934, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ - _(1940, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ - _(1941, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1942, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(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_TMPVAR) \ - _(1969, ZEND_THROW_SPEC_TMPVAR) \ - _(1971, ZEND_THROW_SPEC_CV) \ - _(1972, ZEND_FETCH_CLASS_SPEC_UNUSED_CONST) \ - _(1973, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \ - _(1974, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \ - _(1975, ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED) \ - _(1976, ZEND_FETCH_CLASS_SPEC_UNUSED_CV) \ - _(1977, ZEND_CLONE_SPEC_CONST) \ - _(1978, ZEND_CLONE_SPEC_TMPVAR) \ - _(1979, ZEND_CLONE_SPEC_TMPVAR) \ - _(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) \ + _(1525, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR) \ + _(1526, ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER) \ + _(1529, ZEND_INCLUDE_OR_EVAL_SPEC_CV) \ + _(1530, ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER) \ + _(1531, ZEND_UNSET_VAR_SPEC_CONST_UNUSED) \ + _(1532, ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED) \ + _(1533, ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED) \ + _(1535, ZEND_UNSET_VAR_SPEC_CV_UNUSED) \ + _(1546, ZEND_UNSET_DIM_SPEC_VAR_CONST) \ + _(1547, ZEND_UNSET_DIM_SPEC_VAR_TMPVAR) \ + _(1548, ZEND_UNSET_DIM_SPEC_VAR_TMPVAR) \ + _(1550, ZEND_UNSET_DIM_SPEC_VAR_CV) \ + _(1556, ZEND_UNSET_DIM_SPEC_CV_CONST) \ + _(1557, ZEND_UNSET_DIM_SPEC_CV_TMPVAR) \ + _(1558, ZEND_UNSET_DIM_SPEC_CV_TMPVAR) \ + _(1560, ZEND_UNSET_DIM_SPEC_CV_CV) \ + _(1571, ZEND_UNSET_OBJ_SPEC_VAR_CONST) \ + _(1572, ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR) \ + _(1573, ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR) \ + _(1575, ZEND_UNSET_OBJ_SPEC_VAR_CV) \ + _(1576, ZEND_UNSET_OBJ_SPEC_UNUSED_CONST) \ + _(1577, ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR) \ + _(1578, ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR) \ + _(1580, ZEND_UNSET_OBJ_SPEC_UNUSED_CV) \ + _(1581, ZEND_UNSET_OBJ_SPEC_CV_CONST) \ + _(1582, ZEND_UNSET_OBJ_SPEC_CV_TMPVAR) \ + _(1583, ZEND_UNSET_OBJ_SPEC_CV_TMPVAR) \ + _(1585, ZEND_UNSET_OBJ_SPEC_CV_CV) \ + _(1586, ZEND_FE_RESET_R_SPEC_CONST) \ + _(1587, ZEND_FE_RESET_R_SPEC_TMP) \ + _(1588, ZEND_FE_RESET_R_SPEC_VAR) \ + _(1590, ZEND_FE_RESET_R_SPEC_CV) \ + _(1591, ZEND_FE_FETCH_R_SPEC_VAR) \ + _(1592, ZEND_FETCH_R_SPEC_CONST_UNUSED) \ + _(1593, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \ + _(1594, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \ + _(1596, ZEND_FETCH_R_SPEC_CV_UNUSED) \ + _(1597, ZEND_FETCH_DIM_R_SPEC_CONST_CONST) \ + _(1598, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \ + _(1599, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \ + _(1601, ZEND_FETCH_DIM_R_SPEC_CONST_CV) \ + _(1602, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \ + _(1603, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ + _(1604, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ + _(1606, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \ + _(1607, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \ + _(1608, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ + _(1609, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ + _(1611, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \ + _(1617, ZEND_FETCH_DIM_R_SPEC_CV_CONST) \ + _(1618, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \ + _(1619, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \ + _(1621, ZEND_FETCH_DIM_R_SPEC_CV_CV) \ + _(1622, ZEND_FETCH_OBJ_R_SPEC_CONST_CONST) \ + _(1623, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \ + _(1624, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \ + _(1626, ZEND_FETCH_OBJ_R_SPEC_CONST_CV) \ + _(1627, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \ + _(1628, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ + _(1629, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ + _(1631, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \ + _(1632, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \ + _(1633, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ + _(1634, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ + _(1636, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \ + _(1637, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST) \ + _(1638, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \ + _(1639, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \ + _(1641, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV) \ + _(1642, ZEND_FETCH_OBJ_R_SPEC_CV_CONST) \ + _(1643, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \ + _(1644, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \ + _(1646, ZEND_FETCH_OBJ_R_SPEC_CV_CV) \ + _(1647, ZEND_FETCH_W_SPEC_CONST_UNUSED) \ + _(1648, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \ + _(1649, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \ + _(1651, ZEND_FETCH_W_SPEC_CV_UNUSED) \ + _(1662, ZEND_FETCH_DIM_W_SPEC_VAR_CONST) \ + _(1663, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \ + _(1664, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \ + _(1665, ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED) \ + _(1666, ZEND_FETCH_DIM_W_SPEC_VAR_CV) \ + _(1672, ZEND_FETCH_DIM_W_SPEC_CV_CONST) \ + _(1673, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \ + _(1674, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \ + _(1675, ZEND_FETCH_DIM_W_SPEC_CV_UNUSED) \ + _(1676, ZEND_FETCH_DIM_W_SPEC_CV_CV) \ + _(1687, ZEND_FETCH_OBJ_W_SPEC_VAR_CONST) \ + _(1688, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \ + _(1689, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \ + _(1691, ZEND_FETCH_OBJ_W_SPEC_VAR_CV) \ + _(1692, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST) \ + _(1693, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \ + _(1694, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \ + _(1696, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV) \ + _(1697, ZEND_FETCH_OBJ_W_SPEC_CV_CONST) \ + _(1698, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \ + _(1699, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \ + _(1701, ZEND_FETCH_OBJ_W_SPEC_CV_CV) \ + _(1702, ZEND_FETCH_RW_SPEC_CONST_UNUSED) \ + _(1703, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \ + _(1704, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \ + _(1706, ZEND_FETCH_RW_SPEC_CV_UNUSED) \ + _(1717, ZEND_FETCH_DIM_RW_SPEC_VAR_CONST) \ + _(1718, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \ + _(1719, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \ + _(1720, ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED) \ + _(1721, ZEND_FETCH_DIM_RW_SPEC_VAR_CV) \ + _(1727, ZEND_FETCH_DIM_RW_SPEC_CV_CONST) \ + _(1728, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \ + _(1729, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \ + _(1730, ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED) \ + _(1731, ZEND_FETCH_DIM_RW_SPEC_CV_CV) \ + _(1742, ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST) \ + _(1743, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \ + _(1744, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \ + _(1746, ZEND_FETCH_OBJ_RW_SPEC_VAR_CV) \ + _(1747, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST) \ + _(1748, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \ + _(1749, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \ + _(1751, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV) \ + _(1752, ZEND_FETCH_OBJ_RW_SPEC_CV_CONST) \ + _(1753, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \ + _(1754, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \ + _(1756, ZEND_FETCH_OBJ_RW_SPEC_CV_CV) \ + _(1757, ZEND_FETCH_IS_SPEC_CONST_UNUSED) \ + _(1758, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \ + _(1759, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \ + _(1761, ZEND_FETCH_IS_SPEC_CV_UNUSED) \ + _(1762, ZEND_FETCH_DIM_IS_SPEC_CONST_CONST) \ + _(1763, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \ + _(1764, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \ + _(1766, ZEND_FETCH_DIM_IS_SPEC_CONST_CV) \ + _(1767, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \ + _(1768, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ + _(1769, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ + _(1771, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \ + _(1772, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \ + _(1773, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ + _(1774, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ + _(1776, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \ + _(1782, ZEND_FETCH_DIM_IS_SPEC_CV_CONST) \ + _(1783, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \ + _(1784, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \ + _(1786, ZEND_FETCH_DIM_IS_SPEC_CV_CV) \ + _(1787, ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST) \ + _(1788, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \ + _(1789, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \ + _(1791, ZEND_FETCH_OBJ_IS_SPEC_CONST_CV) \ + _(1792, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \ + _(1793, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ + _(1794, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ + _(1796, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \ + _(1797, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \ + _(1798, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ + _(1799, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ + _(1801, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \ + _(1802, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST) \ + _(1803, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \ + _(1804, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \ + _(1806, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV) \ + _(1807, ZEND_FETCH_OBJ_IS_SPEC_CV_CONST) \ + _(1808, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \ + _(1809, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \ + _(1811, ZEND_FETCH_OBJ_IS_SPEC_CV_CV) \ + _(1812, ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED) \ + _(1813, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \ + _(1814, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \ + _(1816, ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED) \ + _(1817, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST) \ + _(1818, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \ + _(1819, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \ + _(1820, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED) \ + _(1821, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV) \ + _(1822, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST) \ + _(1823, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \ + _(1824, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \ + _(1825, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED) \ + _(1826, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV) \ + _(1827, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST) \ + _(1828, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \ + _(1829, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \ + _(1830, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED) \ + _(1831, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV) \ + _(1837, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST) \ + _(1838, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \ + _(1839, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \ + _(1840, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED) \ + _(1841, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV) \ + _(1842, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST) \ + _(1843, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \ + _(1844, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \ + _(1846, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV) \ + _(1847, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST) \ + _(1848, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \ + _(1849, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \ + _(1851, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV) \ + _(1852, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST) \ + _(1853, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \ + _(1854, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \ + _(1856, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV) \ + _(1857, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST) \ + _(1858, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \ + _(1859, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \ + _(1861, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV) \ + _(1862, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST) \ + _(1863, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \ + _(1864, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \ + _(1866, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV) \ + _(1867, ZEND_FETCH_UNSET_SPEC_CONST_UNUSED) \ + _(1868, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \ + _(1869, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \ + _(1871, ZEND_FETCH_UNSET_SPEC_CV_UNUSED) \ + _(1882, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST) \ + _(1883, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \ + _(1884, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \ + _(1886, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV) \ + _(1892, ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST) \ + _(1893, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \ + _(1894, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \ + _(1896, ZEND_FETCH_DIM_UNSET_SPEC_CV_CV) \ + _(1907, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST) \ + _(1908, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \ + _(1909, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \ + _(1911, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV) \ + _(1912, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST) \ + _(1913, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \ + _(1914, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \ + _(1916, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV) \ + _(1917, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST) \ + _(1918, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \ + _(1919, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \ + _(1921, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV) \ + _(1922, ZEND_FETCH_LIST_R_SPEC_CONST_CONST) \ + _(1923, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \ + _(1924, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \ + _(1926, ZEND_FETCH_LIST_R_SPEC_CONST_CV) \ + _(1927, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ + _(1928, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ + _(1929, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ + _(1931, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ + _(1932, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ + _(1933, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ + _(1934, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ + _(1936, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ + _(1942, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ + _(1943, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ + _(1944, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ + _(1946, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ + _(1947, ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST) \ + _(1948, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST) \ + _(1949, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST) \ + _(1954, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED) \ + _(1955, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK) \ + _(1958, ZEND_EXT_STMT_SPEC) \ + _(1959, ZEND_EXT_FCALL_BEGIN_SPEC) \ + _(1960, ZEND_EXT_FCALL_END_SPEC) \ + _(1961, ZEND_EXT_NOP_SPEC) \ + _(1962, ZEND_TICKS_SPEC) \ + _(1963, ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST) \ + _(1966, ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED) \ + _(1968, ZEND_CATCH_SPEC_CONST) \ + _(1969, ZEND_THROW_SPEC_CONST) \ + _(1970, ZEND_THROW_SPEC_TMPVAR) \ + _(1971, ZEND_THROW_SPEC_TMPVAR) \ + _(1973, ZEND_THROW_SPEC_CV) \ + _(1974, ZEND_FETCH_CLASS_SPEC_UNUSED_CONST) \ + _(1975, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \ + _(1976, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \ + _(1977, ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED) \ + _(1978, ZEND_FETCH_CLASS_SPEC_UNUSED_CV) \ + _(1979, ZEND_CLONE_SPEC_CONST) \ + _(1980, ZEND_CLONE_SPEC_TMPVAR) \ + _(1981, ZEND_CLONE_SPEC_TMPVAR) \ + _(1982, ZEND_CLONE_SPEC_UNUSED) \ + _(1983, ZEND_CLONE_SPEC_CV) \ + _(1984, ZEND_RETURN_BY_REF_SPEC_CONST) \ _(1985, ZEND_RETURN_BY_REF_SPEC_OBSERVER) \ - _(1986, ZEND_RETURN_BY_REF_SPEC_VAR) \ + _(1986, ZEND_RETURN_BY_REF_SPEC_TMP) \ _(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_TMPVAR) \ - _(1994, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \ - _(1996, ZEND_INIT_METHOD_CALL_SPEC_CONST_CV) \ - _(1997, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \ - _(1998, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ - _(1999, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ - _(2001, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \ - _(2002, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \ - _(2003, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ - _(2004, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ - _(2006, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \ - _(2007, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST) \ - _(2008, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ - _(2009, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ - _(2011, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV) \ - _(2012, ZEND_INIT_METHOD_CALL_SPEC_CV_CONST) \ - _(2013, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \ - _(2014, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \ - _(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_TMPVAR) \ - _(2019, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \ - _(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_TMPVAR) \ - _(2029, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \ - _(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_TMPVAR) \ - _(2034, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ - _(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_TMPVAR_UNUSED) \ - _(2044, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_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_TMPVAR) \ - _(2049, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \ - _(2051, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV) \ - _(2052, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \ - _(2053, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2054, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2056, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \ - _(2057, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \ - _(2058, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2059, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2061, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \ - _(2067, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST) \ - _(2068, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \ - _(2069, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \ - _(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_TMPVAR) \ - _(2149, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \ - _(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) \ - _(2155, ZEND_SEND_USER_SPEC_VAR) \ - _(2157, ZEND_SEND_USER_SPEC_CV) \ - _(2158, ZEND_STRLEN_SPEC_CONST) \ - _(2159, ZEND_STRLEN_SPEC_TMPVAR) \ - _(2160, ZEND_STRLEN_SPEC_TMPVAR) \ - _(2162, ZEND_STRLEN_SPEC_CV) \ - _(2163, ZEND_DEFINED_SPEC_CONST_UNUSED) \ - _(2164, ZEND_TYPE_CHECK_SPEC_CONST_UNUSED) \ - _(2165, ZEND_TYPE_CHECK_SPEC_TMPVAR_UNUSED) \ - _(2166, ZEND_TYPE_CHECK_SPEC_TMPVAR_UNUSED) \ - _(2168, ZEND_TYPE_CHECK_SPEC_CV_UNUSED) \ - _(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_TMPVAR) \ - _(2183, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \ - _(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_TMPVAR) \ - _(2210, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \ - _(2212, ZEND_PRE_INC_OBJ_SPEC_VAR_CV) \ - _(2213, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST) \ - _(2214, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2215, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2217, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV) \ - _(2218, ZEND_PRE_INC_OBJ_SPEC_CV_CONST) \ - _(2219, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \ - _(2220, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \ - _(2222, ZEND_PRE_INC_OBJ_SPEC_CV_CV) \ - _(2233, ZEND_POST_INC_OBJ_SPEC_VAR_CONST) \ - _(2234, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \ - _(2235, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \ - _(2237, ZEND_POST_INC_OBJ_SPEC_VAR_CV) \ - _(2238, ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST) \ - _(2239, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2240, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2242, ZEND_POST_INC_OBJ_SPEC_UNUSED_CV) \ - _(2243, ZEND_POST_INC_OBJ_SPEC_CV_CONST) \ - _(2244, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \ - _(2245, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \ - _(2247, ZEND_POST_INC_OBJ_SPEC_CV_CV) \ - _(2248, ZEND_ECHO_SPEC_CONST) \ - _(2249, ZEND_ECHO_SPEC_TMPVAR) \ - _(2250, ZEND_ECHO_SPEC_TMPVAR) \ - _(2252, ZEND_ECHO_SPEC_CV) \ - _(2259, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \ - _(2261, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \ - _(2262, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \ - _(2264, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \ - _(2266, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \ - _(2267, ZEND_INSTANCEOF_SPEC_TMPVAR_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_TMPVAR) \ - _(2294, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \ - _(2296, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV) \ - _(2297, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ - _(2298, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2299, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2301, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ - _(2302, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ - _(2303, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2304, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2306, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ - _(2307, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST) \ - _(2308, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2309, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ - _(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_TMPVAR) \ - _(2314, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ - _(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) \ - _(2322, ZEND_JMP_SET_SPEC_VAR) \ - _(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_TMPVAR) \ - _(2330, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ - _(2332, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \ - _(2333, ZEND_SEPARATE_SPEC_VAR_UNUSED) \ - _(2335, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \ - _(2336, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \ - _(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_TMPVAR) \ - _(2344, ZEND_YIELD_SPEC_CONST_TMPVAR) \ - _(2345, ZEND_YIELD_SPEC_CONST_UNUSED) \ - _(2346, ZEND_YIELD_SPEC_CONST_CV) \ - _(2347, ZEND_YIELD_SPEC_TMP_CONST) \ - _(2348, ZEND_YIELD_SPEC_TMP_TMPVAR) \ - _(2349, ZEND_YIELD_SPEC_TMP_TMPVAR) \ - _(2350, ZEND_YIELD_SPEC_TMP_UNUSED) \ - _(2351, ZEND_YIELD_SPEC_TMP_CV) \ - _(2352, ZEND_YIELD_SPEC_VAR_CONST) \ - _(2353, ZEND_YIELD_SPEC_VAR_TMPVAR) \ - _(2354, ZEND_YIELD_SPEC_VAR_TMPVAR) \ - _(2355, ZEND_YIELD_SPEC_VAR_UNUSED) \ - _(2356, ZEND_YIELD_SPEC_VAR_CV) \ - _(2357, ZEND_YIELD_SPEC_UNUSED_CONST) \ - _(2358, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \ - _(2359, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \ - _(2360, ZEND_YIELD_SPEC_UNUSED_UNUSED) \ - _(2361, ZEND_YIELD_SPEC_UNUSED_CV) \ - _(2362, ZEND_YIELD_SPEC_CV_CONST) \ - _(2363, ZEND_YIELD_SPEC_CV_TMPVAR) \ - _(2364, ZEND_YIELD_SPEC_CV_TMPVAR) \ - _(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_TMPVAR) \ - _(2383, ZEND_YIELD_FROM_SPEC_TMPVAR) \ - _(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) \ - _(2390, ZEND_COALESCE_SPEC_VAR) \ - _(2392, ZEND_COALESCE_SPEC_CV) \ - _(2393, ZEND_SPACESHIP_SPEC_CONST_CONST) \ - _(2394, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ - _(2395, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ - _(2397, ZEND_SPACESHIP_SPEC_CONST_CV) \ - _(2398, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ - _(2399, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(2400, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(2402, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ - _(2403, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ - _(2404, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(2405, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(2407, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ - _(2413, ZEND_SPACESHIP_SPEC_CV_CONST) \ - _(2414, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ - _(2415, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ - _(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) \ - _(2478, ZEND_IN_ARRAY_SPEC_VAR_CONST) \ - _(2480, ZEND_IN_ARRAY_SPEC_CV_CONST) \ - _(2481, ZEND_COUNT_SPEC_CONST_UNUSED) \ - _(2482, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \ - _(2483, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \ - _(2485, ZEND_COUNT_SPEC_CV_UNUSED) \ - _(2486, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \ - _(2487, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \ - _(2488, ZEND_GET_CLASS_SPEC_TMPVAR_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) \ - _(2494, ZEND_GET_TYPE_SPEC_VAR_UNUSED) \ - _(2496, ZEND_GET_TYPE_SPEC_CV_UNUSED) \ - _(2497, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \ - _(2498, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ - _(2499, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ - _(2501, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \ - _(2502, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ - _(2503, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(2504, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(2506, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ - _(2507, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ - _(2508, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(2509, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(2511, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ - _(2517, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \ - _(2518, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ - _(2519, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ - _(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) \ - _(2532, ZEND_CASE_STRICT_SPEC_TMP_CONST) \ - _(2533, ZEND_CASE_STRICT_SPEC_TMP_TMP) \ - _(2534, ZEND_CASE_STRICT_SPEC_TMP_VAR) \ - _(2536, ZEND_CASE_STRICT_SPEC_TMP_CV) \ - _(2537, ZEND_CASE_STRICT_SPEC_VAR_CONST) \ - _(2538, ZEND_CASE_STRICT_SPEC_VAR_TMP) \ - _(2539, ZEND_CASE_STRICT_SPEC_VAR_VAR) \ - _(2541, ZEND_CASE_STRICT_SPEC_VAR_CV) \ - _(2552, ZEND_MATCH_ERROR_SPEC_CONST_UNUSED) \ - _(2553, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ - _(2554, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ - _(2556, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ - _(2557, ZEND_JMP_NULL_SPEC_CONST) \ - _(2558, ZEND_JMP_NULL_SPEC_TMP) \ - _(2559, ZEND_JMP_NULL_SPEC_VAR) \ - _(2561, ZEND_JMP_NULL_SPEC_CV) \ - _(2562, ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED) \ - _(2563, ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED) \ - _(2564, ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED) \ - _(2565, ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED) \ - _(2566, ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV) \ - _(2567, ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED) \ - _(2568, ZEND_FRAMELESS_ICALL_0_SPEC_OBSERVER) \ - _(2569, ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED) \ - _(2570, ZEND_FRAMELESS_ICALL_1_SPEC_OBSERVER) \ - _(2571, ZEND_FRAMELESS_ICALL_2_SPEC) \ - _(2572, ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVER) \ - _(2573, ZEND_FRAMELESS_ICALL_3_SPEC) \ - _(2574, ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER) \ - _(2575, ZEND_JMP_FRAMELESS_SPEC_CONST) \ - _(2576, ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED) \ - _(2577, ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST) \ - _(2578, ZEND_INIT_FCALL_OFFSET_SPEC_CONST) \ - _(2579, ZEND_RECV_NOTYPE_SPEC_UNUSED) \ - _(2581, ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED) \ - _(2582, ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED) \ - _(2584, ZEND_COUNT_ARRAY_SPEC_CV_UNUSED) \ - _(2585, ZEND_JMP_FORWARD_SPEC) \ - _(2591, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2592, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2593, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2595, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2596, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2597, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2598, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2600, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2606, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2607, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2608, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2610, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2616, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2617, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2618, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2620, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2621, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2622, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2623, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2625, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2631, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2632, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2633, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2635, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2641, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2642, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2643, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2645, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2646, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2647, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2648, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2650, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2656, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2657, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2658, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2660, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2662, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2663, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2665, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2666, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2667, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2668, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2670, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2671, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2672, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2673, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2675, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2681, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2682, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2683, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2685, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2687, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2688, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2690, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2691, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2692, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2693, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2695, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2696, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2697, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2698, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2700, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2706, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2707, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2708, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2710, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2712, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2713, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2715, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2716, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2717, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2718, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2720, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2721, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2722, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2723, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2725, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2731, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2732, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2733, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2735, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2741, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2742, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2743, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2745, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2746, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2747, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2748, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2750, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2756, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2757, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2758, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2760, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2766, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2767, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2768, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2770, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2771, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2772, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2773, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2775, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2781, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2782, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2783, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2785, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2791, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2792, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2793, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2795, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2796, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2797, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2798, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2800, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2806, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2807, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2808, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2810, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2826, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2827, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2828, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2829, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2830, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2831, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2832, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2833, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2834, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2838, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2839, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2840, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2841, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2842, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2843, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2844, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2845, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2846, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2847, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2848, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2849, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2853, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2854, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2855, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2871, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2872, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2873, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2874, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2875, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2876, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2877, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2878, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2879, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2883, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2884, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2885, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2901, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2902, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2903, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2904, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2905, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2906, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2907, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2908, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2909, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2913, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2914, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2915, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2916, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2917, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2918, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2919, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2920, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2921, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2922, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2923, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2924, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2928, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2929, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2930, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2946, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2947, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2948, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2949, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2950, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2951, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2952, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2953, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2954, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2958, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2959, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2960, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2976, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2977, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2978, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2979, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2980, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2981, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2982, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2983, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2984, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2988, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2989, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2990, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2991, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2992, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2993, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2994, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2995, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2996, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2997, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2998, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2999, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3003, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3004, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3005, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3021, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3022, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3023, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3024, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3025, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3026, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3027, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3028, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3029, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3033, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3034, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3035, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3051, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3052, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3053, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3054, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3055, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3056, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3057, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3058, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3059, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3063, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3064, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3065, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3066, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3067, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3068, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3069, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3070, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3071, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3072, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3073, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3074, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3078, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3079, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3080, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3096, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3097, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3098, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3099, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3100, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3101, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3102, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3103, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3104, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3108, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3109, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3110, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3111, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST) \ - _(3112, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3113, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3114, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST) \ - _(3115, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3116, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3117, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(3121, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(3122, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(3126, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(3130, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3131, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3132, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3133, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3134, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3135, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3139, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3140, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3141, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3142, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3143, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3144, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3145, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3146, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3147, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3148, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3149, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3150, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3154, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3155, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3156, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3157, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3158, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3159, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3160, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3161, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3162, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3163, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3164, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3165, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3169, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3170, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3171, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3187, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3188, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3189, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3190, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3191, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3192, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3193, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3194, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3195, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3199, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3200, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3201, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3205, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3206, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3207, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3208, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3209, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3210, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3214, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3215, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3216, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3217, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3218, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3219, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3220, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3221, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3222, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3223, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3224, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3225, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3229, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3230, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3231, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3232, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3233, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3234, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3235, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3236, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3237, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3238, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3239, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3240, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3244, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3245, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3246, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3262, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3263, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3264, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3265, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3266, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3267, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3268, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3269, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3270, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3274, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3275, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3276, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3280, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3281, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3282, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3283, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3284, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3285, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3289, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3290, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3291, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3292, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3293, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3294, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3295, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3296, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3297, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3298, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3299, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3300, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3304, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3305, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3306, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3307, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3308, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3309, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3310, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3311, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3312, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3313, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3314, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3315, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3319, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3320, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3321, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3337, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3338, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3339, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3340, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3341, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3342, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3343, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3344, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3345, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3349, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3350, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3351, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3355, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3356, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3357, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3358, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3359, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3360, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3364, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3365, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3366, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3367, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3368, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3369, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3370, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3371, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3372, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3373, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3374, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3375, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3379, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3380, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3381, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3382, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3383, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3384, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3385, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3386, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3387, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3388, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3389, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3390, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3394, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3395, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3396, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3412, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3413, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3414, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3415, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3416, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3417, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3418, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3419, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3420, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3424, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3425, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3426, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3427, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3428, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3429, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3430, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ - _(3431, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3432, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3433, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3434, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ - _(3435, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3436, ZEND_POST_INC_LONG_SPEC_CV) \ - _(3437, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3438, ZEND_POST_DEC_LONG_SPEC_CV) \ - _(3439, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ - _(3440, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3441, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3443, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3444, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ - _(3445, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3446, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3448, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3449, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ - _(3450, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3451, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3453, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3455, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3456, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3458, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3459, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(3460, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3461, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3463, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3464, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(3465, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3466, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3468, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3474, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ - _(3475, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3476, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3478, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3481, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ - _(3483, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ - _(3486, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ - _(3488, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ - _(3489, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ - _(3490, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ - _(3491, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ - _(3492, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ - _(3492+1, ZEND_NULL) + _(1988, ZEND_RETURN_BY_REF_SPEC_VAR) \ + _(1989, ZEND_RETURN_BY_REF_SPEC_OBSERVER) \ + _(1992, ZEND_RETURN_BY_REF_SPEC_CV) \ + _(1993, ZEND_RETURN_BY_REF_SPEC_OBSERVER) \ + _(1994, ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST) \ + _(1995, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \ + _(1996, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \ + _(1998, ZEND_INIT_METHOD_CALL_SPEC_CONST_CV) \ + _(1999, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \ + _(2000, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ + _(2001, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ + _(2003, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \ + _(2004, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \ + _(2005, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ + _(2006, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ + _(2008, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \ + _(2009, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST) \ + _(2010, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ + _(2011, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ + _(2013, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV) \ + _(2014, ZEND_INIT_METHOD_CALL_SPEC_CV_CONST) \ + _(2015, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \ + _(2016, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \ + _(2018, ZEND_INIT_METHOD_CALL_SPEC_CV_CV) \ + _(2019, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST) \ + _(2020, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \ + _(2021, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \ + _(2022, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED) \ + _(2023, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV) \ + _(2029, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST) \ + _(2030, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \ + _(2031, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \ + _(2032, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED) \ + _(2033, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV) \ + _(2034, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST) \ + _(2035, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ + _(2036, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ + _(2037, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED) \ + _(2038, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV) \ + _(2044, ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED) \ + _(2045, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \ + _(2046, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \ + _(2048, ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED) \ + _(2049, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST) \ + _(2050, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \ + _(2051, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \ + _(2053, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV) \ + _(2054, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \ + _(2055, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2056, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2058, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \ + _(2059, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \ + _(2060, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2061, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2063, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \ + _(2069, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST) \ + _(2070, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \ + _(2071, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \ + _(2073, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV) \ + _(2074, ZEND_SEND_VAL_EX_SPEC_CONST_CONST) \ + _(2075, ZEND_SEND_VAL_EX_SPEC_CONST_CONST) \ + _(2080, ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED) \ + _(2081, ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK) \ + _(2084, ZEND_SEND_VAL_EX_SPEC_TMP_CONST) \ + _(2085, ZEND_SEND_VAL_EX_SPEC_TMP_CONST) \ + _(2090, ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED) \ + _(2091, ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK) \ + _(2134, ZEND_SEND_VAR_SPEC_VAR_CONST) \ + _(2137, ZEND_SEND_VAR_SPEC_VAR_UNUSED) \ + _(2144, ZEND_SEND_VAR_SPEC_CV_CONST) \ + _(2147, ZEND_SEND_VAR_SPEC_CV_UNUSED) \ + _(2149, ZEND_INIT_USER_CALL_SPEC_CONST_CONST) \ + _(2150, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \ + _(2151, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \ + _(2153, ZEND_INIT_USER_CALL_SPEC_CONST_CV) \ + _(2154, ZEND_SEND_ARRAY_SPEC) \ + _(2155, ZEND_SEND_USER_SPEC_CONST) \ + _(2156, ZEND_SEND_USER_SPEC_TMP) \ + _(2157, ZEND_SEND_USER_SPEC_VAR) \ + _(2159, ZEND_SEND_USER_SPEC_CV) \ + _(2160, ZEND_STRLEN_SPEC_CONST) \ + _(2161, ZEND_STRLEN_SPEC_TMPVAR) \ + _(2162, ZEND_STRLEN_SPEC_TMPVAR) \ + _(2164, ZEND_STRLEN_SPEC_CV) \ + _(2165, ZEND_DEFINED_SPEC_CONST_UNUSED) \ + _(2166, ZEND_TYPE_CHECK_SPEC_CONST_UNUSED) \ + _(2167, ZEND_TYPE_CHECK_SPEC_TMPVAR_UNUSED) \ + _(2168, ZEND_TYPE_CHECK_SPEC_TMPVAR_UNUSED) \ + _(2170, ZEND_TYPE_CHECK_SPEC_CV_UNUSED) \ + _(2171, ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED) \ + _(2172, ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED) \ + _(2173, ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED) \ + _(2174, ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED) \ + _(2175, ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED) \ + _(2176, ZEND_FE_RESET_RW_SPEC_CONST) \ + _(2177, ZEND_FE_RESET_RW_SPEC_TMP) \ + _(2178, ZEND_FE_RESET_RW_SPEC_VAR) \ + _(2180, ZEND_FE_RESET_RW_SPEC_CV) \ + _(2181, ZEND_FE_FETCH_RW_SPEC_VAR) \ + _(2182, ZEND_FE_FREE_SPEC_TMPVAR) \ + _(2183, ZEND_INIT_DYNAMIC_CALL_SPEC_CONST) \ + _(2184, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \ + _(2185, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \ + _(2187, ZEND_INIT_DYNAMIC_CALL_SPEC_CV) \ + _(2188, ZEND_DO_ICALL_SPEC_RETVAL_UNUSED) \ + _(2189, ZEND_DO_ICALL_SPEC_RETVAL_USED) \ + _(2190, ZEND_DO_ICALL_SPEC_OBSERVER) \ + _(2191, ZEND_DO_ICALL_SPEC_OBSERVER) \ + _(2192, ZEND_DO_UCALL_SPEC_RETVAL_UNUSED) \ + _(2193, ZEND_DO_UCALL_SPEC_RETVAL_USED) \ + _(2194, ZEND_DO_UCALL_SPEC_OBSERVER) \ + _(2195, ZEND_DO_UCALL_SPEC_OBSERVER) \ + _(2196, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED) \ + _(2197, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED) \ + _(2198, ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER) \ + _(2199, ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER) \ + _(2210, ZEND_PRE_INC_OBJ_SPEC_VAR_CONST) \ + _(2211, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \ + _(2212, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \ + _(2214, ZEND_PRE_INC_OBJ_SPEC_VAR_CV) \ + _(2215, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST) \ + _(2216, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2217, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2219, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV) \ + _(2220, ZEND_PRE_INC_OBJ_SPEC_CV_CONST) \ + _(2221, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \ + _(2222, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \ + _(2224, ZEND_PRE_INC_OBJ_SPEC_CV_CV) \ + _(2235, ZEND_PRE_DEC_OBJ_SPEC_VAR_CONST) \ + _(2236, ZEND_PRE_DEC_OBJ_SPEC_VAR_TMPVAR) \ + _(2237, ZEND_PRE_DEC_OBJ_SPEC_VAR_TMPVAR) \ + _(2239, ZEND_PRE_DEC_OBJ_SPEC_VAR_CV) \ + _(2240, ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CONST) \ + _(2241, ZEND_PRE_DEC_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2242, ZEND_PRE_DEC_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2244, ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CV) \ + _(2245, ZEND_PRE_DEC_OBJ_SPEC_CV_CONST) \ + _(2246, ZEND_PRE_DEC_OBJ_SPEC_CV_TMPVAR) \ + _(2247, ZEND_PRE_DEC_OBJ_SPEC_CV_TMPVAR) \ + _(2249, ZEND_PRE_DEC_OBJ_SPEC_CV_CV) \ + _(2260, ZEND_POST_INC_OBJ_SPEC_VAR_CONST) \ + _(2261, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \ + _(2262, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \ + _(2264, ZEND_POST_INC_OBJ_SPEC_VAR_CV) \ + _(2265, ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST) \ + _(2266, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2267, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2269, ZEND_POST_INC_OBJ_SPEC_UNUSED_CV) \ + _(2270, ZEND_POST_INC_OBJ_SPEC_CV_CONST) \ + _(2271, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \ + _(2272, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \ + _(2274, ZEND_POST_INC_OBJ_SPEC_CV_CV) \ + _(2285, ZEND_POST_DEC_OBJ_SPEC_VAR_CONST) \ + _(2286, ZEND_POST_DEC_OBJ_SPEC_VAR_TMPVAR) \ + _(2287, ZEND_POST_DEC_OBJ_SPEC_VAR_TMPVAR) \ + _(2289, ZEND_POST_DEC_OBJ_SPEC_VAR_CV) \ + _(2290, ZEND_POST_DEC_OBJ_SPEC_UNUSED_CONST) \ + _(2291, ZEND_POST_DEC_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2292, ZEND_POST_DEC_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2294, ZEND_POST_DEC_OBJ_SPEC_UNUSED_CV) \ + _(2295, ZEND_POST_DEC_OBJ_SPEC_CV_CONST) \ + _(2296, ZEND_POST_DEC_OBJ_SPEC_CV_TMPVAR) \ + _(2297, ZEND_POST_DEC_OBJ_SPEC_CV_TMPVAR) \ + _(2299, ZEND_POST_DEC_OBJ_SPEC_CV_CV) \ + _(2300, ZEND_ECHO_SPEC_CONST) \ + _(2301, ZEND_ECHO_SPEC_TMPVAR) \ + _(2302, ZEND_ECHO_SPEC_TMPVAR) \ + _(2304, ZEND_ECHO_SPEC_CV) \ + _(2311, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \ + _(2313, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \ + _(2314, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \ + _(2316, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \ + _(2318, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \ + _(2319, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \ + _(2326, ZEND_INSTANCEOF_SPEC_CV_CONST) \ + _(2328, ZEND_INSTANCEOF_SPEC_CV_VAR) \ + _(2329, ZEND_INSTANCEOF_SPEC_CV_UNUSED) \ + _(2331, ZEND_GENERATOR_CREATE_SPEC) \ + _(2334, ZEND_MAKE_REF_SPEC_VAR_UNUSED) \ + _(2336, ZEND_MAKE_REF_SPEC_CV_UNUSED) \ + _(2337, ZEND_DECLARE_FUNCTION_SPEC) \ + _(2338, ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST) \ + _(2339, ZEND_DECLARE_CONST_SPEC_CONST_CONST) \ + _(2340, ZEND_DECLARE_CLASS_SPEC_CONST) \ + _(2341, ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST) \ + _(2342, ZEND_DECLARE_ANON_CLASS_SPEC) \ + _(2343, ZEND_ADD_ARRAY_UNPACK_SPEC) \ + _(2344, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST) \ + _(2345, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \ + _(2346, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \ + _(2348, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV) \ + _(2349, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ + _(2350, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2351, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2353, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ + _(2354, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ + _(2355, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2356, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2358, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ + _(2359, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST) \ + _(2360, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2361, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2363, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV) \ + _(2364, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST) \ + _(2365, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ + _(2366, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ + _(2368, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV) \ + _(2369, ZEND_HANDLE_EXCEPTION_SPEC) \ + _(2370, ZEND_USER_OPCODE_SPEC) \ + _(2371, ZEND_ASSERT_CHECK_SPEC) \ + _(2372, ZEND_JMP_SET_SPEC_CONST) \ + _(2373, ZEND_JMP_SET_SPEC_TMP) \ + _(2374, ZEND_JMP_SET_SPEC_VAR) \ + _(2376, ZEND_JMP_SET_SPEC_CV) \ + _(2377, ZEND_UNSET_CV_SPEC_CV_UNUSED) \ + _(2378, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET) \ + _(2379, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY) \ + _(2380, ZEND_FETCH_LIST_W_SPEC_VAR_CONST) \ + _(2381, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ + _(2382, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ + _(2384, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \ + _(2385, ZEND_SEPARATE_SPEC_VAR_UNUSED) \ + _(2387, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \ + _(2388, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \ + _(2389, ZEND_FETCH_CLASS_NAME_SPEC_UNUSED) \ + _(2390, ZEND_FETCH_CLASS_NAME_SPEC_CV) \ + _(2391, ZEND_CALL_TRAMPOLINE_SPEC) \ + _(2392, ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER) \ + _(2393, ZEND_DISCARD_EXCEPTION_SPEC) \ + _(2394, ZEND_YIELD_SPEC_CONST_CONST) \ + _(2395, ZEND_YIELD_SPEC_CONST_TMPVAR) \ + _(2396, ZEND_YIELD_SPEC_CONST_TMPVAR) \ + _(2397, ZEND_YIELD_SPEC_CONST_UNUSED) \ + _(2398, ZEND_YIELD_SPEC_CONST_CV) \ + _(2399, ZEND_YIELD_SPEC_TMP_CONST) \ + _(2400, ZEND_YIELD_SPEC_TMP_TMPVAR) \ + _(2401, ZEND_YIELD_SPEC_TMP_TMPVAR) \ + _(2402, ZEND_YIELD_SPEC_TMP_UNUSED) \ + _(2403, ZEND_YIELD_SPEC_TMP_CV) \ + _(2404, ZEND_YIELD_SPEC_VAR_CONST) \ + _(2405, ZEND_YIELD_SPEC_VAR_TMPVAR) \ + _(2406, ZEND_YIELD_SPEC_VAR_TMPVAR) \ + _(2407, ZEND_YIELD_SPEC_VAR_UNUSED) \ + _(2408, ZEND_YIELD_SPEC_VAR_CV) \ + _(2409, ZEND_YIELD_SPEC_UNUSED_CONST) \ + _(2410, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \ + _(2411, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \ + _(2412, ZEND_YIELD_SPEC_UNUSED_UNUSED) \ + _(2413, ZEND_YIELD_SPEC_UNUSED_CV) \ + _(2414, ZEND_YIELD_SPEC_CV_CONST) \ + _(2415, ZEND_YIELD_SPEC_CV_TMPVAR) \ + _(2416, ZEND_YIELD_SPEC_CV_TMPVAR) \ + _(2417, ZEND_YIELD_SPEC_CV_UNUSED) \ + _(2418, ZEND_YIELD_SPEC_CV_CV) \ + _(2419, ZEND_GENERATOR_RETURN_SPEC_CONST) \ + _(2420, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \ + _(2421, ZEND_GENERATOR_RETURN_SPEC_TMP) \ + _(2422, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \ + _(2423, ZEND_GENERATOR_RETURN_SPEC_VAR) \ + _(2424, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \ + _(2427, ZEND_GENERATOR_RETURN_SPEC_CV) \ + _(2428, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \ + _(2429, ZEND_FAST_CALL_SPEC) \ + _(2430, ZEND_FAST_RET_SPEC) \ + _(2431, ZEND_RECV_VARIADIC_SPEC_UNUSED) \ + _(2432, ZEND_SEND_UNPACK_SPEC) \ + _(2433, ZEND_YIELD_FROM_SPEC_CONST) \ + _(2434, ZEND_YIELD_FROM_SPEC_TMPVAR) \ + _(2435, ZEND_YIELD_FROM_SPEC_TMPVAR) \ + _(2437, ZEND_YIELD_FROM_SPEC_CV) \ + _(2438, ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED) \ + _(2439, ZEND_BIND_GLOBAL_SPEC_CV_CONST) \ + _(2440, ZEND_COALESCE_SPEC_CONST) \ + _(2441, ZEND_COALESCE_SPEC_TMP) \ + _(2442, ZEND_COALESCE_SPEC_VAR) \ + _(2444, ZEND_COALESCE_SPEC_CV) \ + _(2445, ZEND_SPACESHIP_SPEC_CONST_CONST) \ + _(2446, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ + _(2447, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ + _(2449, ZEND_SPACESHIP_SPEC_CONST_CV) \ + _(2450, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ + _(2451, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ + _(2452, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ + _(2454, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ + _(2455, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ + _(2456, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ + _(2457, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ + _(2459, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ + _(2465, ZEND_SPACESHIP_SPEC_CV_CONST) \ + _(2466, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ + _(2467, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ + _(2469, ZEND_SPACESHIP_SPEC_CV_CV) \ + _(2470, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED) \ + _(2471, ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED) \ + _(2474, ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED) \ + _(2476, ZEND_FETCH_STATIC_PROP_R_SPEC) \ + _(2477, ZEND_FETCH_STATIC_PROP_W_SPEC) \ + _(2478, ZEND_FETCH_STATIC_PROP_RW_SPEC) \ + _(2479, ZEND_FETCH_STATIC_PROP_IS_SPEC) \ + _(2480, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC) \ + _(2481, ZEND_FETCH_STATIC_PROP_UNSET_SPEC) \ + _(2482, ZEND_UNSET_STATIC_PROP_SPEC) \ + _(2483, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC) \ + _(2484, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) \ + _(2485, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV) \ + _(2486, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV) \ + _(2488, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV) \ + _(2494, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) \ + _(2495, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV) \ + _(2496, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV) \ + _(2498, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV) \ + _(2499, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST) \ + _(2500, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV) \ + _(2501, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV) \ + _(2503, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV) \ + _(2509, ZEND_BIND_LEXICAL_SPEC_TMP_CV) \ + _(2510, ZEND_BIND_STATIC_SPEC_CV) \ + _(2511, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED) \ + _(2512, ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST) \ + _(2515, ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED) \ + _(2517, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED) \ + _(2518, ZEND_SWITCH_LONG_SPEC_CONST_CONST) \ + _(2519, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(2520, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(2522, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(2523, ZEND_SWITCH_STRING_SPEC_CONST_CONST) \ + _(2524, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(2525, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(2527, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(2528, ZEND_IN_ARRAY_SPEC_CONST_CONST) \ + _(2529, ZEND_IN_ARRAY_SPEC_TMP_CONST) \ + _(2530, ZEND_IN_ARRAY_SPEC_VAR_CONST) \ + _(2532, ZEND_IN_ARRAY_SPEC_CV_CONST) \ + _(2533, ZEND_COUNT_SPEC_CONST_UNUSED) \ + _(2534, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \ + _(2535, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \ + _(2537, ZEND_COUNT_SPEC_CV_UNUSED) \ + _(2538, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \ + _(2539, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \ + _(2540, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \ + _(2541, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED) \ + _(2542, ZEND_GET_CLASS_SPEC_CV_UNUSED) \ + _(2543, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED) \ + _(2544, ZEND_GET_TYPE_SPEC_CONST_UNUSED) \ + _(2545, ZEND_GET_TYPE_SPEC_TMP_UNUSED) \ + _(2546, ZEND_GET_TYPE_SPEC_VAR_UNUSED) \ + _(2548, ZEND_GET_TYPE_SPEC_CV_UNUSED) \ + _(2549, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \ + _(2550, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ + _(2551, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ + _(2553, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \ + _(2554, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ + _(2555, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(2556, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(2558, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ + _(2559, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ + _(2560, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(2561, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(2563, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ + _(2569, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \ + _(2570, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ + _(2571, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ + _(2573, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \ + _(2574, ZEND_MATCH_SPEC_CONST_CONST) \ + _(2575, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ + _(2576, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ + _(2578, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ + _(2584, ZEND_CASE_STRICT_SPEC_TMP_CONST) \ + _(2585, ZEND_CASE_STRICT_SPEC_TMP_TMP) \ + _(2586, ZEND_CASE_STRICT_SPEC_TMP_VAR) \ + _(2588, ZEND_CASE_STRICT_SPEC_TMP_CV) \ + _(2589, ZEND_CASE_STRICT_SPEC_VAR_CONST) \ + _(2590, ZEND_CASE_STRICT_SPEC_VAR_TMP) \ + _(2591, ZEND_CASE_STRICT_SPEC_VAR_VAR) \ + _(2593, ZEND_CASE_STRICT_SPEC_VAR_CV) \ + _(2604, ZEND_MATCH_ERROR_SPEC_CONST_UNUSED) \ + _(2605, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ + _(2606, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ + _(2608, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ + _(2609, ZEND_JMP_NULL_SPEC_CONST) \ + _(2610, ZEND_JMP_NULL_SPEC_TMP) \ + _(2611, ZEND_JMP_NULL_SPEC_VAR) \ + _(2613, ZEND_JMP_NULL_SPEC_CV) \ + _(2614, ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED) \ + _(2615, ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED) \ + _(2616, ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED) \ + _(2617, ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED) \ + _(2618, ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV) \ + _(2619, ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED) \ + _(2620, ZEND_FRAMELESS_ICALL_0_SPEC_OBSERVER) \ + _(2621, ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED) \ + _(2622, ZEND_FRAMELESS_ICALL_1_SPEC_OBSERVER) \ + _(2623, ZEND_FRAMELESS_ICALL_2_SPEC) \ + _(2624, ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVER) \ + _(2625, ZEND_FRAMELESS_ICALL_3_SPEC) \ + _(2626, ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER) \ + _(2627, ZEND_JMP_FRAMELESS_SPEC_CONST) \ + _(2628, ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED) \ + _(2629, ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST) \ + _(2630, ZEND_INIT_FCALL_OFFSET_SPEC_CONST) \ + _(2631, ZEND_RECV_NOTYPE_SPEC_UNUSED) \ + _(2633, ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED) \ + _(2634, ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED) \ + _(2636, ZEND_COUNT_ARRAY_SPEC_CV_UNUSED) \ + _(2637, ZEND_JMP_FORWARD_SPEC) \ + _(2643, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2644, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2645, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2647, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2648, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2649, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2650, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2652, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2658, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2659, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2660, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2662, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2668, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2669, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2670, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2672, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2673, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2674, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2675, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2677, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2683, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2684, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2685, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2687, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2693, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2694, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2695, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2697, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2698, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2699, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2700, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2702, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2708, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2709, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2710, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2712, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2714, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2715, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2717, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2718, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2719, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2720, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2722, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2723, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2724, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2725, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2727, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2733, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2734, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2735, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2737, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2739, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2740, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2742, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2743, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2744, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2745, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2747, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2748, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2749, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2750, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2752, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2758, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2759, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2760, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2762, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2764, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2765, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2767, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2768, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2769, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2770, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2772, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2773, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2774, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2775, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2777, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2783, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2784, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2785, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2787, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2793, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2794, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2795, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2797, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2798, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2799, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2800, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2802, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2808, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2809, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2810, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2812, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2818, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2819, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2820, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2822, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2823, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2824, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2825, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2827, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2833, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2834, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2835, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2837, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2843, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2844, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2845, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2847, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2848, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2849, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2850, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2852, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2858, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2859, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2860, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2862, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2878, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2879, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2880, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2881, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2882, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2883, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2884, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2885, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2886, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2890, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2891, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2892, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2893, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2894, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2895, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2896, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2897, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2898, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2899, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2900, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2901, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2905, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2906, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2907, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2923, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2924, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2925, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2926, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2927, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2928, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2929, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2930, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2931, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2935, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2936, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2937, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2953, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2954, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2955, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2956, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2957, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2958, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2959, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2960, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2961, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2965, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2966, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2967, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2968, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2969, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2970, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2971, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2972, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2973, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2974, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2975, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2976, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2980, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2981, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2982, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2998, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2999, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3000, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3001, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3002, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3003, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3004, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3005, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3006, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3010, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3011, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3012, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3028, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3029, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3030, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3031, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3032, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3033, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3034, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3035, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3036, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3040, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3041, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3042, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3043, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3044, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3045, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3046, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3047, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3048, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3049, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3050, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3051, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3055, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3056, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3057, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3073, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3074, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3075, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3076, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3077, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3078, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3079, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3080, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3081, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3085, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3086, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3087, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3103, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3104, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3105, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3106, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3107, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3108, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3109, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3110, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3111, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3115, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3116, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3117, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3118, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3119, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3120, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3121, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3122, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3123, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3124, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3125, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3126, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3130, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3131, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3132, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3148, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3149, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3150, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3151, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3152, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3153, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3154, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3155, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3156, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3160, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3161, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3162, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3163, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST) \ + _(3164, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3165, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3166, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST) \ + _(3167, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3168, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3169, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3173, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3174, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3178, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3182, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3183, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3184, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3185, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3186, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3187, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3191, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3192, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3193, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3194, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3195, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3196, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3197, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3198, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3199, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3200, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3201, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3202, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3206, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3207, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3208, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3209, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3210, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3211, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3212, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3213, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3214, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3215, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3216, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3217, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3221, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3222, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3223, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3239, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3240, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3241, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3242, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3243, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3244, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3245, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3246, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3247, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3251, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3252, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3253, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3257, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3258, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3259, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3260, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3261, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3262, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3266, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3267, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3268, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3269, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3270, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3271, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3272, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3273, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3274, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3275, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3276, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3277, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3281, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3282, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3283, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3284, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3285, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3286, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3287, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3288, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3289, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3290, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3291, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3292, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3296, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3297, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3298, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3314, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3315, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3316, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3317, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3318, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3319, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3320, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3321, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3322, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3326, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3327, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3328, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3332, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3333, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3334, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3335, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3336, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3337, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3341, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3342, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3343, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3344, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3345, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3346, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3347, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3348, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3349, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3350, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3351, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3352, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3356, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3357, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3358, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3359, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3360, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3361, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3362, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3363, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3364, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3365, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3366, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3367, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3371, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3372, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3373, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3389, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3390, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3391, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3392, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3393, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3394, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3395, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3396, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3397, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3401, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3402, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3403, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3407, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3408, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3409, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3410, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3411, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3412, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3416, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3417, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3418, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3419, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3420, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3421, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3422, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3423, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3424, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3425, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3426, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3427, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3431, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3432, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3433, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3434, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3435, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3436, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3437, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3438, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3439, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3440, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3441, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3442, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3446, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3447, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3448, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3464, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3465, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3466, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3467, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3468, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3469, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3470, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3471, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3472, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3476, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3477, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3478, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3479, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3480, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3481, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3482, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ + _(3483, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3484, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3485, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3486, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ + _(3487, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3488, ZEND_POST_INC_LONG_SPEC_CV) \ + _(3489, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3490, ZEND_POST_DEC_LONG_SPEC_CV) \ + _(3491, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ + _(3492, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3493, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3495, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3496, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ + _(3497, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3498, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3500, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3501, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ + _(3502, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3503, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3505, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3507, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3508, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3510, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3511, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3512, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3513, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3515, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3516, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3517, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3518, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3520, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3526, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ + _(3527, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3528, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3530, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3533, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ + _(3535, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ + _(3538, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ + _(3540, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ + _(3541, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ + _(3542, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ + _(3543, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ + _(3544, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ + _(3544+1, ZEND_NULL) diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c index b3e7fc8d53de5..909cd297d5515 100644 --- a/Zend/zend_vm_opcodes.c +++ b/Zend/zend_vm_opcodes.c @@ -352,7 +352,7 @@ static uint64_t zend_vm_opcodes_flags[211] = { 0x01040757, 0x01048773, 0x300030107, - 0x00020707, + 0x500020707, 0x00001303, 0x00001301, 0x01000703, @@ -385,7 +385,7 @@ static uint64_t zend_vm_opcodes_flags[211] = { 0x00000303, 0x00040000, 0x100000000, - 0x00060757, + 0x500060757, 0x100000000, 0x100000000, 0x100002000, From 0a4bbe06625679c37c9179dbf48493b72fccfb60 Mon Sep 17 00:00:00 2001 From: Ilija Tovilo Date: Wed, 11 Jun 2025 13:08:55 +0200 Subject: [PATCH 15/19] Fix stale opline for isset --- Zend/zend_compile.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index 83534196ed4a7..90b140f1fbb0f 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -10747,13 +10747,13 @@ static void zend_compile_isset_or_empty(znode *result, zend_ast *ast) /* {{{ */ case ZEND_AST_DIM: opline = zend_compile_dim(result, var_ast, BP_VAR_IS, /* by_ref */ false); opline->opcode = ZEND_ISSET_ISEMPTY_DIM_OBJ; - zend_emit_op_data(NULL); + opline = zend_emit_op_data(NULL) - 1; break; case ZEND_AST_PROP: case ZEND_AST_NULLSAFE_PROP: opline = zend_compile_prop(result, var_ast, BP_VAR_IS, 0); opline->opcode = ZEND_ISSET_ISEMPTY_PROP_OBJ; - zend_emit_op_data(NULL); + opline = zend_emit_op_data(NULL) - 1; break; case ZEND_AST_STATIC_PROP: opline = zend_compile_static_prop(result, var_ast, BP_VAR_IS, 0, 0); From 72557437eb9688969f07cd16b89e93e12c026649 Mon Sep 17 00:00:00 2001 From: Ilija Tovilo Date: Wed, 11 Jun 2025 13:40:26 +0200 Subject: [PATCH 16/19] Add op_data to ZEND_IN_ARRAY --- Zend/zend_compile.c | 1 + Zend/zend_vm_def.h | 16 +++++------ Zend/zend_vm_execute.h | 64 +++++++++++++++++++++--------------------- Zend/zend_vm_gen.php | 2 +- Zend/zend_vm_opcodes.c | 2 +- 5 files changed, 43 insertions(+), 42 deletions(-) diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index 90b140f1fbb0f..f63f045f3ec5a 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -4490,6 +4490,7 @@ static zend_result zend_compile_func_in_array(znode *result, zend_ast_list *args opline = zend_emit_op_tmp(result, ZEND_IN_ARRAY, &needly, &array); opline->extended_value = strict; + zend_emit_op_data(NULL); return SUCCESS; } diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index c44107386a575..8bceb768d47ec 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -9410,13 +9410,13 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(189, ZEND_IN_ARRAY, CONST|TMP|VAR|CV, CONST, NUM if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_str(op1); } - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_OFFSET(result, 0, 2); } if (opline->extended_value) { if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { result = zend_hash_index_find(ht, Z_LVAL_P(op1)); - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_OFFSET(result, 0, 2); } SAVE_OPLINE(); if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) { @@ -9424,11 +9424,11 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(189, ZEND_IN_ARRAY, CONST|TMP|VAR|CV, CONST, NUM if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { result = zend_hash_find(ht, Z_STR_P(op1)); FREE_OP1(); - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_OFFSET(result, 0, 2); } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { result = zend_hash_index_find(ht, Z_LVAL_P(op1)); FREE_OP1(); - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_OFFSET(result, 0, 2); } } else if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { ZVAL_UNDEFINED_OP1(); @@ -9442,7 +9442,7 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(189, ZEND_IN_ARRAY, CONST|TMP|VAR|CV, CONST, NUM } } result = zend_hash_find_known_hash(ht, ZSTR_EMPTY_ALLOC()); - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_OFFSET(result, 0, 2); } else { zend_string *key; zval key_tmp; @@ -9452,7 +9452,7 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(189, ZEND_IN_ARRAY, CONST|TMP|VAR|CV, CONST, NUM if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { result = zend_hash_find(ht, Z_STR_P(op1)); FREE_OP1(); - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_OFFSET(result, 0, 2); } } @@ -9461,12 +9461,12 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(189, ZEND_IN_ARRAY, CONST|TMP|VAR|CV, CONST, NUM ZVAL_STR(&key_tmp, key); if (zend_compare(op1, &key_tmp) == 0) { FREE_OP1(); - ZEND_VM_SMART_BRANCH(1, 1); + ZEND_VM_SMART_BRANCH_OFFSET(1, 1, 2); } } ZEND_HASH_FOREACH_END(); } FREE_OP1(); - ZEND_VM_SMART_BRANCH(0, 1); + ZEND_VM_SMART_BRANCH_OFFSET(0, 1, 2); } ZEND_VM_COLD_CONST_HANDLER(190, ZEND_COUNT, CONST|TMPVAR|CV, UNUSED) diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 059ee67c25b81..2b8032bcd3ea4 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -8252,13 +8252,13 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_CON if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_str(op1); } - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } if (opline->extended_value) { if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { result = zend_hash_index_find(ht, Z_LVAL_P(op1)); - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } SAVE_OPLINE(); if ((IS_CONST & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) { @@ -8266,11 +8266,11 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_CON if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { result = zend_hash_find(ht, Z_STR_P(op1)); - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { result = zend_hash_index_find(ht, Z_LVAL_P(op1)); - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { ZVAL_UNDEFINED_OP1(); @@ -8284,7 +8284,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_CON } } result = zend_hash_find_known_hash(ht, ZSTR_EMPTY_ALLOC()); - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } else { zend_string *key; zval key_tmp; @@ -8294,7 +8294,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_CON if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { result = zend_hash_find(ht, Z_STR_P(op1)); - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } } @@ -8303,12 +8303,12 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_CON ZVAL_STR(&key_tmp, key); if (zend_compare(op1, &key_tmp) == 0) { - ZEND_VM_SMART_BRANCH(1, 1); + ZEND_VM_SMART_BRANCH_EX_OFFSET(1, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } } ZEND_HASH_FOREACH_END(); } - ZEND_VM_SMART_BRANCH(0, 1); + ZEND_VM_SMART_BRANCH_EX_OFFSET(0, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -21135,13 +21135,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_TMP_CONST_HANDLE if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_str(op1); } - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } if (opline->extended_value) { if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { result = zend_hash_index_find(ht, Z_LVAL_P(op1)); - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } SAVE_OPLINE(); if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) { @@ -21149,11 +21149,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_TMP_CONST_HANDLE if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { result = zend_hash_find(ht, Z_STR_P(op1)); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { result = zend_hash_index_find(ht, Z_LVAL_P(op1)); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } } else if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { ZVAL_UNDEFINED_OP1(); @@ -21167,7 +21167,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_TMP_CONST_HANDLE } } result = zend_hash_find_known_hash(ht, ZSTR_EMPTY_ALLOC()); - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } else { zend_string *key; zval key_tmp; @@ -21177,7 +21177,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_TMP_CONST_HANDLE if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { result = zend_hash_find(ht, Z_STR_P(op1)); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } } @@ -21186,12 +21186,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_TMP_CONST_HANDLE ZVAL_STR(&key_tmp, key); if (zend_compare(op1, &key_tmp) == 0) { zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(1, 1); + ZEND_VM_SMART_BRANCH_EX_OFFSET(1, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } } ZEND_HASH_FOREACH_END(); } zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(0, 1); + ZEND_VM_SMART_BRANCH_EX_OFFSET(0, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -26463,13 +26463,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_VAR_CONST_HANDLE if (IS_VAR & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_str(op1); } - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } if (opline->extended_value) { if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { result = zend_hash_index_find(ht, Z_LVAL_P(op1)); - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } SAVE_OPLINE(); if ((IS_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) { @@ -26477,11 +26477,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_VAR_CONST_HANDLE if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { result = zend_hash_find(ht, Z_STR_P(op1)); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { result = zend_hash_index_find(ht, Z_LVAL_P(op1)); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } } else if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { ZVAL_UNDEFINED_OP1(); @@ -26495,7 +26495,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_VAR_CONST_HANDLE } } result = zend_hash_find_known_hash(ht, ZSTR_EMPTY_ALLOC()); - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } else { zend_string *key; zval key_tmp; @@ -26505,7 +26505,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_VAR_CONST_HANDLE if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { result = zend_hash_find(ht, Z_STR_P(op1)); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } } @@ -26514,12 +26514,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_VAR_CONST_HANDLE ZVAL_STR(&key_tmp, key); if (zend_compare(op1, &key_tmp) == 0) { zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(1, 1); + ZEND_VM_SMART_BRANCH_EX_OFFSET(1, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } } ZEND_HASH_FOREACH_END(); } zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(0, 1); + ZEND_VM_SMART_BRANCH_EX_OFFSET(0, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -45969,13 +45969,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_CV_CONST_HANDLER if (IS_CV & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_str(op1); } - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } if (opline->extended_value) { if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { result = zend_hash_index_find(ht, Z_LVAL_P(op1)); - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } SAVE_OPLINE(); if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) { @@ -45983,11 +45983,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_CV_CONST_HANDLER if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { result = zend_hash_find(ht, Z_STR_P(op1)); - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { result = zend_hash_index_find(ht, Z_LVAL_P(op1)); - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { ZVAL_UNDEFINED_OP1(); @@ -46001,7 +46001,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_CV_CONST_HANDLER } } result = zend_hash_find_known_hash(ht, ZSTR_EMPTY_ALLOC()); - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } else { zend_string *key; zval key_tmp; @@ -46011,7 +46011,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_CV_CONST_HANDLER if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { result = zend_hash_find(ht, Z_STR_P(op1)); - ZEND_VM_SMART_BRANCH(result, 0); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } } @@ -46020,12 +46020,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_CV_CONST_HANDLER ZVAL_STR(&key_tmp, key); if (zend_compare(op1, &key_tmp) == 0) { - ZEND_VM_SMART_BRANCH(1, 1); + ZEND_VM_SMART_BRANCH_EX_OFFSET(1, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } } ZEND_HASH_FOREACH_END(); } - ZEND_VM_SMART_BRANCH(0, 1); + ZEND_VM_SMART_BRANCH_EX_OFFSET(0, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) diff --git a/Zend/zend_vm_gen.php b/Zend/zend_vm_gen.php index 1c4efa1901cc6..eac43422f6d54 100755 --- a/Zend/zend_vm_gen.php +++ b/Zend/zend_vm_gen.php @@ -2528,6 +2528,7 @@ function gen_vm_opcodes_header( 'ZEND_FETCH_STATIC_PROP_W', 'ZEND_FE_FETCH_R', 'ZEND_FE_FETCH_RW', + 'ZEND_IN_ARRAY', 'ZEND_ISSET_ISEMPTY_DIM_OBJ', 'ZEND_ISSET_ISEMPTY_PROP_OBJ', 'ZEND_ISSET_ISEMPTY_STATIC_PROP', @@ -2572,7 +2573,6 @@ function get_quick_op_flags_field($opcode) { // Trying to improve 'ZEND_INSTANCEOF', - 'ZEND_IN_ARRAY', ]; $has_free_result = [ diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c index 909cd297d5515..301ad077bd799 100644 --- a/Zend/zend_vm_opcodes.c +++ b/Zend/zend_vm_opcodes.c @@ -426,7 +426,7 @@ static uint64_t zend_vm_opcodes_flags[211] = { 0x00000101, 0x40300030b, 0x40300030b, - 0x01000303, + 0x501000303, 0x00000107, 0x00000107, 0x00000101, From cb8f4645d5f63f8fb1a43e6993c5b9de27105246 Mon Sep 17 00:00:00 2001 From: Ilija Tovilo Date: Wed, 11 Jun 2025 13:45:40 +0200 Subject: [PATCH 17/19] Avoid wop for ZEND_NEW without args --- Zend/zend_opcode.c | 4 ++++ Zend/zend_vm_def.h | 5 +++-- Zend/zend_vm_execute.h | 15 +++++++++------ 3 files changed, 16 insertions(+), 8 deletions(-) diff --git a/Zend/zend_opcode.c b/Zend/zend_opcode.c index 67fb59be3215f..cd014ef44ff3b 100644 --- a/Zend/zend_opcode.c +++ b/Zend/zend_opcode.c @@ -1074,6 +1074,10 @@ ZEND_API void zend_setup_quick_op_flags(zend_op *opline, zend_slim_op *slim_op) quick_flags |= 0x2000; } + if (opline->opcode == ZEND_NEW && opline->extended_value == 0) { + (slim_op+1)->op1.num = opline->opcode; + } + switch (field) { case ZEND_VM_QUICK_OP_FLAGS_FIELD_EXT_VALUE: slim_op->extended_value = quick_flags; diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 8bceb768d47ec..22170ec5f4917 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -5985,8 +5985,9 @@ ZEND_VM_HANDLER(68, ZEND_NEW, UNUSED|CLASS_FETCH|CONST|VAR, UNUSED|CACHE_SLOT, N constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result)); if (constructor == NULL) { /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next - * opcode is DO_FCALL in case EXT instructions are used. */ - if (EXPECTED(opline->extended_value == 0 && Z_WOP_FROM_OP(opline+1)->opcode == ZEND_DO_FCALL)) { + * opcode is DO_FCALL in case EXT instructions are used. We store this info in op1 + * of slim_op for DO_FCALL and DO_FCALL_BY_NAME. */ + if (EXPECTED(opline->extended_value == 0 && (opline+1)->op1.num == ZEND_DO_FCALL)) { ZEND_VM_NEXT_OPCODE_EX(1, 2); } diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 2b8032bcd3ea4..3d92520f0d9d6 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -11015,8 +11015,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_CONST_UNUSED_HANDLER( constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result)); if (constructor == NULL) { /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next - * opcode is DO_FCALL in case EXT instructions are used. */ - if (EXPECTED(opline->extended_value == 0 && Z_WOP_FROM_OP(opline+1)->opcode == ZEND_DO_FCALL)) { + * opcode is DO_FCALL in case EXT instructions are used. We store this info in op1 + * of slim_op for DO_FCALL and DO_FCALL_BY_NAME. */ + if (EXPECTED(opline->extended_value == 0 && (opline+1)->op1.num == ZEND_DO_FCALL)) { ZEND_VM_NEXT_OPCODE_EX(1, 2); } @@ -30664,8 +30665,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_VAR_UNUSED_HANDLER(ZE constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result)); if (constructor == NULL) { /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next - * opcode is DO_FCALL in case EXT instructions are used. */ - if (EXPECTED(opline->extended_value == 0 && Z_WOP_FROM_OP(opline+1)->opcode == ZEND_DO_FCALL)) { + * opcode is DO_FCALL in case EXT instructions are used. We store this info in op1 + * of slim_op for DO_FCALL and DO_FCALL_BY_NAME. */ + if (EXPECTED(opline->extended_value == 0 && (opline+1)->op1.num == ZEND_DO_FCALL)) { ZEND_VM_NEXT_OPCODE_EX(1, 2); } @@ -38192,8 +38194,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_UNUSED_UNUSED_HANDLER constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result)); if (constructor == NULL) { /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next - * opcode is DO_FCALL in case EXT instructions are used. */ - if (EXPECTED(opline->extended_value == 0 && Z_WOP_FROM_OP(opline+1)->opcode == ZEND_DO_FCALL)) { + * opcode is DO_FCALL in case EXT instructions are used. We store this info in op1 + * of slim_op for DO_FCALL and DO_FCALL_BY_NAME. */ + if (EXPECTED(opline->extended_value == 0 && (opline+1)->op1.num == ZEND_DO_FCALL)) { ZEND_VM_NEXT_OPCODE_EX(1, 2); } From 5853f93c2ef010e73b8f2e2a662d1a785a31a6ad Mon Sep 17 00:00:00 2001 From: Ilija Tovilo Date: Wed, 11 Jun 2025 13:50:39 +0200 Subject: [PATCH 18/19] Add op_data to instance of --- Zend/zend_compile.c | 2 ++ Zend/zend_vm_def.h | 2 +- Zend/zend_vm_execute.h | 12 ++++++------ Zend/zend_vm_gen.php | 4 +--- Zend/zend_vm_opcodes.c | 2 +- 5 files changed, 11 insertions(+), 11 deletions(-) diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index f63f045f3ec5a..8751983c9deec 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -10669,6 +10669,8 @@ static void zend_compile_instanceof(znode *result, zend_ast *ast) /* {{{ */ } else { SET_NODE(opline->op2, &class_node); } + + zend_emit_op_data(NULL); } /* }}} */ diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 22170ec5f4917..f5e1298cd0121 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -8059,7 +8059,7 @@ ZEND_VM_C_LABEL(try_instanceof): result = 0; } FREE_OP1(); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_OFFSET(result, 1, 2); } ZEND_VM_HOT_HANDLER(104, ZEND_EXT_NOP, ANY, ANY) diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 3d92520f0d9d6..7f830afdc3d09 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -17171,7 +17171,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_H result = 0; } zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -18637,7 +18637,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_HAN result = 0; } zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -18954,7 +18954,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_ result = 0; } zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_TYPE_CHECK_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -45757,7 +45757,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_CV_CONST_HANDL result = 0; } - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -49870,7 +49870,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_CV_VAR_HANDLER result = 0; } - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -51370,7 +51370,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_CV_UNUSED_HAND result = 0; } - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH_EX_OFFSET(result, 1, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ((opline+1)->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ((opline+1)->op2.num), 2); } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) diff --git a/Zend/zend_vm_gen.php b/Zend/zend_vm_gen.php index eac43422f6d54..f2a0ae49b41db 100755 --- a/Zend/zend_vm_gen.php +++ b/Zend/zend_vm_gen.php @@ -2528,6 +2528,7 @@ function gen_vm_opcodes_header( 'ZEND_FETCH_STATIC_PROP_W', 'ZEND_FE_FETCH_R', 'ZEND_FE_FETCH_RW', + 'ZEND_INSTANCEOF', 'ZEND_IN_ARRAY', 'ZEND_ISSET_ISEMPTY_DIM_OBJ', 'ZEND_ISSET_ISEMPTY_PROP_OBJ', @@ -2570,9 +2571,6 @@ function get_quick_op_flags_field($opcode) { 'ZEND_JMP_NULL', 'ZEND_RETURN_BY_REF', 'ZEND_TICKS', - - // Trying to improve - 'ZEND_INSTANCEOF', ]; $has_free_result = [ diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c index 301ad077bd799..01260cb7bba5d 100644 --- a/Zend/zend_vm_opcodes.c +++ b/Zend/zend_vm_opcodes.c @@ -375,7 +375,7 @@ static uint64_t zend_vm_opcodes_flags[211] = { 0x00040751, 0x100000007, 0x00000000, - 0x00047305, + 0x500047305, 0x100000000, 0x00000101, 0x100001000, From 07645cb3c24694f33b75404984891b503d1a0b22 Mon Sep 17 00:00:00 2001 From: Ilija Tovilo Date: Tue, 17 Jun 2025 10:28:33 +0200 Subject: [PATCH 19/19] Avoid some wop fetches --- Zend/zend.h | 2 +- Zend/zend_exceptions.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Zend/zend.h b/Zend/zend.h index 6576a78ad08ac..7f7ff094b9d0b 100644 --- a/Zend/zend.h +++ b/Zend/zend.h @@ -52,7 +52,7 @@ #define USED_RET() \ (!EX(prev_execute_data) || \ !ZEND_USER_CODE(EX(prev_execute_data)->func->common.type) || \ - (Z_WOP_FROM_EX(EX(prev_execute_data))->result_type != IS_UNUSED)) + (Z_WOP_FROM_EX(EX(prev_execute_data))->result.var != (uint16_t)-1)) #ifdef ZEND_ENABLE_STATIC_TSRMLS_CACHE #define ZEND_TSRMG TSRMG_STATIC diff --git a/Zend/zend_exceptions.c b/Zend/zend_exceptions.c index 5e99921d6e106..e6d743b0adf92 100644 --- a/Zend/zend_exceptions.c +++ b/Zend/zend_exceptions.c @@ -176,7 +176,7 @@ static zend_always_inline bool is_handle_exception_set(void) { return !execute_data || !EX(func) || !ZEND_USER_CODE(EX(func)->common.type) - || EX_WOP->opcode == ZEND_HANDLE_EXCEPTION; + || EX(opline) == EG(exception_slim_op); } ZEND_API ZEND_COLD void zend_throw_exception_internal(zend_object *exception) /* {{{ */