Switch to Mesa 7.9.

media-libs/mesa/files/7.9-optimize-discards.patch

+Backport of the following to 7.9:
+
+Module: Mesa
+Branch: master
+Commit: 9a1d063c6d679c2155f5eb80f1cb94368d36bf2c
+URL:    
+http://cgit.freedesktop.org/mesa/mesa/commit/?id=9a1d063c6d679c2155f5eb80f1cb94368d36bf2c
+
+Author: Kenneth Graunke <kenn...@whitecape.org>
+Date:   Wed Nov 24 22:02:26 2010 -0800
+
+glsl: Add an optimization pass to simplify discards.
+
+NOTE: This is a candidate for the 7.9 branch.
+
+diff -Naurp Mesa-7.9.orig/src/glsl/Makefile Mesa-7.9.work/src/glsl/Makefile
+--- Mesa-7.9.orig/src/glsl/Makefile     2010-12-07 18:22:17.511752000 -0800
++++ Mesa-7.9.work/src/glsl/Makefile     2010-12-13 10:54:43.571340000 -0800
+@@ -78,6 +78,7 @@ CXX_SOURCES = \
+        lower_noise.cpp \
+        lower_variable_index_to_cond_assign.cpp \
+        opt_redundant_jumps.cpp \
++       opt_discard_simplification.cpp \
+        s_expression.cpp
+ 
+ LIBS = \
+diff -Naurp Mesa-7.9.orig/src/glsl/SConscript Mesa-7.9.work/src/glsl/SConscript
+--- Mesa-7.9.orig/src/glsl/SConscript   2010-12-07 18:22:17.518757000 -0800
++++ Mesa-7.9.work/src/glsl/SConscript   2010-12-13 10:57:23.191339000 -0800
+@@ -75,6 +75,7 @@ sources = [
+     'lower_noise.cpp',
+     'lower_variable_index_to_cond_assign.cpp',
+     'opt_redundant_jumps.cpp',
++    'opt_discard_simplification.cpp',
+     's_expression.cpp',
+ ]
+ 
+diff -Naurp Mesa-7.9.orig/src/glsl/glsl_parser_extras.cpp Mesa-7.9.work/src/glsl/glsl_parser_extras.cpp
+--- Mesa-7.9.orig/src/glsl/glsl_parser_extras.cpp       2010-12-07 18:22:17.639797000 -0800
++++ Mesa-7.9.work/src/glsl/glsl_parser_extras.cpp       2010-12-13 10:54:15.435625000 -0800
+@@ -702,6 +702,7 @@ do_common_optimization(exec_list *ir, bo
+    }
+    progress = do_structure_splitting(ir) || progress;
+    progress = do_if_simplification(ir) || progress;
++   progress = do_discard_simplification(ir) || progress;
+    progress = do_copy_propagation(ir) || progress;
+    if (linked)
+       progress = do_dead_code(ir) || progress;
+diff -Naurp Mesa-7.9.orig/src/glsl/ir_optimization.h Mesa-7.9.work/src/glsl/ir_optimization.h
+--- Mesa-7.9.orig/src/glsl/ir_optimization.h    2010-12-07 18:22:17.556757000 -0800
++++ Mesa-7.9.work/src/glsl/ir_optimization.h    2010-12-13 10:54:15.445620000 -0800
+@@ -45,6 +45,7 @@ bool do_explog_to_explog2(exec_list *ins
+ bool do_function_inlining(exec_list *instructions);
+ bool do_lower_jumps(exec_list *instructions, bool pull_out_jumps = true, bool lower_sub_return = true, bool lower_main_return = false, bool lower_continue = false, bool lower_break = false);
+ bool do_if_simplification(exec_list *instructions);
++bool do_discard_simplification(exec_list *instructions);
+ bool do_if_to_cond_assign(exec_list *instructions);
+ bool do_mat_op_to_vec(exec_list *instructions);
+ bool do_mod_to_fract(exec_list *instructions);
+diff -Naurp Mesa-7.9.orig/src/glsl/opt_discard_simplification.cpp Mesa-7.9.work/src/glsl/opt_discard_simplification.cpp
+--- Mesa-7.9.orig/src/glsl/opt_discard_simplification.cpp       1969-12-31 16:00:00.000000000 -0800
++++ Mesa-7.9.work/src/glsl/opt_discard_simplification.cpp       2010-12-13 10:54:15.451643000 -0800
+@@ -0,0 +1,180 @@
++/*
++ * Copyright © 2010 Intel Corporation
++ *
++ * 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 opt_discard_simplification.cpp
++ *
++ * This pass simplifies if-statements and loops containing unconditional
++ * discards.
++ *
++ * Case 1: Both branches contain unconditional discards:
++ * -----------------------------------------------------
++ *
++ *    if (cond) {
++ *      s1;
++ *      discard;
++ *      s2;
++ *    } else {
++ *      s3;
++ *      discard;
++ *      s4;
++ *    }
++ *
++ * becomes:
++ *
++ *    discard
++ *
++ * Case 2: The "then" clause contains an unconditional discard:
++ * ------------------------------------------------------------
++ *
++ *    if (cond) {
++ *       s1;
++ *       discard;
++ *       s2;
++ *    } else {
++ *      s3;
++ *    }
++ *
++ * becomes:
++ *
++ *    if (cond) {
++ *      discard;
++ *    } else {
++ *      s3;
++ *    }
++ *
++ * Case 3: The "else" clause contains an unconditional discard:
++ * ------------------------------------------------------------
++ *
++ *    if (cond) {
++ *       s1;
++ *    } else {
++ *       s2;
++ *       discard;
++ *      s3;
++ *    }
++ *
++ * becomes:
++ *
++ *    if (cond) {
++ *      s1;
++ *    } else {
++ *      discard;
++ *    }
++ */
++
++#include "glsl_types.h"
++#include "ir.h"
++
++class discard_simplifier : public ir_hierarchical_visitor {
++public:
++   discard_simplifier()
++   {
++      this->progress = false;
++   }
++
++   ir_visitor_status visit_enter(ir_if *);
++   ir_visitor_status visit_enter(ir_loop *);
++
++   bool progress;
++};
++
++static ir_discard *
++find_unconditional_discard(exec_list &instructions)
++{
++   foreach_list(n, &instructions) {
++      ir_discard *ir = ((ir_instruction *) n)->as_discard();
++      if (ir != NULL && ir->condition == NULL)
++        return ir;
++   }
++   return NULL;
++}
++
++static bool
++is_only_instruction(ir_discard *discard)
++{
++   return (discard->prev->is_head_sentinel() &&
++          discard->next->is_tail_sentinel());
++}
++
++ir_visitor_status
++discard_simplifier::visit_enter(ir_if *ir)
++{
++   ir_discard *then_discard = find_unconditional_discard(ir->then_instructions);
++   ir_discard *else_discard = find_unconditional_discard(ir->else_instructions);
++
++   if (then_discard == NULL && else_discard == NULL)
++      return visit_continue;
++
++   /* If both branches result in discard, replace whole if with discard. */
++   if (then_discard != NULL && else_discard != NULL) {
++      this->progress = true;
++      ir->replace_with(then_discard);
++      return visit_continue_with_parent;
++   }
++
++   /* Otherwise, one branch has a discard. */
++   if (then_discard != NULL && !is_only_instruction(then_discard)) {
++      this->progress = true;
++      ir->then_instructions.make_empty();
++      ir->then_instructions.push_tail(then_discard);
++   } else if (else_discard != NULL && !is_only_instruction(else_discard)) {
++      this->progress = true;
++      ir->else_instructions.make_empty();
++      ir->else_instructions.push_tail(else_discard);
++   }
++
++   visit_list_elements(this, &ir->then_instructions);
++   return visit_continue_with_parent;
++}
++
++ir_visitor_status
++discard_simplifier::visit_enter(ir_loop *ir)
++{
++   ir_discard *discard = find_unconditional_discard(ir->body_instructions);
++
++   if (discard) {
++      ir->replace_with(discard);
++      return visit_continue_with_parent;
++   }
++
++   return visit_continue;
++}
++
++bool
++do_discard_simplification(exec_list *instructions)
++{
++   /* Look for a top-level unconditional discard */
++   ir_discard *discard = find_unconditional_discard(*instructions);
++   if (discard != NULL) {
++      instructions->make_empty();
++      instructions->push_tail(discard);
++      return true;
++   }
++
++   discard_simplifier v;
++
++   visit_list_elements(&v, instructions);
++
++   return v.progress;
++}