Try with pass_two modification of result_op instead

bwoebi · bwoebi · commit 72d298a998a2 · 2024-03-10T22:56:31.000+01:00
diff --git a/Zend/Optimizer/optimize_temp_vars_5.c b/Zend/Optimizer/optimize_temp_vars_5.c
@@ -49,7 +49,6 @@ void zend_optimize_temporary_variables(zend_op_array *op_array, zend_optimizer_c
 	int *map_T;				/* Map's the T to its new index */
 	zend_op *opline, *end;
 	int currT;
-	int exclNextT = -1;
 	int i;
 	int max = -1;
 	void *checkpoint = zend_arena_checkpoint(ctx->arena);
@@ -145,11 +144,6 @@ void zend_optimize_temporary_variables(zend_op_array *op_array, zend_optimizer_c
 			opline->op2.var = NUM_VAR(map_T[currT] + offset);
 		}
 
-		if (exclNextT != -1) {
-			zend_bitset_excl(taken_T, exclNextT);
-			exclNextT = -1;
-		}
-
 		if (opline->result_type & (IS_VAR | IS_TMP_VAR)) {
 			currT = VAR_NUM(opline->result.var) - offset;
 			if (map_T[currT] == INVALID_VAR) {
@@ -163,12 +157,7 @@ void zend_optimize_temporary_variables(zend_op_array *op_array, zend_optimizer_c
 				 * since the fast_var could also be set by ZEND_HANDLE_EXCEPTION
 				 * which could be ahead of it */
 				if (opline->opcode != ZEND_FAST_CALL) {
-					if (opline->opcode == ZEND_OP_DATA) {
-						/* ZEND_OP_DATA may contain a result, which must not be equal to any of its prior opcode vars */
-						exclNextT = map_T[currT];
-					} else {
-						zend_bitset_excl(taken_T, map_T[currT]);
-					}
+					zend_bitset_excl(taken_T, map_T[currT]);
 				}
 				if (opline->opcode == ZEND_ROPE_INIT) {
 					uint32_t num = ((opline->extended_value * sizeof(zend_string*)) + (sizeof(zval) - 1)) / sizeof(zval);
diff --git a/Zend/Optimizer/sccp.c b/Zend/Optimizer/sccp.c
@@ -2139,10 +2139,6 @@ static int try_remove_definition(sccp_ctx *ctx, int var_num, zend_ssa_var *var,
 				}
 				return 0;
 			}
-			if (opline->opcode == ZEND_OP_DATA) {
-				/* Consider the primary opline for matching */
-				--opline;
-			}
 			if (ssa_op->op1_def >= 0 || ssa_op->op2_def >= 0) {
 				if (var->use_chain < 0 && var->phi_use_chain == NULL) {
 					switch (opline->opcode) {
@@ -2213,8 +2209,6 @@ static int try_remove_definition(sccp_ctx *ctx, int var_num, zend_ssa_var *var,
 						zend_ssa_remove_instr(ssa, opline, ssa_op);
 						removed_ops++;
 						if (has_op_data) {
-							old_type = opline[1].result_type;
-							old_var = opline[1].result.var;
 							zend_ssa_remove_instr(ssa, opline + 1, ssa_op + 1);
 							removed_ops++;
 						}
diff --git a/Zend/Optimizer/scdf.c b/Zend/Optimizer/scdf.c
@@ -124,10 +124,7 @@ void scdf_solve(scdf_ctx *scdf, const char *name) {
 				zend_ssa_op *ssa_op = &ssa->ops[i];
 				if (opline->opcode == ZEND_OP_DATA) {
 					opline--;
-					if (opline->opcode != ZEND_FRAMELESS_ICALL_3) {
-						// result op not on OP_DATA
-						ssa_op--;
-					}
+					ssa_op--;
 				}
 				scdf->handlers.visit_instr(scdf, opline, ssa_op);
 				if (i == block->start + block->len - 1) {
@@ -165,7 +162,7 @@ void scdf_solve(scdf_ctx *scdf, const char *name) {
 				for (j = block->start; j < end; j++) {
 					opline = &scdf->op_array->opcodes[j];
 					zend_bitset_excl(scdf->instr_worklist, j);
-					if (opline->opcode != ZEND_OP_DATA || opline[-1].opcode == ZEND_FRAMELESS_ICALL_3) {
+					if (opline->opcode != ZEND_OP_DATA) {
 						scdf->handlers.visit_instr(scdf, opline, &ssa->ops[j]);
 					}
 				}
@@ -175,10 +172,7 @@ void scdf_solve(scdf_ctx *scdf, const char *name) {
 					ZEND_ASSERT(opline && "Should have opline in non-empty block");
 					if (opline->opcode == ZEND_OP_DATA) {
 						opline--;
-						if (opline->opcode != ZEND_FRAMELESS_ICALL_3) {
-							// result op not on OP_DATA
-							j--;
-						}
+						j--;
 					}
 					scdf->handlers.mark_feasible_successors(scdf, i, block, opline, &ssa->ops[j-1]);
 				}
diff --git a/Zend/Optimizer/zend_dfg.c b/Zend/Optimizer/zend_dfg.c
@@ -130,9 +130,6 @@ static zend_always_inline void _zend_dfg_add_use_def_op(const zend_op_array *op_
 					zend_bitset_incl(use, var_num);
 				}
 			}
-			if (opline->opcode == ZEND_FRAMELESS_ICALL_3) {
-				++opline; // OP_DATA has result
-			}
 			break;
 		case ZEND_ASSIGN_DIM_OP:
 		case ZEND_ASSIGN_OBJ_OP:
diff --git a/Zend/Optimizer/zend_inference.c b/Zend/Optimizer/zend_inference.c
@@ -3869,7 +3869,7 @@ static zend_always_inline zend_result _zend_update_type_info(
 				UPDATE_SSA_TYPE(tmp, ssa_op->op2_def);
 			}
 			if (opline->opcode == ZEND_FRAMELESS_ICALL_3) {
-				zend_ssa_op *next_ssa_op = ++ssa_op; // OP_DATA has result op
+				zend_ssa_op *next_ssa_op = ssa_op + 1;
 				if (next_ssa_op->op1_def >= 0) {
 					ZEND_ASSERT(next_ssa_op->op1_use >= 0);
 					tmp = ssa->var_info[next_ssa_op->op1_use].type;
diff --git a/Zend/Optimizer/zend_optimizer.c b/Zend/Optimizer/zend_optimizer.c
@@ -1096,6 +1096,9 @@ 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);
+		if (opline->opcode == ZEND_FRAMELESS_ICALL_3) {
+			(opline+1)->result_type = IS_UNUSED;
+		}
 		opline++;
 	}
 #if !ZEND_USE_ABS_CONST_ADDR
@@ -1215,6 +1218,10 @@ static void zend_redo_pass_two(zend_op_array *op_array)
 					}
 				}
 				break;
+			case ZEND_FRAMELESS_ICALL_3:
+				(opline+1)->result.var = opline->result.var;
+				(opline+1)->result_type = opline->result_type;
+				break;
 		}
 		ZEND_VM_SET_OPCODE_HANDLER(opline);
 		opline++;
@@ -1337,6 +1344,10 @@ static void zend_redo_pass_two_ex(zend_op_array *op_array, zend_ssa *ssa)
 					}
 				}
 				break;
+			case ZEND_FRAMELESS_ICALL_3:
+				(opline+1)->result.var = opline->result.var;
+				(opline+1)->result_type = opline->result_type;
+				break;
 		}
 #ifdef ZEND_VERIFY_TYPE_INFERENCE
 		if (ssa_op->op1_use >= 0) {
diff --git a/Zend/Optimizer/zend_ssa.c b/Zend/Optimizer/zend_ssa.c
@@ -782,14 +782,12 @@ static zend_always_inline int _zend_ssa_rename_op(const zend_op_array *op_array,
 				//NEW_SSA_VAR(opline->op2.var)
 			}
 			if (opline->opcode == ZEND_FRAMELESS_ICALL_3) {
-				// Result is on following OP_DATA
-				next = ++opline;
-				++k;
+				next = opline + 1;
 				if (next->op1_type & (IS_CV|IS_VAR|IS_TMP_VAR)) {
-					ssa_ops[k].op1_use = var[EX_VAR_TO_NUM(next->op1.var)];
+					ssa_ops[k + 1].op1_use = var[EX_VAR_TO_NUM(next->op1.var)];
 					//USE_SSA_VAR(op_array->last_var + next->op1.var);
 					if ((build_flags & ZEND_SSA_RC_INFERENCE) && next->op1_type == IS_CV) {
-						ssa_ops[k].op1_def = ssa_vars_count;
+						ssa_ops[k + 1].op1_def = ssa_vars_count;
 						var[EX_VAR_TO_NUM(next->op1.var)] = ssa_vars_count;
 						ssa_vars_count++;
 						//NEW_SSA_VAR(next->op1.var)
diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
@@ -4608,12 +4608,7 @@ static uint32_t zend_compile_frameless_icall_ex(znode *result, zend_ast_list *ar
 		SET_NODE(opline->op2, &arg_zvs[1]);
 	}
 	if (num_args >= 3) {
-		// Put result znode on OP_DATA to ensure dispatch in observer fallback can be aligned with the last opcode of the call
-		zend_op *op_data = zend_emit_op_data(&arg_zvs[2]);
-		op_data->result = opline->result;
-		op_data->result_type = opline->result_type;
-		opline->result_type = IS_UNUSED;
-		++opnum;
+		zend_emit_op_data(&arg_zvs[2]);
 	}
 	return opnum;
 }
diff --git a/Zend/zend_opcode.c b/Zend/zend_opcode.c
@@ -1122,6 +1122,11 @@ ZEND_API void pass_two(zend_op_array *op_array)
 			case ZEND_JMP_FRAMELESS:
 				ZEND_PASS_TWO_UPDATE_JMP_TARGET(op_array, opline, opline->op2);
 				break;
+			case ZEND_FRAMELESS_ICALL_3:
+				// Copy result to OP_DATA to ensure dispatch in observer fallback can be aligned with the last opcode of the call
+				opline[1].result.var = opline->result.var;
+				opline[1].result_type = opline->result_type;
+				break;
 			case ZEND_ASSERT_CHECK:
 			{
 				/* If result of assert is unused, result of check is unused as well */
diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
@@ -9676,7 +9676,7 @@ ZEND_VM_HANDLER(207, ZEND_FRAMELESS_ICALL_3, ANY, ANY, SPEC(OBSERVER))
 	USE_OPLINE
 	SAVE_OPLINE();
 	zend_frameless_function_3 function = (zend_frameless_function_3)ZEND_FLF_HANDLER(opline);
-	zval *result = EX_VAR(opline[1].result.var);
+	zval *result = EX_VAR(opline->result.var);
 	ZVAL_NULL(result);
 	zval *arg1 = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
 	zval *arg2 = GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R);
diff --git a/ext/opcache/jit/zend_jit_internal.h b/ext/opcache/jit/zend_jit_internal.h
@@ -90,8 +90,6 @@ typedef uintptr_t zend_jit_addr;
 	OP_ADDR(opline, result_type, result)
 #define OP1_DATA_ADDR() \
 	OP_ADDR(opline + 1, op1_type, op1)
-#define RES_DATA_ADDR() \
-	OP_ADDR(opline + 1, result_type, result)
 
 #define OP1_REG_ADDR() \
 	OP_REG_ADDR(opline, op1_type, op1, op1_use)
diff --git a/ext/opcache/jit/zend_jit_ir.c b/ext/opcache/jit/zend_jit_ir.c
@@ -16886,7 +16886,7 @@ static void jit_frameless_icall3(zend_jit_ctx *jit, int checked_stack, const zen
 
 	void *function = ZEND_FLF_HANDLER(opline);
 	uint8_t op_data_type = (opline + 1)->op1_type;
-	zend_jit_addr res_addr = RES_DATA_ADDR();
+	zend_jit_addr res_addr = RES_ADDR();
 	zend_jit_addr op1_addr = OP1_ADDR();
 	zend_jit_addr op2_addr = OP2_ADDR();
 	zend_jit_addr op3_addr = OP1_DATA_ADDR();
diff --git a/ext/opcache/tests/opt/inference_frameless.phpt b/ext/opcache/tests/opt/inference_frameless.phpt
@@ -25,6 +25,6 @@ _strpos:
      ; (after optimizer)
      ; %sinference_frameless.php:2-4
 0000 CV0($str) = RECV 1
-0001 FRAMELESS_ICALL_3(strpos) CV0($str) string("o")
+0001 T1 = FRAMELESS_ICALL_3(strpos) CV0($str) string("o")
 0002 T1 = OP_DATA int(1)
 0003 RETURN T1

Original file line number	Diff line number	Diff line change
`@@ -2139,10 +2139,6 @@ static int try_remove_definition(sccp_ctx ctx, int var_num, zend_ssa_var var,`
`2139`	`2139`	`}`
`2140`	`2140`	`return 0;`
`2141`	`2141`	`}`
`2142`		`- if (opline->opcode == ZEND_OP_DATA) {`
`2143`		`- /* Consider the primary opline for matching */`
`2144`		`- --opline;`
`2145`		`- }`
`2146`	`2142`	`if (ssa_op->op1_def >= 0 \|\| ssa_op->op2_def >= 0) {`
`2147`	`2143`	`if (var->use_chain < 0 && var->phi_use_chain == NULL) {`
`2148`	`2144`	`switch (opline->opcode) {`
`@@ -2213,8 +2209,6 @@ static int try_remove_definition(sccp_ctx ctx, int var_num, zend_ssa_var var,`
`2213`	`2209`	`zend_ssa_remove_instr(ssa, opline, ssa_op);`
`2214`	`2210`	`removed_ops++;`
`2215`	`2211`	`if (has_op_data) {`
`2216`		`- old_type = opline[1].result_type;`
`2217`		`- old_var = opline[1].result.var;`
`2218`	`2212`	`zend_ssa_remove_instr(ssa, opline + 1, ssa_op + 1);`
`2219`	`2213`	`removed_ops++;`
`2220`	`2214`	`}`
Original file line number	Diff line number	Diff line change
`@@ -130,9 +130,6 @@ static zend_always_inline void _zend_dfg_add_use_def_op(const zend_op_array *op_`
`130`	`130`	`zend_bitset_incl(use, var_num);`
`131`	`131`	`}`
`132`	`132`	`}`
`133`		`- if (opline->opcode == ZEND_FRAMELESS_ICALL_3) {`
`134`		`- ++opline; // OP_DATA has result`
`135`		`- }`
`136`	`133`	`break;`
`137`	`134`	`case ZEND_ASSIGN_DIM_OP:`
`138`	`135`	`case ZEND_ASSIGN_OBJ_OP:`
Original file line number	Diff line number	Diff line change
`@@ -3869,7 +3869,7 @@ static zend_always_inline zend_result _zend_update_type_info(`
`3869`	`3869`	`UPDATE_SSA_TYPE(tmp, ssa_op->op2_def);`
`3870`	`3870`	`}`
`3871`	`3871`	`if (opline->opcode == ZEND_FRAMELESS_ICALL_3) {`
`3872`		`- zend_ssa_op *next_ssa_op = ++ssa_op; // OP_DATA has result op`
	`3872`	`+ zend_ssa_op *next_ssa_op = ssa_op + 1;`
`3873`	`3873`	`if (next_ssa_op->op1_def >= 0) {`
`3874`	`3874`	`ZEND_ASSERT(next_ssa_op->op1_use >= 0);`
`3875`	`3875`	`tmp = ssa->var_info[next_ssa_op->op1_use].type;`
Original file line number	Diff line number	Diff line change
`@@ -1096,6 +1096,9 @@ static void zend_revert_pass_two(zend_op_array *op_array)`
`1096`	`1096`	`}`
`1097`	`1097`	`/* reset smart branch flags IS_SMART_BRANCH_JMP[N]Z */`
`1098`	`1098`	`opline->result_type &= (IS_TMP_VAR\|IS_VAR\|IS_CV\|IS_CONST);`
	`1099`	`+ if (opline->opcode == ZEND_FRAMELESS_ICALL_3) {`
	`1100`	`+ (opline+1)->result_type = IS_UNUSED;`
	`1101`	`+ }`
`1099`	`1102`	`opline++;`
`1100`	`1103`	`}`
`1101`	`1104`	`#if !ZEND_USE_ABS_CONST_ADDR`
`@@ -1215,6 +1218,10 @@ static void zend_redo_pass_two(zend_op_array *op_array)`
`1215`	`1218`	`}`
`1216`	`1219`	`}`
`1217`	`1220`	`break;`
	`1221`	`+ case ZEND_FRAMELESS_ICALL_3:`
	`1222`	`+ (opline+1)->result.var = opline->result.var;`
	`1223`	`+ (opline+1)->result_type = opline->result_type;`
	`1224`	`+ break;`
`1218`	`1225`	`}`
`1219`	`1226`	`ZEND_VM_SET_OPCODE_HANDLER(opline);`
`1220`	`1227`	`opline++;`
`@@ -1337,6 +1344,10 @@ static void zend_redo_pass_two_ex(zend_op_array op_array, zend_ssa ssa)`
`1337`	`1344`	`}`
`1338`	`1345`	`}`
`1339`	`1346`	`break;`
	`1347`	`+ case ZEND_FRAMELESS_ICALL_3:`
	`1348`	`+ (opline+1)->result.var = opline->result.var;`
	`1349`	`+ (opline+1)->result_type = opline->result_type;`
	`1350`	`+ break;`
`1340`	`1351`	`}`
`1341`	`1352`	`#ifdef ZEND_VERIFY_TYPE_INFERENCE`
`1342`	`1353`	`if (ssa_op->op1_use >= 0) {`
Original file line number	Diff line number	Diff line change
`@@ -4608,12 +4608,7 @@ static uint32_t zend_compile_frameless_icall_ex(znode result, zend_ast_list ar`
`4608`	`4608`	`SET_NODE(opline->op2, &arg_zvs[1]);`
`4609`	`4609`	`}`
`4610`	`4610`	`if (num_args >= 3) {`
`4611`		`- // Put result znode on OP_DATA to ensure dispatch in observer fallback can be aligned with the last opcode of the call`
`4612`		`- zend_op *op_data = zend_emit_op_data(&arg_zvs[2]);`
`4613`		`- op_data->result = opline->result;`
`4614`		`- op_data->result_type = opline->result_type;`
`4615`		`- opline->result_type = IS_UNUSED;`
`4616`		`- ++opnum;`
	`4611`	`+ zend_emit_op_data(&arg_zvs[2]);`
`4617`	`4612`	`}`
`4618`	`4613`	`return opnum;`
`4619`	`4614`	`}`