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..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; } @@ -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..a755d3523d239 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: @@ -2205,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) { @@ -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; @@ -2247,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) { @@ -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..01dd9efc86d3e 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,45 @@ 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); + + // 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++; } op_array->fn_flags |= ZEND_ACC_DONE_PASS_TWO; @@ -1302,31 +1357,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 +1390,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 +1426,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 +1462,29 @@ 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); + + // 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++; } 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..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) || \ - (EX(prev_execute_data)->opline->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_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..8751983c9deec 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++; } /* }}} */ @@ -2482,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; } /* }}} */ @@ -3198,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); @@ -3223,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; } /* }}} */ @@ -3465,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(); @@ -3580,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); @@ -3634,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(); @@ -4471,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; } @@ -4689,9 +4709,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; } @@ -5847,7 +5873,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 +5922,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; } } /* }}} */ @@ -6090,12 +6124,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"); @@ -8361,10 +8397,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 @@ -10480,10 +10516,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: @@ -10632,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); } /* }}} */ @@ -10711,11 +10750,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; + 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; + 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); @@ -11043,11 +11084,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..e6d743b0adf92 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(opline) == EG(exception_slim_op); } 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..90ddbb06a6e5f 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) @@ -397,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); } } @@ -412,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; @@ -432,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; @@ -452,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; @@ -472,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; @@ -492,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; @@ -521,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); } } @@ -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()))) { @@ -2256,17 +2265,17 @@ 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) { if (EXPECTED(Z_TYPE_P(prop) == IS_LONG)) { - if (ZEND_IS_INCREMENT(opline->opcode)) { + if (is_inc) { 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 +2291,31 @@ 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 (is_inc) { increment_function(prop); } else { decrement_function(prop); } } while (0); } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->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) { 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(result), Z_LVAL_P(prop)); + if (is_inc) { 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 +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(opline->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(opline->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(opline->result.var), prop); - if (ZEND_IS_INCREMENT(opline->opcode)) { + ZVAL_COPY(EX_VAR(result), prop); + if (is_inc) { increment_function(prop); } else { decrement_function(prop); @@ -2336,18 +2346,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 +2376,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 +2410,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 +2603,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); @@ -2780,7 +2794,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: @@ -2901,9 +2915,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); @@ -2961,7 +2975,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); @@ -3106,10 +3120,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); @@ -3131,7 +3145,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) { @@ -3192,7 +3206,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 { @@ -3203,7 +3217,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(); } @@ -3242,7 +3256,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(); } @@ -3422,7 +3436,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(); @@ -3441,7 +3455,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) { @@ -3495,7 +3509,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; } @@ -3503,7 +3517,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); @@ -3548,8 +3562,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; @@ -3558,12 +3573,12 @@ 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) && + if (/*OP_DATA_TYPE & IS_VAR &&*/ + (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 +3592,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); @@ -3609,15 +3624,13 @@ 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; - uint8_t op1_type = opline->op1_type, op2_type = opline->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); @@ -3625,7 +3638,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, op1); return NULL; } if (UNEXPECTED(op1_type != IS_CONST)) { @@ -3634,33 +3647,35 @@ 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, op2); if (UNEXPECTED(ce == NULL)) { - FREE_OP(op1_type, opline->op1.var); + FREE_OP(op1_type, op1); return NULL; } } else { - ce = Z_CE_P(EX_VAR(opline->op2.var)); + ce = Z_CE_P(EX_VAR(op2)); } - 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 { zend_string *tmp_name; - zval *varname = get_zval_ptr_undef(opline->op1_type, opline->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(opline->op1.var EXECUTE_DATA_CC); + if ((op1_type & IS_CV) && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) { + zval_undefined_cv(op1 EXECUTE_DATA_CC); } name = zval_get_tmp_string(varname, &tmp_name); } @@ -3668,7 +3683,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, op1); } if (UNEXPECTED(result == NULL)) { @@ -3677,7 +3692,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); @@ -3687,13 +3702,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, uint32_t op1, uint8_t op2_type, uint32_t op2 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)) { @@ -3709,7 +3724,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; } @@ -3737,19 +3752,20 @@ 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); + 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); @@ -4314,9 +4330,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 +4420,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 +4448,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 +4927,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 +4938,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 +5328,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 +5365,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 +5484,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 +5513,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 +5533,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 +5550,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,32 +5703,44 @@ 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_OFFSET(_result, _check, _check_jmpz, _check_jmpnz, _offset) 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); \ + 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(opline->result_type == (IS_SMART_BRANCH_JMPNZ|IS_TMP_VAR))) { \ + } 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); \ @@ -5737,10 +5766,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 +5777,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 +5793,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 +5804,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 +5828,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..cd014ef44ff3b 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,53 @@ 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; + } + + 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; + 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 +1118,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 +1140,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 +1155,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 +1168,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 +1178,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 +1191,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 +1201,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 +1230,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 617e114dd05db..f5e1298cd0121 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 @@ -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; @@ -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 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(); @@ -1186,7 +1186,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))) { @@ -1203,7 +1203,7 @@ ZEND_VM_C_LABEL(assign_dim_op_new_array): if (UNEXPECTED(RETURN_VALUE_USED(opline))) { 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); @@ -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; @@ -1432,7 +1442,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, opline->op1.var, OP2_TYPE, opline->op2.var OPLINE_CC EXECUTE_DATA_CC); if (UNEXPECTED(!prop)) { UNDEF_RESULT(); HANDLE_EXCEPTION(); @@ -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_CHECK_EXCEPTION(); + 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; @@ -1466,7 +1482,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, opline->op1.var, OP2_TYPE, opline->op2.var OPLINE_CC EXECUTE_DATA_CC); if (UNEXPECTED(!prop)) { UNDEF_RESULT(); HANDLE_EXCEPTION(); @@ -1480,18 +1496,24 @@ 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_CHECK_EXCEPTION(); + 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) +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 +1564,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 +1616,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 +1664,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; @@ -1854,7 +1876,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, OPTIONS(quick_op_flags_field=op_data), int type) { USE_OPLINE zval *prop; @@ -1864,7 +1886,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, 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,7 +1907,7 @@ 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) */ @@ -2143,9 +2165,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(); @@ -2624,7 +2646,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, opline->op1.var, OP2_TYPE, opline->op2.var OPLINE_CC EXECUTE_DATA_CC); if (UNEXPECTED(!prop)) { FREE_OP_DATA(); UNDEF_RESULT(); @@ -2855,7 +2877,7 @@ 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); } @@ -2919,7 +2941,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, opline->op1.var, OP2_TYPE, opline->op2.var OPLINE_CC EXECUTE_DATA_CC); if (UNEXPECTED(!prop)) { FREE_OP_DATA(); UNDEF_RESULT(); @@ -2937,7 +2959,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)) { @@ -5695,7 +5717,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; @@ -5855,7 +5877,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 @@ -5963,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 && (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); } @@ -6070,7 +6093,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(); } @@ -7012,7 +7035,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 +7150,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 +7220,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 +7229,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 +7432,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)) @@ -7487,7 +7510,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, 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 && @@ -7496,7 +7519,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) @@ -7550,7 +7573,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 +7598,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 +7648,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) @@ -7794,7 +7817,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; @@ -8036,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) @@ -8053,20 +8076,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 +8103,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 +8155,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 +8232,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 +8256,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); } @@ -8618,7 +8645,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 +8653,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 +8665,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); } @@ -8784,7 +8811,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 +8847,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; @@ -8835,7 +8862,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,7 +8875,7 @@ 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); + zend_slim_op *target = OP_JMP_ADDR(opline, opline->op2); if (RETURN_VALUE_USED(opline)) { ZVAL_TRUE(EX_VAR(opline->result.var)); } @@ -9149,7 +9176,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; @@ -9384,13 +9411,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) { @@ -9398,11 +9425,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(); @@ -9416,7 +9443,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; @@ -9426,7 +9453,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); } } @@ -9435,12 +9462,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) @@ -9727,7 +9754,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(); @@ -9741,13 +9768,13 @@ ZEND_VM_HANDLER(204, ZEND_FRAMELESS_ICALL_0, UNUSED, UNUSED, 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(); } -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(); @@ -9766,14 +9793,14 @@ ZEND_VM_HANDLER(205, ZEND_FRAMELESS_ICALL_1, ANY, UNUSED, 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(); 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(); @@ -9794,7 +9821,7 @@ ZEND_VM_HANDLER(206, ZEND_FRAMELESS_ICALL_2, ANY, ANY, 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); } @@ -9804,10 +9831,10 @@ ZEND_VM_HANDLER(206, ZEND_FRAMELESS_ICALL_2, ANY, ANY, 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, SPEC(OBSERVER)) +ZEND_VM_HANDLER(207, ZEND_FRAMELESS_ICALL_3, ANY, ANY, NUM, SPEC(OBSERVER)) { USE_OPLINE SAVE_OPLINE(); @@ -9830,7 +9857,7 @@ ZEND_VM_HANDLER(207, ZEND_FRAMELESS_ICALL_3, ANY, ANY, 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); } @@ -10482,7 +10509,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); @@ -10497,7 +10524,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 791e4b4e88437..7f830afdc3d09 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,13 +437,13 @@ 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); @@ -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 (opline->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 (opline->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 (opline->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 (opline->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 (opline->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 (opline->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 (opline->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 (opline->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 (opline->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 (opline->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 (opline->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 (opline->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 (opline->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 (opline->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 (opline->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 (opline->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 (opline->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 (opline->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 (opline->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 (opline->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 (opline->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 (opline->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 (opline->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 (opline->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 (opline->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 (opline->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(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(); } @@ -780,10 +780,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), 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((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 +791,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,16 +815,16 @@ 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); } -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; @@ -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 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(); @@ -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_CHECK_EXCEPTION(); + 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; @@ -860,7 +872,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, 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(); @@ -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_CHECK_EXCEPTION(); + 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 @@ -890,7 +913,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, 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,7 +934,7 @@ 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) */ @@ -960,8 +983,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 +995,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 +1010,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), 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(); @@ -1003,7 +1026,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 +1047,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), 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(); @@ -1040,7 +1063,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 +1084,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), 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(); @@ -1077,7 +1100,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 +1121,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), 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(); @@ -1114,7 +1137,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 +1158,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), 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((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 +1168,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 +1185,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 +1193,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 +1489,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 +1523,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 +1595,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 +1838,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 +1849,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 +1859,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 +1884,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 +1925,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 +2199,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 +2213,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 +2223,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 +2257,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 +2296,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 +2399,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 +2411,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 +2424,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 +2453,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 +2472,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 +2498,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 +2607,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 +2623,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 +2643,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 +2659,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 +2708,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 +2722,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 +2764,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,18 +2790,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; @@ -2792,10 +2803,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 (opline->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) @@ -2805,7 +2816,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: @@ -2854,7 +2865,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) @@ -2928,7 +2939,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(); } @@ -2941,38 +2952,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(); } } @@ -2980,7 +2991,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(); } @@ -3030,7 +3041,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]) { @@ -3073,7 +3084,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)) { @@ -3087,7 +3098,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(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 { @@ -3099,7 +3110,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) @@ -3110,7 +3121,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, 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 && @@ -3119,7 +3130,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) @@ -3206,7 +3217,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(); } @@ -3259,20 +3270,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)) { @@ -3286,7 +3297,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); @@ -3338,14 +3349,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) @@ -3414,8 +3426,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) { @@ -3435,7 +3450,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); } @@ -3447,8 +3462,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(); } @@ -3484,7 +3499,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); } @@ -3492,10 +3507,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); } @@ -3504,7 +3519,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)); } @@ -3513,8 +3528,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); @@ -3817,11 +3832,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(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(opline->op1_type, opline->op1.var); - FREE_OP(opline->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(); } @@ -3831,17 +3846,17 @@ 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(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(opline->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) @@ -3851,11 +3866,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(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(opline->op1_type, opline->op1.var); - FREE_OP(opline->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(); } @@ -3865,17 +3880,17 @@ 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(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(opline->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) @@ -3885,13 +3900,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(); } @@ -3901,20 +3916,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); } @@ -3925,13 +3940,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(); } @@ -3941,20 +3956,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); } @@ -3976,7 +3991,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) @@ -4275,6 +4290,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 @@ -4354,9 +4381,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 +4393,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 +4407,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 +4419,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(); } @@ -4452,46 +4479,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 @@ -4743,31 +4730,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))) { @@ -4792,7 +4779,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); @@ -4889,38 +4876,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; } @@ -4935,7 +4922,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); @@ -4996,19 +4983,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); @@ -5109,7 +5096,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. */ @@ -5296,18 +5283,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)); @@ -5318,7 +5305,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); } @@ -5368,10 +5355,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)); @@ -5379,18 +5366,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)); @@ -5401,7 +5388,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); } @@ -5422,7 +5409,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); @@ -5435,12 +5422,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(); } @@ -5791,7 +5778,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(); } @@ -5868,7 +5855,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(); @@ -5908,7 +5895,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)); } @@ -5984,65 +5971,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 @@ -6346,7 +6274,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) @@ -6361,7 +6289,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) @@ -6378,10 +6306,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); @@ -6436,10 +6364,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); @@ -6494,10 +6422,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); @@ -6537,12 +6465,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(); } @@ -6798,9 +6726,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(); @@ -7887,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)); @@ -7912,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) @@ -7962,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) @@ -7994,7 +7922,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) @@ -8079,7 +8007,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); @@ -8193,7 +8121,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); @@ -8324,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) { @@ -8338,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(); @@ -8356,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; @@ -8366,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); } } @@ -8375,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) @@ -8820,7 +8748,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); @@ -8829,7 +8757,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 { @@ -8842,18 +8770,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 @@ -8866,14 +8794,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(); } @@ -8890,7 +8818,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(); } } @@ -8900,14 +8828,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(); } } @@ -8918,14 +8846,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(); } @@ -9429,9 +9357,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(); @@ -10322,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)); @@ -10347,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) @@ -10397,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) @@ -10430,7 +10358,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) @@ -10537,7 +10465,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); @@ -10553,6 +10481,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 @@ -11047,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 && (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); } @@ -11274,7 +11243,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) */ @@ -11381,7 +11350,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); @@ -11397,6 +11366,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_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_EX(result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->op2.num)); + } +} + +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_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_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->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 { + 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 @@ -11922,9 +11950,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(); @@ -12814,7 +12842,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)); @@ -12839,7 +12867,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) @@ -12889,7 +12917,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) @@ -12921,7 +12949,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 +13055,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); @@ -13043,20 +13071,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 @@ -13969,9 +13983,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); } @@ -13982,9 +13996,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); } @@ -13995,9 +14009,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); } @@ -14008,9 +14022,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); } @@ -14021,9 +14035,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); } @@ -14034,9 +14048,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); } @@ -15103,6 +15117,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 +15154,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 @@ -15498,18 +15500,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)); @@ -15520,7 +15522,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); } @@ -15610,7 +15612,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(); @@ -15651,7 +15653,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)); } @@ -15727,42 +15729,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; @@ -16433,9 +16399,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(); @@ -16963,10 +16929,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); @@ -17053,7 +17019,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)); @@ -17078,7 +17044,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) @@ -17128,7 +17094,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) @@ -17160,7 +17126,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) @@ -17205,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) @@ -17926,9 +17892,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(); @@ -18428,10 +18394,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); @@ -18518,7 +18484,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)); @@ -18543,7 +18509,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) @@ -18593,7 +18559,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) @@ -18626,7 +18592,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) @@ -18671,7 +18637,33 @@ 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) +{ + 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) @@ -18916,7 +18908,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) */ @@ -18962,7 +18954,43 @@ 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) +{ + 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_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_EX(result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->op2.num)); + } } static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COUNT_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -19333,9 +19361,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 +19863,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); @@ -19925,7 +19953,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)); @@ -19950,7 +19978,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) @@ -20000,7 +20028,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) @@ -20032,7 +20060,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 +20685,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 +20699,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 +20714,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 +21107,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); @@ -21108,13 +21136,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) { @@ -21122,11 +21150,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(); @@ -21140,7 +21168,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; @@ -21150,7 +21178,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); } } @@ -21159,12 +21187,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) @@ -21521,7 +21549,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 +21577,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 +21591,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 +21606,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 +21620,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 +22005,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 +22050,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 +22406,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 +22479,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 +22549,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 +23153,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 +23176,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,11 +23184,11 @@ 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(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); @@ -23169,7 +23197,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); } } @@ -23206,7 +23234,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 +23254,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 +23314,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 +23355,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 +23386,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(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; @@ -23372,7 +23400,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) @@ -23574,7 +23602,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 +23616,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 +23631,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 +23652,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 +23682,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 +23707,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 +23719,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 +23760,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 +23774,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 +23816,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 +23849,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); } @@ -23829,7 +23857,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; @@ -23874,12 +23902,12 @@ 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 { 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); @@ -23893,7 +23921,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; @@ -23941,7 +23979,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); @@ -23955,6 +23993,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 @@ -24156,7 +24205,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 +24262,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 +24301,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 +24359,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 +24416,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 +24455,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 +24513,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 +24570,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 +24609,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 +24667,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 +24724,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 +24763,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 +24843,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 +24917,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 +24995,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 +25070,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 +25148,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 +25223,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 +25301,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 +25375,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 +26435,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); @@ -26415,13 +26464,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) { @@ -26429,11 +26478,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(); @@ -26447,7 +26496,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; @@ -26457,7 +26506,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); } } @@ -26466,12 +26515,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) @@ -26498,7 +26547,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 +26556,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 +26569,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 +26593,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 +26617,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 +26627,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 +26645,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 +26674,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 +26704,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 +26729,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 +26741,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 +26782,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 +26796,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 +26838,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 +26872,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); } @@ -26832,7 +26881,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; @@ -26877,12 +26926,12 @@ 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 { 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); @@ -26897,7 +26946,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; @@ -26945,7 +27004,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); @@ -26960,6 +27019,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 @@ -27162,7 +27232,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 +27289,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 +27328,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 +27386,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 +27443,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 +27482,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 +27540,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 +27597,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 +27636,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 +27694,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 +27751,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 +27790,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 +27870,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 +27944,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 +28022,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 +28097,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 +28175,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 +28250,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 +28328,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 +28402,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 +28982,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 +29010,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 +29024,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 +29039,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 +29112,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 +29126,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 +29141,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 +29223,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 +29274,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 +29288,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 +29330,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 +29455,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 +29529,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 +29607,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 +29682,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 +29760,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 +29835,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 +29913,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 +29987,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)); } } @@ -30595,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 && (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); } @@ -30863,7 +30934,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 +31034,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 +31055,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 +31085,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 +31110,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 +31122,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 +31163,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 +31177,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 +31219,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 +31252,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); } @@ -31189,7 +31260,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; @@ -31234,12 +31305,12 @@ 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 { 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); @@ -31253,7 +31324,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; @@ -31301,7 +31382,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); @@ -31315,6 +31396,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 @@ -31516,7 +31608,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 +31665,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 +31704,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 +31762,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 +31819,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 +31858,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 +31916,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 +31973,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 +32012,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 +32070,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 +32127,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 +32166,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 +32246,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 +32320,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 +32398,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 +32473,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 +32551,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 +32626,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 +32704,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 +32778,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 +32870,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 +33451,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); @@ -33439,7 +33531,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); } @@ -33507,7 +33599,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); } @@ -33654,7 +33746,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 +33776,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 +33801,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 +33813,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! */ @@ -33729,7 +33821,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; @@ -33774,12 +33866,12 @@ 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 { 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); @@ -33793,7 +33885,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; @@ -33841,7 +33943,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); @@ -33855,6 +33957,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 @@ -33934,9 +34047,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 +34377,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 +34434,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 +34473,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 +34531,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 +34588,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 +34627,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 +34685,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 +34742,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 +34781,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 +34839,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 +34896,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 +34935,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 +35431,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(); } @@ -35567,7 +35680,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) @@ -35673,7 +35786,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 +35826,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 +35835,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 +35848,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 +35872,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 +35896,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 +35906,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 +35924,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 +35953,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 +35983,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 +36008,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 +36020,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! */ @@ -35915,7 +36028,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; @@ -35960,12 +36073,12 @@ 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 { 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); @@ -35980,7 +36093,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; @@ -36028,7 +36151,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); @@ -36043,6 +36166,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 @@ -36122,9 +36256,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 +36581,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 +36638,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 +36677,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 +36735,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 +36792,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 +36831,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 +36889,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 +36946,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 +36985,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 +37043,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 +37100,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 +37139,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); } @@ -37572,7 +37706,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) @@ -37679,7 +37813,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); @@ -38060,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 && (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); } @@ -38216,7 +38351,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 +38580,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 +38600,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 +38624,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 +38654,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 +38679,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 +38691,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! */ @@ -38564,7 +38699,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; @@ -38609,12 +38744,12 @@ 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 { 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); @@ -38628,7 +38763,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; @@ -38676,7 +38821,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); @@ -38690,6 +38835,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 @@ -38769,9 +38925,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 +39250,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 +39307,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 +39346,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 +39404,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 +39461,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 +39500,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 +39558,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 +39615,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 +39654,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 +39712,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 +39769,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 +39808,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); } @@ -40217,7 +40373,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) @@ -40323,7 +40479,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); @@ -40339,32 +40495,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 @@ -40390,7 +40520,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); } @@ -40459,7 +40589,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); } @@ -41158,18 +41288,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)); @@ -41180,7 +41310,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); } @@ -41611,7 +41741,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(); @@ -41651,7 +41781,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)); } @@ -41727,42 +41857,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; @@ -41850,12 +41944,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; @@ -41866,8 +41960,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 { @@ -42188,7 +42282,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) @@ -42203,7 +42297,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) @@ -42600,7 +42694,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) { @@ -42630,7 +42724,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 { @@ -42655,7 +42749,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); } } @@ -42667,7 +42761,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! */ @@ -42708,7 +42802,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))) { @@ -42722,10 +42816,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); @@ -42764,8 +42858,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)); } } @@ -42797,7 +42891,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); } @@ -42805,7 +42899,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; @@ -42850,12 +42944,12 @@ 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 { 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); @@ -42869,7 +42963,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; @@ -42917,7 +43021,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); @@ -42931,6 +43035,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 @@ -43122,9 +43237,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(); @@ -43452,7 +43567,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; @@ -43509,7 +43624,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; @@ -43548,7 +43663,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); } @@ -43606,7 +43721,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; @@ -43663,7 +43778,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; @@ -43702,7 +43817,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)); @@ -43760,7 +43875,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; @@ -43817,7 +43932,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; @@ -43856,7 +43971,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)); @@ -43914,7 +44029,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; @@ -43971,7 +44086,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; @@ -44010,7 +44125,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); } @@ -44090,7 +44205,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) { @@ -44164,7 +44279,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)); } } @@ -44242,7 +44357,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) { @@ -44317,7 +44432,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)); } } @@ -44395,7 +44510,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) { @@ -44470,7 +44585,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)); } } @@ -44548,7 +44663,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) { @@ -44622,7 +44737,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)); } } @@ -45490,7 +45605,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)); @@ -45515,7 +45630,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) @@ -45565,7 +45680,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) @@ -45597,7 +45712,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) @@ -45642,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) @@ -45748,7 +45863,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); @@ -45857,13 +45972,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) { @@ -45871,11 +45986,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(); @@ -45889,7 +46004,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; @@ -45899,7 +46014,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); } } @@ -45908,12 +46023,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) @@ -45929,7 +46044,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) @@ -45942,7 +46057,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) @@ -46554,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) { @@ -46584,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 { @@ -46609,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); } } @@ -46621,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! */ @@ -46662,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))) { @@ -46676,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); @@ -46718,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)); } } @@ -46752,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); } @@ -46761,7 +46876,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; @@ -46806,12 +46921,12 @@ 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 { 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); @@ -46826,7 +46941,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; @@ -46874,7 +46999,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); @@ -46889,6 +47014,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 @@ -47080,9 +47216,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(); @@ -47405,7 +47541,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; @@ -47462,7 +47598,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; @@ -47501,7 +47637,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); } @@ -47559,7 +47695,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; @@ -47616,7 +47752,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; @@ -47655,7 +47791,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)); @@ -47713,7 +47849,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; @@ -47770,7 +47906,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; @@ -47809,7 +47945,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)); @@ -47867,7 +48003,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; @@ -47924,7 +48060,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; @@ -47963,7 +48099,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); } @@ -48043,7 +48179,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) { @@ -48117,7 +48253,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)); } } @@ -48195,7 +48331,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) { @@ -48270,7 +48406,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)); } } @@ -48348,7 +48484,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) { @@ -48423,7 +48559,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)); } } @@ -48501,7 +48637,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) { @@ -48575,7 +48711,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)); } } @@ -49246,7 +49382,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)); @@ -49271,7 +49407,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) @@ -49321,7 +49457,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) @@ -49354,7 +49490,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) @@ -49461,7 +49597,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); @@ -49489,7 +49625,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) @@ -49504,7 +49640,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) @@ -49577,7 +49713,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) @@ -49592,7 +49728,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) @@ -49674,12 +49810,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 +49870,33 @@ 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) +{ + 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) @@ -49770,7 +49932,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))) { @@ -49784,10 +49946,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); @@ -49826,8 +49988,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)); } } @@ -50086,7 +50248,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) { @@ -50160,7 +50322,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)); } } @@ -50238,7 +50400,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) { @@ -50313,7 +50475,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)); } } @@ -50391,7 +50553,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) { @@ -50466,7 +50628,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)); } } @@ -50544,7 +50706,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) { @@ -50618,7 +50780,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)); } } @@ -51087,16 +51249,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)); } } @@ -51109,16 +51271,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)); } } @@ -51162,7 +51324,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) */ @@ -51208,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) @@ -51314,7 +51476,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); @@ -51330,6 +51492,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_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_EX(result, 0, QUICK_OP_FLAGS_SMART_BRANCH_JMPZ(opline->op2.num), QUICK_OP_FLAGS_SMART_BRANCH_JMPNZ(opline->op2.num)); + } +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CHECK_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -51646,7 +51844,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 +51859,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) @@ -52058,7 +52256,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 +52286,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 +52311,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 +52323,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 +52364,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 +52378,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 +52420,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 +52453,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); } @@ -52263,7 +52461,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; @@ -52308,12 +52506,12 @@ 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 { 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); @@ -52327,7 +52525,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; @@ -52375,7 +52583,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); @@ -52389,6 +52597,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 @@ -52580,9 +52799,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 +53124,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 +53181,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 +53220,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 +53278,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 +53335,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 +53374,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 +53432,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 +53489,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 +53528,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 +53586,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 +53643,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 +53682,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 +53762,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 +53836,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 +53914,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 +53989,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 +54067,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 +54142,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 +54220,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 +54294,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 +54386,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); } @@ -54840,7 +55059,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)); @@ -54865,7 +55084,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) @@ -54915,7 +55134,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) @@ -54947,7 +55166,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 +55272,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 +55301,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 +55314,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 +55322,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 +55362,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; @@ -55464,16 +55683,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, @@ -56417,7 +56636,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, @@ -57326,12 +57547,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, @@ -57396,6 +57617,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, @@ -57411,6 +57657,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, @@ -57742,7 +58013,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, @@ -58708,11 +58979,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); @@ -58987,11 +59268,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 +59433,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 +59458,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); @@ -59299,31 +59570,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))) { @@ -59348,7 +59619,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); @@ -59481,16 +59752,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 +60257,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 +60357,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 +60502,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 +61052,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 +61067,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 +61132,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 +61372,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 +61427,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); @@ -61784,11 +62065,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); @@ -61989,11 +62280,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); @@ -62329,11 +62630,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); @@ -62504,11 +62815,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); @@ -62639,11 +62960,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); @@ -62854,11 +63185,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); @@ -62959,11 +63300,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 +63514,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); @@ -63348,11 +63679,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); @@ -63648,11 +63989,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); @@ -63863,6 +64214,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 +64359,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); @@ -64123,11 +64484,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); @@ -64334,7 +64705,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(); @@ -64692,16 +65063,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, @@ -65645,7 +66016,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, @@ -66554,12 +66927,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, @@ -66624,6 +66997,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, @@ -66639,6 +67037,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, @@ -66970,7 +67393,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, @@ -67926,223 +68349,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; @@ -68218,7 +68641,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; @@ -68315,7 +68738,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); } @@ -68323,7 +68746,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); } @@ -68331,7 +68754,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); } @@ -68342,17 +68765,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: @@ -68363,17 +68786,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: @@ -68384,16 +68807,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: @@ -68404,16 +68827,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: @@ -68424,12 +68847,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: @@ -68440,12 +68863,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: @@ -68453,12 +68876,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: @@ -68466,79 +68889,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: @@ -68546,22 +68969,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: @@ -68593,7 +69016,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 +69028,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 +69044,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..f2a0ae49b41db 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,79 @@ 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\(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", - "/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_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) { + 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 +862,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); @@ -832,7 +938,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) { @@ -849,6 +957,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); @@ -1052,7 +1169,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 +1230,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"); @@ -1126,7 +1243,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; @@ -1136,6 +1253,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"); } @@ -1176,7 +1295,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($helper, $f, $spec, $kind, $code, $op1, $op2, $name, $extra_spec); } @@ -1545,7 +1664,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 +1869,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 +1937,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 +1992,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 +2021,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 +2043,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 +2064,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 +2084,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 +2110,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 +2186,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 +2295,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 +2486,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 +2507,105 @@ 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_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_FE_FETCH_R', + 'ZEND_FE_FETCH_RW', + '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', +]; + +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_BIND_INIT_STATIC_OR_JMP', + 'ZEND_CAST', + 'ZEND_CATCH', + 'ZEND_DECLARE_ANON_CLASS', + 'ZEND_FETCH_CLASS_CONSTANT', + 'ZEND_INCLUDE_OR_EVAL', + 'ZEND_INIT_DYNAMIC_CALL', + 'ZEND_INIT_FCALL', + 'ZEND_INIT_FCALL_BY_NAME', + 'ZEND_INIT_NS_FCALL_BY_NAME', + 'ZEND_JMP_NULL', + '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 +2701,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 +2757,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 +2765,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 +2784,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"])) { @@ -2560,6 +2810,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", @@ -2573,11 +2824,29 @@ 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') { + // 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"); + } + } + } + // Store parameters if ((ZEND_VM_KIND == ZEND_VM_KIND_GOTO || ZEND_VM_KIND == ZEND_VM_KIND_SWITCH @@ -2591,7 +2860,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]); @@ -2679,7 +2948,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 +2961,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 +3241,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 +3254,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 +3276,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_handlers.h b/Zend/zend_vm_handlers.h index 33d951141550e..c4dd76d7143bf 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) \ @@ -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) \ - _(2164, ZEND_TYPE_CHECK_SPEC_CONST) \ - _(2165, ZEND_TYPE_CHECK_SPEC_TMPVAR) \ - _(2166, ZEND_TYPE_CHECK_SPEC_TMPVAR) \ - _(2168, ZEND_TYPE_CHECK_SPEC_CV) \ - _(2169, ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED) \ - _(2170, ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED) \ - _(2171, ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED) \ - _(2172, ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED) \ - _(2173, ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED) \ - _(2174, ZEND_FE_RESET_RW_SPEC_CONST) \ - _(2175, ZEND_FE_RESET_RW_SPEC_TMP) \ - _(2176, ZEND_FE_RESET_RW_SPEC_VAR) \ - _(2178, ZEND_FE_RESET_RW_SPEC_CV) \ - _(2179, ZEND_FE_FETCH_RW_SPEC_VAR) \ - _(2180, ZEND_FE_FREE_SPEC_TMPVAR) \ - _(2181, ZEND_INIT_DYNAMIC_CALL_SPEC_CONST) \ - _(2182, ZEND_INIT_DYNAMIC_CALL_SPEC_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) \ - _(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 00ad38baaafeb..01260cb7bba5d 100644 --- a/Zend/zend_vm_opcodes.c +++ b/Zend/zend_vm_opcodes.c @@ -236,86 +236,86 @@ 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, - 0x0000000b, - 0x00000007, - 0x80000707, - 0x80000303, - 0x80000303, - 0x80000707, + 0x10000010b, + 0x00000107, 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, - 0x00040000, - 0x00040000, - 0x00040000, - 0x00040000, - 0x00000020, - 0x00002007, - 0x00002007, + 0x100000003, + 0x50b040751, + 0x50b040000, + 0x100000001, + 0x100000001, + 0x100000001, + 0x100000001, + 0x500040000, + 0x500040000, + 0x500040000, + 0x500040000, + 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, - 0x03000001, + 0x100002003, + 0x503000001, 0x00000000, 0x00010107, 0x00000707, @@ -335,119 +335,119 @@ 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, - 0x00020707, + 0x300030107, + 0x500020707, 0x00001303, 0x00001301, 0x01000703, - 0x01000000, - 0x00001003, - 0x00000007, - 0x00040003, - 0x09000007, + 0x401000000, + 0x100001003, + 0x100000007, + 0x300040103, + 0x309000107, 0x00000103, - 0x00002003, - 0x03000001, - 0x00000005, + 0x100002003, + 0x503000001, + 0x100000005, 0x01000700, - 0x00000000, - 0x00000000, - 0x00000000, + 0x100000000, + 0x100000000, + 0x100000000, 0x00040751, 0x00040751, 0x00040751, 0x00040751, - 0x00000007, - 0x00000000, - 0x00047305, + 0x100000007, 0x00000000, + 0x500047305, + 0x100000000, 0x00000101, - 0x00001000, - 0x00001003, + 0x100001000, + 0x100001003, 0x00000303, - 0x00000003, + 0x100000003, 0x00000303, 0x00040000, - 0x00000000, - 0x00060757, - 0x00000000, - 0x00000000, - 0x00002000, - 0x00002003, + 0x100000000, + 0x500060757, + 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, - 0x00047000, - 0x00647000, - 0x00047000, - 0x00047000, - 0x00247000, - 0x00047000, - 0x00040000, - 0x00067000, + 0x500047000, + 0x500647000, + 0x500047000, + 0x500047000, + 0x500247000, + 0x500047000, + 0x400040000, + 0x500067000, 0x00040b73, 0x00100101, - 0x00100001, + 0x400100001, 0x00000101, 0x00001301, 0x00000101, - 0x0300030b, - 0x0300030b, - 0x01000303, + 0x40300030b, + 0x40300030b, + 0x501000303, 0x00000107, 0x00000107, 0x00000101, 0x00000103, - 0x00000707, - 0x0300030b, - 0x00000301, - 0x0000010b, - 0x00002003, + 0x100000707, + 0x40300030b, + 0x100000301, + 0x10000010b, + 0x01002003, 0x00000101, 0x00000101, 0x00000101, 0x00000101, - 0x00002001, - 0x00000101, - 0x00000100, - 0x00000000, - 0x00000000, - 0x01042003, + 0x01002001, + 0x01000101, + 0x301000100, + 0x501000000, + 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/tests/match/005.phpt b/ext/opcache/tests/match/005.phpt index 5726336d53922..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) string("/Welcome/") CV0($text) -0002 JMPNZ T2 0010 -0003 T2 = FRAMELESS_ICALL_2(preg_match) string("/Hello/") CV0($text) -0004 JMPNZ T2 0010 -0005 T2 = FRAMELESS_ICALL_2(preg_match) string("/Bienvenue/") CV0($text) -0006 JMPNZ T2 0012 -0007 T2 = FRAMELESS_ICALL_2(preg_match) 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) +0001 T2 = FRAMELESS_ICALL_2(preg_match) %d string("/Welcome/") CV0($text) +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 d442128d023c8..42d1f0f84a89e 100644 --- a/ext/opcache/tests/opt/gh14873.phpt +++ b/ext/opcache/tests/opt/gh14873.phpt @@ -108,46 +108,53 @@ 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) 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) CV0($value) int(100) -0002 CV0($value) = QM_ASSIGN T1 -0003 VERIFY_RETURN_TYPE CV0($value) -0004 RETURN CV0($value) +0001 T1 = FRAMELESS_ICALL_2(min) %d CV0($value) int(100) +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) int(100) CV0($value) -0002 CV0($value) = QM_ASSIGN T1 -0003 VERIFY_RETURN_TYPE CV0($value) -0004 RETURN CV0($value) +0001 T1 = FRAMELESS_ICALL_2(min) %d int(100) 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) T1 int(100) -0003 VERIFY_RETURN_TYPE CV0($value) -0004 RETURN CV0($value) +0002 CV0($value) = FRAMELESS_ICALL_2(min) %d T1 int(100) +0003 OP_DATA +0004 VERIFY_RETURN_TYPE CV0($value) +0005 RETURN CV0($value) testStrstr3First: ; (lines=6, args=1, vars=1, tmps=%d) ; (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 +167,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 +180,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] 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;