0,0 → 1,570 |
/* |
* Copyright © 2010 Luca Barbieri |
* |
* Permission is hereby granted, free of charge, to any person obtaining a |
* copy of this software and associated documentation files (the "Software"), |
* to deal in the Software without restriction, including without limitation |
* the rights to use, copy, modify, merge, publish, distribute, sublicense, |
* and/or sell copies of the Software, and to permit persons to whom the |
* Software is furnished to do so, subject to the following conditions: |
* |
* The above copyright notice and this permission notice (including the next |
* paragraph) shall be included in all copies or substantial portions of the |
* Software. |
* |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
* DEALINGS IN THE SOFTWARE. |
*/ |
|
/** |
* \file lower_jumps.cpp |
* |
* This pass lowers jumps (break, continue, and return) to if/else structures. |
* |
* It can be asked to: |
* 1. Pull jumps out of ifs where possible |
* 2. Remove all "continue"s, replacing them with an "execute flag" |
* 3. Replace all "break" with a single conditional one at the end of the loop |
* 4. Replace all "return"s with a single return at the end of the function, |
* for the main function and/or other functions |
* |
* Applying this pass gives several benefits: |
* 1. All functions can be inlined. |
* 2. nv40 and other pre-DX10 chips without "continue" can be supported |
* 3. nv30 and other pre-DX10 chips with no control flow at all are better |
* supported |
* |
* Continues are lowered by adding a per-loop "execute flag", initialized to |
* true, that when cleared inhibits all execution until the end of the loop. |
* |
* Breaks are lowered to continues, plus setting a "break flag" that is checked |
* at the end of the loop, and trigger the unique "break". |
* |
* Returns are lowered to breaks/continues, plus adding a "return flag" that |
* causes loops to break again out of their enclosing loops until all the |
* loops are exited: then the "execute flag" logic will ignore everything |
* until the end of the function. |
* |
* Note that "continue" and "return" can also be implemented by adding |
* a dummy loop and using break. |
* However, this is bad for hardware with limited nesting depth, and |
* prevents further optimization, and thus is not currently performed. |
*/ |
|
#include "glsl_types.h" |
#include <string.h> |
#include "ir.h" |
|
enum jump_strength |
{ |
strength_none, |
strength_always_clears_execute_flag, |
strength_continue, |
strength_break, |
strength_return, |
}; |
|
struct block_record |
{ |
/* minimum jump strength (of lowered IR, not pre-lowering IR) |
* |
* If the block ends with a jump, must be the strength of the jump. |
* Otherwise, the jump would be dead and have been deleted before) |
* |
* 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 |
* (e.g. an if with a return in one branch, and a break in the other, while not lowering them) |
* Note that identical jumps are usually unified though. |
*/ |
jump_strength min_strength; |
|
/* can anything clear the execute flag? */ |
bool may_clear_execute_flag; |
|
block_record() |
{ |
this->min_strength = strength_none; |
this->may_clear_execute_flag = false; |
} |
}; |
|
struct loop_record |
{ |
ir_function_signature* signature; |
ir_loop* loop; |
|
/* used to avoid lowering the break used to represent lowered breaks */ |
unsigned nesting_depth; |
bool in_if_at_the_end_of_the_loop; |
|
bool may_set_return_flag; |
|
ir_variable* break_flag; |
ir_variable* execute_flag; /* cleared to emulate continue */ |
|
loop_record(ir_function_signature* p_signature = 0, ir_loop* p_loop = 0) |
{ |
this->signature = p_signature; |
this->loop = p_loop; |
this->nesting_depth = 0; |
this->in_if_at_the_end_of_the_loop = false; |
this->may_set_return_flag = false; |
this->break_flag = 0; |
this->execute_flag = 0; |
} |
|
ir_variable* get_execute_flag() |
{ |
/* also supported for the "function loop" */ |
if(!this->execute_flag) { |
exec_list& list = this->loop ? this->loop->body_instructions : signature->body; |
this->execute_flag = new(this->signature) ir_variable(glsl_type::bool_type, "execute_flag", ir_var_temporary); |
list.push_head(new(this->signature) ir_assignment(new(this->signature) ir_dereference_variable(execute_flag), new(this->signature) ir_constant(true), 0)); |
list.push_head(this->execute_flag); |
} |
return this->execute_flag; |
} |
|
ir_variable* get_break_flag() |
{ |
assert(this->loop); |
if(!this->break_flag) { |
this->break_flag = new(this->signature) ir_variable(glsl_type::bool_type, "break_flag", ir_var_temporary); |
this->loop->insert_before(this->break_flag); |
this->loop->insert_before(new(this->signature) ir_assignment(new(this->signature) ir_dereference_variable(break_flag), new(this->signature) ir_constant(false), 0)); |
} |
return this->break_flag; |
} |
}; |
|
struct function_record |
{ |
ir_function_signature* signature; |
ir_variable* return_flag; /* used to break out of all loops and then jump to the return instruction */ |
ir_variable* return_value; |
bool is_main; |
unsigned nesting_depth; |
|
function_record(ir_function_signature* p_signature = 0) |
{ |
this->signature = p_signature; |
this->return_flag = 0; |
this->return_value = 0; |
this->nesting_depth = 0; |
this->is_main = this->signature && (strcmp(this->signature->function_name(), "main") == 0); |
} |
|
ir_variable* get_return_flag() |
{ |
if(!this->return_flag) { |
this->return_flag = new(this->signature) ir_variable(glsl_type::bool_type, "return_flag", ir_var_temporary); |
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)); |
this->signature->body.push_head(this->return_flag); |
} |
return this->return_flag; |
} |
|
ir_variable* get_return_value() |
{ |
if(!this->return_value) { |
assert(!this->signature->return_type->is_void()); |
return_value = new(this->signature) ir_variable(this->signature->return_type, "return_value", ir_var_temporary); |
this->signature->body.push_head(this->return_value); |
} |
return this->return_value; |
} |
}; |
|
struct ir_lower_jumps_visitor : public ir_control_flow_visitor { |
bool progress; |
|
struct function_record function; |
struct loop_record loop; |
struct block_record block; |
|
bool pull_out_jumps; |
bool lower_continue; |
bool lower_break; |
bool lower_sub_return; |
bool lower_main_return; |
|
ir_lower_jumps_visitor() |
{ |
this->progress = false; |
} |
|
void truncate_after_instruction(exec_node *ir) |
{ |
if (!ir) |
return; |
|
while (!ir->get_next()->is_tail_sentinel()) { |
((ir_instruction *)ir->get_next())->remove(); |
this->progress = true; |
} |
} |
|
void move_outer_block_inside(ir_instruction *ir, exec_list *inner_block) |
{ |
while (!ir->get_next()->is_tail_sentinel()) { |
ir_instruction *move_ir = (ir_instruction *)ir->get_next(); |
|
move_ir->remove(); |
inner_block->push_tail(move_ir); |
} |
} |
|
virtual void visit(class ir_loop_jump * ir) |
{ |
truncate_after_instruction(ir); |
this->block.min_strength = ir->is_break() ? strength_break : strength_continue; |
} |
|
virtual void visit(class ir_return * ir) |
{ |
truncate_after_instruction(ir); |
this->block.min_strength = strength_return; |
} |
|
virtual void visit(class ir_discard * ir) |
{ |
} |
|
enum jump_strength get_jump_strength(ir_instruction* ir) |
{ |
if(!ir) |
return strength_none; |
else if(ir->ir_type == ir_type_loop_jump) { |
if(((ir_loop_jump*)ir)->is_break()) |
return strength_break; |
else |
return strength_continue; |
} else if(ir->ir_type == ir_type_return) |
return strength_return; |
else |
return strength_none; |
} |
|
bool should_lower_jump(ir_jump* ir) |
{ |
unsigned strength = get_jump_strength(ir); |
bool lower; |
switch(strength) |
{ |
case strength_none: |
lower = false; /* don't change this, code relies on it */ |
break; |
case strength_continue: |
lower = lower_continue; |
break; |
case strength_break: |
assert(this->loop.loop); |
/* never lower "canonical break" */ |
if(ir->get_next()->is_tail_sentinel() && (this->loop.nesting_depth == 0 |
|| (this->loop.nesting_depth == 1 && this->loop.in_if_at_the_end_of_the_loop))) |
lower = false; |
else |
lower = lower_break; |
break; |
case strength_return: |
/* never lower return at the end of a this->function */ |
if(this->function.nesting_depth == 0 && ir->get_next()->is_tail_sentinel()) |
lower = false; |
else if (this->function.is_main) |
lower = lower_main_return; |
else |
lower = lower_sub_return; |
break; |
} |
return lower; |
} |
|
block_record visit_block(exec_list* list) |
{ |
block_record saved_block = this->block; |
this->block = block_record(); |
visit_exec_list(list, this); |
block_record ret = this->block; |
this->block = saved_block; |
return ret; |
} |
|
virtual void visit(ir_if *ir) |
{ |
if(this->loop.nesting_depth == 0 && ir->get_next()->is_tail_sentinel()) |
this->loop.in_if_at_the_end_of_the_loop = true; |
|
++this->function.nesting_depth; |
++this->loop.nesting_depth; |
|
block_record block_records[2]; |
ir_jump* jumps[2]; |
|
block_records[0] = visit_block(&ir->then_instructions); |
block_records[1] = visit_block(&ir->else_instructions); |
|
retry: /* we get here if we put code after the if inside a branch */ |
for(unsigned i = 0; i < 2; ++i) { |
exec_list& list = i ? ir->else_instructions : ir->then_instructions; |
jumps[i] = 0; |
if(!list.is_empty() && get_jump_strength((ir_instruction*)list.get_tail())) |
jumps[i] = (ir_jump*)list.get_tail(); |
} |
|
for(;;) { |
jump_strength jump_strengths[2]; |
|
for(unsigned i = 0; i < 2; ++i) { |
if(jumps[i]) { |
jump_strengths[i] = block_records[i].min_strength; |
assert(jump_strengths[i] == get_jump_strength(jumps[i])); |
} else |
jump_strengths[i] = strength_none; |
} |
|
/* move both jumps out if possible */ |
if(pull_out_jumps && jump_strengths[0] == jump_strengths[1]) { |
bool unify = true; |
if(jump_strengths[0] == strength_continue) |
ir->insert_after(new(ir) ir_loop_jump(ir_loop_jump::jump_continue)); |
else if(jump_strengths[0] == strength_break) |
ir->insert_after(new(ir) ir_loop_jump(ir_loop_jump::jump_break)); |
/* FINISHME: unify returns with identical expressions */ |
else if(jump_strengths[0] == strength_return && this->function.signature->return_type->is_void()) |
ir->insert_after(new(ir) ir_return(NULL)); |
else |
unify = false; |
|
if(unify) { |
jumps[0]->remove(); |
jumps[1]->remove(); |
this->progress = true; |
|
jumps[0] = 0; |
jumps[1] = 0; |
block_records[0].min_strength = strength_none; |
block_records[1].min_strength = strength_none; |
break; |
} |
} |
|
/* lower a jump: if both need to lowered, start with the strongest one, so that |
* we might later unify the lowered version with the other one |
*/ |
bool should_lower[2]; |
for(unsigned i = 0; i < 2; ++i) |
should_lower[i] = should_lower_jump(jumps[i]); |
|
int lower; |
if(should_lower[1] && should_lower[0]) |
lower = jump_strengths[1] > jump_strengths[0]; |
else if(should_lower[0]) |
lower = 0; |
else if(should_lower[1]) |
lower = 1; |
else |
break; |
|
if(jump_strengths[lower] == strength_return) { |
ir_variable* return_flag = this->function.get_return_flag(); |
if(!this->function.signature->return_type->is_void()) { |
ir_variable* return_value = this->function.get_return_value(); |
jumps[lower]->insert_before(new(ir) ir_assignment(new (ir) ir_dereference_variable(return_value), ((ir_return*)jumps[lower])->value, NULL)); |
} |
jumps[lower]->insert_before(new(ir) ir_assignment(new (ir) ir_dereference_variable(return_flag), new (ir) ir_constant(true), NULL)); |
this->loop.may_set_return_flag = true; |
if(this->loop.loop) { |
ir_loop_jump* lowered = 0; |
lowered = new(ir) ir_loop_jump(ir_loop_jump::jump_break); |
block_records[lower].min_strength = strength_break; |
jumps[lower]->replace_with(lowered); |
jumps[lower] = lowered; |
} else |
goto lower_continue; |
this->progress = true; |
} else if(jump_strengths[lower] == strength_break) { |
/* We can't lower to an actual continue because that would execute the increment. |
* |
* In the lowered code, we instead put the break check between the this->loop body and the increment, |
* which is impossible with a real continue as defined by the GLSL IR currently. |
* |
* Smarter options (such as undoing the increment) are possible but it's not worth implementing them, |
* because if break is lowered, continue is almost surely lowered too. |
*/ |
jumps[lower]->insert_before(new(ir) ir_assignment(new (ir) ir_dereference_variable(this->loop.get_break_flag()), new (ir) ir_constant(true), 0)); |
goto lower_continue; |
} else if(jump_strengths[lower] == strength_continue) { |
lower_continue: |
ir_variable* execute_flag = this->loop.get_execute_flag(); |
jumps[lower]->replace_with(new(ir) ir_assignment(new (ir) ir_dereference_variable(execute_flag), new (ir) ir_constant(false), 0)); |
jumps[lower] = 0; |
block_records[lower].min_strength = strength_always_clears_execute_flag; |
block_records[lower].may_clear_execute_flag = true; |
this->progress = true; |
break; |
} |
} |
|
/* move out a jump out if possible */ |
if(pull_out_jumps) { |
int move_out = -1; |
if(jumps[0] && block_records[1].min_strength >= strength_continue) |
move_out = 0; |
else if(jumps[1] && block_records[0].min_strength >= strength_continue) |
move_out = 1; |
|
if(move_out >= 0) |
{ |
jumps[move_out]->remove(); |
ir->insert_after(jumps[move_out]); |
jumps[move_out] = 0; |
block_records[move_out].min_strength = strength_none; |
this->progress = true; |
} |
} |
|
if(block_records[0].min_strength < block_records[1].min_strength) |
this->block.min_strength = block_records[0].min_strength; |
else |
this->block.min_strength = block_records[1].min_strength; |
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; |
|
if(this->block.min_strength) |
truncate_after_instruction(ir); |
else if(this->block.may_clear_execute_flag) |
{ |
int move_into = -1; |
if(block_records[0].min_strength && !block_records[1].may_clear_execute_flag) |
move_into = 1; |
else if(block_records[1].min_strength && !block_records[0].may_clear_execute_flag) |
move_into = 0; |
|
if(move_into >= 0) { |
assert(!block_records[move_into].min_strength && !block_records[move_into].may_clear_execute_flag); /* otherwise, we just truncated */ |
|
exec_list* list = move_into ? &ir->else_instructions : &ir->then_instructions; |
exec_node* next = ir->get_next(); |
if(!next->is_tail_sentinel()) { |
move_outer_block_inside(ir, list); |
|
exec_list list; |
list.head = next; |
block_records[move_into] = visit_block(&list); |
|
this->progress = true; |
goto retry; |
} |
} else { |
ir_instruction* ir_after; |
for(ir_after = (ir_instruction*)ir->get_next(); !ir_after->is_tail_sentinel();) |
{ |
ir_if* ir_if = ir_after->as_if(); |
if(ir_if && ir_if->else_instructions.is_empty()) { |
ir_dereference_variable* ir_if_cond_deref = ir_if->condition->as_dereference_variable(); |
if(ir_if_cond_deref && ir_if_cond_deref->var == this->loop.execute_flag) { |
ir_instruction* ir_next = (ir_instruction*)ir_after->get_next(); |
ir_after->insert_before(&ir_if->then_instructions); |
ir_after->remove(); |
ir_after = ir_next; |
continue; |
} |
} |
ir_after = (ir_instruction*)ir_after->get_next(); |
|
/* only set this if we find any unprotected instruction */ |
this->progress = true; |
} |
|
if(!ir->get_next()->is_tail_sentinel()) { |
assert(this->loop.execute_flag); |
ir_if* if_execute = new(ir) ir_if(new(ir) ir_dereference_variable(this->loop.execute_flag)); |
move_outer_block_inside(ir, &if_execute->then_instructions); |
ir->insert_after(if_execute); |
} |
} |
} |
--this->loop.nesting_depth; |
--this->function.nesting_depth; |
} |
|
virtual void visit(ir_loop *ir) |
{ |
++this->function.nesting_depth; |
loop_record saved_loop = this->loop; |
this->loop = loop_record(this->function.signature, ir); |
|
block_record body = visit_block(&ir->body_instructions); |
|
if(body.min_strength >= strength_break) { |
/* FINISHME: turn the this->loop into an if, or replace it with its body */ |
} |
|
if(this->loop.break_flag) { |
ir_if* break_if = new(ir) ir_if(new(ir) ir_dereference_variable(this->loop.break_flag)); |
break_if->then_instructions.push_tail(new(ir) ir_loop_jump(ir_loop_jump::jump_break)); |
ir->body_instructions.push_tail(break_if); |
} |
|
if(this->loop.may_set_return_flag) { |
assert(this->function.return_flag); |
ir_if* return_if = new(ir) ir_if(new(ir) ir_dereference_variable(this->function.return_flag)); |
saved_loop.may_set_return_flag = true; |
if(saved_loop.loop) |
return_if->then_instructions.push_tail(new(ir) ir_loop_jump(ir_loop_jump::jump_break)); |
else |
move_outer_block_inside(ir, &return_if->else_instructions); |
ir->insert_after(return_if); |
} |
|
this->loop = saved_loop; |
--this->function.nesting_depth; |
} |
|
virtual void visit(ir_function_signature *ir) |
{ |
/* these are not strictly necessary */ |
assert(!this->function.signature); |
assert(!this->loop.loop); |
|
function_record saved_function = this->function; |
loop_record saved_loop = this->loop; |
this->function = function_record(ir); |
this->loop = loop_record(ir); |
|
assert(!this->loop.loop); |
visit_block(&ir->body); |
|
if(this->function.return_value) |
ir->body.push_tail(new(ir) ir_return(new (ir) ir_dereference_variable(this->function.return_value))); |
|
this->loop = saved_loop; |
this->function = saved_function; |
} |
|
virtual void visit(class ir_function * ir) |
{ |
visit_block(&ir->signatures); |
} |
}; |
|
bool |
do_lower_jumps(exec_list *instructions, bool pull_out_jumps, bool lower_sub_return, bool lower_main_return, bool lower_continue, bool lower_break) |
{ |
ir_lower_jumps_visitor v; |
v.pull_out_jumps = pull_out_jumps; |
v.lower_continue = lower_continue; |
v.lower_break = lower_break; |
v.lower_sub_return = lower_sub_return; |
v.lower_main_return = lower_main_return; |
|
do { |
v.progress = false; |
visit_exec_list(instructions, &v); |
} while (v.progress); |
|
return v.progress; |
} |