1 //
2 // Copyright (C) 2013 LunarG, Inc.
3 //
4 // All rights reserved.
5 //
6 // Redistribution and use in source and binary forms, with or without
7 // modification, are permitted provided that the following conditions
8 // are met:
9 //
10 // Redistributions of source code must retain the above copyright
11 // notice, this list of conditions and the following disclaimer.
12 //
13 // Redistributions in binary form must reproduce the above
14 // copyright notice, this list of conditions and the following
15 // disclaimer in the documentation and/or other materials provided
16 // with the distribution.
17 //
18 // Neither the name of 3Dlabs Inc. Ltd. nor the names of its
19 // contributors may be used to endorse or promote products derived
20 // from this software without specific prior written permission.
21 //
22 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
25 // FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
26 // COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
27 // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
28 // BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
29 // LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
30 // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 // LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
32 // ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
33 // POSSIBILITY OF SUCH DAMAGE.
34 //
35
36 //
37 // Do sub tree walks for
38 // 1) inductive loop bodies to see if the inductive variable is modified
39 // 2) array-index expressions to see if they are "constant-index-expression"
40 //
41 // These are per Appendix A of ES 2.0:
42 //
43 // "Within the body of the loop, the loop index is not statically assigned to nor is it used as the
44 // argument to a function out or inout parameter."
45 //
46 // "The following are constant-index-expressions:
47 // - Constant expressions
48 // - Loop indices as defined in section 4
49 // - Expressions composed of both of the above"
50 //
51 // N.B.: assuming the last rule excludes function calls
52 //
53
54 #include "ParseHelper.h"
55
56 namespace glslang {
57
58 //
59 // The inductive loop-body traverser.
60 //
61 // Just look at things that might modify the loop index.
62 //
63
64 class TInductiveTraverser : public TIntermTraverser {
65 public:
TInductiveTraverser(int id,TSymbolTable & st)66 TInductiveTraverser(int id, TSymbolTable& st)
67 : loopId(id), symbolTable(st), bad(false) { }
68
69 virtual bool visitBinary(TVisit, TIntermBinary* node);
70 virtual bool visitUnary(TVisit, TIntermUnary* node);
71 virtual bool visitAggregate(TVisit, TIntermAggregate* node);
72
73 int loopId; // unique ID of the symbol that's the loop inductive variable
74 TSymbolTable& symbolTable;
75 bool bad;
76 TSourceLoc badLoc;
77
78 protected:
79 TInductiveTraverser(TInductiveTraverser&);
80 TInductiveTraverser& operator=(TInductiveTraverser&);
81 };
82
83 // check binary operations for those modifying the loop index
visitBinary(TVisit,TIntermBinary * node)84 bool TInductiveTraverser::visitBinary(TVisit /* visit */, TIntermBinary* node)
85 {
86 if (node->modifiesState() && node->getLeft()->getAsSymbolNode() &&
87 node->getLeft()->getAsSymbolNode()->getId() == loopId) {
88 bad = true;
89 badLoc = node->getLoc();
90 }
91
92 return true;
93 }
94
95 // check unary operations for those modifying the loop index
visitUnary(TVisit,TIntermUnary * node)96 bool TInductiveTraverser::visitUnary(TVisit /* visit */, TIntermUnary* node)
97 {
98 if (node->modifiesState() && node->getOperand()->getAsSymbolNode() &&
99 node->getOperand()->getAsSymbolNode()->getId() == loopId) {
100 bad = true;
101 badLoc = node->getLoc();
102 }
103
104 return true;
105 }
106
107 // check function calls for arguments modifying the loop index
visitAggregate(TVisit,TIntermAggregate * node)108 bool TInductiveTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node)
109 {
110 if (node->getOp() == EOpFunctionCall) {
111 // see if an out or inout argument is the loop index
112 const TIntermSequence& args = node->getSequence();
113 for (int i = 0; i < (int)args.size(); ++i) {
114 if (args[i]->getAsSymbolNode() && args[i]->getAsSymbolNode()->getId() == loopId) {
115 TSymbol* function = symbolTable.find(node->getName());
116 const TType* type = (*function->getAsFunction())[i].type;
117 if (type->getQualifier().storage == EvqOut ||
118 type->getQualifier().storage == EvqInOut) {
119 bad = true;
120 badLoc = node->getLoc();
121 }
122 }
123 }
124 }
125
126 return true;
127 }
128
129 //
130 // External function to call for loop check.
131 //
inductiveLoopBodyCheck(TIntermNode * body,int loopId,TSymbolTable & symbolTable)132 void TParseContext::inductiveLoopBodyCheck(TIntermNode* body, int loopId, TSymbolTable& symbolTable)
133 {
134 TInductiveTraverser it(loopId, symbolTable);
135
136 if (body == nullptr)
137 return;
138
139 body->traverse(&it);
140
141 if (it.bad)
142 error(it.badLoc, "inductive loop index modified", "limitations", "");
143 }
144
145 //
146 // The "constant-index-expression" tranverser.
147 //
148 // Just look at things that can form an index.
149 //
150
151 class TIndexTraverser : public TIntermTraverser {
152 public:
TIndexTraverser(const TIdSetType & ids)153 TIndexTraverser(const TIdSetType& ids) : inductiveLoopIds(ids), bad(false) { }
154 virtual void visitSymbol(TIntermSymbol* symbol);
155 virtual bool visitAggregate(TVisit, TIntermAggregate* node);
156 const TIdSetType& inductiveLoopIds;
157 bool bad;
158 TSourceLoc badLoc;
159
160 protected:
161 TIndexTraverser(TIndexTraverser&);
162 TIndexTraverser& operator=(TIndexTraverser&);
163 };
164
165 // make sure symbols are inductive-loop indexes
visitSymbol(TIntermSymbol * symbol)166 void TIndexTraverser::visitSymbol(TIntermSymbol* symbol)
167 {
168 if (inductiveLoopIds.find(symbol->getId()) == inductiveLoopIds.end()) {
169 bad = true;
170 badLoc = symbol->getLoc();
171 }
172 }
173
174 // check for function calls, assuming they are bad; spec. doesn't really say
visitAggregate(TVisit,TIntermAggregate * node)175 bool TIndexTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node)
176 {
177 if (node->getOp() == EOpFunctionCall) {
178 bad = true;
179 badLoc = node->getLoc();
180 }
181
182 return true;
183 }
184
185 //
186 // External function to call for loop check.
187 //
constantIndexExpressionCheck(TIntermNode * index)188 void TParseContext::constantIndexExpressionCheck(TIntermNode* index)
189 {
190 TIndexTraverser it(inductiveLoopIds);
191
192 index->traverse(&it);
193
194 if (it.bad)
195 error(it.badLoc, "Non-constant-index-expression", "limitations", "");
196 }
197
198 } // end namespace glslang
199