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
40using 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 */
65static int
66count_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 */
124bool
125fs_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