src/compiler/glsl/opt_swizzle.cpp

   1 /*
   2  * Copyright © 2010 Intel Corporation
   3  *
   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:
  10  *
  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
  13  * Software.
  14  *
  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.
  22  */
  23
  24 /**
  25  * \file opt_swizzle.cpp
  26  * Optimize swizzle operations.
  27  *
  28  * First, compact a sequence of swizzled swizzles into a single swizzle.
  29  *
  30  * If the final resulting swizzle doesn't change the order or count of
  31  * components, then remove the swizzle so that other optimization passes see
  32  * the value behind it.
  33  */
  34
  35 #include "ir.h"
  36 #include "ir_visitor.h"
  37 #include "ir_rvalue_visitor.h"
  38 #include "compiler/glsl_types.h"
  39
  40 namespace {
  41
  42 class ir_opt_swizzle_visitor : public ir_rvalue_visitor {
  43 public:
  44    ir_opt_swizzle_visitor()
  45    {
  46       this->progress = false;
  47    }
  48
  49    void handle_rvalue(ir_rvalue **rvalue);
  50    bool progress;
  51 };
  52
  53 } /* unnamed namespace */
  54
  55 void
  56 ir_opt_swizzle_visitor::handle_rvalue(ir_rvalue **rvalue)
  57 {
  58    if (!*rvalue)
  59       return;
  60
  61    ir_swizzle *swiz = (*rvalue)->as_swizzle();
  62
  63    if (!swiz)
  64       return;
  65
  66    ir_swizzle *swiz2;
  67
  68    while ((swiz2 = swiz->val->as_swizzle()) != NULL) {
  69       int mask2[4];
  70
  71       memset(&mask2, 0, sizeof(mask2));
  72       if (swiz2->mask.num_components >= 1)
  73          mask2[0] = swiz2->mask.x;
  74       if (swiz2->mask.num_components >= 2)
  75          mask2[1] = swiz2->mask.y;
  76       if (swiz2->mask.num_components >= 3)
  77          mask2[2] = swiz2->mask.z;
  78       if (swiz2->mask.num_components >= 4)
  79          mask2[3] = swiz2->mask.w;
  80
  81       if (swiz->mask.num_components >= 1)
  82          swiz->mask.x = mask2[swiz->mask.x];
  83       if (swiz->mask.num_components >= 2)
  84          swiz->mask.y = mask2[swiz->mask.y];
  85       if (swiz->mask.num_components >= 3)
  86          swiz->mask.z = mask2[swiz->mask.z];
  87       if (swiz->mask.num_components >= 4)
  88          swiz->mask.w = mask2[swiz->mask.w];
  89
  90       swiz->val = swiz2->val;
  91
  92       this->progress = true;
  93    }
  94
  95    if (swiz->type != swiz->val->type)
  96       return;
  97
  98    int elems = swiz->val->type->vector_elements;
  99    if (swiz->mask.x != 0)
 100       return;
 101    if (elems >= 2 && swiz->mask.y != 1)
 102       return;
 103    if (elems >= 3 && swiz->mask.z != 2)
 104       return;
 105    if (elems >= 4 && swiz->mask.w != 3)
 106       return;
 107
 108    this->progress = true;
 109    *rvalue = swiz->val;
 110 }
 111
 112 bool
 113 optimize_swizzles(exec_list *instructions)
 114 {
 115    ir_opt_swizzle_visitor v;
 116    visit_list_elements(&v, instructions);
 117
 118    return v.progress;
 119 }