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. */
41 * Scans forwards from an IF counting consecutive MOV instructions in the
42 * "then" and "else" blocks of the if statement.
44 * A pointer to the fs_inst* for IF is passed as the <if_inst> argument. The
45 * function stores pointers to the MOV instructions in the <then_mov> and
48 * \return the minimum number of MOVs found in the two branches or zero if
53 * then_mov[0] = MOV g4, ...
54 * then_mov[1] = MOV g5, ...
55 * then_mov[2] = MOV g6, ...
57 * else_mov[0] = MOV g4, ...
58 * else_mov[1] = MOV g5, ...
59 * else_mov[2] = MOV g7, ...
64 count_movs_from_if(fs_inst
*then_mov
[MAX_MOVS
], fs_inst
*else_mov
[MAX_MOVS
],
65 fs_inst
*if_inst
, fs_inst
*else_inst
)
69 assert(m
->opcode
== BRW_OPCODE_IF
);
70 m
= (fs_inst
*) m
->next
;
73 while (then_movs
< MAX_MOVS
&& m
->opcode
== BRW_OPCODE_MOV
) {
74 then_mov
[then_movs
] = m
;
75 m
= (fs_inst
*) m
->next
;
79 m
= (fs_inst
*) else_inst
->next
;
82 while (else_movs
< MAX_MOVS
&& m
->opcode
== BRW_OPCODE_MOV
) {
83 else_mov
[else_movs
] = m
;
84 m
= (fs_inst
*) m
->next
;
88 return MIN2(then_movs
, else_movs
);
92 * Try to replace IF/MOV+/ELSE/MOV+/ENDIF with SEL.
94 * Many GLSL shaders contain the following pattern:
96 * x = condition ? foo : bar
100 * if (...) a.xyzw = foo.xyzw;
101 * else a.xyzw = bar.xyzw;
103 * The compiler emits an ir_if tree for this, since each subexpression might be
104 * a complex tree that could have side-effects or short-circuit logic.
106 * However, the common case is to simply select one of two constants or
107 * variable values---which is exactly what SEL is for. In this case, the
108 * assembly looks like:
118 * where each pair of MOVs to a common destination and can be easily translated
121 * (+f0) SEL dst src0 src1
123 * If src0 is an immediate value, we promote it to a temporary GRF.
126 fs_visitor::opt_peephole_sel()
128 bool progress
= false;
132 for (int b
= 0; b
< cfg
->num_blocks
; b
++) {
133 bblock_t
*block
= cfg
->blocks
[b
];
135 /* IF instructions, by definition, can only be found at the ends of
138 fs_inst
*if_inst
= (fs_inst
*) block
->end
;
139 if (if_inst
->opcode
!= BRW_OPCODE_IF
)
142 if (!block
->else_inst
)
145 fs_inst
*else_inst
= (fs_inst
*) block
->else_inst
;
146 assert(else_inst
->opcode
== BRW_OPCODE_ELSE
);
148 fs_inst
*else_mov
[MAX_MOVS
] = { NULL
};
149 fs_inst
*then_mov
[MAX_MOVS
] = { NULL
};
151 int movs
= count_movs_from_if(then_mov
, else_mov
, if_inst
, else_inst
);
156 fs_inst
*sel_inst
[MAX_MOVS
] = { NULL
};
157 fs_inst
*mov_imm_inst
[MAX_MOVS
] = { NULL
};
159 enum brw_predicate predicate
;
160 bool predicate_inverse
;
161 if (brw
->gen
== 6 && if_inst
->conditional_mod
) {
162 /* For Sandybridge with IF with embedded comparison */
163 predicate
= BRW_PREDICATE_NORMAL
;
164 predicate_inverse
= false;
166 /* Separate CMP and IF instructions */
167 predicate
= if_inst
->predicate
;
168 predicate_inverse
= if_inst
->predicate_inverse
;
171 /* Generate SEL instructions for pairs of MOVs to a common destination. */
172 for (int i
= 0; i
< movs
; i
++) {
173 if (!then_mov
[i
] || !else_mov
[i
])
176 /* Check that the MOVs are the right form. */
177 if (!then_mov
[i
]->dst
.equals(else_mov
[i
]->dst
) ||
178 then_mov
[i
]->is_partial_write() ||
179 else_mov
[i
]->is_partial_write()) {
184 /* Check that source types for mov operations match. */
185 if (then_mov
[i
]->src
[0].type
!= else_mov
[i
]->src
[0].type
) {
190 if (then_mov
[i
]->src
[0].equals(else_mov
[i
]->src
[0])) {
191 sel_inst
[i
] = MOV(then_mov
[i
]->dst
, then_mov
[i
]->src
[0]);
193 /* Only the last source register can be a constant, so if the MOV
194 * in the "then" clause uses a constant, we need to put it in a
197 fs_reg
src0(then_mov
[i
]->src
[0]);
198 if (src0
.file
== IMM
) {
199 src0
= fs_reg(this, glsl_type::float_type
);
200 src0
.type
= then_mov
[i
]->src
[0].type
;
201 mov_imm_inst
[i
] = MOV(src0
, then_mov
[i
]->src
[0]);
204 sel_inst
[i
] = SEL(then_mov
[i
]->dst
, src0
, else_mov
[i
]->src
[0]);
205 sel_inst
[i
]->predicate
= predicate
;
206 sel_inst
[i
]->predicate_inverse
= predicate_inverse
;
213 /* Emit a CMP if our IF used the embedded comparison */
214 if (brw
->gen
== 6 && if_inst
->conditional_mod
) {
215 fs_inst
*cmp_inst
= CMP(reg_null_d
, if_inst
->src
[0], if_inst
->src
[1],
216 if_inst
->conditional_mod
);
217 if_inst
->insert_before(cmp_inst
);
220 for (int i
= 0; i
< movs
; i
++) {
222 if_inst
->insert_before(mov_imm_inst
[i
]);
223 if_inst
->insert_before(sel_inst
[i
]);
225 then_mov
[i
]->remove();
226 else_mov
[i
]->remove();
233 invalidate_live_intervals();