1 /* 2 * Copyright 2013 Intel Corporation 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice (including the next 12 * paragraph) shall be included in all copies or substantial portions of the 13 * Software. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 21 * IN THE SOFTWARE. 22 */ 23 24 #include "brw_fs.h" 25 #include "brw_cfg.h" 26 27 /** @file brw_fs_sel_peephole.cpp 28 * 29 * This file contains the opt_peephole_sel() optimization pass that replaces 30 * MOV instructions to the same destination in the "then" and "else" bodies of 31 * an if statement with SEL instructions. 32 */ 33 34 /* Four MOVs seems to be pretty typical, so I picked the next power of two in 35 * the hopes that it would handle almost anything possible in a single 36 * pass. 37 */ 38 #define MAX_MOVS 8 /**< The maximum number of MOVs to attempt to match. */ 39 40 using namespace brw; 41 42 /** 43 * Scans forwards from an IF counting consecutive MOV instructions in the 44 * "then" and "else" blocks of the if statement. 45 * 46 * A pointer to the bblock_t following the IF is passed as the <then_block> 47 * argument. The function stores pointers to the MOV instructions in the 48 * <then_mov> and <else_mov> arrays. 49 * 50 * \return the minimum number of MOVs found in the two branches or zero if 51 * an error occurred. 52 * 53 * E.g.: 54 * IF ... 55 * then_mov[0] = MOV g4, ... 56 * then_mov[1] = MOV g5, ... 57 * then_mov[2] = MOV g6, ... 58 * ELSE ... 59 * else_mov[0] = MOV g4, ... 60 * else_mov[1] = MOV g5, ... 61 * else_mov[2] = MOV g7, ... 62 * ENDIF 63 * returns 3. 64 */ 65 static int 66 count_movs_from_if(fs_inst *then_mov[MAX_MOVS], fs_inst *else_mov[MAX_MOVS], 67 bblock_t *then_block, bblock_t *else_block) 68 { 69 int then_movs = 0; 70 foreach_inst_in_block(fs_inst, inst, then_block) { 71 if (then_movs == MAX_MOVS || inst->opcode != BRW_OPCODE_MOV) 72 break; 73 74 then_mov[then_movs] = inst; 75 then_movs++; 76 } 77 78 int else_movs = 0; 79 foreach_inst_in_block(fs_inst, inst, else_block) { 80 if (else_movs == MAX_MOVS || inst->opcode != BRW_OPCODE_MOV) 81 break; 82 83 else_mov[else_movs] = inst; 84 else_movs++; 85 } 86 87 return MIN2(then_movs, else_movs); 88 } 89 90 /** 91 * Try to replace IF/MOV+/ELSE/MOV+/ENDIF with SEL. 92 * 93 * Many GLSL shaders contain the following pattern: 94 * 95 * x = condition ? foo : bar 96 * 97 * or 98 * 99 * if (...) a.xyzw = foo.xyzw; 100 * else a.xyzw = bar.xyzw; 101 * 102 * The compiler emits an ir_if tree for this, since each subexpression might be 103 * a complex tree that could have side-effects or short-circuit logic. 104 * 105 * However, the common case is to simply select one of two constants or 106 * variable values---which is exactly what SEL is for. In this case, the 107 * assembly looks like: 108 * 109 * (+f0) IF 110 * MOV dst src0 111 * ... 112 * ELSE 113 * MOV dst src1 114 * ... 115 * ENDIF 116 * 117 * where each pair of MOVs to a common destination and can be easily translated 118 * into 119 * 120 * (+f0) SEL dst src0 src1 121 * 122 * If src0 is an immediate value, we promote it to a temporary GRF. 123 */ 124 bool 125 fs_visitor::opt_peephole_sel() 126 { 127 bool progress = false; 128 129 foreach_block (block, cfg) { 130 /* IF instructions, by definition, can only be found at the ends of 131 * basic blocks. 132 */ 133 fs_inst *if_inst = (fs_inst *)block->end(); 134 if (if_inst->opcode != BRW_OPCODE_IF) 135 continue; 136 137 fs_inst *else_mov[MAX_MOVS] = { NULL }; 138 fs_inst *then_mov[MAX_MOVS] = { NULL }; 139 140 bblock_t *then_block = block->next(); 141 bblock_t *else_block = NULL; 142 foreach_list_typed(bblock_link, child, link, &block->children) { 143 if (child->block != then_block) { 144 if (child->block->prev()->end()->opcode == BRW_OPCODE_ELSE) { 145 else_block = child->block; 146 } 147 break; 148 } 149 } 150 if (else_block == NULL) 151 continue; 152 153 int movs = count_movs_from_if(then_mov, else_mov, then_block, else_block); 154 155 if (movs == 0) 156 continue; 157 158 /* Generate SEL instructions for pairs of MOVs to a common destination. */ 159 for (int i = 0; i < movs; i++) { 160 if (!then_mov[i] || !else_mov[i]) 161 break; 162 163 /* Check that the MOVs are the right form. */ 164 if (!then_mov[i]->dst.equals(else_mov[i]->dst) || 165 then_mov[i]->exec_size != else_mov[i]->exec_size || 166 then_mov[i]->group != else_mov[i]->group || 167 then_mov[i]->force_writemask_all != else_mov[i]->force_writemask_all || 168 then_mov[i]->dst.type != then_mov[i]->src[0].type || 169 else_mov[i]->dst.type != else_mov[i]->src[0].type || 170 then_mov[i]->is_partial_write() || 171 else_mov[i]->is_partial_write() || 172 then_mov[i]->conditional_mod != BRW_CONDITIONAL_NONE || 173 else_mov[i]->conditional_mod != BRW_CONDITIONAL_NONE) { 174 movs = i; 175 break; 176 } 177 178 /* Check that source types for mov operations match. */ 179 if (then_mov[i]->src[0].type != else_mov[i]->src[0].type) { 180 movs = i; 181 break; 182 } 183 } 184 185 if (movs == 0) 186 continue; 187 188 for (int i = 0; i < movs; i++) { 189 const fs_builder ibld = fs_builder(this, then_block, then_mov[i]) 190 .at(block, if_inst); 191 192 if (then_mov[i]->src[0].equals(else_mov[i]->src[0])) { 193 ibld.MOV(then_mov[i]->dst, then_mov[i]->src[0]); 194 } else { 195 /* Only the last source register can be a constant, so if the MOV 196 * in the "then" clause uses a constant, we need to put it in a 197 * temporary. 198 */ 199 fs_reg src0(then_mov[i]->src[0]); 200 if (src0.file == IMM) { 201 src0 = vgrf(glsl_type::float_type); 202 src0.type = then_mov[i]->src[0].type; 203 ibld.MOV(src0, then_mov[i]->src[0]); 204 } 205 206 set_predicate_inv(if_inst->predicate, if_inst->predicate_inverse, 207 ibld.SEL(then_mov[i]->dst, src0, 208 else_mov[i]->src[0])); 209 } 210 211 then_mov[i]->remove(then_block); 212 else_mov[i]->remove(else_block); 213 } 214 215 progress = true; 216 } 217 218 if (progress) 219 invalidate_live_intervals(); 220 221 return progress; 222 } 223
