diff --git a/Zend/Optimizer/block_pass.c b/Zend/Optimizer/block_pass.c index 5339de4b6449b..49f1990511eaf 100644 --- a/Zend/Optimizer/block_pass.c +++ b/Zend/Optimizer/block_pass.c @@ -945,7 +945,7 @@ static void assemble_code_blocks(zend_cfg *cfg, zend_op_array *op_array, zend_op if (b->len == 0) { continue; } - if (b->flags & (ZEND_BB_REACHABLE|ZEND_BB_UNREACHABLE_FREE)) { + if (b->flags & ZEND_BB_REACHABLE) { opline = op_array->opcodes + b->start + b->len - 1; if (opline->opcode == ZEND_JMP) { zend_basic_block *next = b + 1; @@ -983,7 +983,7 @@ static void assemble_code_blocks(zend_cfg *cfg, zend_op_array *op_array, zend_op /* Copy code of reachable blocks into a single buffer */ for (b = blocks; b < end; b++) { - if (b->flags & (ZEND_BB_REACHABLE|ZEND_BB_UNREACHABLE_FREE)) { + if (b->flags & ZEND_BB_REACHABLE) { memcpy(opline, op_array->opcodes + b->start, b->len * sizeof(zend_op)); b->start = opline - new_opcodes; opline += b->len; @@ -1100,7 +1100,7 @@ static void assemble_code_blocks(zend_cfg *cfg, zend_op_array *op_array, zend_op /* rebuild map (just for printing) */ memset(cfg->map, -1, sizeof(int) * op_array->last); for (int n = 0; n < cfg->blocks_count; n++) { - if (cfg->blocks[n].flags & (ZEND_BB_REACHABLE|ZEND_BB_UNREACHABLE_FREE)) { + if (cfg->blocks[n].flags & ZEND_BB_REACHABLE) { cfg->map[cfg->blocks[n].start] = n; } } @@ -1725,16 +1725,7 @@ void zend_optimize_cfg(zend_op_array *op_array, zend_optimizer_ctx *ctx) /* Eliminate NOPs */ for (b = blocks; b < end; b++) { - if (b->flags & ZEND_BB_UNREACHABLE_FREE) { - /* In unreachable_free blocks only preserve loop var frees. */ - for (uint32_t i = b->start; i < b->start + b->len; i++) { - zend_op *opline = &op_array->opcodes[i]; - if (!zend_optimizer_is_loop_var_free(opline)) { - MAKE_NOP(opline); - } - } - } - if (b->flags & (ZEND_BB_REACHABLE|ZEND_BB_UNREACHABLE_FREE)) { + if (b->flags & ZEND_BB_REACHABLE) { strip_nops(op_array, b); } } diff --git a/Zend/Optimizer/dfa_pass.c b/Zend/Optimizer/dfa_pass.c index b1f568da5d920..8224e9d6e7f75 100644 --- a/Zend/Optimizer/dfa_pass.c +++ b/Zend/Optimizer/dfa_pass.c @@ -138,7 +138,7 @@ static void zend_ssa_remove_nops(zend_op_array *op_array, zend_ssa *ssa, zend_op } for (b = blocks; b < blocks_end; b++) { - if (b->flags & (ZEND_BB_REACHABLE|ZEND_BB_UNREACHABLE_FREE)) { + if (b->flags & ZEND_BB_REACHABLE) { if (b->len) { uint32_t new_start, old_end; while (i < b->start) { @@ -146,13 +146,6 @@ static void zend_ssa_remove_nops(zend_op_array *op_array, zend_ssa *ssa, zend_op i++; } - if (b->flags & ZEND_BB_UNREACHABLE_FREE) { - /* Only keep the FREE for the loop var */ - ZEND_ASSERT(op_array->opcodes[b->start].opcode == ZEND_FREE - || op_array->opcodes[b->start].opcode == ZEND_FE_FREE); - b->len = 1; - } - new_start = target; old_end = b->start + b->len; while (i < old_end) { @@ -757,9 +750,6 @@ static int zend_dfa_optimize_jmps(zend_op_array *op_array, zend_ssa *ssa) while (next_block_num < ssa->cfg.blocks_count && !(ssa->cfg.blocks[next_block_num].flags & ZEND_BB_REACHABLE)) { - if (ssa->cfg.blocks[next_block_num].flags & ZEND_BB_UNREACHABLE_FREE) { - can_follow = 0; - } next_block_num++; } diff --git a/Zend/Optimizer/zend_cfg.c b/Zend/Optimizer/zend_cfg.c index ce7d078bb957e..7f0a58a7e2ae5 100644 --- a/Zend/Optimizer/zend_cfg.c +++ b/Zend/Optimizer/zend_cfg.c @@ -196,33 +196,6 @@ static void zend_mark_reachable_blocks(const zend_op_array *op_array, zend_cfg * } } while (changed); } - - if (cfg->flags & ZEND_FUNC_FREE_LOOP_VAR) { - zend_basic_block *b; - int j; - uint32_t *block_map = cfg->map; - - /* Mark blocks that are unreachable, but free a loop var created in a reachable block. */ - for (b = blocks; b < blocks + cfg->blocks_count; b++) { - if (b->flags & ZEND_BB_REACHABLE) { - continue; - } - - for (j = b->start; j < b->start + b->len; j++) { - zend_op *opline = &op_array->opcodes[j]; - if (zend_optimizer_is_loop_var_free(opline)) { - zend_op *def_opline = zend_optimizer_get_loop_var_def(op_array, opline); - if (def_opline) { - uint32_t def_block = block_map[def_opline - op_array->opcodes]; - if (blocks[def_block].flags & ZEND_BB_REACHABLE) { - b->flags |= ZEND_BB_UNREACHABLE_FREE; - break; - } - } - } - } - } - } } /* }}} */ @@ -305,9 +278,7 @@ ZEND_API void zend_build_cfg(zend_arena **arena, const zend_op_array *op_array, case ZEND_MATCH_ERROR: case ZEND_EXIT: case ZEND_THROW: - /* Don't treat THROW as terminator if it's used in expression context, - * as we may lose live ranges when eliminating unreachable code. */ - if (opline->extended_value != ZEND_THROW_IS_EXPR && i + 1 < op_array->last) { + if (i + 1 < op_array->last) { BB_START(i + 1); } break; @@ -430,8 +401,7 @@ ZEND_API void zend_build_cfg(zend_arena **arena, const zend_op_array *op_array, case ZEND_FREE: case ZEND_FE_FREE: if (zend_optimizer_is_loop_var_free(opline) - && ((opline-1)->opcode != ZEND_MATCH_ERROR - || (opline-1)->extended_value != ZEND_THROW_IS_EXPR)) { + && ((opline-1)->opcode != ZEND_MATCH_ERROR)) { BB_START(i); flags |= ZEND_FUNC_FREE_LOOP_VAR; } diff --git a/Zend/Optimizer/zend_cfg.h b/Zend/Optimizer/zend_cfg.h index 93d455060686e..eb38ba5ce9fce 100644 --- a/Zend/Optimizer/zend_cfg.h +++ b/Zend/Optimizer/zend_cfg.h @@ -29,7 +29,6 @@ #define ZEND_BB_CATCH (1<<6) /* start of catch block */ #define ZEND_BB_FINALLY (1<<7) /* start of finally block */ #define ZEND_BB_FINALLY_END (1<<8) /* end of finally block */ -#define ZEND_BB_UNREACHABLE_FREE (1<<11) /* unreachable loop free */ #define ZEND_BB_RECV_ENTRY (1<<12) /* RECV entry */ #define ZEND_BB_LOOP_HEADER (1<<16) @@ -37,7 +36,7 @@ #define ZEND_BB_REACHABLE (1U<<31) -#define ZEND_BB_PROTECTED (ZEND_BB_ENTRY|ZEND_BB_RECV_ENTRY|ZEND_BB_TRY|ZEND_BB_CATCH|ZEND_BB_FINALLY|ZEND_BB_FINALLY_END|ZEND_BB_UNREACHABLE_FREE) +#define ZEND_BB_PROTECTED (ZEND_BB_ENTRY|ZEND_BB_RECV_ENTRY|ZEND_BB_TRY|ZEND_BB_CATCH|ZEND_BB_FINALLY|ZEND_BB_FINALLY_END) typedef struct _zend_basic_block { int *successors; /* successor block indices */ diff --git a/Zend/Optimizer/zend_dump.c b/Zend/Optimizer/zend_dump.c index 9eaca19f18f57..56abd11106305 100644 --- a/Zend/Optimizer/zend_dump.c +++ b/Zend/Optimizer/zend_dump.c @@ -803,9 +803,6 @@ static void zend_dump_block_info(const zend_cfg *cfg, int n, uint32_t dump_flags if (!(dump_flags & ZEND_DUMP_HIDE_UNREACHABLE) && !(b->flags & ZEND_BB_REACHABLE)) { fprintf(stderr, " unreachable"); } - if (b->flags & ZEND_BB_UNREACHABLE_FREE) { - fprintf(stderr, " unreachable_free"); - } if (b->flags & ZEND_BB_LOOP_HEADER) { fprintf(stderr, " loop_header"); } diff --git a/Zend/Optimizer/zend_optimizer.c b/Zend/Optimizer/zend_optimizer.c index 463bbbfa84b45..ba67963cb7fb1 100644 --- a/Zend/Optimizer/zend_optimizer.c +++ b/Zend/Optimizer/zend_optimizer.c @@ -1027,7 +1027,7 @@ static void zend_optimize(zend_op_array *op_array, */ if ((ZEND_OPTIMIZER_PASS_9 & ctx->optimization_level) && !(ZEND_OPTIMIZER_PASS_7 & ctx->optimization_level)) { - zend_optimize_temporary_variables(op_array, ctx); + // zend_optimize_temporary_variables(op_array, ctx); if (ctx->debug_level & ZEND_DUMP_AFTER_PASS_9) { zend_dump_op_array(op_array, 0, "after pass 9", NULL); } @@ -1536,7 +1536,7 @@ ZEND_API void zend_optimize_script(zend_script *script, zend_long optimization_l if (ZEND_OPTIMIZER_PASS_9 & optimization_level) { for (i = 0; i < call_graph.op_arrays_count; i++) { - zend_optimize_temporary_variables(call_graph.op_arrays[i], &ctx); + // zend_optimize_temporary_variables(call_graph.op_arrays[i], &ctx); if (debug_level & ZEND_DUMP_AFTER_PASS_9) { zend_dump_op_array(call_graph.op_arrays[i], 0, "after pass 9", NULL); } diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index 1595f51fb13a5..a7cdcad110fca 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -5181,10 +5181,8 @@ static void zend_compile_throw(znode *result, zend_ast *ast) /* {{{ */ znode expr_node; zend_compile_expr(&expr_node, expr_ast); - zend_op *opline = zend_emit_op(NULL, ZEND_THROW, &expr_node, NULL); + zend_emit_op(NULL, ZEND_THROW, &expr_node, NULL); if (result) { - /* Mark this as an "expression throw" for opcache. */ - opline->extended_value = ZEND_THROW_IS_EXPR; result->op_type = IS_CONST; ZVAL_TRUE(&result->u.constant); } @@ -5947,10 +5945,6 @@ static void zend_compile_match(znode *result, zend_ast *ast) if (opline->op1_type == IS_CONST) { Z_TRY_ADDREF_P(CT_CONSTANT(opline->op1)); } - if (arms->children == 0) { - /* Mark this as an "expression throw" for opcache. */ - opline->extended_value = ZEND_THROW_IS_EXPR; - } } for (uint32_t i = 0; i < arms->children; ++i) { @@ -9432,10 +9426,8 @@ static void zend_compile_exit(znode *result, zend_ast *ast) /* {{{ */ expr_node.op_type = IS_UNUSED; } - zend_op *opline = zend_emit_op(NULL, ZEND_EXIT, &expr_node, NULL); + zend_emit_op(NULL, ZEND_EXIT, &expr_node, NULL); if (result) { - /* Mark this as an "expression throw" for opcache. */ - opline->extended_value = ZEND_THROW_IS_EXPR; result->op_type = IS_CONST; ZVAL_TRUE(&result->u.constant); } diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h index 724b5b8c8a57c..f1c10ffc899e9 100644 --- a/Zend/zend_compile.h +++ b/Zend/zend_compile.h @@ -1021,8 +1021,6 @@ ZEND_API zend_string *zend_type_to_string(zend_type type); #define ZEND_SEND_BY_REF 1u #define ZEND_SEND_PREFER_REF 2u -#define ZEND_THROW_IS_EXPR 1u - #define ZEND_FCALL_MAY_HAVE_EXTRA_NAMED_PARAMS 1 /* The send mode, the is_variadic, the is_promoted, and the is_tentative flags are stored as part of zend_type */ diff --git a/Zend/zend_opcode.c b/Zend/zend_opcode.c index dc968bc395303..0ba694a9b904a 100644 --- a/Zend/zend_opcode.c +++ b/Zend/zend_opcode.c @@ -746,6 +746,9 @@ static void emit_live_range( case ZEND_DECLARE_ANON_CLASS: /* FAST_CALLs don't have to be destroyed. */ case ZEND_FAST_CALL: + /* JMP_NULL only define null, false and true. */ + case ZEND_JMP_NULL: + case ZEND_JMP_SET: return; case ZEND_BEGIN_SILENCE: kind = ZEND_LIVE_SILENCE; @@ -912,6 +915,9 @@ static void swap_live_range(zend_live_range *a, zend_live_range *b) { b->end = tmp; } +#define LIVE_RANGE_VAR_UNUSED ((uint32_t) -1) +#define LIVE_RANGE_VAR_DEFINED ((uint32_t) -2) + static void zend_calc_live_ranges( zend_op_array *op_array, zend_needs_live_range_cb needs_live_range) { uint32_t opnum = op_array->last; @@ -928,12 +934,35 @@ static void zend_calc_live_ranges( if ((opline->result_type & (IS_TMP_VAR|IS_VAR)) && !is_fake_def(opline)) { uint32_t var_num = EX_VAR_TO_NUM(opline->result.var) - var_offset; + // FIXME: Outdated comment /* Defs without uses can occur for two reasons: Either because the result is * genuinely unused (e.g. omitted FREE opcode for an unused boolean result), or * because there are multiple defining opcodes (e.g. JMPZ_EX and QM_ASSIGN), in * which case the last one starts the live range. As such, we can simply ignore * missing uses here. */ - if (EXPECTED(last_use[var_num] != (uint32_t) -1)) { + if (UNEXPECTED(last_use[var_num] == LIVE_RANGE_VAR_UNUSED)) { + // FIXME: Make sure not to insert unnecessary live-ranges. But I think this is already handled. + /* Find the innermost try/catch that we are inside of. */ + uint32_t live_range_end = (uint32_t) -1; + for (uint32_t i = 0; i < op_array->last_try_catch; i++) { + zend_try_catch_element *try_catch = &op_array->try_catch_array[i]; + if (opnum < try_catch->try_op) { + break; + } + if (opnum < try_catch->catch_op) { + live_range_end = try_catch->catch_op; + } else if (opnum < try_catch->finally_end) { + live_range_end = try_catch->finally_end; + } + } + if (live_range_end == (uint32_t) -1) { + live_range_end = op_array->last; + } + if (opnum + 1 != live_range_end) { + emit_live_range(op_array, var_num, opnum, live_range_end, needs_live_range); + } + last_use[var_num] = LIVE_RANGE_VAR_DEFINED; + } else if (last_use[var_num] != LIVE_RANGE_VAR_DEFINED) { /* Skip trivial live-range */ if (opnum + 1 != last_use[var_num]) { uint32_t num; @@ -948,13 +977,13 @@ static void zend_calc_live_ranges( #endif emit_live_range(op_array, var_num, num, last_use[var_num], needs_live_range); } - last_use[var_num] = (uint32_t) -1; + last_use[var_num] = LIVE_RANGE_VAR_DEFINED; } } if ((opline->op1_type & (IS_TMP_VAR|IS_VAR))) { uint32_t var_num = EX_VAR_TO_NUM(opline->op1.var) - var_offset; - if (EXPECTED(last_use[var_num] == (uint32_t) -1)) { + if (EXPECTED(last_use[var_num] == LIVE_RANGE_VAR_UNUSED || last_use[var_num] == LIVE_RANGE_VAR_DEFINED)) { if (EXPECTED(!keeps_op1_alive(opline))) { /* OP_DATA is really part of the previous opcode. */ last_use[var_num] = opnum - (opline->opcode == ZEND_OP_DATA); @@ -966,14 +995,14 @@ static void zend_calc_live_ranges( if (UNEXPECTED(opline->opcode == ZEND_FE_FETCH_R || opline->opcode == ZEND_FE_FETCH_RW)) { /* OP2 of FE_FETCH is actually a def, not a use. */ - if (last_use[var_num] != (uint32_t) -1) { + if (last_use[var_num] != LIVE_RANGE_VAR_UNUSED && last_use[var_num] != LIVE_RANGE_VAR_DEFINED) { if (opnum + 1 != last_use[var_num]) { emit_live_range( op_array, var_num, opnum, last_use[var_num], needs_live_range); } - last_use[var_num] = (uint32_t) -1; + last_use[var_num] = LIVE_RANGE_VAR_DEFINED; } - } else if (EXPECTED(last_use[var_num] == (uint32_t) -1)) { + } else if (EXPECTED(last_use[var_num] == LIVE_RANGE_VAR_UNUSED || last_use[var_num] == LIVE_RANGE_VAR_DEFINED)) { #if 1 /* OP_DATA uses only op1 operand */ ZEND_ASSERT(opline->opcode != ZEND_OP_DATA); diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 51f35118d9de4..715c129d9e811 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -7680,6 +7680,7 @@ ZEND_VM_COLD_CONST_HANDLER(169, ZEND_COALESCE, CONST|TMP|VAR|CV, JMP_ADDR) efree_size(ref, sizeof(zend_reference)); } } + ZVAL_UNDEF(EX_VAR(opline->result.var)); ZEND_VM_NEXT_OPCODE(); } diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 90f105f611e61..8862a25000b33 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -5374,6 +5374,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COALESCE_SPEC_CON efree_size(ref, sizeof(zend_reference)); } } + ZVAL_UNDEF(EX_VAR(opline->result.var)); ZEND_VM_NEXT_OPCODE(); } @@ -19737,6 +19738,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COALESCE_SPEC_TMP_HANDLER(ZEND efree_size(ref, sizeof(zend_reference)); } } + ZVAL_UNDEF(EX_VAR(opline->result.var)); ZEND_VM_NEXT_OPCODE(); } @@ -22685,6 +22687,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COALESCE_SPEC_VAR_HANDLER(ZEND efree_size(ref, sizeof(zend_reference)); } } + ZVAL_UNDEF(EX_VAR(opline->result.var)); ZEND_VM_NEXT_OPCODE(); } @@ -40135,6 +40138,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COALESCE_SPEC_CV_HANDLER(ZEND_ efree_size(ref, sizeof(zend_reference)); } } + ZVAL_UNDEF(EX_VAR(opline->result.var)); ZEND_VM_NEXT_OPCODE(); } diff --git a/ext/opcache/tests/match/001.phpt b/ext/opcache/tests/match/001.phpt index 37f564b5bbc80..5eea6aa9a8652 100644 --- a/ext/opcache/tests/match/001.phpt +++ b/ext/opcache/tests/match/001.phpt @@ -27,26 +27,26 @@ foreach (range('a', 'i') as $char) { ?> --EXPECTF-- $_main: - ; (lines=15, args=0, vars=1, tmps=2) + ; (lines=15, args=0, vars=1, tmps=3) ; (after optimizer) ; %s 0000 INIT_FCALL 2 %d string("range") 0001 SEND_VAL string("a") 1 0002 SEND_VAL string("i") 2 -0003 V2 = DO_ICALL -0004 V1 = FE_RESET_R V2 0013 -0005 FE_FETCH_R V1 CV0($char) 0013 +0003 V1 = DO_ICALL +0004 V2 = FE_RESET_R V1 0013 +0005 FE_FETCH_R V2 CV0($char) 0013 0006 INIT_FCALL 1 %d string("var_dump") 0007 INIT_FCALL 1 %d string("test") 0008 SEND_VAR CV0($char) 1 -0009 V2 = DO_UCALL -0010 SEND_VAR V2 1 +0009 V3 = DO_UCALL +0010 SEND_VAR V3 1 0011 DO_ICALL 0012 JMP 0005 -0013 FE_FREE V1 +0013 FE_FREE V2 0014 RETURN int(1) LIVE RANGES: - 1: 0005 - 0013 (loop) + 2: 0005 - 0013 (loop) test: ; (lines=9, args=1, vars=1, tmps=0) diff --git a/ext/opcache/tests/match/003.phpt b/ext/opcache/tests/match/003.phpt index 9e55cbba942c5..ecc60cc03e238 100644 --- a/ext/opcache/tests/match/003.phpt +++ b/ext/opcache/tests/match/003.phpt @@ -28,26 +28,26 @@ foreach (range(0, 10) as $char) { ?> --EXPECTF-- $_main: - ; (lines=15, args=0, vars=1, tmps=2) + ; (lines=15, args=0, vars=1, tmps=3) ; (after optimizer) ; %s 0000 INIT_FCALL 2 %d string("range") 0001 SEND_VAL int(0) 1 0002 SEND_VAL int(10) 2 -0003 V2 = DO_ICALL -0004 V1 = FE_RESET_R V2 0013 -0005 FE_FETCH_R V1 CV0($char) 0013 +0003 V1 = DO_ICALL +0004 V2 = FE_RESET_R V1 0013 +0005 FE_FETCH_R V2 CV0($char) 0013 0006 INIT_FCALL 1 %d string("var_dump") 0007 INIT_FCALL 1 %d string("test") 0008 SEND_VAR CV0($char) 1 -0009 V2 = DO_UCALL -0010 SEND_VAR V2 1 +0009 V3 = DO_UCALL +0010 SEND_VAR V3 1 0011 DO_ICALL 0012 JMP 0005 -0013 FE_FREE V1 +0013 FE_FREE V2 0014 RETURN int(1) LIVE RANGES: - 1: 0005 - 0013 (loop) + 2: 0005 - 0013 (loop) test: ; (lines=9, args=1, vars=1, tmps=0) diff --git a/ext/opcache/tests/match/004.phpt b/ext/opcache/tests/match/004.phpt index 551c9a5d0e1dc..f91bd4ff5554a 100644 --- a/ext/opcache/tests/match/004.phpt +++ b/ext/opcache/tests/match/004.phpt @@ -33,33 +33,33 @@ foreach (range(0, 6) as $number) { ?> --EXPECTF-- $_main: - ; (lines=22, args=0, vars=1, tmps=2) + ; (lines=22, args=0, vars=1, tmps=5) ; (after optimizer) ; %s.php:1-25 0000 INIT_FCALL 2 %d string("range") 0001 SEND_VAL int(0) 1 0002 SEND_VAL int(6) 2 -0003 V2 = DO_ICALL -0004 V1 = FE_RESET_R V2 0020 -0005 FE_FETCH_R V1 CV0($number) 0020 +0003 V1 = DO_ICALL +0004 V2 = FE_RESET_R V1 0020 +0005 FE_FETCH_R V2 CV0($number) 0020 0006 INIT_FCALL 1 %d string("var_dump") 0007 INIT_FCALL 1 %d string("test") 0008 SEND_VAR CV0($number) 1 -0009 V2 = DO_UCALL -0010 SEND_VAR V2 1 +0009 V3 = DO_UCALL +0010 SEND_VAR V3 1 0011 DO_ICALL 0012 INIT_FCALL 1 %d string("var_dump") 0013 INIT_FCALL 1 %d string("test") -0014 T2 = CAST (string) CV0($number) -0015 SEND_VAL T2 1 -0016 V2 = DO_UCALL -0017 SEND_VAR V2 1 +0014 T4 = CAST (string) CV0($number) +0015 SEND_VAL T4 1 +0016 V5 = DO_UCALL +0017 SEND_VAR V5 1 0018 DO_ICALL 0019 JMP 0005 -0020 FE_FREE V1 +0020 FE_FREE V2 0021 RETURN int(1) LIVE RANGES: - 1: 0005 - 0020 (loop) + 2: 0005 - 0020 (loop) test: ; (lines=13, args=1, vars=1, tmps=0) diff --git a/ext/opcache/tests/opt/nullsafe_001.phpt b/ext/opcache/tests/opt/nullsafe_001.phpt index f0c317564136e..2e344321270d5 100644 --- a/ext/opcache/tests/opt/nullsafe_001.phpt +++ b/ext/opcache/tests/opt/nullsafe_001.phpt @@ -47,7 +47,7 @@ test: 0009 RETURN null test2: - ; (lines=17, args=1, vars=1, tmps=1) + ; (lines=17, args=1, vars=1, tmps=3) ; (after optimizer) ; %s 0000 CV0($obj) = RECV 1 @@ -57,13 +57,13 @@ test2: 0004 SEND_VAL T1 1 0005 DO_ICALL 0006 INIT_FCALL 1 %d string("var_dump") -0007 T1 = JMP_NULL CV0($obj) 0009 -0008 T1 = ISSET_ISEMPTY_PROP_OBJ (isset) CV0($obj) string("foo") -0009 SEND_VAL T1 1 +0007 T2 = JMP_NULL CV0($obj) 0009 +0008 T2 = ISSET_ISEMPTY_PROP_OBJ (isset) CV0($obj) string("foo") +0009 SEND_VAL T2 1 0010 DO_ICALL 0011 INIT_FCALL 1 %d string("var_dump") -0012 T1 = JMP_NULL CV0($obj) 0014 -0013 T1 = ISSET_ISEMPTY_PROP_OBJ (empty) CV0($obj) string("foo") -0014 SEND_VAL T1 1 +0012 T3 = JMP_NULL CV0($obj) 0014 +0013 T3 = ISSET_ISEMPTY_PROP_OBJ (empty) CV0($obj) string("foo") +0014 SEND_VAL T3 1 0015 DO_ICALL 0016 RETURN null diff --git a/ext/opcache/tests/opt/sccp_006.phpt b/ext/opcache/tests/opt/sccp_006.phpt index c8b6253e5c725..301f91eff4090 100644 --- a/ext/opcache/tests/opt/sccp_006.phpt +++ b/ext/opcache/tests/opt/sccp_006.phpt @@ -23,7 +23,7 @@ $_main: 0000 RETURN int(1) foo: - ; (lines=8, args=1, vars=2, tmps=1) + ; (lines=8, args=1, vars=2, tmps=2) ; (after optimizer) ; %ssccp_006.php:2-5 0000 CV0($x) = RECV 1 @@ -31,8 +31,8 @@ foo: 0002 T2 = ADD_ARRAY_ELEMENT int(2) string("a") 0003 T2 = ADD_ARRAY_ELEMENT CV0($x) string("a") 0004 CV1($a) = QM_ASSIGN T2 -0005 T2 = FETCH_DIM_R CV1($a) string("a") -0006 ECHO T2 +0005 T3 = FETCH_DIM_R CV1($a) string("a") +0006 ECHO T3 0007 RETURN null LIVE RANGES: 2: 0002 - 0004 (tmp/var) diff --git a/ext/opcache/tests/opt/sccp_024.phpt b/ext/opcache/tests/opt/sccp_024.phpt index 5fd33e2b7e1a4..afe30342cbe56 100644 --- a/ext/opcache/tests/opt/sccp_024.phpt +++ b/ext/opcache/tests/opt/sccp_024.phpt @@ -29,16 +29,16 @@ $_main: 0000 RETURN int(1) A::t: - ; (lines=10, args=1, vars=2, tmps=2) + ; (lines=10, args=1, vars=2, tmps=4) ; (after optimizer) ; %ssccp_024.php:3-10 0000 CV0($obj) = RECV 1 0001 CV1($c) = QM_ASSIGN int(1) 0002 T2 = INSTANCEOF CV0($obj) string("A") 0003 ECHO T2 -0004 T2 = INSTANCEOF CV0($obj) string("self") -0005 ECHO T2 -0006 V3 = FETCH_CLASS (no-autoload) (silent) (exception) CV1($c) -0007 T2 = INSTANCEOF CV0($obj) V3 -0008 ECHO T2 +0004 T3 = INSTANCEOF CV0($obj) string("self") +0005 ECHO T3 +0006 V4 = FETCH_CLASS (no-autoload) (silent) (exception) CV1($c) +0007 T5 = INSTANCEOF CV0($obj) V4 +0008 ECHO T5 0009 RETURN null diff --git a/ext/opcache/tests/opt/sccp_032.phpt b/ext/opcache/tests/opt/sccp_032.phpt index 9a03fe4e1d576..c00b9c028d575 100644 --- a/ext/opcache/tests/opt/sccp_032.phpt +++ b/ext/opcache/tests/opt/sccp_032.phpt @@ -29,19 +29,19 @@ $_main: ; (after optimizer) ; %ssccp_032.php:1-15 0000 INIT_FCALL 0 %d string("test") -0001 V2 = DO_UCALL -0002 V1 = FE_RESET_R V2 0009 -0003 FE_FETCH_R V1 CV0($x) 0009 +0001 V1 = DO_UCALL +0002 V2 = FE_RESET_R V1 0009 +0003 FE_FETCH_R V2 CV0($x) 0009 0004 INIT_FCALL 1 %d string("var_export") 0005 SEND_VAR CV0($x) 1 0006 DO_ICALL 0007 ECHO string(" ") 0008 JMP 0003 -0009 FE_FREE V1 +0009 FE_FREE V2 0010 RETURN int(1) LIVE RANGES: - 1: 0003 - 0009 (loop) + 2: 0003 - 0009 (loop) test: ; (lines=5, args=0, vars=0, tmps=1)