Merge branch 'PHP-8.4'

dstogov · dstogov · commit 6a015491a043 · 2024-12-19T20:30:05.000+03:00
* PHP-8.4:
  Update IR
diff --git a/ext/opcache/jit/ir/ir.c b/ext/opcache/jit/ir/ir.c
@@ -330,6 +330,7 @@ static ir_ref ir_next_const(ir_ctx *ctx)
 
 static void ir_grow_top(ir_ctx *ctx)
 {
+	ir_ref old_insns_limit = ctx->insns_limit;
 	ir_insn *buf = ctx->ir_base - ctx->consts_limit;
 
 	if (ctx->insns_limit < 1024 * 4) {
@@ -341,6 +342,12 @@ static void ir_grow_top(ir_ctx *ctx)
 	}
 	buf = ir_mem_realloc(buf, (ctx->consts_limit + ctx->insns_limit) * sizeof(ir_insn));
 	ctx->ir_base = buf + ctx->consts_limit;
+
+	if (ctx->use_lists) {
+		ctx->use_lists = ir_mem_realloc(ctx->use_lists, ctx->insns_limit * sizeof(ir_use_list));
+		memset(ctx->use_lists + old_insns_limit, 0,
+			(ctx->insns_limit - old_insns_limit) * sizeof(ir_use_list));
+	}
 }
 
 static ir_ref ir_next_insn(ir_ctx *ctx)
@@ -1152,7 +1159,7 @@ void ir_build_def_use_lists(ir_ctx *ctx)
 	ir_ref n, i, j, *p, def;
 	ir_insn *insn;
 	uint32_t edges_count;
-	ir_use_list *lists = ir_mem_calloc(ctx->insns_count, sizeof(ir_use_list));
+	ir_use_list *lists = ir_mem_calloc(ctx->insns_limit, sizeof(ir_use_list));
 	ir_ref *edges;
 	ir_use_list *use_list;
 
@@ -1207,7 +1214,7 @@ void ir_build_def_use_lists(ir_ctx *ctx)
 	ir_ref n, i, j, *p, def;
 	ir_insn *insn;
 	size_t linked_lists_size, linked_lists_top = 0, edges_count = 0;
-	ir_use_list *lists = ir_mem_calloc(ctx->insns_count, sizeof(ir_use_list));
+	ir_use_list *lists = ir_mem_calloc(ctx->insns_limit, sizeof(ir_use_list));
 	ir_ref *edges;
 	ir_use_list *use_list;
 	ir_ref *linked_lists;
diff --git a/ext/opcache/jit/ir/ir.h b/ext/opcache/jit/ir/ir.h
@@ -528,11 +528,12 @@ void ir_strtab_free(ir_strtab *strtab);
 #define IR_OPT_INLINE          (1<<16)
 #define IR_OPT_FOLDING         (1<<17)
 #define IR_OPT_CFG             (1<<18) /* merge BBs, by remove END->BEGIN nodes during CFG construction */
-#define IR_OPT_CODEGEN         (1<<19)
-#define IR_GEN_NATIVE          (1<<20)
-#define IR_GEN_CODE            (1<<21) /* C or LLVM */
+#define IR_OPT_MEM2SSA         (1<<19)
+#define IR_OPT_CODEGEN         (1<<20)
+#define IR_GEN_NATIVE          (1<<21)
+#define IR_GEN_CODE            (1<<22) /* C or LLVM */
 
-#define IR_GEN_CACHE_DEMOTE    (1<<22) /* Demote the generated code from closest CPU caches */
+#define IR_GEN_CACHE_DEMOTE    (1<<23) /* Demote the generated code from closest CPU caches */
 
 /* debug related */
 #ifdef IR_DEBUG
@@ -751,13 +752,15 @@ ir_ref ir_binding_find(const ir_ctx *ctx, ir_ref ref);
 /* Def -> Use lists */
 void ir_build_def_use_lists(ir_ctx *ctx);
 
+/* SSA Construction */
+int ir_mem2ssa(ir_ctx *ctx);
+
 /* CFG - Control Flow Graph (implementation in ir_cfg.c) */
 int ir_build_cfg(ir_ctx *ctx);
-int ir_remove_unreachable_blocks(ir_ctx *ctx);
 int ir_build_dominators_tree(ir_ctx *ctx);
 int ir_find_loops(ir_ctx *ctx);
 int ir_schedule_blocks(ir_ctx *ctx);
