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 "glsl_types.h"
25 #include "loop_analysis.h"
26 #include "ir_hierarchical_visitor.h"
30 class loop_unroll_visitor
: public ir_hierarchical_visitor
{
32 loop_unroll_visitor(loop_state
*state
, unsigned max_iterations
)
35 this->progress
= false;
36 this->max_iterations
= max_iterations
;
39 virtual ir_visitor_status
visit_leave(ir_loop
*ir
);
44 unsigned max_iterations
;
47 } /* anonymous namespace */
50 is_break(ir_instruction
*ir
)
52 return ir
!= NULL
&& ir
->ir_type
== ir_type_loop_jump
53 && ((ir_loop_jump
*) ir
)->is_break();
56 class loop_unroll_count
: public ir_hierarchical_visitor
{
61 loop_unroll_count(exec_list
*list
)
69 virtual ir_visitor_status
visit_enter(ir_assignment
*ir
)
72 return visit_continue
;
75 virtual ir_visitor_status
visit_enter(ir_expression
*ir
)
78 return visit_continue
;
81 virtual ir_visitor_status
visit_enter(ir_loop
*ir
)
84 return visit_continue
;
90 loop_unroll_visitor::visit_leave(ir_loop
*ir
)
92 loop_variable_state
*const ls
= this->state
->get(ir
);
95 /* If we've entered a loop that hasn't been analyzed, something really,
96 * really bad has happened.
100 return visit_continue
;
103 iterations
= ls
->max_iterations
;
105 /* Don't try to unroll loops where the number of iterations is not known
109 return visit_continue
;
111 /* Don't try to unroll loops that have zillions of iterations either.
113 if (iterations
> (int) max_iterations
)
114 return visit_continue
;
116 /* Don't try to unroll nested loops and loops with a huge body.
118 loop_unroll_count
count(&ir
->body_instructions
);
120 if (count
.fail
|| count
.nodes
* iterations
> (int)max_iterations
* 5)
121 return visit_continue
;
123 if (ls
->num_loop_jumps
> 1)
124 return visit_continue
;
125 else if (ls
->num_loop_jumps
) {
126 ir_instruction
*last_ir
= (ir_instruction
*) ir
->body_instructions
.get_tail();
127 assert(last_ir
!= NULL
);
129 if (is_break(last_ir
)) {
130 /* If the only loop-jump is a break at the end of the loop, the loop
131 * will execute exactly once. Remove the break, set the iteration
132 * count, and fall through to the normal unroller.
137 this->progress
= true;
140 ir_instruction
*break_ir
= NULL
;
141 bool continue_from_then_branch
= false;
143 foreach_list(node
, &ir
->body_instructions
) {
144 /* recognize loops in the form produced by ir_lower_jumps */
145 ir_instruction
*cur_ir
= (ir_instruction
*) node
;
147 ir_if
= cur_ir
->as_if();
149 /* Determine which if-statement branch, if any, ends with a
150 * break. The branch that did *not* have the break will get a
151 * temporary continue inserted in each iteration of the loop
154 * Note that since ls->num_loop_jumps is <= 1, it is impossible
155 * for both branches to end with a break.
157 ir_instruction
*ir_if_last
=
158 (ir_instruction
*) ir_if
->then_instructions
.get_tail();
160 if (is_break(ir_if_last
)) {
161 continue_from_then_branch
= false;
162 break_ir
= ir_if_last
;
166 (ir_instruction
*) ir_if
->else_instructions
.get_tail();
168 if (is_break(ir_if_last
)) {
169 break_ir
= ir_if_last
;
170 continue_from_then_branch
= true;
177 if (break_ir
== NULL
)
178 return visit_continue
;
180 /* move instructions after then if in the continue branch */
181 while (!ir_if
->get_next()->is_tail_sentinel()) {
182 ir_instruction
*move_ir
= (ir_instruction
*) ir_if
->get_next();
185 if (continue_from_then_branch
)
186 ir_if
->then_instructions
.push_tail(move_ir
);
188 ir_if
->else_instructions
.push_tail(move_ir
);
191 /* Remove the break from the if-statement.
195 void *const mem_ctx
= ralloc_parent(ir
);
196 ir_instruction
*ir_to_replace
= ir
;
198 for (int i
= 0; i
< iterations
; i
++) {
201 copy_list
.make_empty();
202 clone_ir_list(mem_ctx
, ©_list
, &ir
->body_instructions
);
204 ir_if
= ((ir_instruction
*) copy_list
.get_tail())->as_if();
205 assert(ir_if
!= NULL
);
207 ir_to_replace
->insert_before(©_list
);
208 ir_to_replace
->remove();
210 /* placeholder that will be removed in the next iteration */
212 new(mem_ctx
) ir_loop_jump(ir_loop_jump::jump_continue
);
214 exec_list
*const list
= (continue_from_then_branch
)
215 ? &ir_if
->then_instructions
: &ir_if
->else_instructions
;
217 list
->push_tail(ir_to_replace
);
220 ir_to_replace
->remove();
222 this->progress
= true;
223 return visit_continue
;
227 void *const mem_ctx
= ralloc_parent(ir
);
229 for (int i
= 0; i
< iterations
; i
++) {
232 copy_list
.make_empty();
233 clone_ir_list(mem_ctx
, ©_list
, &ir
->body_instructions
);
235 ir
->insert_before(©_list
);
238 /* The loop has been replaced by the unrolled copies. Remove the original
239 * loop from the IR sequence.
243 this->progress
= true;
244 return visit_continue
;
249 unroll_loops(exec_list
*instructions
, loop_state
*ls
, unsigned max_iterations
)
251 loop_unroll_visitor
v(ls
, max_iterations
);