1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
|
//
// Copyright (c) 2016 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// Implementation of the integer pow expressions HLSL bug workaround.
// See header for more info.
#include "compiler/translator/ExpandIntegerPowExpressions.h"
#include <cmath>
#include <cstdlib>
#include "compiler/translator/IntermNode.h"
namespace sh
{
namespace
{
class Traverser : public TIntermTraverser
{
public:
static void Apply(TIntermNode *root, unsigned int *tempIndex);
private:
Traverser();
bool visitAggregate(Visit visit, TIntermAggregate *node) override;
void nextIteration();
bool mFound = false;
};
// static
void Traverser::Apply(TIntermNode *root, unsigned int *tempIndex)
{
Traverser traverser;
traverser.useTemporaryIndex(tempIndex);
do
{
traverser.nextIteration();
root->traverse(&traverser);
if (traverser.mFound)
{
traverser.updateTree();
}
} while (traverser.mFound);
}
Traverser::Traverser() : TIntermTraverser(true, false, false)
{
}
void Traverser::nextIteration()
{
mFound = false;
nextTemporaryIndex();
}
bool Traverser::visitAggregate(Visit visit, TIntermAggregate *node)
{
if (mFound)
{
return false;
}
// Test 0: skip non-pow operators.
if (node->getOp() != EOpPow)
{
return true;
}
const TIntermSequence *sequence = node->getSequence();
ASSERT(sequence->size() == 2u);
const TIntermConstantUnion *constantNode = sequence->at(1)->getAsConstantUnion();
// Test 1: check for a single constant.
if (!constantNode || constantNode->getNominalSize() != 1)
{
return true;
}
const TConstantUnion *constant = constantNode->getUnionArrayPointer();
TConstantUnion asFloat;
asFloat.cast(EbtFloat, *constant);
float value = asFloat.getFConst();
// Test 2: value is in the problematic range.
if (value < -5.0f || value > 9.0f)
{
return true;
}
// Test 3: value is integer or pretty close to an integer.
float absval = std::abs(value);
float frac = absval - std::round(absval);
if (frac > 0.0001f)
{
return true;
}
// Test 4: skip -1, 0, and 1
int exponent = static_cast<int>(value);
int n = std::abs(exponent);
if (n < 2)
{
return true;
}
// Potential problem case detected, apply workaround.
nextTemporaryIndex();
TIntermTyped *lhs = sequence->at(0)->getAsTyped();
ASSERT(lhs);
TIntermDeclaration *init = createTempInitDeclaration(lhs);
TIntermTyped *current = createTempSymbol(lhs->getType());
insertStatementInParentBlock(init);
// Create a chain of n-1 multiples.
for (int i = 1; i < n; ++i)
{
TIntermBinary *mul = new TIntermBinary(EOpMul, current, createTempSymbol(lhs->getType()));
mul->setLine(node->getLine());
current = mul;
}
// For negative pow, compute the reciprocal of the positive pow.
if (exponent < 0)
{
TConstantUnion *oneVal = new TConstantUnion();
oneVal->setFConst(1.0f);
TIntermConstantUnion *oneNode = new TIntermConstantUnion(oneVal, node->getType());
TIntermBinary *div = new TIntermBinary(EOpDiv, oneNode, current);
current = div;
}
queueReplacement(node, current, OriginalNode::IS_DROPPED);
mFound = true;
return false;
}
} // anonymous namespace
void ExpandIntegerPowExpressions(TIntermNode *root, unsigned int *tempIndex)
{
Traverser::Apply(root, tempIndex);
}
} // namespace sh
|
