← Back to branch summary

~mmach/netext73/mesa-haswell

« back to all changes in this revision

Viewing changes to src/compiler/glsl/opt_swizzle.cpp

  • Committer: mmach
  • Date: 2022-09-22 19:56:13 UTC
  • Revision ID: netbit73@gmail.com-20220922195613-wtik9mmy20tmor0i
2022-09-22 21:17:09

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
 
}