-void ir_build_prev_refs(ir_ctx *ctx);
+void ir_reset_cfg(ir_ctx *ctx);
 
 /* SCCP - Sparse Conditional Constant Propagation (implementation in ir_sccp.c) */
 int ir_sccp(ir_ctx *ctx);
@@ -929,7 +932,7 @@ IR_ALWAYS_INLINE void *ir_jit_compile(ir_ctx *ctx, int opt_level, size_t *size)
 		}
 
 		return ir_emit_code(ctx, size);
-	} else if (opt_level == 1 || opt_level == 2) {
+	} else if (opt_level > 0) {
 		if (!(ctx->flags & IR_OPT_FOLDING)) {
 			// IR_ASSERT(0 && "IR_OPT_FOLDING must be set in ir_init() for -O1 and -O2");
 			return NULL;
@@ -938,14 +941,29 @@ IR_ALWAYS_INLINE void *ir_jit_compile(ir_ctx *ctx, int opt_level, size_t *size)
 
 		ir_build_def_use_lists(ctx);
 
-		if (opt_level == 2
-		 && !ir_sccp(ctx)) {
-			return NULL;
+		if (ctx->flags & IR_OPT_MEM2SSA) {
+			if (!ir_build_cfg(ctx)
+			 || !ir_build_dominators_tree(ctx)
+			 || !ir_mem2ssa(ctx)) {
+				return NULL;
+			}
 		}
 
-		if (!ir_build_cfg(ctx)
-		 || !ir_build_dominators_tree(ctx)
-		 || !ir_find_loops(ctx)
+		if (opt_level > 1) {
+			ir_reset_cfg(ctx);
+			if (!ir_sccp(ctx)) {
+				return NULL;
+			}
+		}
+
+		if (!ctx->cfg_blocks) {
+			if (!ir_build_cfg(ctx)
+			 || !ir_build_dominators_tree(ctx)) {
+				return NULL;
+			}
+		}
+
+		if (!ir_find_loops(ctx)
 		 || !ir_gcm(ctx)
 		 || !ir_schedule(ctx)
 		 || !ir_match(ctx)
diff --git a/ext/opcache/jit/ir/ir_aarch64.dasc b/ext/opcache/jit/ir/ir_aarch64.dasc
@@ -1095,6 +1095,8 @@ binop_fp:
 				}
 			}
 			return IR_SKIPPED | IR_NOP;
+		case IR_NOP:
+			return IR_SKIPPED | IR_NOP;
 		default:
 			break;
 	}
@@ -5603,7 +5605,8 @@ static void ir_allocate_unique_spill_slots(ir_ctx *ctx)
 						} else if (def_flags & IR_USE_MUST_BE_IN_REG) {
 							if (insn->op == IR_VLOAD
 							 && ctx->live_intervals[ctx->vregs[i]]
-							 && ctx->live_intervals[ctx->vregs[i]]->stack_spill_pos != -1) {
+							 && ctx->live_intervals[ctx->vregs[i]]->stack_spill_pos != -1
+							 && ir_is_same_mem_var(ctx, i, ctx->ir_base[insn->op2].op3)) {
 								/* pass */
 							} else if (insn->op != IR_PARAM) {
 								reg = ir_get_free_reg(insn->type, available);
@@ -5704,7 +5707,7 @@ static void ir_allocate_unique_spill_slots(ir_ctx *ctx)
 								if (reg != IR_REG_NONE && IR_REGSET_IN(available, reg)) {
 									IR_REGSET_EXCL(available, reg);
 									ctx->regs[i][j] = reg | IR_REG_SPILL_LOAD;
-								} else if (j > 1 && input == insn->op1 && ctx->regs[i][1] != IR_REG_NONE) {
+								} else if (IR_IS_FOLDABLE_OP(insn->op) && j > 1 && input == insn->op1 && ctx->regs[i][1] != IR_REG_NONE) {
 									ctx->regs[i][j] = ctx->regs[i][1];
 								} else if (use_flags & IR_USE_MUST_BE_IN_REG) {
 									reg = ir_get_free_reg(ctx->ir_base[input].type, available);
diff --git a/ext/opcache/jit/ir/ir_cfg.c b/ext/opcache/jit/ir/ir_cfg.c
@@ -8,6 +8,8 @@
 #include "ir.h"
 #include "ir_private.h"
 
+static int ir_remove_unreachable_blocks(ir_ctx *ctx);
+
 IR_ALWAYS_INLINE void _ir_add_successors(const ir_ctx *ctx, ir_ref ref, ir_worklist *worklist)
 {
 	ir_use_list *use_list = &ctx->use_lists[ref];
@@ -57,6 +59,24 @@ IR_ALWAYS_INLINE void _ir_add_predecessors(const ir_insn *insn, ir_worklist *wor
 	}
 }
 
+void ir_reset_cfg(ir_ctx *ctx)
+{
+	ctx->cfg_blocks_count = 0;
+	ctx->cfg_edges_count = 0;
+	if (ctx->cfg_blocks) {
+		ir_mem_free(ctx->cfg_blocks);
+		ctx->cfg_blocks = NULL;
+		if (ctx->cfg_edges) {
+			ir_mem_free(ctx->cfg_edges);
+			ctx->cfg_edges = NULL;
+		}
+		if (ctx->cfg_map) {
+			ir_mem_free(ctx->cfg_map);
+			ctx->cfg_map = NULL;
+		}
+	}
+}
+
 int ir_build_cfg(ir_ctx *ctx)
 {
 	ir_ref n, *p, ref, start, end;
@@ -330,11 +350,15 @@ static void ir_remove_merge_input(ir_ctx *ctx, ir_ref merge, ir_ref from)
 		}
 	}
 	i--;
+	for (j = i + 1; j <= n; j++) {
+		ir_insn_set_op(insn, j, IR_UNUSED);
+	}
 	if (i == 1) {
 		insn->op = IR_BEGIN;
 		insn->inputs_count = 1;
 		use_list = &ctx->use_lists[merge];
 		if (use_list->count > 1) {
+			n++;
 			for (k = 0, p = &ctx->use_edges[use_list->refs]; k < use_list->count; k++, p++) {
 				use = *p;
 				use_insn = &ctx->ir_base[use];
@@ -347,22 +371,24 @@ static void ir_remove_merge_input(ir_ctx *ctx, ir_ref merge, ir_ref from)
 						if (ir_bitset_in(life_inputs, j - 1)) {
 							use_insn->op1 = ir_insn_op(use_insn, j);
 						} else if (input > 0) {
-							ir_use_list_remove_all(ctx, input, use);
+							ir_use_list_remove_one(ctx, input, use);
 						}
 					}
 					use_insn->op = IR_COPY;
-					use_insn->op2 = IR_UNUSED;
-					use_insn->op3 = IR_UNUSED;
+					use_insn->inputs_count = 1;
+					for (j = 2; j <= n; j++) {
+						ir_insn_set_op(use_insn, j, IR_UNUSED);
+					}
 					ir_use_list_remove_all(ctx, merge, use);
 				}
 			}
 		}
 	} else {
 		insn->inputs_count = i;
 
-		n++;
 		use_list = &ctx->use_lists[merge];
 		if (use_list->count > 1) {
+			n++;
 			for (k = 0, p = &ctx->use_edges[use_list->refs]; k < use_list->count; k++, p++) {
 				use = *p;
 				use_insn = &ctx->ir_base[use];
@@ -378,9 +404,13 @@ static void ir_remove_merge_input(ir_ctx *ctx, ir_ref merge, ir_ref from)
 							}
 							i++;
 						} else if (input > 0) {
-							ir_use_list_remove_all(ctx, input, use);
+							ir_use_list_remove_one(ctx, input, use);
 						}
 					}
+					use_insn->inputs_count = i - 1;
+					for (j = i; j <= n; j++) {
+						ir_insn_set_op(use_insn, j, IR_UNUSED);
+					}
 				}
 			}
 		}
