2 * Copyright © 2013 Intel Corporation
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:
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
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
27 /** @file brw_fs_sel_peephole.cpp
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.
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
38 #define MAX_MOVS 8 /**< The maximum number of MOVs to attempt to match. */
43 * Scans forwards from an IF counting consecutive MOV instructions in the
44 * "then" and "else" blocks of the if statement.
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.
50 * \return the minimum number of MOVs found in the two branches or zero if
55 * then_mov[0] = MOV g4, ...
56 * then_mov[1] = MOV g5, ...
57 * then_mov[2] = MOV g6, ...
59 * else_mov[0] = MOV g4, ...
60 * else_mov[1] = MOV g5, ...
61 * else_mov[2] = MOV g7, ...
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
)
70 foreach_inst_in_block(fs_inst
, inst
, then_block
) {
71 if (then_movs
== MAX_MOVS
|| inst
->opcode
!= BRW_OPCODE_MOV
||
72 inst
->flags_written())
75 then_mov
[then_movs
] = inst
;
80 foreach_inst_in_block(fs_inst
, inst
, else_block
) {
81 if (else_movs
== MAX_MOVS
|| inst
->opcode
!= BRW_OPCODE_MOV
||
82 inst
->flags_written())
85 else_mov
[else_movs
] = inst
;
89 return MIN2(then_movs
, else_movs
);
93 * Try to replace IF/MOV+/ELSE/MOV+/ENDIF with SEL.
95 * Many GLSL shaders contain the following pattern:
97 * x = condition ? foo : bar
101 * if (...) a.xyzw = foo.xyzw;
102 * else a.xyzw = bar.xyzw;
104 * The compiler emits an ir_if tree for this, since each subexpression might be
105 * a complex tree that could have side-effects or short-circuit logic.
107 * However, the common case is to simply select one of two constants or
108 * variable values---which is exactly what SEL is for. In this case, the
109 * assembly looks like:
119 * where each pair of MOVs to a common destination and can be easily translated
122 * (+f0) SEL dst src0 src1
124 * If src0 is an immediate value, we promote it to a temporary GRF.
127 fs_visitor::opt_peephole_sel()
129 bool progress
= false;
131 foreach_block (block
, cfg
) {
132 /* IF instructions, by definition, can only be found at the ends of
135 fs_inst
*if_inst
= (fs_inst
*)block
->end();
136 if (if_inst
->opcode
!= BRW_OPCODE_IF
)
139 fs_inst
*else_mov
[MAX_MOVS
] = { NULL
};
140 fs_inst
*then_mov
[MAX_MOVS
] = { NULL
};
142 bblock_t
*then_block
= block
->next();
143 bblock_t
*else_block
= NULL
;
144 foreach_list_typed(bblock_link
, child
, link
, &block
->children
) {
145 if (child
->block
!= then_block
) {
146 if (child
->block
->prev()->end()->opcode
== BRW_OPCODE_ELSE
) {
147 else_block
= child
->block
;
152 if (else_block
== NULL
)
155 int movs
= count_movs_from_if(then_mov
, else_mov
, then_block
, else_block
);
160 /* Generate SEL instructions for pairs of MOVs to a common destination. */
161 for (int i
= 0; i
< movs
; i
++) {
162 if (!then_mov
[i
] || !else_mov
[i
])
165 /* Check that the MOVs are the right form. */
166 if (!then_mov
[i
]->dst
.equals(else_mov
[i
]->dst
) ||
167 then_mov
[i
]->exec_size
!= else_mov
[i
]->exec_size
||
168 then_mov
[i
]->group
!= else_mov
[i
]->group
||
169 then_mov
[i
]->force_writemask_all
!= else_mov
[i
]->force_writemask_all
||
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
) {
178 /* Check that source types for mov operations match. */
179 if (then_mov
[i
]->src
[0].type
!= else_mov
[i
]->src
[0].type
) {
188 for (int i
= 0; i
< movs
; i
++) {
189 const fs_builder ibld
= fs_builder(this, then_block
, then_mov
[i
])
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]);
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
199 fs_reg
src0(then_mov
[i
]->src
[0]);
200 if (src0
.file
== IMM
) {
201 src0
= ibld
.vgrf(then_mov
[i
]->src
[0].type
);
202 ibld
.MOV(src0
, then_mov
[i
]->src
[0]);
205 /* 64-bit immediates can't be placed in src1. */
206 fs_reg
src1(else_mov
[i
]->src
[0]);
207 if (src1
.file
== IMM
&& type_sz(src1
.type
) == 8) {
208 src1
= ibld
.vgrf(else_mov
[i
]->src
[0].type
);
209 ibld
.MOV(src1
, else_mov
[i
]->src
[0]);
212 set_predicate_inv(if_inst
->predicate
, if_inst
->predicate_inverse
,
213 ibld
.SEL(then_mov
[i
]->dst
, src0
, src1
));
216 then_mov
[i
]->remove(then_block
);
217 else_mov
[i
]->remove(else_block
);
224 invalidate_analysis(DEPENDENCY_INSTRUCTIONS
| DEPENDENCY_VARIABLES
);