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"
28 static bool is_loop_terminator(ir_if
*ir
);
30 static bool all_expression_operands_are_loop_constant(ir_rvalue
*,
33 static ir_rvalue
*get_basic_induction_increment(ir_assignment
*, hash_table
*);
36 loop_state::loop_state()
38 this->ht
= hash_table_ctor(0, hash_table_pointer_hash
,
39 hash_table_pointer_compare
);
40 this->mem_ctx
= ralloc_context(NULL
);
41 this->loop_found
= false;
45 loop_state::~loop_state()
47 hash_table_dtor(this->ht
);
48 ralloc_free(this->mem_ctx
);
53 loop_state::insert(ir_loop
*ir
)
55 loop_variable_state
*ls
= new(this->mem_ctx
) loop_variable_state
;
57 hash_table_insert(this->ht
, ls
, ir
);
58 this->loop_found
= true;
65 loop_state::get(const ir_loop
*ir
)
67 return (loop_variable_state
*) hash_table_find(this->ht
, ir
);
72 loop_variable_state::get(const ir_variable
*ir
)
74 return (loop_variable
*) hash_table_find(this->var_hash
, ir
);
79 loop_variable_state::insert(ir_variable
*var
)
81 void *mem_ctx
= ralloc_parent(this);
82 loop_variable
*lv
= rzalloc(mem_ctx
, loop_variable
);
86 hash_table_insert(this->var_hash
, lv
, lv
->var
);
87 this->variables
.push_tail(lv
);
94 loop_variable_state::insert(ir_if
*if_stmt
)
96 void *mem_ctx
= ralloc_parent(this);
97 loop_terminator
*t
= rzalloc(mem_ctx
, loop_terminator
);
100 this->terminators
.push_tail(t
);
106 class loop_analysis
: public ir_hierarchical_visitor
{
110 virtual ir_visitor_status
visit(ir_loop_jump
*);
111 virtual ir_visitor_status
visit(ir_dereference_variable
*);
113 virtual ir_visitor_status
visit_enter(ir_call
*);
115 virtual ir_visitor_status
visit_enter(ir_loop
*);
116 virtual ir_visitor_status
visit_leave(ir_loop
*);
117 virtual ir_visitor_status
visit_enter(ir_assignment
*);
118 virtual ir_visitor_status
visit_leave(ir_assignment
*);
119 virtual ir_visitor_status
visit_enter(ir_if
*);
120 virtual ir_visitor_status
visit_leave(ir_if
*);
124 int if_statement_depth
;
126 ir_assignment
*current_assignment
;
132 loop_analysis::loop_analysis()
134 this->loops
= new loop_state
;
136 this->if_statement_depth
= 0;
137 this->current_assignment
= NULL
;
142 loop_analysis::visit(ir_loop_jump
*ir
)
146 assert(!this->state
.is_empty());
148 loop_variable_state
*const ls
=
149 (loop_variable_state
*) this->state
.get_head();
151 ls
->num_loop_jumps
++;
153 return visit_continue
;
158 loop_analysis::visit_enter(ir_call
*ir
)
160 /* If we're not somewhere inside a loop, there's nothing to do. */
161 if (this->state
.is_empty())
162 return visit_continue
;
164 loop_variable_state
*const ls
=
165 (loop_variable_state
*) this->state
.get_head();
167 ls
->contains_calls
= true;
168 return visit_continue_with_parent
;
173 loop_analysis::visit(ir_dereference_variable
*ir
)
175 /* If we're not somewhere inside a loop, there's nothing to do.
177 if (this->state
.is_empty())
178 return visit_continue
;
180 loop_variable_state
*const ls
=
181 (loop_variable_state
*) this->state
.get_head();
183 ir_variable
*var
= ir
->variable_referenced();
184 loop_variable
*lv
= ls
->get(var
);
187 lv
= ls
->insert(var
);
188 lv
->read_before_write
= !this->in_assignee
;
191 if (this->in_assignee
) {
192 assert(this->current_assignment
!= NULL
);
194 lv
->conditional_assignment
= (this->if_statement_depth
> 0)
195 || (this->current_assignment
->condition
!= NULL
);
197 if (lv
->first_assignment
== NULL
) {
198 assert(lv
->num_assignments
== 0);
200 lv
->first_assignment
= this->current_assignment
;
203 lv
->num_assignments
++;
204 } else if (lv
->first_assignment
== this->current_assignment
) {
205 /* This catches the case where the variable is used in the RHS of an
206 * assignment where it is also in the LHS.
208 lv
->read_before_write
= true;
211 return visit_continue
;
215 loop_analysis::visit_enter(ir_loop
*ir
)
217 loop_variable_state
*ls
= this->loops
->insert(ir
);
218 this->state
.push_head(ls
);
220 return visit_continue
;
224 loop_analysis::visit_leave(ir_loop
*ir
)
226 loop_variable_state
*const ls
=
227 (loop_variable_state
*) this->state
.pop_head();
229 /* Function calls may contain side effects. These could alter any of our
230 * variables in ways that cannot be known, and may even terminate shader
231 * execution (say, calling discard in the fragment shader). So we can't
232 * rely on any of our analysis about assignments to variables.
234 * We could perform some conservative analysis (prove there's no statically
235 * possible assignment, etc.) but it isn't worth it for now; function
236 * inlining will allow us to unroll loops anyway.
238 if (ls
->contains_calls
)
239 return visit_continue
;
241 foreach_list(node
, &ir
->body_instructions
) {
242 /* Skip over declarations at the start of a loop.
244 if (((ir_instruction
*) node
)->as_variable())
247 ir_if
*if_stmt
= ((ir_instruction
*) node
)->as_if();
249 if ((if_stmt
!= NULL
) && is_loop_terminator(if_stmt
))
256 foreach_list_safe(node
, &ls
->variables
) {
257 loop_variable
*lv
= (loop_variable
*) node
;
259 /* Move variables that are already marked as being loop constant to
260 * a separate list. These trivially don't need to be tested.
262 if (lv
->is_loop_constant()) {
264 ls
->constants
.push_tail(lv
);
268 /* Each variable assigned in the loop that isn't already marked as being loop
269 * constant might still be loop constant. The requirements at this point
272 * - Variable is written before it is read.
274 * - Only one assignment to the variable.
276 * - All operands on the RHS of the assignment are also loop constants.
278 * The last requirement is the reason for the progress loop. A variable
279 * marked as a loop constant on one pass may allow other variables to be
280 * marked as loop constant on following passes.
286 foreach_list_safe(node
, &ls
->variables
) {
287 loop_variable
*lv
= (loop_variable
*) node
;
289 if (lv
->conditional_assignment
|| (lv
->num_assignments
> 1))
292 /* Process the RHS of the assignment. If all of the variables
293 * accessed there are loop constants, then add this
295 ir_rvalue
*const rhs
= lv
->first_assignment
->rhs
;
296 if (all_expression_operands_are_loop_constant(rhs
, ls
->var_hash
)) {
297 lv
->rhs_clean
= true;
299 if (lv
->is_loop_constant()) {
303 ls
->constants
.push_tail(lv
);
309 /* The remaining variables that are not loop invariant might be loop
310 * induction variables.
312 foreach_list_safe(node
, &ls
->variables
) {
313 loop_variable
*lv
= (loop_variable
*) node
;
315 /* If there is more than one assignment to a variable, it cannot be a
316 * loop induction variable. This isn't strictly true, but this is a
317 * very simple induction variable detector, and it can't handle more
320 if (lv
->num_assignments
> 1)
323 /* All of the variables with zero assignments in the loop are loop
324 * invariant, and they should have already been filtered out.
326 assert(lv
->num_assignments
== 1);
327 assert(lv
->first_assignment
!= NULL
);
329 /* The assignmnet to the variable in the loop must be unconditional.
331 if (lv
->conditional_assignment
)
334 /* Basic loop induction variables have a single assignment in the loop
335 * that has the form 'VAR = VAR + i' or 'VAR = VAR - i' where i is a
338 ir_rvalue
*const inc
=
339 get_basic_induction_increment(lv
->first_assignment
, ls
->var_hash
);
346 ls
->induction_variables
.push_tail(lv
);
350 return visit_continue
;
354 loop_analysis::visit_enter(ir_if
*ir
)
358 if (!this->state
.is_empty())
359 this->if_statement_depth
++;
361 return visit_continue
;
365 loop_analysis::visit_leave(ir_if
*ir
)
369 if (!this->state
.is_empty())
370 this->if_statement_depth
--;
372 return visit_continue
;
376 loop_analysis::visit_enter(ir_assignment
*ir
)
378 /* If we're not somewhere inside a loop, there's nothing to do.
380 if (this->state
.is_empty())
381 return visit_continue_with_parent
;
383 this->current_assignment
= ir
;
385 return visit_continue
;
389 loop_analysis::visit_leave(ir_assignment
*ir
)
391 /* Since the visit_enter exits with visit_continue_with_parent for this
392 * case, the loop state stack should never be empty here.
394 assert(!this->state
.is_empty());
396 assert(this->current_assignment
== ir
);
397 this->current_assignment
= NULL
;
399 return visit_continue
;
403 class examine_rhs
: public ir_hierarchical_visitor
{
405 examine_rhs(hash_table
*loop_variables
)
407 this->only_uses_loop_constants
= true;
408 this->loop_variables
= loop_variables
;
411 virtual ir_visitor_status
visit(ir_dereference_variable
*ir
)
414 (loop_variable
*) hash_table_find(this->loop_variables
, ir
->var
);
418 if (lv
->is_loop_constant()) {
419 return visit_continue
;
421 this->only_uses_loop_constants
= false;
426 hash_table
*loop_variables
;
427 bool only_uses_loop_constants
;
432 all_expression_operands_are_loop_constant(ir_rvalue
*ir
, hash_table
*variables
)
434 examine_rhs
v(variables
);
438 return v
.only_uses_loop_constants
;
443 get_basic_induction_increment(ir_assignment
*ir
, hash_table
*var_hash
)
445 /* The RHS must be a binary expression.
447 ir_expression
*const rhs
= ir
->rhs
->as_expression();
449 || ((rhs
->operation
!= ir_binop_add
)
450 && (rhs
->operation
!= ir_binop_sub
)))
453 /* One of the of operands of the expression must be the variable assigned.
454 * If the operation is subtraction, the variable in question must be the
457 ir_variable
*const var
= ir
->lhs
->variable_referenced();
459 ir_variable
*const op0
= rhs
->operands
[0]->variable_referenced();
460 ir_variable
*const op1
= rhs
->operands
[1]->variable_referenced();
462 if (((op0
!= var
) && (op1
!= var
))
463 || ((op1
== var
) && (rhs
->operation
== ir_binop_sub
)))
466 ir_rvalue
*inc
= (op0
== var
) ? rhs
->operands
[1] : rhs
->operands
[0];
468 if (inc
->as_constant() == NULL
) {
469 ir_variable
*const inc_var
= inc
->variable_referenced();
470 if (inc_var
!= NULL
) {
472 (loop_variable
*) hash_table_find(var_hash
, inc_var
);
474 if (!lv
->is_loop_constant())
480 if ((inc
!= NULL
) && (rhs
->operation
== ir_binop_sub
)) {
481 void *mem_ctx
= ralloc_parent(ir
);
483 inc
= new(mem_ctx
) ir_expression(ir_unop_neg
,
485 inc
->clone(mem_ctx
, NULL
),
494 * Detect whether an if-statement is a loop terminating condition
496 * Detects if-statements of the form
498 * (if (expression bool ...) (break))
501 is_loop_terminator(ir_if
*ir
)
503 if (!ir
->else_instructions
.is_empty())
506 ir_instruction
*const inst
=
507 (ir_instruction
*) ir
->then_instructions
.get_head();
508 assert(inst
!= NULL
);
510 if (inst
->ir_type
!= ir_type_loop_jump
)
513 ir_loop_jump
*const jump
= (ir_loop_jump
*) inst
;
514 if (jump
->mode
!= ir_loop_jump::jump_break
)
522 analyze_loop_variables(exec_list
*instructions
)