@@ -390,7 +420,7 @@ static void ir_remove_merge_input(ir_ctx *ctx, ir_ref merge, ir_ref from)
 }
 
 /* CFG constructed after SCCP pass doesn't have unreachable BBs, otherwise they should be removed */
-int ir_remove_unreachable_blocks(ir_ctx *ctx)
+static int ir_remove_unreachable_blocks(ir_ctx *ctx)
 {
 	uint32_t b, *p, i;
 	uint32_t unreachable_count = 0;
diff --git a/ext/opcache/jit/ir/ir_check.c b/ext/opcache/jit/ir/ir_check.c
@@ -362,6 +362,10 @@ bool ir_check(const ir_ctx *ctx)
 									break;
 								}
 							}
+							if (count == 0 && (insn->op == IR_END || insn->op == IR_LOOP_END)) {
+								/* Dead block */
+								break;
+							}
 							fprintf(stderr, "ir_base[%d].op (%s) must have 1 successor (%d)\n",
 								i, ir_op_name[insn->op], count);
 							ok = 0;
diff --git a/ext/opcache/jit/ir/ir_gcm.c b/ext/opcache/jit/ir/ir_gcm.c
@@ -356,9 +356,11 @@ static bool ir_split_partially_dead_node(ir_ctx *ctx, ir_ref ref, uint32_t b)
 			}
 		} else {
 			j = i = ctx->cfg_map[use];
-			IR_ASSERT(i > 0);
-			while (ir_sparse_set_in(&data->totally_useful, ctx->cfg_blocks[j].idom)) {
-				j = ctx->cfg_blocks[j].idom;
+			if (i) {
+				IR_ASSERT(i > 0);
+				while (ir_sparse_set_in(&data->totally_useful, ctx->cfg_blocks[j].idom)) {
+					j = ctx->cfg_blocks[j].idom;
+				}
 			}
 			clone = ir_hashtab_find(&hash, j);
 			if (clone == IR_INVALID_VAL) {
@@ -941,8 +943,9 @@ int ir_schedule(ir_ctx *ctx)
 
 				for (p = &ctx->use_edges[use_list->refs]; count > 0; p++, count--) {
 					ir_ref use = *p;
-					if (!_xlat[use]) {
-						ir_insn *use_insn = &ctx->ir_base[use];
+					ir_insn *use_insn = &ctx->ir_base[use];
+					if (!_xlat[use] && (_blocks[use] || use_insn->op == IR_PARAM)) {
+						IR_ASSERT(_blocks[use] == b || use_insn->op == IR_PARAM);
 						if (use_insn->op == IR_PARAM
 						 || use_insn->op == IR_VAR
 						 || use_insn->op == IR_PI
diff --git a/ext/opcache/jit/ir/ir_private.h b/ext/opcache/jit/ir/ir_private.h
@@ -1120,6 +1120,7 @@ struct _ir_block {
 	uint32_t     loop_depth;
 };
 
+void ir_build_prev_refs(ir_ctx *ctx);
 uint32_t ir_skip_empty_target_blocks(const ir_ctx *ctx, uint32_t b);
 uint32_t ir_next_block(const ir_ctx *ctx, uint32_t b);
 void ir_get_true_false_blocks(const ir_ctx *ctx, uint32_t b, uint32_t *true_block, uint32_t *false_block);
diff --git a/ext/opcache/jit/ir/ir_x86.dasc b/ext/opcache/jit/ir/ir_x86.dasc

Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,8 @@`
`8`	`8`	`#include "ir.h"`
`9`	`9`	`#include "ir_private.h"`
`10`	`10`
	`11`	`+static int ir_remove_unreachable_blocks(ir_ctx *ctx);`
	`12`	`+`
`11`	`13`	`IR_ALWAYS_INLINE void _ir_add_successors(const ir_ctx ctx, ir_ref ref, ir_worklist worklist)`
`12`	`14`	`{`
`13`	`15`	`ir_use_list *use_list = &ctx->use_lists[ref];`
`@@ -57,6 +59,24 @@ IR_ALWAYS_INLINE void _ir_add_predecessors(const ir_insn insn, ir_worklist wor`
`57`	`59`	`}`
`58`	`60`	`}`
`59`	`61`
	`62`	`+void ir_reset_cfg(ir_ctx *ctx)`
	`63`	`+{`
	`64`	`+ ctx->cfg_blocks_count = 0;`
	`65`	`+ ctx->cfg_edges_count = 0;`
	`66`	`+ if (ctx->cfg_blocks) {`
	`67`	`+ ir_mem_free(ctx->cfg_blocks);`
	`68`	`+ ctx->cfg_blocks = NULL;`
	`69`	`+ if (ctx->cfg_edges) {`
	`70`	`+ ir_mem_free(ctx->cfg_edges);`
	`71`	`+ ctx->cfg_edges = NULL;`
	`72`	`+ }`
	`73`	`+ if (ctx->cfg_map) {`
	`74`	`+ ir_mem_free(ctx->cfg_map);`
	`75`	`+ ctx->cfg_map = NULL;`
	`76`	`+ }`
	`77`	`+ }`
	`78`	`+}`
	`79`	`+`
`60`	`80`	`int ir_build_cfg(ir_ctx *ctx)`
`61`	`81`	`{`
`62`	`82`	`ir_ref n, *p, ref, start, end;`
`@@ -330,11 +350,15 @@ static void ir_remove_merge_input(ir_ctx *ctx, ir_ref merge, ir_ref from)`
`330`	`350`	`}`
`331`	`351`	`}`
`332`	`352`	`i--;`
	`353`	`+ for (j = i + 1; j <= n; j++) {`
	`354`	`+ ir_insn_set_op(insn, j, IR_UNUSED);`
	`355`	`+ }`
`333`	`356`	`if (i == 1) {`
`334`	`357`	`insn->op = IR_BEGIN;`
`335`	`358`	`insn->inputs_count = 1;`
`336`	`359`	`use_list = &ctx->use_lists[merge];`
`337`	`360`	`if (use_list->count > 1) {`
	`361`	`+ n++;`
`338`	`362`	`for (k = 0, p = &ctx->use_edges[use_list->refs]; k < use_list->count; k++, p++) {`
`339`	`363`	`use = *p;`
`340`	`364`	`use_insn = &ctx->ir_base[use];`
`@@ -347,22 +371,24 @@ static void ir_remove_merge_input(ir_ctx *ctx, ir_ref merge, ir_ref from)`
`347`	`371`	`if (ir_bitset_in(life_inputs, j - 1)) {`
`348`	`372`	`use_insn->op1 = ir_insn_op(use_insn, j);`
`349`	`373`	`} else if (input > 0) {`
`350`		`- ir_use_list_remove_all(ctx, input, use);`
	`374`	`+ ir_use_list_remove_one(ctx, input, use);`
`351`	`375`	`}`
`352`	`376`	`}`
`353`	`377`	`use_insn->op = IR_COPY;`
`354`		`- use_insn->op2 = IR_UNUSED;`
`355`		`- use_insn->op3 = IR_UNUSED;`
	`378`	`+ use_insn->inputs_count = 1;`
	`379`	`+ for (j = 2; j <= n; j++) {`
	`380`	`+ ir_insn_set_op(use_insn, j, IR_UNUSED);`
	`381`	`+ }`
`356`	`382`	`ir_use_list_remove_all(ctx, merge, use);`
`357`	`383`	`}`
`358`	`384`	`}`
`359`	`385`	`}`
`360`	`386`	`} else {`
`361`	`387`	`insn->inputs_count = i;`
`362`	`388`
`363`		`- n++;`
`364`	`389`	`use_list = &ctx->use_lists[merge];`
`365`	`390`	`if (use_list->count > 1) {`
	`391`	`+ n++;`
`366`	`392`	`for (k = 0, p = &ctx->use_edges[use_list->refs]; k < use_list->count; k++, p++) {`
`367`	`393`	`use = *p;`
`368`	`394`	`use_insn = &ctx->ir_base[use];`
`@@ -378,9 +404,13 @@ static void ir_remove_merge_input(ir_ctx *ctx, ir_ref merge, ir_ref from)`
`378`	`404`	`}`
`379`	`405`	`i++;`
`380`	`406`	`} else if (input > 0) {`
`381`		`- ir_use_list_remove_all(ctx, input, use);`
	`407`	`+ ir_use_list_remove_one(ctx, input, use);`
`382`	`408`	`}`
`383`	`409`	`}`
	`410`	`+ use_insn->inputs_count = i - 1;`
	`411`	`+ for (j = i; j <= n; j++) {`
	`412`	`+ ir_insn_set_op(use_insn, j, IR_UNUSED);`
	`413`	`+ }`
`384`	`414`	`}`
`385`	`415`	`}`
`386`	`416`	`}`
`@@ -390,7 +420,7 @@ static void ir_remove_merge_input(ir_ctx *ctx, ir_ref merge, ir_ref from)`
`390`	`420`	`}`
`391`	`421`
`392`	`422`	`/* CFG constructed after SCCP pass doesn't have unreachable BBs, otherwise they should be removed */`
`393`		`-int ir_remove_unreachable_blocks(ir_ctx *ctx)`
	`423`	`+static int ir_remove_unreachable_blocks(ir_ctx *ctx)`
`394`	`424`	`{`
`395`	`425`	`uint32_t b, *p, i;`
`396`	`426`	`uint32_t unreachable_count = 0;`
Original file line number	Diff line number	Diff line change
`@@ -362,6 +362,10 @@ bool ir_check(const ir_ctx *ctx)`
`362`	`362`	`break;`
`363`	`363`	`}`
`364`	`364`	`}`
	`365`	`+ if (count == 0 && (insn->op == IR_END \|\| insn->op == IR_LOOP_END)) {`
	`366`	`+ /* Dead block */`
	`367`	`+ break;`
	`368`	`+ }`
`365`	`369`	`fprintf(stderr, "ir_base[%d].op (%s) must have 1 successor (%d)\n",`
`366`	`370`	`i, ir_op_name[insn->op], count);`
`367`	`371`	`ok = 0;`