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 static void try_add_loop_terminator(loop_variable_state
*ls
, 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 * Find an initializer of a variable outside a loop
38 * Works backwards from the loop to find the pre-loop value of the variable.
39 * This is used, for example, to find the initial value of loop induction
42 * \param loop Loop where \c var is an induction variable
43 * \param var Variable whose initializer is to be found
46 * The \c ir_rvalue assigned to the variable outside the loop. May return
47 * \c NULL if no initializer can be found.
50 find_initial_value(ir_loop
*loop
, ir_variable
*var
)
52 for (exec_node
*node
= loop
->prev
; !node
->is_head_sentinel();
54 ir_instruction
*ir
= (ir_instruction
*) node
;
56 switch (ir
->ir_type
) {
59 case ir_type_loop_jump
:
64 case ir_type_function
:
65 case ir_type_function_signature
:
66 assert(!"Should not get here.");
69 case ir_type_assignment
: {
70 ir_assignment
*assign
= ir
->as_assignment();
71 ir_variable
*assignee
= assign
->lhs
->whole_variable_referenced();
74 return (assign
->condition
!= NULL
) ? NULL
: assign
->rhs
;
89 calculate_iterations(ir_rvalue
*from
, ir_rvalue
*to
, ir_rvalue
*increment
,
90 enum ir_expression_operation op
, bool continue_from_then
,
91 bool swap_compare_operands
, bool inc_before_terminator
)
93 if (from
== NULL
|| to
== NULL
|| increment
== NULL
)
96 void *mem_ctx
= ralloc_context(NULL
);
98 ir_expression
*const sub
=
99 new(mem_ctx
) ir_expression(ir_binop_sub
, from
->type
, to
, from
);
101 ir_expression
*const div
=
102 new(mem_ctx
) ir_expression(ir_binop_div
, sub
->type
, sub
, increment
);
104 ir_constant
*iter
= div
->constant_expression_value(mem_ctx
);
106 ralloc_free(mem_ctx
);
110 if (!iter
->type
->is_integer_32()) {
111 const ir_expression_operation op
= iter
->type
->is_double()
112 ? ir_unop_d2i
: ir_unop_f2i
;
114 new(mem_ctx
) ir_expression(op
, glsl_type::int_type
, iter
, NULL
);
116 iter
= cast
->constant_expression_value(mem_ctx
);
119 int iter_value
= iter
->get_int_component(0);
121 /* Code after this block works under assumption that iterator will be
122 * incremented or decremented until it hits the limit,
123 * however the loop condition can be false on the first iteration.
124 * Handle such loops first.
127 ir_rvalue
*first_value
= from
;
128 if (inc_before_terminator
) {
130 new(mem_ctx
) ir_expression(ir_binop_add
, from
->type
, from
, increment
);
133 ir_expression
*cmp
= swap_compare_operands
134 ? new(mem_ctx
) ir_expression(op
, glsl_type::bool_type
, to
, first_value
)
135 : new(mem_ctx
) ir_expression(op
, glsl_type::bool_type
, first_value
, to
);
136 if (continue_from_then
)
137 cmp
= new(mem_ctx
) ir_expression(ir_unop_logic_not
, cmp
);
139 ir_constant
*const cmp_result
= cmp
->constant_expression_value(mem_ctx
);
140 assert(cmp_result
!= NULL
);
141 if (cmp_result
->get_bool_component(0)) {
142 ralloc_free(mem_ctx
);
147 /* Make sure that the calculated number of iterations satisfies the exit
148 * condition. This is needed to catch off-by-one errors and some types of
149 * ill-formed loops. For example, we need to detect that the following
150 * loop does not have a maximum iteration count.
152 * for (float x = 0.0; x != 0.9; x += 0.2)
155 const int bias
[] = { -1, 0, 1 };
156 bool valid_loop
= false;
158 for (unsigned i
= 0; i
< ARRAY_SIZE(bias
); i
++) {
159 /* Increment may be of type int, uint or float. */
160 switch (increment
->type
->base_type
) {
162 iter
= new(mem_ctx
) ir_constant(iter_value
+ bias
[i
]);
164 case GLSL_TYPE_INT16
:
165 iter
= new(mem_ctx
) ir_constant(uint16_t(iter_value
+ bias
[i
]));
168 iter
= new(mem_ctx
) ir_constant(unsigned(iter_value
+ bias
[i
]));
170 case GLSL_TYPE_UINT16
:
171 iter
= new(mem_ctx
) ir_constant(uint16_t(iter_value
+ bias
[i
]));
173 case GLSL_TYPE_FLOAT
:
174 iter
= new(mem_ctx
) ir_constant(float(iter_value
+ bias
[i
]));
176 case GLSL_TYPE_FLOAT16
:
177 iter
= new(mem_ctx
) ir_constant(float16_t(float(iter_value
+ bias
[i
])));
179 case GLSL_TYPE_DOUBLE
:
180 iter
= new(mem_ctx
) ir_constant(double(iter_value
+ bias
[i
]));
183 unreachable("Unsupported type for loop iterator.");
186 ir_expression
*const mul
=
187 new(mem_ctx
) ir_expression(ir_binop_mul
, increment
->type
, iter
,
190 ir_expression
*const add
=
191 new(mem_ctx
) ir_expression(ir_binop_add
, mul
->type
, mul
, from
);
193 ir_expression
*cmp
= swap_compare_operands
194 ? new(mem_ctx
) ir_expression(op
, glsl_type::bool_type
, to
, add
)
195 : new(mem_ctx
) ir_expression(op
, glsl_type::bool_type
, add
, to
);
196 if (continue_from_then
)
197 cmp
= new(mem_ctx
) ir_expression(ir_unop_logic_not
, cmp
);
199 ir_constant
*const cmp_result
= cmp
->constant_expression_value(mem_ctx
);
201 assert(cmp_result
!= NULL
);
202 if (cmp_result
->get_bool_component(0)) {
203 iter_value
+= bias
[i
];
209 ralloc_free(mem_ctx
);
211 if (inc_before_terminator
) {
215 return (valid_loop
) ? iter_value
: -1;
219 incremented_before_terminator(ir_loop
*loop
, ir_variable
*var
,
222 for (exec_node
*node
= loop
->body_instructions
.get_head();
223 !node
->is_tail_sentinel();
224 node
= node
->get_next()) {
225 ir_instruction
*ir
= (ir_instruction
*) node
;
227 switch (ir
->ir_type
) {
229 if (ir
->as_if() == terminator
)
233 case ir_type_assignment
: {
234 ir_assignment
*assign
= ir
->as_assignment();
235 ir_variable
*assignee
= assign
->lhs
->whole_variable_referenced();
237 if (assignee
== var
) {
238 assert(assign
->condition
== NULL
);
250 unreachable("Unable to find induction variable");
254 * Record the fact that the given loop variable was referenced inside the loop.
256 * \arg in_assignee is true if the reference was on the LHS of an assignment.
258 * \arg in_conditional_code_or_nested_loop is true if the reference occurred
259 * inside an if statement or a nested loop.
261 * \arg current_assignment is the ir_assignment node that the loop variable is
262 * on the LHS of, if any (ignored if \c in_assignee is false).
265 loop_variable::record_reference(bool in_assignee
,
266 bool in_conditional_code_or_nested_loop
,
267 ir_assignment
*current_assignment
)
270 assert(current_assignment
!= NULL
);
272 if (in_conditional_code_or_nested_loop
||
273 current_assignment
->condition
!= NULL
) {
274 this->conditional_or_nested_assignment
= true;
277 if (this->first_assignment
== NULL
) {
278 assert(this->num_assignments
== 0);
280 this->first_assignment
= current_assignment
;
283 this->num_assignments
++;
284 } else if (this->first_assignment
== current_assignment
) {
285 /* This catches the case where the variable is used in the RHS of an
286 * assignment where it is also in the LHS.
288 this->read_before_write
= true;
293 loop_state::loop_state()
295 this->ht
= _mesa_pointer_hash_table_create(NULL
);
296 this->mem_ctx
= ralloc_context(NULL
);
297 this->loop_found
= false;
301 loop_state::~loop_state()
303 _mesa_hash_table_destroy(this->ht
, NULL
);
304 ralloc_free(this->mem_ctx
);
308 loop_variable_state
*
309 loop_state::insert(ir_loop
*ir
)
311 loop_variable_state
*ls
= new(this->mem_ctx
) loop_variable_state
;
313 _mesa_hash_table_insert(this->ht
, ir
, ls
);
314 this->loop_found
= true;
320 loop_variable_state
*
321 loop_state::get(const ir_loop
*ir
)
323 hash_entry
*entry
= _mesa_hash_table_search(this->ht
, ir
);
324 return entry
? (loop_variable_state
*) entry
->data
: NULL
;
329 loop_variable_state::get(const ir_variable
*ir
)
334 hash_entry
*entry
= _mesa_hash_table_search(this->var_hash
, ir
);
335 return entry
? (loop_variable
*) entry
->data
: NULL
;
340 loop_variable_state::insert(ir_variable
*var
)
342 void *mem_ctx
= ralloc_parent(this);
343 loop_variable
*lv
= rzalloc(mem_ctx
, loop_variable
);
347 _mesa_hash_table_insert(this->var_hash
, lv
->var
, lv
);
348 this->variables
.push_tail(lv
);
355 loop_variable_state::insert(ir_if
*if_stmt
, bool continue_from_then
)
357 void *mem_ctx
= ralloc_parent(this);
358 loop_terminator
*t
= new(mem_ctx
) loop_terminator();
361 t
->continue_from_then
= continue_from_then
;
363 this->terminators
.push_tail(t
);
370 * If the given variable already is recorded in the state for this loop,
371 * return the corresponding loop_variable object that records information
374 * Otherwise, create a new loop_variable object to record information about
375 * the variable, and set its \c read_before_write field appropriately based on
378 * \arg in_assignee is true if this variable was encountered on the LHS of an
382 loop_variable_state::get_or_insert(ir_variable
*var
, bool in_assignee
)
384 loop_variable
*lv
= this->get(var
);
387 lv
= this->insert(var
);
388 lv
->read_before_write
= !in_assignee
;
397 class loop_analysis
: public ir_hierarchical_visitor
{
399 loop_analysis(loop_state
*loops
);
401 virtual ir_visitor_status
visit(ir_loop_jump
*);
402 virtual ir_visitor_status
visit(ir_dereference_variable
*);
404 virtual ir_visitor_status
visit_enter(ir_call
*);
406 virtual ir_visitor_status
visit_enter(ir_loop
*);
407 virtual ir_visitor_status
visit_leave(ir_loop
*);
408 virtual ir_visitor_status
visit_enter(ir_assignment
*);
409 virtual ir_visitor_status
visit_leave(ir_assignment
*);
410 virtual ir_visitor_status
visit_enter(ir_if
*);
411 virtual ir_visitor_status
visit_leave(ir_if
*);
415 int if_statement_depth
;
417 ir_assignment
*current_assignment
;
422 } /* anonymous namespace */
424 loop_analysis::loop_analysis(loop_state
*loops
)
425 : loops(loops
), if_statement_depth(0), current_assignment(NULL
)
432 loop_analysis::visit(ir_loop_jump
*ir
)
436 assert(!this->state
.is_empty());
438 loop_variable_state
*const ls
=
439 (loop_variable_state
*) this->state
.get_head();
441 ls
->num_loop_jumps
++;
443 return visit_continue
;
448 loop_analysis::visit_enter(ir_call
*)
450 /* Mark every loop that we're currently analyzing as containing an ir_call
451 * (even those at outer nesting levels).
453 foreach_in_list(loop_variable_state
, ls
, &this->state
) {
454 ls
->contains_calls
= true;
457 return visit_continue_with_parent
;
462 loop_analysis::visit(ir_dereference_variable
*ir
)
464 /* If we're not somewhere inside a loop, there's nothing to do.
466 if (this->state
.is_empty())
467 return visit_continue
;
471 foreach_in_list(loop_variable_state
, ls
, &this->state
) {
472 ir_variable
*var
= ir
->variable_referenced();
473 loop_variable
*lv
= ls
->get_or_insert(var
, this->in_assignee
);
475 lv
->record_reference(this->in_assignee
,
476 nested
|| this->if_statement_depth
> 0,
477 this->current_assignment
);
481 return visit_continue
;
485 loop_analysis::visit_enter(ir_loop
*ir
)
487 loop_variable_state
*ls
= this->loops
->insert(ir
);
488 this->state
.push_head(ls
);
490 return visit_continue
;
494 loop_analysis::visit_leave(ir_loop
*ir
)
496 loop_variable_state
*const ls
=
497 (loop_variable_state
*) this->state
.pop_head();
499 /* Function calls may contain side effects. These could alter any of our
500 * variables in ways that cannot be known, and may even terminate shader
501 * execution (say, calling discard in the fragment shader). So we can't
502 * rely on any of our analysis about assignments to variables.
504 * We could perform some conservative analysis (prove there's no statically
505 * possible assignment, etc.) but it isn't worth it for now; function
506 * inlining will allow us to unroll loops anyway.
508 if (ls
->contains_calls
)
509 return visit_continue
;
511 foreach_in_list(ir_instruction
, node
, &ir
->body_instructions
) {
512 /* Skip over declarations at the start of a loop.
514 if (node
->as_variable())
517 ir_if
*if_stmt
= ((ir_instruction
*) node
)->as_if();
520 try_add_loop_terminator(ls
, if_stmt
);
524 foreach_in_list_safe(loop_variable
, lv
, &ls
->variables
) {
525 /* Move variables that are already marked as being loop constant to
526 * a separate list. These trivially don't need to be tested.
528 if (lv
->is_loop_constant()) {
530 ls
->constants
.push_tail(lv
);
534 /* Each variable assigned in the loop that isn't already marked as being loop
535 * constant might still be loop constant. The requirements at this point
538 * - Variable is written before it is read.
540 * - Only one assignment to the variable.
542 * - All operands on the RHS of the assignment are also loop constants.
544 * The last requirement is the reason for the progress loop. A variable
545 * marked as a loop constant on one pass may allow other variables to be
546 * marked as loop constant on following passes.
552 foreach_in_list_safe(loop_variable
, lv
, &ls
->variables
) {
553 if (lv
->conditional_or_nested_assignment
|| (lv
->num_assignments
> 1))
556 /* Process the RHS of the assignment. If all of the variables
557 * accessed there are loop constants, then add this
559 ir_rvalue
*const rhs
= lv
->first_assignment
->rhs
;
560 if (all_expression_operands_are_loop_constant(rhs
, ls
->var_hash
)) {
561 lv
->rhs_clean
= true;
563 if (lv
->is_loop_constant()) {
567 ls
->constants
.push_tail(lv
);
573 /* The remaining variables that are not loop invariant might be loop
574 * induction variables.
576 foreach_in_list_safe(loop_variable
, lv
, &ls
->variables
) {
577 /* If there is more than one assignment to a variable, it cannot be a
578 * loop induction variable. This isn't strictly true, but this is a
579 * very simple induction variable detector, and it can't handle more
582 if (lv
->num_assignments
> 1)
585 /* All of the variables with zero assignments in the loop are loop
586 * invariant, and they should have already been filtered out.
588 assert(lv
->num_assignments
== 1);
589 assert(lv
->first_assignment
!= NULL
);
591 /* The assignment to the variable in the loop must be unconditional and
592 * not inside a nested loop.
594 if (lv
->conditional_or_nested_assignment
)
597 /* Basic loop induction variables have a single assignment in the loop
598 * that has the form 'VAR = VAR + i' or 'VAR = VAR - i' where i is a
601 ir_rvalue
*const inc
=
602 get_basic_induction_increment(lv
->first_assignment
, ls
->var_hash
);
607 ls
->induction_variables
.push_tail(lv
);
611 /* Search the loop terminating conditions for those of the form 'i < c'
612 * where i is a loop induction variable, c is a constant, and < is any
613 * relative operator. From each of these we can infer an iteration count.
614 * Also figure out which terminator (if any) produces the smallest
615 * iteration count--this is the limiting terminator.
617 foreach_in_list(loop_terminator
, t
, &ls
->terminators
) {
618 ir_if
*if_stmt
= t
->ir
;
620 /* If-statements can be either 'if (expr)' or 'if (deref)'. We only care
621 * about the former here.
623 ir_expression
*cond
= if_stmt
->condition
->as_expression();
627 switch (cond
->operation
) {
629 case ir_binop_gequal
: {
630 /* The expressions that we care about will either be of the form
631 * 'counter < limit' or 'limit < counter'. Figure out which is
634 ir_rvalue
*counter
= cond
->operands
[0]->as_dereference_variable();
635 ir_constant
*limit
= cond
->operands
[1]->as_constant();
636 enum ir_expression_operation cmp
= cond
->operation
;
637 bool swap_compare_operands
= false;
640 counter
= cond
->operands
[1]->as_dereference_variable();
641 limit
= cond
->operands
[0]->as_constant();
642 swap_compare_operands
= true;
645 if ((counter
== NULL
) || (limit
== NULL
))
648 ir_variable
*var
= counter
->variable_referenced();
650 ir_rvalue
*init
= find_initial_value(ir
, var
);
652 loop_variable
*lv
= ls
->get(var
);
653 if (lv
!= NULL
&& lv
->is_induction_var()) {
654 bool inc_before_terminator
=
655 incremented_before_terminator(ir
, var
, t
->ir
);
657 t
->iterations
= calculate_iterations(init
, limit
, lv
->increment
,
658 cmp
, t
->continue_from_then
,
659 swap_compare_operands
,
660 inc_before_terminator
);
662 if (t
->iterations
>= 0 &&
663 (ls
->limiting_terminator
== NULL
||
664 t
->iterations
< ls
->limiting_terminator
->iterations
)) {
665 ls
->limiting_terminator
= t
;
676 return visit_continue
;
680 loop_analysis::visit_enter(ir_if
*ir
)
684 if (!this->state
.is_empty())
685 this->if_statement_depth
++;
687 return visit_continue
;
691 loop_analysis::visit_leave(ir_if
*ir
)
695 if (!this->state
.is_empty())
696 this->if_statement_depth
--;
698 return visit_continue
;
702 loop_analysis::visit_enter(ir_assignment
*ir
)
704 /* If we're not somewhere inside a loop, there's nothing to do.
706 if (this->state
.is_empty())
707 return visit_continue_with_parent
;
709 this->current_assignment
= ir
;
711 return visit_continue
;
715 loop_analysis::visit_leave(ir_assignment
*ir
)
717 /* Since the visit_enter exits with visit_continue_with_parent for this
718 * case, the loop state stack should never be empty here.
720 assert(!this->state
.is_empty());
722 assert(this->current_assignment
== ir
);
723 this->current_assignment
= NULL
;
725 return visit_continue
;
729 class examine_rhs
: public ir_hierarchical_visitor
{
731 examine_rhs(hash_table
*loop_variables
)
733 this->only_uses_loop_constants
= true;
734 this->loop_variables
= loop_variables
;
737 virtual ir_visitor_status
visit(ir_dereference_variable
*ir
)
739 hash_entry
*entry
= _mesa_hash_table_search(this->loop_variables
,
741 loop_variable
*lv
= entry
? (loop_variable
*) entry
->data
: NULL
;
745 if (lv
->is_loop_constant()) {
746 return visit_continue
;
748 this->only_uses_loop_constants
= false;
753 hash_table
*loop_variables
;
754 bool only_uses_loop_constants
;
759 all_expression_operands_are_loop_constant(ir_rvalue
*ir
, hash_table
*variables
)
761 examine_rhs
v(variables
);
765 return v
.only_uses_loop_constants
;
770 get_basic_induction_increment(ir_assignment
*ir
, hash_table
*var_hash
)
772 /* The RHS must be a binary expression.
774 ir_expression
*const rhs
= ir
->rhs
->as_expression();
776 || ((rhs
->operation
!= ir_binop_add
)
777 && (rhs
->operation
!= ir_binop_sub
)))
780 /* One of the of operands of the expression must be the variable assigned.
781 * If the operation is subtraction, the variable in question must be the
784 ir_variable
*const var
= ir
->lhs
->variable_referenced();
786 ir_variable
*const op0
= rhs
->operands
[0]->variable_referenced();
787 ir_variable
*const op1
= rhs
->operands
[1]->variable_referenced();
789 if (((op0
!= var
) && (op1
!= var
))
790 || ((op1
== var
) && (rhs
->operation
== ir_binop_sub
)))
793 ir_rvalue
*inc
= (op0
== var
) ? rhs
->operands
[1] : rhs
->operands
[0];
795 if (inc
->as_constant() == NULL
) {
796 ir_variable
*const inc_var
= inc
->variable_referenced();
797 if (inc_var
!= NULL
) {
798 hash_entry
*entry
= _mesa_hash_table_search(var_hash
, inc_var
);
799 loop_variable
*lv
= entry
? (loop_variable
*) entry
->data
: NULL
;
801 if (lv
== NULL
|| !lv
->is_loop_constant()) {
809 if ((inc
!= NULL
) && (rhs
->operation
== ir_binop_sub
)) {
810 void *mem_ctx
= ralloc_parent(ir
);
812 inc
= new(mem_ctx
) ir_expression(ir_unop_neg
,
814 inc
->clone(mem_ctx
, NULL
),
823 * Detect whether an if-statement is a loop terminating condition, if so
824 * add it to the list of loop terminators.
826 * Detects if-statements of the form
828 * (if (expression bool ...) (...then_instrs...break))
832 * (if (expression bool ...) ... (...else_instrs...break))
835 try_add_loop_terminator(loop_variable_state
*ls
, ir_if
*ir
)
837 ir_instruction
*inst
= (ir_instruction
*) ir
->then_instructions
.get_tail();
838 ir_instruction
*else_inst
=
839 (ir_instruction
*) ir
->else_instructions
.get_tail();
841 if (is_break(inst
) || is_break(else_inst
))
842 ls
->insert(ir
, is_break(else_inst
));
847 analyze_loop_variables(exec_list
*instructions
)
849 loop_state
*loops
= new loop_state
;
850 loop_analysis
v(loops
);