[Mesa-dev] [PATCH 06/11] glsl: Refactor logic for determining whether to lower return statements.

[Kenneth Graunke]

On 07/05/2011 03:07 PM, Paul Berry wrote:
> Previously, do_lower_jumps.cpp determined whether to lower return
> statements in ir_lower_jumps_visitor::should_lower_jumps().  Moved
> this logic to ir_lower_jumps_visitor::visit(ir_function_signature *),
> so that it can be used in determining whether to lower a return
> statement at the end of a function.
> ---
>   src/glsl/lower_jumps.cpp |   19 ++++++++++++-------
>   1 files changed, 12 insertions(+), 7 deletions(-)
>
> diff --git a/src/glsl/lower_jumps.cpp b/src/glsl/lower_jumps.cpp
> index da85c6b..fa247c6 100644
> --- a/src/glsl/lower_jumps.cpp
> +++ b/src/glsl/lower_jumps.cpp
> @@ -210,16 +210,17 @@ 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;
> +   bool lower_return;
>      unsigned nesting_depth;
>
> -   function_record(ir_function_signature* p_signature = 0)
> +   function_record(ir_function_signature* p_signature = 0,
> +                   bool lower_return = false)
>      {
>         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);
> +      this->lower_return = lower_return;
>      }
>
>      ir_variable* get_return_flag()
> @@ -398,10 +399,8 @@ struct ir_lower_jumps_visitor : public ir_control_flow_visitor {
>            /* 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;
> +            lower = this->function.lower_return;
>            break;
>         }
>         return lower;
> @@ -833,9 +832,15 @@ lower_continue:
>         assert(!this->function.signature);
>         assert(!this->loop.loop);
>
> +      bool lower_return;
> +      if (strcmp(ir->function_name(), "main") == 0)
> +         lower_return = lower_main_return;
> +      else
> +         lower_return = lower_sub_return;

What exactly is the difference between lowering returns in "main" and 
lowering them in other subroutines?  void vs. non-void is definitely 
different, but I don't see why main is special.  Looking at the code, it 
doesn't actually seem to use lower_main_return anywhere...

(I realize this code was already there, but as long as you're cleaning 
it up, maybe that can just get removed...)

>         function_record saved_function = this->function;
>         loop_record saved_loop = this->loop;
> -      this->function = function_record(ir);
> +      this->function = function_record(ir, lower_return);
>         this->loop = loop_record(ir);
>
>         assert(!this->loop.loop);