| /* |
| * Copyright (C) 2019 Collabora, Ltd. |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the "Software"), |
| * to deal in the Software without restriction, including without limitation |
| * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| * and/or sell copies of the Software, and to permit persons to whom the |
| * Software is furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice (including the next |
| * paragraph) shall be included in all copies or substantial portions of the |
| * Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
| * SOFTWARE. |
| */ |
| |
| /* Midgard has some accelerated support for perspective projection on the |
| * load/store pipes. So the first perspective projection pass looks for |
| * lowered/open-coded perspective projection of the form "fmul (A.xyz, |
| * frcp(A.w))" or "fmul (A.xy, frcp(A.z))" and rewrite with a native |
| * perspective division opcode (on the load/store pipe). Caveats apply: the |
| * frcp should be used only once to make this optimization worthwhile. And the |
| * source of the frcp ought to be a varying to make it worthwhile... |
| * |
| * The second pass in this file is a step #2 of sorts: fusing that load/store |
| * projection into a varying load instruction (they can be done together |
| * implicitly). This depends on the combination pass. Again caveat: the vary |
| * should only be used once to make this worthwhile. |
| */ |
| |
| #include "compiler.h" |
| |
| static bool |
| is_swizzle_0(unsigned *swizzle) |
| { |
| for (unsigned c = 0; c < MIR_VEC_COMPONENTS; ++c) |
| if (swizzle[c]) |
| return false; |
| |
| return true; |
| } |
| |
| bool |
| midgard_opt_combine_projection(compiler_context *ctx, midgard_block *block) |
| { |
| bool progress = false; |
| |
| mir_foreach_instr_in_block_safe(block, ins) { |
| /* First search for fmul */ |
| if (ins->type != TAG_ALU_4) continue; |
| if (ins->op != midgard_alu_op_fmul) continue; |
| |
| /* TODO: Flip */ |
| |
| /* Check the swizzles */ |
| |
| if (!mir_is_simple_swizzle(ins->swizzle[0], ins->mask)) continue; |
| if (!is_swizzle_0(ins->swizzle[1])) continue; |
| |
| /* Awesome, we're the right form. Now check where src2 is from */ |
| unsigned frcp = ins->src[1]; |
| unsigned to = ins->dest; |
| |
| if (frcp & PAN_IS_REG) continue; |
| if (to & PAN_IS_REG) continue; |
| |
| bool frcp_found = false; |
| unsigned frcp_component = 0; |
| unsigned frcp_from = 0; |
| |
| mir_foreach_instr_in_block_safe(block, sub) { |
| if (sub->dest != frcp) continue; |
| |
| frcp_component = sub->swizzle[0][0]; |
| frcp_from = sub->src[0]; |
| |
| frcp_found = |
| (sub->type == TAG_ALU_4) && |
| (sub->op == midgard_alu_op_frcp); |
| break; |
| } |
| |
| if (!frcp_found) continue; |
| if (frcp_from != ins->src[0]) continue; |
| if (frcp_component != COMPONENT_W && frcp_component != COMPONENT_Z) continue; |
| if (!mir_single_use(ctx, frcp)) continue; |
| |
| /* Heuristic: check if the frcp is from a single-use varying */ |
| |
| bool ok = false; |
| |
| /* One for frcp and one for fmul */ |
| if (mir_use_count(ctx, frcp_from) > 2) continue; |
| |
| mir_foreach_instr_in_block_safe(block, v) { |
| if (v->dest != frcp_from) continue; |
| if (v->type != TAG_LOAD_STORE_4) break; |
| if (!OP_IS_LOAD_VARY_F(v->op)) break; |
| |
| ok = true; |
| break; |
| } |
| |
| if (!ok) |
| continue; |
| |
| /* Nice, we got the form spot on. Let's convert! */ |
| |
| midgard_instruction accel = { |
| .type = TAG_LOAD_STORE_4, |
| .mask = ins->mask, |
| .dest = to, |
| .dest_type = nir_type_float32, |
| .src = { frcp_from, ~0, ~0, ~0 }, |
| .src_types = { nir_type_float32 }, |
| .swizzle = SWIZZLE_IDENTITY_4, |
| .op = frcp_component == COMPONENT_W ? |
| midgard_op_ldst_perspective_div_w : |
| midgard_op_ldst_perspective_div_z, |
| .load_store = { |
| .bitsize_toggle = true, |
| } |
| }; |
| |
| mir_insert_instruction_before(ctx, ins, accel); |
| mir_remove_instruction(ins); |
| |
| progress |= true; |
| } |
| |
| return progress; |
| } |
| |
| bool |
| midgard_opt_varying_projection(compiler_context *ctx, midgard_block *block) |
| { |
| bool progress = false; |
| |
| mir_foreach_instr_in_block_safe(block, ins) { |
| /* Search for a projection */ |
| if (ins->type != TAG_LOAD_STORE_4) continue; |
| if (!OP_IS_PROJECTION(ins->op)) continue; |
| |
| unsigned vary = ins->src[0]; |
| unsigned to = ins->dest; |
| |
| if (vary & PAN_IS_REG) continue; |
| if (to & PAN_IS_REG) continue; |
| if (!mir_single_use(ctx, vary)) continue; |
| |
| /* Check for a varying source. If we find it, we rewrite */ |
| |
| bool rewritten = false; |
| |
| mir_foreach_instr_in_block_safe(block, v) { |
| if (v->dest != vary) continue; |
| if (v->type != TAG_LOAD_STORE_4) break; |
| if (!OP_IS_LOAD_VARY_F(v->op)) break; |
| |
| /* We found it, so rewrite it to project. Grab the |
| * modifier */ |
| |
| midgard_varying_params p = |
| midgard_unpack_varying_params(v->load_store); |
| |
| if (p.modifier != midgard_varying_mod_none) |
| break; |
| |
| bool projects_w = |
| ins->op == midgard_op_ldst_perspective_div_w; |
| |
| p.modifier = projects_w ? |
| midgard_varying_mod_perspective_w : |
| midgard_varying_mod_perspective_z; |
| |
| midgard_pack_varying_params(&v->load_store, p); |
| |
| /* Use the new destination */ |
| v->dest = to; |
| |
| rewritten = true; |
| break; |
| } |
| |
| if (rewritten) |
| mir_remove_instruction(ins); |
| |
| progress |= rewritten; |
| } |
| |
| return progress; |
| } |
