2 * Copyright © 2010 Luca Barbieri
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.
25 * \file lower_jumps.cpp
27 * This pass lowers jumps (break, continue, and return) to if/else structures.
30 * 1. Pull jumps out of ifs where possible
31 * 2. Remove all "continue"s, replacing them with an "execute flag"
32 * 3. Replace all "break" with a single conditional one at the end of the loop
33 * 4. Replace all "return"s with a single return at the end of the function,
34 * for the main function and/or other functions
36 * Applying this pass gives several benefits:
37 * 1. All functions can be inlined.
38 * 2. nv40 and other pre-DX10 chips without "continue" can be supported
39 * 3. nv30 and other pre-DX10 chips with no control flow at all are better
42 * Continues are lowered by adding a per-loop "execute flag", initialized to
43 * true, that when cleared inhibits all execution until the end of the loop.
45 * Breaks are lowered to continues, plus setting a "break flag" that is checked
46 * at the end of the loop, and trigger the unique "break".
48 * Returns are lowered to breaks/continues, plus adding a "return flag" that
49 * causes loops to break again out of their enclosing loops until all the
50 * loops are exited: then the "execute flag" logic will ignore everything
51 * until the end of the function.
53 * Note that "continue" and "return" can also be implemented by adding
54 * a dummy loop and using break.
55 * However, this is bad for hardware with limited nesting depth, and
56 * prevents further optimization, and thus is not currently performed.
59 #include "glsl_types.h"
64 * Enum recording the result of analyzing how control flow might exit
67 * Each possible value of jump_strength indicates a strictly stronger
68 * guarantee on control flow than the previous value.
70 * The ordering of strengths roughly reflects the way jumps are
71 * lowered: jumps with higher strength tend to be lowered to jumps of
72 * lower strength. Accordingly, strength is used as a heuristic to
73 * determine which lowering to perform first.
75 * This enum is also used by get_jump_strength() to categorize
76 * instructions as either break, continue, return, or other. When
77 * used in this fashion, strength_always_clears_execute_flag is not
80 * The control flow analysis made by this optimization pass makes two
81 * simplifying assumptions:
83 * - It ignores discard instructions, since they are lowered by a
84 * separate pass (lower_discard.cpp).
86 * - It assumes it is always possible for control to flow from a loop
87 * to the instruction immediately following it. Technically, this
88 * is not true (since all execution paths through the loop might
89 * jump back to the top, or return from the function).
91 * Both of these simplifying assumtions are safe, since they can never
92 * cause reachable code to be incorrectly classified as unreachable;
93 * they can only do the opposite.
98 * Analysis has produced no guarantee on how control flow might
99 * exit this IR node. It might fall out the bottom (with or
100 * without clearing the execute flag, if present), or it might
101 * continue to the top of the innermost enclosing loop, break out
102 * of it, or return from the function.
107 * The only way control can fall out the bottom of this node is
108 * through a code path that clears the execute flag. It might also
109 * continue to the top of the innermost enclosing loop, break out
110 * of it, or return from the function.
112 strength_always_clears_execute_flag
,
115 * Control cannot fall out the bottom of this node. It might
116 * continue to the top of the innermost enclosing loop, break out
117 * of it, or return from the function.
122 * Control cannot fall out the bottom of this node, or continue the
123 * top of the innermost enclosing loop. It can only break out of
124 * it or return from the function.
129 * Control cannot fall out the bottom of this node, continue to the
130 * top of the innermost enclosing loop, or break out of it. It can
131 * only return from the function.
138 /* minimum jump strength (of lowered IR, not pre-lowering IR)
140 * If the block ends with a jump, must be the strength of the jump.
141 * Otherwise, the jump would be dead and have been deleted before)
143 * If the block doesn't end with a jump, it can be different than strength_none if all paths before it lead to some jump
144 * (e.g. an if with a return in one branch, and a break in the other, while not lowering them)
145 * Note that identical jumps are usually unified though.
147 jump_strength min_strength
;
149 /* can anything clear the execute flag? */
150 bool may_clear_execute_flag
;
154 this->min_strength
= strength_none
;
155 this->may_clear_execute_flag
= false;
161 ir_function_signature
* signature
;
164 /* used to avoid lowering the break used to represent lowered breaks */
165 unsigned nesting_depth
;
166 bool in_if_at_the_end_of_the_loop
;
168 bool may_set_return_flag
;
170 ir_variable
* break_flag
;
171 ir_variable
* execute_flag
; /* cleared to emulate continue */
173 loop_record(ir_function_signature
* p_signature
= 0, ir_loop
* p_loop
= 0)
175 this->signature
= p_signature
;
177 this->nesting_depth
= 0;
178 this->in_if_at_the_end_of_the_loop
= false;
179 this->may_set_return_flag
= false;
180 this->break_flag
= 0;
181 this->execute_flag
= 0;
184 ir_variable
* get_execute_flag()
186 /* also supported for the "function loop" */
187 if(!this->execute_flag
) {
188 exec_list
& list
= this->loop
? this->loop
->body_instructions
: signature
->body
;
189 this->execute_flag
= new(this->signature
) ir_variable(glsl_type::bool_type
, "execute_flag", ir_var_temporary
);
190 list
.push_head(new(this->signature
) ir_assignment(new(this->signature
) ir_dereference_variable(execute_flag
), new(this->signature
) ir_constant(true), 0));
191 list
.push_head(this->execute_flag
);
193 return this->execute_flag
;
196 ir_variable
* get_break_flag()
199 if(!this->break_flag
) {
200 this->break_flag
= new(this->signature
) ir_variable(glsl_type::bool_type
, "break_flag", ir_var_temporary
);
201 this->loop
->insert_before(this->break_flag
);
202 this->loop
->insert_before(new(this->signature
) ir_assignment(new(this->signature
) ir_dereference_variable(break_flag
), new(this->signature
) ir_constant(false), 0));
204 return this->break_flag
;
208 struct function_record
210 ir_function_signature
* signature
;
211 ir_variable
* return_flag
; /* used to break out of all loops and then jump to the return instruction */
212 ir_variable
* return_value
;
214 unsigned nesting_depth
;
216 function_record(ir_function_signature
* p_signature
= 0,
217 bool lower_return
= false)
219 this->signature
= p_signature
;
220 this->return_flag
= 0;
221 this->return_value
= 0;
222 this->nesting_depth
= 0;
223 this->lower_return
= lower_return
;
226 ir_variable
* get_return_flag()
228 if(!this->return_flag
) {
229 this->return_flag
= new(this->signature
) ir_variable(glsl_type::bool_type
, "return_flag", ir_var_temporary
);
230 this->signature
->body
.push_head(new(this->signature
) ir_assignment(new(this->signature
) ir_dereference_variable(return_flag
), new(this->signature
) ir_constant(false), 0));
231 this->signature
->body
.push_head(this->return_flag
);
233 return this->return_flag
;
236 ir_variable
* get_return_value()
238 if(!this->return_value
) {
239 assert(!this->signature
->return_type
->is_void());
240 return_value
= new(this->signature
) ir_variable(this->signature
->return_type
, "return_value", ir_var_temporary
);
241 this->signature
->body
.push_head(this->return_value
);
243 return this->return_value
;
247 struct ir_lower_jumps_visitor
: public ir_control_flow_visitor
{
248 /* Postconditions: on exit of any visit() function:
250 * ANALYSIS: this->block.min_strength,
251 * this->block.may_clear_execute_flag, and
252 * this->loop.may_set_return_flag are updated to reflect the
253 * characteristics of the visited statement.
255 * DEAD_CODE_ELIMINATION: If this->block.min_strength is not
256 * strength_none, the visited node is at the end of its exec_list.
257 * In other words, any unreachable statements that follow the
258 * visited statement in its exec_list have been removed.
260 * CONTAINED_JUMPS_LOWERED: If the visited statement contains other
261 * statements, then should_lower_jump() is false for all of the
262 * return, break, or continue statements it contains.
264 * Note that visiting a jump does not lower it. That is the
265 * responsibility of the statement (or function signature) that
271 struct function_record function
;
272 struct loop_record loop
;
273 struct block_record block
;
278 bool lower_sub_return
;
279 bool lower_main_return
;
281 ir_lower_jumps_visitor()
283 this->progress
= false;
286 void truncate_after_instruction(exec_node
*ir
)
291 while (!ir
->get_next()->is_tail_sentinel()) {
292 ((ir_instruction
*)ir
->get_next())->remove();
293 this->progress
= true;
297 void move_outer_block_inside(ir_instruction
*ir
, exec_list
*inner_block
)
299 while (!ir
->get_next()->is_tail_sentinel()) {
300 ir_instruction
*move_ir
= (ir_instruction
*)ir
->get_next();
303 inner_block
->push_tail(move_ir
);
308 * Insert the instructions necessary to lower a return statement,
309 * before the given return instruction.
311 void insert_lowered_return(ir_return
*ir
)
313 ir_variable
* return_flag
= this->function
.get_return_flag();
314 if(!this->function
.signature
->return_type
->is_void()) {
315 ir_variable
* return_value
= this->function
.get_return_value();
317 new(ir
) ir_assignment(
318 new (ir
) ir_dereference_variable(return_value
),
322 new(ir
) ir_assignment(
323 new (ir
) ir_dereference_variable(return_flag
),
324 new (ir
) ir_constant(true)));
325 this->loop
.may_set_return_flag
= true;
329 * If the given instruction is a return, lower it to instructions
330 * that store the return value (if there is one), set the return
331 * flag, and then break.
333 * It is safe to pass NULL to this function.
335 void lower_return_unconditionally(ir_instruction
*ir
)
337 if (get_jump_strength(ir
) != strength_return
) {
340 insert_lowered_return((ir_return
*)ir
);
341 ir
->replace_with(new(ir
) ir_loop_jump(ir_loop_jump::jump_break
));
345 * Create the necessary instruction to replace a break instruction.
347 ir_instruction
*create_lowered_break()
349 void *ctx
= this->function
.signature
;
350 return new(ctx
) ir_assignment(
351 new(ctx
) ir_dereference_variable(this->loop
.get_break_flag()),
352 new(ctx
) ir_constant(true),
357 * If the given instruction is a break, lower it to an instruction
358 * that sets the break flag, without consulting
359 * should_lower_jump().
361 * It is safe to pass NULL to this function.
363 void lower_break_unconditionally(ir_instruction
*ir
)
365 if (get_jump_strength(ir
) != strength_break
) {
368 ir
->replace_with(create_lowered_break());
372 * If the block ends in a conditional or unconditional break, lower
373 * it, even though should_lower_jump() says it needn't be lowered.
375 void lower_final_breaks(exec_list
*block
)
377 ir_instruction
*ir
= (ir_instruction
*) block
->get_tail();
378 lower_break_unconditionally(ir
);
379 ir_if
*ir_if
= ir
->as_if();
381 lower_break_unconditionally(
382 (ir_instruction
*) ir_if
->then_instructions
.get_tail());
383 lower_break_unconditionally(
384 (ir_instruction
*) ir_if
->else_instructions
.get_tail());
388 virtual void visit(class ir_loop_jump
* ir
)
390 /* Eliminate all instructions after each one, since they are
391 * unreachable. This satisfies the DEAD_CODE_ELIMINATION
394 truncate_after_instruction(ir
);
396 /* Set this->block.min_strength based on this instruction. This
397 * satisfies the ANALYSIS postcondition. It is not necessary to
398 * update this->block.may_clear_execute_flag or
399 * this->loop.may_set_return_flag, because an unlowered jump
400 * instruction can't change any flags.
402 this->block
.min_strength
= ir
->is_break() ? strength_break
: strength_continue
;
404 /* The CONTAINED_JUMPS_LOWERED postcondition is already
405 * satisfied, because jump statements can't contain other
410 virtual void visit(class ir_return
* ir
)
412 /* Eliminate all instructions after each one, since they are
413 * unreachable. This satisfies the DEAD_CODE_ELIMINATION
416 truncate_after_instruction(ir
);
418 /* Set this->block.min_strength based on this instruction. This
419 * satisfies the ANALYSIS postcondition. It is not necessary to
420 * update this->block.may_clear_execute_flag or
421 * this->loop.may_set_return_flag, because an unlowered return
422 * instruction can't change any flags.
424 this->block
.min_strength
= strength_return
;
426 /* The CONTAINED_JUMPS_LOWERED postcondition is already
427 * satisfied, because jump statements can't contain other
432 virtual void visit(class ir_discard
* ir
)
434 /* Nothing needs to be done. The ANALYSIS and
435 * DEAD_CODE_ELIMINATION postconditions are already satisfied,
436 * because discard statements are ignored by this optimization
437 * pass. The CONTAINED_JUMPS_LOWERED postcondition is already
438 * satisfied, because discard statements can't contain other
443 enum jump_strength
get_jump_strength(ir_instruction
* ir
)
446 return strength_none
;
447 else if(ir
->ir_type
== ir_type_loop_jump
) {
448 if(((ir_loop_jump
*)ir
)->is_break())
449 return strength_break
;
451 return strength_continue
;
452 } else if(ir
->ir_type
== ir_type_return
)
453 return strength_return
;
455 return strength_none
;
458 bool should_lower_jump(ir_jump
* ir
)
460 unsigned strength
= get_jump_strength(ir
);
465 lower
= false; /* don't change this, code relies on it */
467 case strength_continue
:
468 lower
= lower_continue
;
471 assert(this->loop
.loop
);
472 /* never lower "canonical break" */
473 if(ir
->get_next()->is_tail_sentinel() && (this->loop
.nesting_depth
== 0
474 || (this->loop
.nesting_depth
== 1 && this->loop
.in_if_at_the_end_of_the_loop
)))
479 case strength_return
:
480 /* never lower return at the end of a this->function */
481 if(this->function
.nesting_depth
== 0 && ir
->get_next()->is_tail_sentinel())
484 lower
= this->function
.lower_return
;
490 block_record
visit_block(exec_list
* list
)
492 /* Note: since visiting a node may change that node's next
493 * pointer, we can't use visit_exec_list(), because
494 * visit_exec_list() caches the node's next pointer before
495 * visiting it. So we use foreach_list() instead.
497 * foreach_list() isn't safe if the node being visited gets
498 * removed, but fortunately this visitor doesn't do that.
501 block_record saved_block
= this->block
;
502 this->block
= block_record();
503 foreach_list(node
, list
) {
504 ((ir_instruction
*) node
)->accept(this);
506 block_record ret
= this->block
;
507 this->block
= saved_block
;
511 virtual void visit(ir_if
*ir
)
513 if(this->loop
.nesting_depth
== 0 && ir
->get_next()->is_tail_sentinel())
514 this->loop
.in_if_at_the_end_of_the_loop
= true;
516 ++this->function
.nesting_depth
;
517 ++this->loop
.nesting_depth
;
519 block_record block_records
[2];
522 /* Recursively lower nested jumps. This satisfies the
523 * CONTAINED_JUMPS_LOWERED postcondition, except in the case of
524 * unconditional jumps at the end of ir->then_instructions and
525 * ir->else_instructions, which are handled below.
527 block_records
[0] = visit_block(&ir
->then_instructions
);
528 block_records
[1] = visit_block(&ir
->else_instructions
);
530 retry
: /* we get here if we put code after the if inside a branch */
532 /* Determine which of ir->then_instructions and
533 * ir->else_instructions end with an unconditional jump.
535 for(unsigned i
= 0; i
< 2; ++i
) {
536 exec_list
& list
= i
? ir
->else_instructions
: ir
->then_instructions
;
538 if(!list
.is_empty() && get_jump_strength((ir_instruction
*)list
.get_tail()))
539 jumps
[i
] = (ir_jump
*)list
.get_tail();
542 /* Loop until we have satisfied the CONTAINED_JUMPS_LOWERED
543 * postcondition by lowering jumps in both then_instructions and
547 /* Determine the types of the jumps that terminate
548 * ir->then_instructions and ir->else_instructions.
550 jump_strength jump_strengths
[2];
552 for(unsigned i
= 0; i
< 2; ++i
) {
554 jump_strengths
[i
] = block_records
[i
].min_strength
;
555 assert(jump_strengths
[i
] == get_jump_strength(jumps
[i
]));
557 jump_strengths
[i
] = strength_none
;
560 /* If both code paths end in a jump, and the jumps are the
561 * same, and we are pulling out jumps, replace them with a
562 * single jump that comes after the if instruction. The new
563 * jump will be visited next, and it will be lowered if
564 * necessary by the loop or conditional that encloses it.
566 if(pull_out_jumps
&& jump_strengths
[0] == jump_strengths
[1]) {
568 if(jump_strengths
[0] == strength_continue
)
569 ir
->insert_after(new(ir
) ir_loop_jump(ir_loop_jump::jump_continue
));
570 else if(jump_strengths
[0] == strength_break
)
571 ir
->insert_after(new(ir
) ir_loop_jump(ir_loop_jump::jump_break
));
572 /* FINISHME: unify returns with identical expressions */
573 else if(jump_strengths
[0] == strength_return
&& this->function
.signature
->return_type
->is_void())
574 ir
->insert_after(new(ir
) ir_return(NULL
));
581 this->progress
= true;
583 /* Update jumps[] to reflect the fact that the jumps
584 * are gone, and update block_records[] to reflect the
585 * fact that control can now flow to the next
590 block_records
[0].min_strength
= strength_none
;
591 block_records
[1].min_strength
= strength_none
;
593 /* The CONTAINED_JUMPS_LOWERED postcondition is now
594 * satisfied, so we can break out of the loop.
600 /* lower a jump: if both need to lowered, start with the strongest one, so that
601 * we might later unify the lowered version with the other one
603 bool should_lower
[2];
604 for(unsigned i
= 0; i
< 2; ++i
)
605 should_lower
[i
] = should_lower_jump(jumps
[i
]);
608 if(should_lower
[1] && should_lower
[0])
609 lower
= jump_strengths
[1] > jump_strengths
[0];
610 else if(should_lower
[0])
612 else if(should_lower
[1])
615 /* Neither code path ends in a jump that needs to be
616 * lowered, so the CONTAINED_JUMPS_LOWERED postcondition
617 * is satisfied and we can break out of the loop.
621 if(jump_strengths
[lower
] == strength_return
) {
622 /* To lower a return, we create a return flag (if the
623 * function doesn't have one already) and add instructions
624 * that: 1. store the return value (if this function has a
625 * non-void return) and 2. set the return flag
627 insert_lowered_return((ir_return
*)jumps
[lower
]);
628 if(this->loop
.loop
) {
629 /* If we are in a loop, replace the return instruction
630 * with a break instruction, and then loop so that the
631 * break instruction can be lowered if necessary.
633 ir_loop_jump
* lowered
= 0;
634 lowered
= new(ir
) ir_loop_jump(ir_loop_jump::jump_break
);
635 /* Note: we must update block_records and jumps to
636 * reflect the fact that the control path has been
637 * altered from a return to a break.
639 block_records
[lower
].min_strength
= strength_break
;
640 jumps
[lower
]->replace_with(lowered
);
641 jumps
[lower
] = lowered
;
643 /* If we are not in a loop, we then proceed as we would
644 * for a continue statement (set the execute flag to
645 * false to prevent the rest of the function from
650 this->progress
= true;
651 } else if(jump_strengths
[lower
] == strength_break
) {
652 /* To lower a break, we create a break flag (if the loop
653 * doesn't have one already) and add an instruction that
656 * Then we proceed as we would for a continue statement
657 * (set the execute flag to false to prevent the rest of
658 * the loop body from executing).
660 * The visit() function for the loop will ensure that the
661 * break flag is checked after executing the loop body.
663 jumps
[lower
]->insert_before(create_lowered_break());
665 } else if(jump_strengths
[lower
] == strength_continue
) {
667 /* To lower a continue, we create an execute flag (if the
668 * loop doesn't have one already) and replace the continue
669 * with an instruction that clears it.
671 * Note that this code path gets exercised when lowering
672 * return statements that are not inside a loop, so
673 * this->loop must be initialized even outside of loops.
675 ir_variable
* execute_flag
= this->loop
.get_execute_flag();
676 jumps
[lower
]->replace_with(new(ir
) ir_assignment(new (ir
) ir_dereference_variable(execute_flag
), new (ir
) ir_constant(false), 0));
677 /* Note: we must update block_records and jumps to reflect
678 * the fact that the control path has been altered to an
679 * instruction that clears the execute flag.
682 block_records
[lower
].min_strength
= strength_always_clears_execute_flag
;
683 block_records
[lower
].may_clear_execute_flag
= true;
684 this->progress
= true;
686 /* Let the loop run again, in case the other branch of the
687 * if needs to be lowered too.
692 /* move out a jump out if possible */
694 /* If one of the branches ends in a jump, and control cannot
695 * fall out the bottom of the other branch, then we can move
696 * the jump after the if.
698 * Set move_out to the branch we are moving a jump out of.
701 if(jumps
[0] && block_records
[1].min_strength
>= strength_continue
)
703 else if(jumps
[1] && block_records
[0].min_strength
>= strength_continue
)
708 jumps
[move_out
]->remove();
709 ir
->insert_after(jumps
[move_out
]);
710 /* Note: we must update block_records and jumps to reflect
711 * the fact that the jump has been moved out of the if.
714 block_records
[move_out
].min_strength
= strength_none
;
715 this->progress
= true;
719 /* Now satisfy the ANALYSIS postcondition by setting
720 * this->block.min_strength and
721 * this->block.may_clear_execute_flag based on the
722 * characteristics of the two branches.
724 if(block_records
[0].min_strength
< block_records
[1].min_strength
)
725 this->block
.min_strength
= block_records
[0].min_strength
;
727 this->block
.min_strength
= block_records
[1].min_strength
;
728 this->block
.may_clear_execute_flag
= this->block
.may_clear_execute_flag
|| block_records
[0].may_clear_execute_flag
|| block_records
[1].may_clear_execute_flag
;
730 /* Now we need to clean up the instructions that follow the
733 * If those instructions are unreachable, then satisfy the
734 * DEAD_CODE_ELIMINATION postcondition by eliminating them.
735 * Otherwise that postcondition is already satisfied.
737 if(this->block
.min_strength
)
738 truncate_after_instruction(ir
);
739 else if(this->block
.may_clear_execute_flag
)
741 /* If the "if" instruction might clear the execute flag, then
742 * we need to guard any instructions that follow so that they
743 * are only executed if the execute flag is set.
745 * If one of the branches of the "if" always clears the
746 * execute flag, and the other branch never clears it, then
747 * this is easy: just move all the instructions following the
748 * "if" into the branch that never clears it.
751 if(block_records
[0].min_strength
&& !block_records
[1].may_clear_execute_flag
)
753 else if(block_records
[1].min_strength
&& !block_records
[0].may_clear_execute_flag
)
757 assert(!block_records
[move_into
].min_strength
&& !block_records
[move_into
].may_clear_execute_flag
); /* otherwise, we just truncated */
759 exec_list
* list
= move_into
? &ir
->else_instructions
: &ir
->then_instructions
;
760 exec_node
* next
= ir
->get_next();
761 if(!next
->is_tail_sentinel()) {
762 move_outer_block_inside(ir
, list
);
764 /* If any instructions moved, then we need to visit
765 * them (since they are now inside the "if"). Since
766 * block_records[move_into] is in its default state
767 * (see assertion above), we can safely replace
768 * block_records[move_into] with the result of this
773 block_records
[move_into
] = visit_block(&list
);
776 * Then we need to re-start our jump lowering, since one
777 * of the instructions we moved might be a jump that
778 * needs to be lowered.
780 this->progress
= true;
784 /* If we get here, then the simple case didn't apply; we
785 * need to actually guard the instructions that follow.
787 * To avoid creating unnecessarily-deep nesting, first
788 * look through the instructions that follow and unwrap
789 * any instructions that that are already wrapped in the
792 ir_instruction
* ir_after
;
793 for(ir_after
= (ir_instruction
*)ir
->get_next(); !ir_after
->is_tail_sentinel();)
795 ir_if
* ir_if
= ir_after
->as_if();
796 if(ir_if
&& ir_if
->else_instructions
.is_empty()) {
797 ir_dereference_variable
* ir_if_cond_deref
= ir_if
->condition
->as_dereference_variable();
798 if(ir_if_cond_deref
&& ir_if_cond_deref
->var
== this->loop
.execute_flag
) {
799 ir_instruction
* ir_next
= (ir_instruction
*)ir_after
->get_next();
800 ir_after
->insert_before(&ir_if
->then_instructions
);
806 ir_after
= (ir_instruction
*)ir_after
->get_next();
808 /* only set this if we find any unprotected instruction */
809 this->progress
= true;
812 /* Then, wrap all the instructions that follow in a single
815 if(!ir
->get_next()->is_tail_sentinel()) {
816 assert(this->loop
.execute_flag
);
817 ir_if
* if_execute
= new(ir
) ir_if(new(ir
) ir_dereference_variable(this->loop
.execute_flag
));
818 move_outer_block_inside(ir
, &if_execute
->then_instructions
);
819 ir
->insert_after(if_execute
);
823 --this->loop
.nesting_depth
;
824 --this->function
.nesting_depth
;
827 virtual void visit(ir_loop
*ir
)
829 /* Visit the body of the loop, with a fresh data structure in
830 * this->loop so that the analysis we do here won't bleed into
833 * We assume that all code after a loop is reachable from the
834 * loop (see comments on enum jump_strength), so the
835 * DEAD_CODE_ELIMINATION postcondition is automatically
836 * satisfied, as is the block.min_strength portion of the
837 * ANALYSIS postcondition.
839 * The block.may_clear_execute_flag portion of the ANALYSIS
840 * postcondition is automatically satisfied because execute
841 * flags do not propagate outside of loops.
843 * The loop.may_set_return_flag portion of the ANALYSIS
844 * postcondition is handled below.
846 ++this->function
.nesting_depth
;
847 loop_record saved_loop
= this->loop
;
848 this->loop
= loop_record(this->function
.signature
, ir
);
850 /* Recursively lower nested jumps. This satisfies the
851 * CONTAINED_JUMPS_LOWERED postcondition, except in the case of
852 * an unconditional continue or return at the bottom of the
853 * loop, which are handled below.
855 block_record body
= visit_block(&ir
->body_instructions
);
857 /* If the loop ends in an unconditional continue, eliminate it
858 * because it is redundant.
860 ir_instruction
*ir_last
861 = (ir_instruction
*) ir
->body_instructions
.get_tail();
862 if (get_jump_strength(ir_last
) == strength_continue
) {
866 /* If the loop ends in an unconditional return, and we are
867 * lowering returns, lower it.
869 if (this->function
.lower_return
)
870 lower_return_unconditionally(ir_last
);
872 if(body
.min_strength
>= strength_break
) {
873 /* FINISHME: If the min_strength of the loop body is
874 * strength_break or strength_return, that means that it
875 * isn't a loop at all, since control flow always leaves the
876 * body of the loop via break or return. In principle the
877 * loop could be eliminated in this case. This optimization
878 * is not implemented yet.
882 if(this->loop
.break_flag
) {
883 /* We only get here if we are lowering breaks */
884 assert (lower_break
);
886 /* If a break flag was generated while visiting the body of
887 * the loop, then at least one break was lowered, so we need
888 * to generate an if statement at the end of the loop that
889 * does a "break" if the break flag is set. The break we
890 * generate won't violate the CONTAINED_JUMPS_LOWERED
891 * postcondition, because should_lower_jump() always returns
892 * false for a break that happens at the end of a loop.
894 * However, if the loop already ends in a conditional or
895 * unconditional break, then we need to lower that break,
896 * because it won't be at the end of the loop anymore.
898 lower_final_breaks(&ir
->body_instructions
);
900 ir_if
* break_if
= new(ir
) ir_if(new(ir
) ir_dereference_variable(this->loop
.break_flag
));
901 break_if
->then_instructions
.push_tail(new(ir
) ir_loop_jump(ir_loop_jump::jump_break
));
902 ir
->body_instructions
.push_tail(break_if
);
905 /* If the body of the loop may set the return flag, then at
906 * least one return was lowered to a break, so we need to ensure
907 * that the return flag is checked after the body of the loop is
910 if(this->loop
.may_set_return_flag
) {
911 assert(this->function
.return_flag
);
912 /* Generate the if statement to check the return flag */
913 ir_if
* return_if
= new(ir
) ir_if(new(ir
) ir_dereference_variable(this->function
.return_flag
));
914 /* Note: we also need to propagate the knowledge that the
915 * return flag may get set to the outer context. This
916 * satisfies the loop.may_set_return_flag part of the
917 * ANALYSIS postcondition.
919 saved_loop
.may_set_return_flag
= true;
921 /* If this loop is nested inside another one, then the if
922 * statement that we generated should break out of that
923 * loop if the return flag is set. Caller will lower that
924 * break statement if necessary.
926 return_if
->then_instructions
.push_tail(new(ir
) ir_loop_jump(ir_loop_jump::jump_break
));
928 /* Otherwise, all we need to do is ensure that the
929 * instructions that follow are only executed if the
930 * return flag is clear. We can do that by moving those
931 * instructions into the else clause of the generated if
934 move_outer_block_inside(ir
, &return_if
->else_instructions
);
935 ir
->insert_after(return_if
);
938 this->loop
= saved_loop
;
939 --this->function
.nesting_depth
;
942 virtual void visit(ir_function_signature
*ir
)
944 /* these are not strictly necessary */
945 assert(!this->function
.signature
);
946 assert(!this->loop
.loop
);
949 if (strcmp(ir
->function_name(), "main") == 0)
950 lower_return
= lower_main_return
;
952 lower_return
= lower_sub_return
;
954 function_record saved_function
= this->function
;
955 loop_record saved_loop
= this->loop
;
956 this->function
= function_record(ir
, lower_return
);
957 this->loop
= loop_record(ir
);
959 assert(!this->loop
.loop
);
961 /* Visit the body of the function to lower any jumps that occur
962 * in it, except possibly an unconditional return statement at
965 visit_block(&ir
->body
);
967 /* If the body ended in an unconditional return of non-void,
968 * then we don't need to lower it because it's the one canonical
971 * If the body ended in a return of void, eliminate it because
974 if (ir
->return_type
->is_void() &&
975 get_jump_strength((ir_instruction
*) ir
->body
.get_tail())) {
976 ir_jump
*jump
= (ir_jump
*) ir
->body
.get_tail();
977 assert (jump
->ir_type
== ir_type_return
);
981 if(this->function
.return_value
)
982 ir
->body
.push_tail(new(ir
) ir_return(new (ir
) ir_dereference_variable(this->function
.return_value
)));
984 this->loop
= saved_loop
;
985 this->function
= saved_function
;
988 virtual void visit(class ir_function
* ir
)
990 visit_block(&ir
->signatures
);
995 do_lower_jumps(exec_list
*instructions
, bool pull_out_jumps
, bool lower_sub_return
, bool lower_main_return
, bool lower_continue
, bool lower_break
)
997 ir_lower_jumps_visitor v
;
998 v
.pull_out_jumps
= pull_out_jumps
;
999 v
.lower_continue
= lower_continue
;
1000 v
.lower_break
= lower_break
;
1001 v
.lower_sub_return
= lower_sub_return
;
1002 v
.lower_main_return
= lower_main_return
;
1006 visit_exec_list(instructions
, &v
);
1007 } while (v
.progress
);