From 37bdb2b7921f8c461f179fb651f66d825f2b2b34 Mon Sep 17 00:00:00 2001 From: Caius-Moldovan-img Date: Tue, 24 Mar 2026 14:52:49 +0200 Subject: [PATCH] pco: Move part of legalization after register allocation Signed-off-by: Caius Moldovan Reviewed-by: Simon Perretta Part-of: --- src/imagination/pco/pco_internal.h | 2 +- src/imagination/pco/pco_ir.c | 2 +- src/imagination/pco/pco_legalize.c | 42 ++++++++++++++---------------- 3 files changed, 22 insertions(+), 24 deletions(-) diff --git a/src/imagination/pco/pco_internal.h b/src/imagination/pco/pco_internal.h index 874a8236cd1..59fbc595b25 100644 --- a/src/imagination/pco/pco_internal.h +++ b/src/imagination/pco/pco_internal.h @@ -1782,10 +1782,10 @@ bool pco_bool(pco_shader *shader); bool pco_cf(pco_shader *shader); bool pco_dce(pco_shader *shader); bool pco_post_ra_legalize(pco_shader *shader); +bool pco_pre_ra_legalize(pco_shader *shader); bool pco_end(pco_shader *shader); bool pco_group_instrs(pco_shader *shader); bool pco_index(pco_shader *shader, bool skip_ssa); -bool pco_legalize(pco_shader *shader); bool pco_opt_comp_only_vecs(pco_shader *shader); bool pco_nir_compute_instance_check(nir_shader *shader); bool pco_nir_link_clip_cull_vars(nir_shader *producer, nir_shader *consumer); diff --git a/src/imagination/pco/pco_ir.c b/src/imagination/pco/pco_ir.c index 7660cfe5224..defcd0d4353 100644 --- a/src/imagination/pco/pco_ir.c +++ b/src/imagination/pco/pco_ir.c @@ -53,7 +53,7 @@ void pco_process_ir(pco_ctx *ctx, pco_shader *shader) * time a drc result is used. */ PCO_PASS(_, shader, pco_schedule); - PCO_PASS(_, shader, pco_legalize); + PCO_PASS(_, shader, pco_pre_ra_legalize); PCO_PASS(_, shader, pco_ra); PCO_PASS(_, shader, pco_post_ra_legalize); PCO_PASS(_, shader, pco_end); diff --git a/src/imagination/pco/pco_legalize.c b/src/imagination/pco/pco_legalize.c index be64a3d5706..a9bc08d4969 100644 --- a/src/imagination/pco/pco_legalize.c +++ b/src/imagination/pco/pco_legalize.c @@ -163,9 +163,6 @@ static inline bool xfer_op_mods(pco_instr *dest, pco_instr *src) */ static bool legalize_fence(pco_instr *instr) { - if (instr->op != PCO_OP_FENCE) - return false; - pco_builder b = pco_builder_create(instr->parent_func, pco_cursor_before_instr(instr)); @@ -181,6 +178,9 @@ static bool legalize_fence(pco_instr *instr) static bool legalize_pseudo(pco_instr *instr) { switch (instr->op) { + case PCO_OP_FENCE: + return legalize_fence(instr); + case PCO_OP_MOV: if (pco_ref_is_reg(instr->src[0]) && pco_ref_get_reg_class(instr->src[0]) == PCO_REG_CLASS_SPEC) @@ -452,43 +452,35 @@ static bool try_legalize(pco_instr *instr) bool progress = false; progress |= try_legalize_large_hwreg_offsets(instr, info); - - /* Skip pseudo instructions. */ - if (info->type == PCO_OP_TYPE_PSEUDO) { - progress |= legalize_pseudo(instr); - } else { - progress |= try_legalize_src_mappings(instr, info); - } + progress |= try_legalize_ditr_fence(instr); return progress; } /** * \brief Legalizes instructions where additional restrictions apply. + * This should be run after register allocation. * * \param[in,out] shader PCO shader. * \return True if the pass made progress. */ -bool pco_legalize(pco_shader *shader) +bool pco_pre_ra_legalize(pco_shader *shader) { bool progress = false; assert(!shader->is_grouped); assert(!shader->is_legalized); - pco_foreach_func_in_shader (func, shader) { - pco_foreach_instr_in_func_safe (instr, func) { - progress |= try_legalize(instr); - } - } + const struct pco_op_info *info; pco_foreach_func_in_shader (func, shader) { pco_foreach_instr_in_func_safe (instr, func) { - progress |= legalize_fence(instr); + info = &pco_op_info[instr->op]; + if (info->type != PCO_OP_TYPE_PSEUDO) + progress |= try_legalize_src_mappings(instr, info); } } - shader->is_legalized = true; return progress; } @@ -500,20 +492,26 @@ bool pco_legalize(pco_shader *shader) */ bool pco_post_ra_legalize(pco_shader *shader) { + assert(!shader->is_grouped); + bool progress = false; - assert(!shader->is_grouped); - pco_foreach_func_in_shader (func, shader) { pco_foreach_instr_in_func_safe (instr, func) { - progress |= try_legalize_ditr_fence(instr); + progress |= try_legalize(instr); } } + const struct pco_op_info *info; + pco_foreach_func_in_shader (func, shader) { pco_foreach_instr_in_func_safe (instr, func) { - progress |= legalize_fence(instr); + info = &pco_op_info[instr->op]; + if (info->type == PCO_OP_TYPE_PSEUDO) + progress |= legalize_pseudo(instr); } } + + shader->is_legalized = true; return progress; }