The Tor Browser / file comparison

comparison: gfx/angle/src/compiler/ValidateLimitations.cpp

gfx/angle/src/compiler/ValidateLimitations.cpp

branch
TOR_BUG_9701
changeset 3
141e0f1194b1
equal deleted inserted replaced
-1:000000000000 0:920a41c7dffb
1 //
2 // Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
3 // Use of this source code is governed by a BSD-style license that can be
4 // found in the LICENSE file.
5 //
6
7 #include "compiler/ValidateLimitations.h"
8 #include "compiler/InfoSink.h"
9 #include "compiler/InitializeParseContext.h"
10 #include "compiler/ParseHelper.h"
11
12 namespace {
13 bool IsLoopIndex(const TIntermSymbol* symbol, const TLoopStack& stack) {
14 for (TLoopStack::const_iterator i = stack.begin(); i != stack.end(); ++i) {
15 if (i->index.id == symbol->getId())
16 return true;
17 }
18 return false;
19 }
20
21 void MarkLoopForUnroll(const TIntermSymbol* symbol, TLoopStack& stack) {
22 for (TLoopStack::iterator i = stack.begin(); i != stack.end(); ++i) {
23 if (i->index.id == symbol->getId()) {
24 ASSERT(i->loop != NULL);
25 i->loop->setUnrollFlag(true);
26 return;
27 }
28 }
29 UNREACHABLE();
30 }
31
32 // Traverses a node to check if it represents a constant index expression.
33 // Definition:
34 // constant-index-expressions are a superset of constant-expressions.
35 // Constant-index-expressions can include loop indices as defined in
36 // GLSL ES 1.0 spec, Appendix A, section 4.
37 // The following are constant-index-expressions:
38 // - Constant expressions
39 // - Loop indices as defined in section 4
40 // - Expressions composed of both of the above
41 class ValidateConstIndexExpr : public TIntermTraverser {
42 public:
43 ValidateConstIndexExpr(const TLoopStack& stack)
44 : mValid(true), mLoopStack(stack) {}
45
46 // Returns true if the parsed node represents a constant index expression.
47 bool isValid() const { return mValid; }
48
49 virtual void visitSymbol(TIntermSymbol* symbol) {
50 // Only constants and loop indices are allowed in a
51 // constant index expression.
52 if (mValid) {
53 mValid = (symbol->getQualifier() == EvqConst) ||
54 IsLoopIndex(symbol, mLoopStack);
55 }
56 }
57
58 private:
59 bool mValid;
60 const TLoopStack& mLoopStack;
61 };
62
63 // Traverses a node to check if it uses a loop index.
64 // If an int loop index is used in its body as a sampler array index,
65 // mark the loop for unroll.
66 class ValidateLoopIndexExpr : public TIntermTraverser {
67 public:
68 ValidateLoopIndexExpr(TLoopStack& stack)
69 : mUsesFloatLoopIndex(false),
70 mUsesIntLoopIndex(false),
71 mLoopStack(stack) {}
72
73 bool usesFloatLoopIndex() const { return mUsesFloatLoopIndex; }
74 bool usesIntLoopIndex() const { return mUsesIntLoopIndex; }
75
76 virtual void visitSymbol(TIntermSymbol* symbol) {
77 if (IsLoopIndex(symbol, mLoopStack)) {
78 switch (symbol->getBasicType()) {
79 case EbtFloat:
80 mUsesFloatLoopIndex = true;
81 break;
82 case EbtInt:
83 mUsesIntLoopIndex = true;
84 MarkLoopForUnroll(symbol, mLoopStack);
85 break;
86 default:
87 UNREACHABLE();
88 }
89 }
90 }
91
92 private:
93 bool mUsesFloatLoopIndex;
94 bool mUsesIntLoopIndex;
95 TLoopStack& mLoopStack;
96 };
97 } // namespace
98
99 ValidateLimitations::ValidateLimitations(ShShaderType shaderType,
100 TInfoSinkBase& sink)
101 : mShaderType(shaderType),
102 mSink(sink),
103 mNumErrors(0)
104 {
105 }
106
107 bool ValidateLimitations::visitBinary(Visit, TIntermBinary* node)
108 {
109 // Check if loop index is modified in the loop body.
110 validateOperation(node, node->getLeft());
111
112 // Check indexing.
113 switch (node->getOp()) {
114 case EOpIndexDirect:
115 validateIndexing(node);
116 break;
117 case EOpIndexIndirect:
118 #if defined(__APPLE__)
119 // Loop unrolling is a work-around for a Mac Cg compiler bug where it
120 // crashes when a sampler array's index is also the loop index.
121 // Once Apple fixes this bug, we should remove the code in this CL.
122 // See http://codereview.appspot.com/4331048/.
123 if ((node->getLeft() != NULL) && (node->getRight() != NULL) &&
124 (node->getLeft()->getAsSymbolNode())) {
125 TIntermSymbol* symbol = node->getLeft()->getAsSymbolNode();
126 if (IsSampler(symbol->getBasicType()) && symbol->isArray()) {
127 ValidateLoopIndexExpr validate(mLoopStack);
128 node->getRight()->traverse(&validate);
129 if (validate.usesFloatLoopIndex()) {
130 error(node->getLine(),
131 "sampler array index is float loop index",
132 "for");
133 }
134 }
135 }
136 #endif
137 validateIndexing(node);
138 break;
139 default: break;
140 }
141 return true;
142 }
143
144 bool ValidateLimitations::visitUnary(Visit, TIntermUnary* node)
145 {
146 // Check if loop index is modified in the loop body.
147 validateOperation(node, node->getOperand());
148
149 return true;
150 }
151
152 bool ValidateLimitations::visitAggregate(Visit, TIntermAggregate* node)
153 {
154 switch (node->getOp()) {
155 case EOpFunctionCall:
156 validateFunctionCall(node);
157 break;
158 default:
159 break;
160 }
161 return true;
162 }
163
164 bool ValidateLimitations::visitLoop(Visit, TIntermLoop* node)
165 {
166 if (!validateLoopType(node))
167 return false;
168
169 TLoopInfo info;
170 memset(&info, 0, sizeof(TLoopInfo));
171 info.loop = node;
172 if (!validateForLoopHeader(node, &info))
173 return false;
174
175 TIntermNode* body = node->getBody();
176 if (body != NULL) {
177 mLoopStack.push_back(info);
178 body->traverse(this);
179 mLoopStack.pop_back();
180 }
181
182 // The loop is fully processed - no need to visit children.
183 return false;
184 }
185
186 void ValidateLimitations::error(TSourceLoc loc,
187 const char *reason, const char* token)
188 {
189 mSink.prefix(EPrefixError);
190 mSink.location(loc);
191 mSink << "'" << token << "' : " << reason << "\n";
192 ++mNumErrors;
193 }
194
195 bool ValidateLimitations::withinLoopBody() const
196 {
197 return !mLoopStack.empty();
198 }
199
200 bool ValidateLimitations::isLoopIndex(const TIntermSymbol* symbol) const
201 {
202 return IsLoopIndex(symbol, mLoopStack);
203 }
204
205 bool ValidateLimitations::validateLoopType(TIntermLoop* node) {
206 TLoopType type = node->getType();
207 if (type == ELoopFor)
208 return true;
209
210 // Reject while and do-while loops.
211 error(node->getLine(),
212 "This type of loop is not allowed",
213 type == ELoopWhile ? "while" : "do");
214 return false;
215 }
216
217 bool ValidateLimitations::validateForLoopHeader(TIntermLoop* node,
218 TLoopInfo* info)
219 {
220 ASSERT(node->getType() == ELoopFor);
221
222 //
223 // The for statement has the form:
224 // for ( init-declaration ; condition ; expression ) statement
225 //
226 if (!validateForLoopInit(node, info))
227 return false;
228 if (!validateForLoopCond(node, info))
229 return false;
230 if (!validateForLoopExpr(node, info))
231 return false;
232
233 return true;
234 }
235
236 bool ValidateLimitations::validateForLoopInit(TIntermLoop* node,
237 TLoopInfo* info)
238 {
239 TIntermNode* init = node->getInit();
240 if (init == NULL) {
241 error(node->getLine(), "Missing init declaration", "for");
242 return false;
243 }
244
245 //
246 // init-declaration has the form:
247 // type-specifier identifier = constant-expression
248 //
249 TIntermAggregate* decl = init->getAsAggregate();
250 if ((decl == NULL) || (decl->getOp() != EOpDeclaration)) {
251 error(init->getLine(), "Invalid init declaration", "for");
252 return false;
253 }
254 // To keep things simple do not allow declaration list.
255 TIntermSequence& declSeq = decl->getSequence();
256 if (declSeq.size() != 1) {
257 error(decl->getLine(), "Invalid init declaration", "for");
258 return false;
259 }
260 TIntermBinary* declInit = declSeq[0]->getAsBinaryNode();
261 if ((declInit == NULL) || (declInit->getOp() != EOpInitialize)) {
262 error(decl->getLine(), "Invalid init declaration", "for");
263 return false;
264 }
265 TIntermSymbol* symbol = declInit->getLeft()->getAsSymbolNode();
266 if (symbol == NULL) {
267 error(declInit->getLine(), "Invalid init declaration", "for");
268 return false;
269 }
270 // The loop index has type int or float.
271 TBasicType type = symbol->getBasicType();
272 if ((type != EbtInt) && (type != EbtFloat)) {
273 error(symbol->getLine(),
274 "Invalid type for loop index", getBasicString(type));
275 return false;
276 }
277 // The loop index is initialized with constant expression.
278 if (!isConstExpr(declInit->getRight())) {
279 error(declInit->getLine(),
280 "Loop index cannot be initialized with non-constant expression",
281 symbol->getSymbol().c_str());
282 return false;
283 }
284
285 info->index.id = symbol->getId();
286 return true;
287 }
288
289 bool ValidateLimitations::validateForLoopCond(TIntermLoop* node,
290 TLoopInfo* info)
291 {
292 TIntermNode* cond = node->getCondition();
293 if (cond == NULL) {
294 error(node->getLine(), "Missing condition", "for");
295 return false;
296 }
297 //
298 // condition has the form:
299 // loop_index relational_operator constant_expression
300 //
301 TIntermBinary* binOp = cond->getAsBinaryNode();
302 if (binOp == NULL) {
303 error(node->getLine(), "Invalid condition", "for");
304 return false;
305 }
306 // Loop index should be to the left of relational operator.
307 TIntermSymbol* symbol = binOp->getLeft()->getAsSymbolNode();
308 if (symbol == NULL) {
309 error(binOp->getLine(), "Invalid condition", "for");
310 return false;
311 }
312 if (symbol->getId() != info->index.id) {
313 error(symbol->getLine(),
314 "Expected loop index", symbol->getSymbol().c_str());
315 return false;
316 }
317 // Relational operator is one of: > >= < <= == or !=.
318 switch (binOp->getOp()) {
319 case EOpEqual:
320 case EOpNotEqual:
321 case EOpLessThan:
322 case EOpGreaterThan:
323 case EOpLessThanEqual:
324 case EOpGreaterThanEqual:
325 break;
326 default:
327 error(binOp->getLine(),
328 "Invalid relational operator",
329 getOperatorString(binOp->getOp()));
330 break;
331 }
332 // Loop index must be compared with a constant.
333 if (!isConstExpr(binOp->getRight())) {
334 error(binOp->getLine(),
335 "Loop index cannot be compared with non-constant expression",
336 symbol->getSymbol().c_str());
337 return false;
338 }
339
340 return true;
341 }
342
343 bool ValidateLimitations::validateForLoopExpr(TIntermLoop* node,
344 TLoopInfo* info)
345 {
346 TIntermNode* expr = node->getExpression();
347 if (expr == NULL) {
348 error(node->getLine(), "Missing expression", "for");
349 return false;
350 }
351
352 // for expression has one of the following forms:
353 // loop_index++
354 // loop_index--
355 // loop_index += constant_expression
356 // loop_index -= constant_expression
357 // ++loop_index
358 // --loop_index
359 // The last two forms are not specified in the spec, but I am assuming
360 // its an oversight.
361 TIntermUnary* unOp = expr->getAsUnaryNode();
362 TIntermBinary* binOp = unOp ? NULL : expr->getAsBinaryNode();
363
364 TOperator op = EOpNull;
365 TIntermSymbol* symbol = NULL;
366 if (unOp != NULL) {
367 op = unOp->getOp();
368 symbol = unOp->getOperand()->getAsSymbolNode();
369 } else if (binOp != NULL) {
370 op = binOp->getOp();
371 symbol = binOp->getLeft()->getAsSymbolNode();
372 }
373
374 // The operand must be loop index.
375 if (symbol == NULL) {
376 error(expr->getLine(), "Invalid expression", "for");
377 return false;
378 }
379 if (symbol->getId() != info->index.id) {
380 error(symbol->getLine(),
381 "Expected loop index", symbol->getSymbol().c_str());
382 return false;
383 }
384
385 // The operator is one of: ++ -- += -=.
386 switch (op) {
387 case EOpPostIncrement:
388 case EOpPostDecrement:
389 case EOpPreIncrement:
390 case EOpPreDecrement:
391 ASSERT((unOp != NULL) && (binOp == NULL));
392 break;
393 case EOpAddAssign:
394 case EOpSubAssign:
395 ASSERT((unOp == NULL) && (binOp != NULL));
396 break;
397 default:
398 error(expr->getLine(), "Invalid operator", getOperatorString(op));
399 return false;
400 }
401
402 // Loop index must be incremented/decremented with a constant.
403 if (binOp != NULL) {
404 if (!isConstExpr(binOp->getRight())) {
405 error(binOp->getLine(),
406 "Loop index cannot be modified by non-constant expression",
407 symbol->getSymbol().c_str());
408 return false;
409 }
410 }
411
412 return true;
413 }
414
415 bool ValidateLimitations::validateFunctionCall(TIntermAggregate* node)
416 {
417 ASSERT(node->getOp() == EOpFunctionCall);
418
419 // If not within loop body, there is nothing to check.
420 if (!withinLoopBody())
421 return true;
422
423 // List of param indices for which loop indices are used as argument.
424 typedef std::vector<size_t> ParamIndex;
425 ParamIndex pIndex;
426 TIntermSequence& params = node->getSequence();
427 for (TIntermSequence::size_type i = 0; i < params.size(); ++i) {
428 TIntermSymbol* symbol = params[i]->getAsSymbolNode();
429 if (symbol && isLoopIndex(symbol))
430 pIndex.push_back(i);
431 }
432 // If none of the loop indices are used as arguments,
433 // there is nothing to check.
434 if (pIndex.empty())
435 return true;
436
437 bool valid = true;
438 TSymbolTable& symbolTable = GetGlobalParseContext()->symbolTable;
439 TSymbol* symbol = symbolTable.find(node->getName());
440 ASSERT(symbol && symbol->isFunction());
441 TFunction* function = static_cast<TFunction*>(symbol);
442 for (ParamIndex::const_iterator i = pIndex.begin();
443 i != pIndex.end(); ++i) {
444 const TParameter& param = function->getParam(*i);
445 TQualifier qual = param.type->getQualifier();
446 if ((qual == EvqOut) || (qual == EvqInOut)) {
447 error(params[*i]->getLine(),
448 "Loop index cannot be used as argument to a function out or inout parameter",
449 params[*i]->getAsSymbolNode()->getSymbol().c_str());
450 valid = false;
451 }
452 }
453
454 return valid;
455 }
456
457 bool ValidateLimitations::validateOperation(TIntermOperator* node,
458 TIntermNode* operand) {
459 // Check if loop index is modified in the loop body.
460 if (!withinLoopBody() || !node->modifiesState())
461 return true;
462
463 const TIntermSymbol* symbol = operand->getAsSymbolNode();
464 if (symbol && isLoopIndex(symbol)) {
465 error(node->getLine(),
466 "Loop index cannot be statically assigned to within the body of the loop",
467 symbol->getSymbol().c_str());
468 }
469 return true;
470 }
471
472 bool ValidateLimitations::isConstExpr(TIntermNode* node)
473 {
474 ASSERT(node != NULL);
475 return node->getAsConstantUnion() != NULL;
476 }
477
478 bool ValidateLimitations::isConstIndexExpr(TIntermNode* node)
479 {
480 ASSERT(node != NULL);
481
482 ValidateConstIndexExpr validate(mLoopStack);
483 node->traverse(&validate);
484 return validate.isValid();
485 }
486
487 bool ValidateLimitations::validateIndexing(TIntermBinary* node)
488 {
489 ASSERT((node->getOp() == EOpIndexDirect) ||
490 (node->getOp() == EOpIndexIndirect));
491
492 bool valid = true;
493 TIntermTyped* index = node->getRight();
494 // The index expression must have integral type.
495 if (!index->isScalar() || (index->getBasicType() != EbtInt)) {
496 error(index->getLine(),
497 "Index expression must have integral type",
498 index->getCompleteString().c_str());
499 valid = false;
500 }
501 // The index expession must be a constant-index-expression unless
502 // the operand is a uniform in a vertex shader.
503 TIntermTyped* operand = node->getLeft();
504 bool skip = (mShaderType == SH_VERTEX_SHADER) &&
505 (operand->getQualifier() == EvqUniform);
506 if (!skip && !isConstIndexExpr(index)) {
507 error(index->getLine(), "Index expression must be constant", "[]");
508 valid = false;
509 }
510 return valid;
511 }
512

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial