2 * Copyright © 2010 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
21 * DEALINGS IN THE SOFTWARE.
24 #include "compiler/glsl_types.h"
25 #include "loop_analysis.h"
26 #include "ir_hierarchical_visitor.h"
28 #include "main/mtypes.h"
32 class loop_unroll_visitor
: public ir_hierarchical_visitor
{
34 loop_unroll_visitor(loop_state
*state
,
35 const struct gl_shader_compiler_options
*options
)
38 this->progress
= false;
39 this->options
= options
;
42 virtual ir_visitor_status
visit_leave(ir_loop
*ir
);
43 void simple_unroll(ir_loop
*ir
, int iterations
);
44 void complex_unroll(ir_loop
*ir
, int iterations
,
45 bool continue_from_then_branch
);
46 void splice_post_if_instructions(ir_if
*ir_if
, exec_list
*splice_dest
);
51 const struct gl_shader_compiler_options
*options
;
54 } /* anonymous namespace */
57 is_break(ir_instruction
*ir
)
59 return ir
!= NULL
&& ir
->ir_type
== ir_type_loop_jump
60 && ((ir_loop_jump
*) ir
)->is_break();
63 class loop_unroll_count
: public ir_hierarchical_visitor
{
66 bool unsupported_variable_indexing
;
67 bool array_indexed_by_induction_var_with_exact_iterations
;
68 /* If there are nested loops, the node count will be inaccurate. */
71 loop_unroll_count(exec_list
*list
, loop_variable_state
*ls
,
72 const struct gl_shader_compiler_options
*options
)
73 : ls(ls
), options(options
)
77 unsupported_variable_indexing
= false;
78 array_indexed_by_induction_var_with_exact_iterations
= false;
83 virtual ir_visitor_status
visit_enter(ir_assignment
*)
86 return visit_continue
;
89 virtual ir_visitor_status
visit_enter(ir_expression
*)
92 return visit_continue
;
95 virtual ir_visitor_status
visit_enter(ir_loop
*)
98 return visit_continue
;
101 virtual ir_visitor_status
visit_enter(ir_dereference_array
*ir
)
103 /* Force unroll in case of dynamic indexing with sampler arrays
104 * when EmitNoIndirectSampler is set.
106 if (options
->EmitNoIndirectSampler
) {
107 if ((ir
->array
->type
->is_array() &&
108 ir
->array
->type
->contains_sampler()) &&
109 !ir
->array_index
->constant_expression_value()) {
110 unsupported_variable_indexing
= true;
111 return visit_continue
;
115 /* Check for arrays variably-indexed by a loop induction variable.
116 * Unrolling the loop may convert that access into constant-indexing.
118 * Many drivers don't support particular kinds of variable indexing,
119 * and have to resort to using lower_variable_index_to_cond_assign to
120 * handle it. This results in huge amounts of horrible code, so we'd
121 * like to avoid that if possible. Here, we just note that it will
124 if ((ir
->array
->type
->is_array() || ir
->array
->type
->is_matrix()) &&
125 !ir
->array_index
->as_constant()) {
126 ir_variable
*array
= ir
->array
->variable_referenced();
127 loop_variable
*lv
= ls
->get(ir
->array_index
->variable_referenced());
128 if (array
&& lv
&& lv
->is_induction_var()) {
129 /* If an array is indexed by a loop induction variable, and the
130 * array size is exactly the number of loop iterations, this is
131 * probably a simple for-loop trying to access each element in
132 * turn; the application may expect it to be unrolled.
134 if (int(array
->type
->length
) == ls
->limiting_terminator
->iterations
)
135 array_indexed_by_induction_var_with_exact_iterations
= true;
137 switch (array
->data
.mode
) {
139 case ir_var_temporary
:
140 case ir_var_const_in
:
141 case ir_var_function_in
:
142 case ir_var_function_out
:
143 case ir_var_function_inout
:
144 if (options
->EmitNoIndirectTemp
)
145 unsupported_variable_indexing
= true;
148 case ir_var_shader_storage
:
149 if (options
->EmitNoIndirectUniform
)
150 unsupported_variable_indexing
= true;
152 case ir_var_shader_in
:
153 if (options
->EmitNoIndirectInput
)
154 unsupported_variable_indexing
= true;
156 case ir_var_shader_out
:
157 if (options
->EmitNoIndirectOutput
)
158 unsupported_variable_indexing
= true;
163 return visit_continue
;
167 loop_variable_state
*ls
;
168 const struct gl_shader_compiler_options
*options
;
173 * Unroll a loop which does not contain any jumps. For example, if the input
176 * (loop (...) ...instrs...)
178 * And the iteration count is 3, the output will be:
180 * ...instrs... ...instrs... ...instrs...
183 loop_unroll_visitor::simple_unroll(ir_loop
*ir
, int iterations
)
185 void *const mem_ctx
= ralloc_parent(ir
);
187 for (int i
= 0; i
< iterations
; i
++) {
190 copy_list
.make_empty();
191 clone_ir_list(mem_ctx
, ©_list
, &ir
->body_instructions
);
193 ir
->insert_before(©_list
);
196 /* The loop has been replaced by the unrolled copies. Remove the original
197 * loop from the IR sequence.
201 this->progress
= true;
206 * Unroll a loop whose last statement is an ir_if. If \c
207 * continue_from_then_branch is true, the loop is repeated only when the
208 * "then" branch of the if is taken; otherwise it is repeated only when the
209 * "else" branch of the if is taken.
211 * For example, if the input is:
216 * (...then_instrs...)
217 * (...else_instrs...)))
219 * And the iteration count is 3, and \c continue_from_then_branch is true,
220 * then the output will be:
230 * (...then_instrs...)
231 * (...else_instrs...)))
232 * (...else_instrs...)))
236 loop_unroll_visitor::complex_unroll(ir_loop
*ir
, int iterations
,
237 bool continue_from_then_branch
)
239 void *const mem_ctx
= ralloc_parent(ir
);
240 ir_instruction
*ir_to_replace
= ir
;
242 for (int i
= 0; i
< iterations
; i
++) {
245 copy_list
.make_empty();
246 clone_ir_list(mem_ctx
, ©_list
, &ir
->body_instructions
);
248 ir_if
*ir_if
= ((ir_instruction
*) copy_list
.get_tail())->as_if();
249 assert(ir_if
!= NULL
);
251 ir_to_replace
->insert_before(©_list
);
252 ir_to_replace
->remove();
254 /* placeholder that will be removed in the next iteration */
256 new(mem_ctx
) ir_loop_jump(ir_loop_jump::jump_continue
);
258 exec_list
*const list
= (continue_from_then_branch
)
259 ? &ir_if
->then_instructions
: &ir_if
->else_instructions
;
261 list
->push_tail(ir_to_replace
);
264 ir_to_replace
->remove();
266 this->progress
= true;
271 * Move all of the instructions which follow \c ir_if to the end of
274 * For example, in the code snippet:
277 * (...then_instructions...
279 * (...else_instructions...))
280 * ...post_if_instructions...
282 * If \c ir_if points to the "if" instruction, and \c splice_dest points to
283 * (...else_instructions...), the code snippet is transformed into:
286 * (...then_instructions...
288 * (...else_instructions...
289 * ...post_if_instructions...))
292 loop_unroll_visitor::splice_post_if_instructions(ir_if
*ir_if
,
293 exec_list
*splice_dest
)
295 while (!ir_if
->get_next()->is_tail_sentinel()) {
296 ir_instruction
*move_ir
= (ir_instruction
*) ir_if
->get_next();
299 splice_dest
->push_tail(move_ir
);
305 loop_unroll_visitor::visit_leave(ir_loop
*ir
)
307 loop_variable_state
*const ls
= this->state
->get(ir
);
310 /* If we've entered a loop that hasn't been analyzed, something really,
311 * really bad has happened.
315 return visit_continue
;
318 if (ls
->limiting_terminator
== NULL
) {
319 ir_instruction
*last_ir
=
320 (ir_instruction
*) ir
->body_instructions
.get_tail();
322 /* If a loop has no induction variable and the last instruction is
323 * a break, unroll the loop with a count of 1. This is the classic
329 * that is used to wrap multi-line macros.
331 * If num_loop_jumps is not zero, last_ir cannot be NULL... there has to
332 * be at least num_loop_jumps instructions in the loop.
334 if (ls
->num_loop_jumps
== 1 && is_break(last_ir
)) {
337 simple_unroll(ir
, 1);
340 /* Don't try to unroll loops where the number of iterations is not known
343 return visit_continue
;
346 iterations
= ls
->limiting_terminator
->iterations
;
348 const int max_iterations
= options
->MaxUnrollIterations
;
350 /* Don't try to unroll loops that have zillions of iterations either.
352 if (iterations
> max_iterations
)
353 return visit_continue
;
355 /* Don't try to unroll nested loops and loops with a huge body.
357 loop_unroll_count
count(&ir
->body_instructions
, ls
, options
);
359 bool loop_too_large
=
360 count
.nested_loop
|| count
.nodes
* iterations
> max_iterations
* 5;
362 if (loop_too_large
&& !count
.unsupported_variable_indexing
&&
363 !count
.array_indexed_by_induction_var_with_exact_iterations
)
364 return visit_continue
;
366 /* Note: the limiting terminator contributes 1 to ls->num_loop_jumps.
367 * We'll be removing the limiting terminator before we unroll.
369 assert(ls
->num_loop_jumps
> 0);
370 unsigned predicted_num_loop_jumps
= ls
->num_loop_jumps
- 1;
372 if (predicted_num_loop_jumps
> 1)
373 return visit_continue
;
375 if (predicted_num_loop_jumps
== 0) {
376 ls
->limiting_terminator
->ir
->remove();
377 simple_unroll(ir
, iterations
);
378 return visit_continue
;
381 ir_instruction
*last_ir
= (ir_instruction
*) ir
->body_instructions
.get_tail();
382 assert(last_ir
!= NULL
);
384 if (is_break(last_ir
)) {
385 /* If the only loop-jump is a break at the end of the loop, the loop
386 * will execute exactly once. Remove the break and use the simple
387 * unroller with an iteration count of 1.
391 ls
->limiting_terminator
->ir
->remove();
392 simple_unroll(ir
, 1);
393 return visit_continue
;
396 /* recognize loops in the form produced by ir_lower_jumps */
397 foreach_in_list(ir_instruction
, cur_ir
, &ir
->body_instructions
) {
398 /* Skip the limiting terminator, since it will go away when we
401 if (cur_ir
== ls
->limiting_terminator
->ir
)
404 ir_if
*ir_if
= cur_ir
->as_if();
406 /* Determine which if-statement branch, if any, ends with a
407 * break. The branch that did *not* have the break will get a
408 * temporary continue inserted in each iteration of the loop
411 * Note that since ls->num_loop_jumps is <= 1, it is impossible
412 * for both branches to end with a break.
414 ir_instruction
*ir_if_last
=
415 (ir_instruction
*) ir_if
->then_instructions
.get_tail();
417 if (is_break(ir_if_last
)) {
418 ls
->limiting_terminator
->ir
->remove();
419 splice_post_if_instructions(ir_if
, &ir_if
->else_instructions
);
420 ir_if_last
->remove();
421 complex_unroll(ir
, iterations
, false);
422 return visit_continue
;
425 (ir_instruction
*) ir_if
->else_instructions
.get_tail();
427 if (is_break(ir_if_last
)) {
428 ls
->limiting_terminator
->ir
->remove();
429 splice_post_if_instructions(ir_if
, &ir_if
->then_instructions
);
430 ir_if_last
->remove();
431 complex_unroll(ir
, iterations
, true);
432 return visit_continue
;
438 /* Did not find the break statement. It must be in a complex if-nesting,
439 * so don't try to unroll.
441 return visit_continue
;
446 unroll_loops(exec_list
*instructions
, loop_state
*ls
,
447 const struct gl_shader_compiler_options
*options
)
449 loop_unroll_visitor
v(ls
, options
);