X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fglsl%2Fopt_structure_splitting.cpp;h=9f4b3dd8ff574fb9627f2a347c5e61a1b979ebe4;hb=5d326fa963d4af85af50687ecc7d0eb0a8989fda;hp=8686da06afa60d0bebcac9698b09c05fd3749318;hpb=61c59234f916406512b3591f46599cc29a5d8e23;p=mesa.git

diff --git a/src/glsl/opt_structure_splitting.cpp b/src/glsl/opt_structure_splitting.cpp
index 8686da06afa..9f4b3dd8ff5 100644
--- a/src/glsl/opt_structure_splitting.cpp
+++ b/src/glsl/opt_structure_splitting.cpp
@@ -34,23 +34,17 @@
 
 #include "ir.h"
 #include "ir_visitor.h"
-#include "ir_print_visitor.h"
 #include "ir_rvalue_visitor.h"
 #include "glsl_types.h"
 
-using std::printf;
-using std::strcmp;
+namespace {
 
 static bool debug = false;
 
-// XXX using variable_entry2 here to avoid collision (MSVC multiply-defined
-// function) with the variable_entry class seen in ir_variable_refcount.h
-// Perhaps we can use the one in ir_variable_refcount.h and make this class
-// here go away?
-class variable_entry2 : public exec_node
+class variable_entry : public exec_node
 {
 public:
-   variable_entry2(ir_variable *var)
+   variable_entry(ir_variable *var)
    {
       this->var = var;
       this->whole_structure_access = 0;
@@ -64,7 +58,11 @@ public:
    /** Number of times the variable is referenced, including assignments. */
    unsigned whole_structure_access;
 
-   bool declaration; /* If the variable had a decl in the instruction stream */
+   /* If the variable had a decl we can work with in the instruction
+    * stream.  We can't do splitting on function arguments, which
+    * don't get this variable set.
+    */
+   bool declaration;
 
    ir_variable **components;
 
@@ -92,7 +90,7 @@ public:
    virtual ir_visitor_status visit_enter(ir_assignment *);
    virtual ir_visitor_status visit_enter(ir_function_signature *);
 
-   variable_entry2 *get_variable_entry2(ir_variable *var);
+   variable_entry *get_variable_entry(ir_variable *var);
 
    /* List of variable_entry */
    exec_list variable_list;
@@ -100,21 +98,22 @@ public:
    void *mem_ctx;
 };
 
-variable_entry2 *
-ir_structure_reference_visitor::get_variable_entry2(ir_variable *var)
+variable_entry *
+ir_structure_reference_visitor::get_variable_entry(ir_variable *var)
 {
    assert(var);
 
-   if (!var->type->is_record() || var->mode == ir_var_uniform)
+   if (!var->type->is_record() || var->mode == ir_var_uniform
+       || var->mode == ir_var_shader_in || var->mode == ir_var_shader_out)
       return NULL;
 
    foreach_iter(exec_list_iterator, iter, this->variable_list) {
-      variable_entry2 *entry = (variable_entry2 *)iter.get();
+      variable_entry *entry = (variable_entry *)iter.get();
       if (entry->var == var)
 	 return entry;
    }
 
-   variable_entry2 *entry = new(mem_ctx) variable_entry2(var);
+   variable_entry *entry = new(mem_ctx) variable_entry(var);
    this->variable_list.push_tail(entry);
    return entry;
 }
@@ -123,7 +122,7 @@ ir_structure_reference_visitor::get_variable_entry2(ir_variable *var)
 ir_visitor_status
 ir_structure_reference_visitor::visit(ir_variable *ir)
 {
-   variable_entry2 *entry = this->get_variable_entry2(ir);
+   variable_entry *entry = this->get_variable_entry(ir);
 
    if (entry)
       entry->declaration = true;
@@ -135,7 +134,7 @@ ir_visitor_status
 ir_structure_reference_visitor::visit(ir_dereference_variable *ir)
 {
    ir_variable *const var = ir->variable_referenced();
-   variable_entry2 *entry = this->get_variable_entry2(var);
+   variable_entry *entry = this->get_variable_entry(var);
 
    if (entry)
       entry->whole_structure_access++;
@@ -154,6 +153,12 @@ ir_structure_reference_visitor::visit_enter(ir_dereference_record *ir)
 ir_visitor_status
 ir_structure_reference_visitor::visit_enter(ir_assignment *ir)
 {
+   /* If there are no structure references yet, no need to bother with
+    * processing the expression tree.
+    */
+   if (this->variable_list.is_empty())
+      return visit_continue_with_parent;
+
    if (ir->lhs->as_dereference_variable() &&
        ir->rhs->as_dereference_variable() &&
        !ir->condition) {
@@ -168,8 +173,9 @@ ir_structure_reference_visitor::visit_enter(ir_assignment *ir)
 ir_visitor_status
 ir_structure_reference_visitor::visit_enter(ir_function_signature *ir)
 {
-   /* We don't want to descend into the function parameters and
-    * dead-code eliminate them, so just accept the body here.
+   /* We don't have logic for structure-splitting function arguments,
+    * so just look at the body instructions and not the parameter
+    * declarations.
     */
    visit_list_elements(this, &ir->body);
    return visit_continue_with_parent;
@@ -190,13 +196,12 @@ public:
 
    void split_deref(ir_dereference **deref);
    void handle_rvalue(ir_rvalue **rvalue);
-   variable_entry2 *get_splitting_entry(ir_variable *var);
+   variable_entry *get_splitting_entry(ir_variable *var);
 
    exec_list *variable_list;
-   void *mem_ctx;
 };
 
-variable_entry2 *
+variable_entry *
 ir_structure_splitting_visitor::get_splitting_entry(ir_variable *var)
 {
    assert(var);
@@ -205,7 +210,7 @@ ir_structure_splitting_visitor::get_splitting_entry(ir_variable *var)
       return NULL;
 
    foreach_iter(exec_list_iterator, iter, *this->variable_list) {
-      variable_entry2 *entry = (variable_entry2 *)iter.get();
+      variable_entry *entry = (variable_entry *)iter.get();
       if (entry->var == var) {
 	 return entry;
       }
@@ -225,7 +230,7 @@ ir_structure_splitting_visitor::split_deref(ir_dereference **deref)
    if (!deref_var)
       return;
 
-   variable_entry2 *entry = get_splitting_entry(deref_var->var);
+   variable_entry *entry = get_splitting_entry(deref_var->var);
    if (!entry)
       return;
 
@@ -260,8 +265,8 @@ ir_structure_splitting_visitor::visit_leave(ir_assignment *ir)
 {
    ir_dereference_variable *lhs_deref = ir->lhs->as_dereference_variable();
    ir_dereference_variable *rhs_deref = ir->rhs->as_dereference_variable();
-   variable_entry2 *lhs_entry = lhs_deref ? get_splitting_entry(lhs_deref->var) : NULL;
-   variable_entry2 *rhs_entry = rhs_deref ? get_splitting_entry(rhs_deref->var) : NULL;
+   variable_entry *lhs_entry = lhs_deref ? get_splitting_entry(lhs_deref->var) : NULL;
+   variable_entry *rhs_entry = rhs_deref ? get_splitting_entry(rhs_deref->var) : NULL;
    const glsl_type *type = ir->rhs->type;
 
    if ((lhs_entry || rhs_entry) && !ir->condition) {
@@ -300,6 +305,8 @@ ir_structure_splitting_visitor::visit_leave(ir_assignment *ir)
    return visit_continue;
 }
 
+} /* unnamed namespace */
+
 bool
 do_structure_splitting(exec_list *instructions)
 {
@@ -309,7 +316,7 @@ do_structure_splitting(exec_list *instructions)
 
    /* Trim out variables we can't split. */
    foreach_iter(exec_list_iterator, iter, refs.variable_list) {
-      variable_entry2 *entry = (variable_entry2 *)iter.get();
+      variable_entry *entry = (variable_entry *)iter.get();
 
       if (debug) {
 	 printf("structure %s@%p: decl %d, whole_access %d\n",
@@ -331,7 +338,7 @@ do_structure_splitting(exec_list *instructions)
     * components.
     */
    foreach_iter(exec_list_iterator, iter, refs.variable_list) {
-      variable_entry2 *entry = (variable_entry2 *)iter.get();
+      variable_entry *entry = (variable_entry *)iter.get();
       const struct glsl_type *type = entry->var->type;
 
       entry->mem_ctx = ralloc_parent(entry->var);