1 //
2 // Copyright (C) 2013-2016 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 #if !defined(GLSLANG_WEB) && !defined(GLSLANG_ANGLE)
37
38 #include "../Include/Common.h"
39 #include "reflection.h"
40 #include "LiveTraverser.h"
41 #include "localintermediate.h"
42
43 #include "gl_types.h"
44
45 //
46 // Grow the reflection database through a friend traverser class of TReflection and a
47 // collection of functions to do a liveness traversal that note what uniforms are used
48 // in semantically non-dead code.
49 //
50 // Can be used multiple times, once per stage, to grow a program reflection.
51 //
52 // High-level algorithm for one stage:
53 //
54 // 1. Put the entry point on the list of live functions.
55 //
56 // 2. Traverse any live function, while skipping if-tests with a compile-time constant
57 // condition of false, and while adding any encountered function calls to the live
58 // function list.
59 //
60 // Repeat until the live function list is empty.
61 //
62 // 3. Add any encountered uniform variables and blocks to the reflection database.
63 //
64 // Can be attempted with a failed link, but will return false if recursion had been detected, or
65 // there wasn't exactly one entry point.
66 //
67
68 namespace glslang {
69
70 //
71 // The traverser: mostly pass through, except
72 // - processing binary nodes to see if they are dereferences of an aggregates to track
73 // - processing symbol nodes to see if they are non-aggregate objects to track
74 //
75 // This ignores semantically dead code by using TLiveTraverser.
76 //
77 // This is in the glslang namespace directly so it can be a friend of TReflection.
78 //
79
80 class TReflectionTraverser : public TIntermTraverser {
81 public:
TReflectionTraverser(const TIntermediate & i,TReflection & r)82 TReflectionTraverser(const TIntermediate& i, TReflection& r) :
83 TIntermTraverser(), intermediate(i), reflection(r), updateStageMasks(true) { }
84
85 virtual bool visitBinary(TVisit, TIntermBinary* node);
86 virtual void visitSymbol(TIntermSymbol* base);
87
88 // Add a simple reference to a uniform variable to the uniform database, no dereference involved.
89 // However, no dereference doesn't mean simple... it could be a complex aggregate.
addUniform(const TIntermSymbol & base)90 void addUniform(const TIntermSymbol& base)
91 {
92 if (processedDerefs.find(&base) == processedDerefs.end()) {
93 processedDerefs.insert(&base);
94
95 int blockIndex = -1;
96 int offset = -1;
97 TList<TIntermBinary*> derefs;
98 TString baseName = base.getName();
99
100 if (base.getType().getBasicType() == EbtBlock) {
101 offset = 0;
102 bool anonymous = IsAnonymous(baseName);
103 const TString& blockName = base.getType().getTypeName();
104
105 if (!anonymous)
106 baseName = blockName;
107 else
108 baseName = "";
109
110 blockIndex = addBlockName(blockName, base.getType(), intermediate.getBlockSize(base.getType()));
111 }
112
113 // Use a degenerate (empty) set of dereferences to immediately put as at the end of
114 // the dereference change expected by blowUpActiveAggregate.
115 blowUpActiveAggregate(base.getType(), baseName, derefs, derefs.end(), offset, blockIndex, 0, -1, 0,
116 base.getQualifier().storage, updateStageMasks);
117 }
118 }
119
addPipeIOVariable(const TIntermSymbol & base)120 void addPipeIOVariable(const TIntermSymbol& base)
121 {
122 if (processedDerefs.find(&base) == processedDerefs.end()) {
123 processedDerefs.insert(&base);
124
125 const TString &name = base.getName();
126 const TType &type = base.getType();
127 const bool input = base.getQualifier().isPipeInput();
128
129 TReflection::TMapIndexToReflection &ioItems =
130 input ? reflection.indexToPipeInput : reflection.indexToPipeOutput;
131
132
133 TReflection::TNameToIndex &ioMapper =
134 input ? reflection.pipeInNameToIndex : reflection.pipeOutNameToIndex;
135
136 if (reflection.options & EShReflectionUnwrapIOBlocks) {
137 bool anonymous = IsAnonymous(name);
138
139 TString baseName;
140 if (type.getBasicType() == EbtBlock) {
141 baseName = anonymous ? TString() : type.getTypeName();
142 } else {
143 baseName = anonymous ? TString() : name;
144 }
145
146 // by convention if this is an arrayed block we ignore the array in the reflection
147 if (type.isArray() && type.getBasicType() == EbtBlock) {
148 blowUpIOAggregate(input, baseName, TType(type, 0));
149 } else {
150 blowUpIOAggregate(input, baseName, type);
151 }
152 } else {
153 TReflection::TNameToIndex::const_iterator it = ioMapper.find(name.c_str());
154 if (it == ioMapper.end()) {
155 // seperate pipe i/o params from uniforms and blocks
156 // in is only for input in first stage as out is only for last stage. check traverse in call stack.
157 ioMapper[name.c_str()] = static_cast<int>(ioItems.size());
158 ioItems.push_back(
159 TObjectReflection(name.c_str(), type, 0, mapToGlType(type), mapToGlArraySize(type), 0));
160 EShLanguageMask& stages = ioItems.back().stages;
161 stages = static_cast<EShLanguageMask>(stages | 1 << intermediate.getStage());
162 } else {
163 EShLanguageMask& stages = ioItems[it->second].stages;
164 stages = static_cast<EShLanguageMask>(stages | 1 << intermediate.getStage());
165 }
166 }
167 }
168 }
169
170 // Lookup or calculate the offset of all block members at once, using the recursively
171 // defined block offset rules.
getOffsets(const TType & type,TVector<int> & offsets)172 void getOffsets(const TType& type, TVector<int>& offsets)
173 {
174 const TTypeList& memberList = *type.getStruct();
175 int memberSize = 0;
176 int offset = 0;
177
178 for (size_t m = 0; m < offsets.size(); ++m) {
179 // if the user supplied an offset, snap to it now
180 if (memberList[m].type->getQualifier().hasOffset())
181 offset = memberList[m].type->getQualifier().layoutOffset;
182
183 // calculate the offset of the next member and align the current offset to this member
184 intermediate.updateOffset(type, *memberList[m].type, offset, memberSize);
185
186 // save the offset of this member
187 offsets[m] = offset;
188
189 // update for the next member
190 offset += memberSize;
191 }
192 }
193
194 // Calculate the stride of an array type
getArrayStride(const TType & baseType,const TType & type)195 int getArrayStride(const TType& baseType, const TType& type)
196 {
197 int dummySize;
198 int stride;
199
200 // consider blocks to have 0 stride, so that all offsets are relative to the start of their block
201 if (type.getBasicType() == EbtBlock)
202 return 0;
203
204 TLayoutMatrix subMatrixLayout = type.getQualifier().layoutMatrix;
205 intermediate.getMemberAlignment(type, dummySize, stride,
206 baseType.getQualifier().layoutPacking,
207 subMatrixLayout != ElmNone
208 ? subMatrixLayout == ElmRowMajor
209 : baseType.getQualifier().layoutMatrix == ElmRowMajor);
210
211 return stride;
212 }
213
214 // count the total number of leaf members from iterating out of a block type
countAggregateMembers(const TType & parentType)215 int countAggregateMembers(const TType& parentType)
216 {
217 if (! parentType.isStruct())
218 return 1;
219
220 const bool strictArraySuffix = (reflection.options & EShReflectionStrictArraySuffix);
221
222 bool blockParent = (parentType.getBasicType() == EbtBlock && parentType.getQualifier().storage == EvqBuffer);
223
224 const TTypeList &memberList = *parentType.getStruct();
225
226 int ret = 0;
227
228 for (size_t i = 0; i < memberList.size(); i++)
229 {
230 const TType &memberType = *memberList[i].type;
231 int numMembers = countAggregateMembers(memberType);
232 // for sized arrays of structs, apply logic to expand out the same as we would below in
233 // blowUpActiveAggregate
234 if (memberType.isArray() && ! memberType.getArraySizes()->hasUnsized() && memberType.isStruct()) {
235 if (! strictArraySuffix || ! blockParent)
236 numMembers *= memberType.getArraySizes()->getCumulativeSize();
237 }
238 ret += numMembers;
239 }
240
241 return ret;
242 }
243
244 // Traverse the provided deref chain, including the base, and
245 // - build a full reflection-granularity name, array size, etc. entry out of it, if it goes down to that granularity
246 // - recursively expand any variable array index in the middle of that traversal
247 // - recursively expand what's left at the end if the deref chain did not reach down to reflection granularity
248 //
249 // arraySize tracks, just for the final dereference in the chain, if there was a specific known size.
250 // A value of 0 for arraySize will mean to use the full array's size.
blowUpActiveAggregate(const TType & baseType,const TString & baseName,const TList<TIntermBinary * > & derefs,TList<TIntermBinary * >::const_iterator deref,int offset,int blockIndex,int arraySize,int topLevelArraySize,int topLevelArrayStride,TStorageQualifier baseStorage,bool active)251 void blowUpActiveAggregate(const TType& baseType, const TString& baseName, const TList<TIntermBinary*>& derefs,
252 TList<TIntermBinary*>::const_iterator deref, int offset, int blockIndex, int arraySize,
253 int topLevelArraySize, int topLevelArrayStride, TStorageQualifier baseStorage, bool active)
254 {
255 // when strictArraySuffix is enabled, we closely follow the rules from ARB_program_interface_query.
256 // Broadly:
257 // * arrays-of-structs always have a [x] suffix.
258 // * with array-of-struct variables in the root of a buffer block, only ever return [0].
259 // * otherwise, array suffixes are added whenever we iterate, even if that means expanding out an array.
260 const bool strictArraySuffix = (reflection.options & EShReflectionStrictArraySuffix);
261
262 // is this variable inside a buffer block. This flag is set back to false after we iterate inside the first array element.
263 bool blockParent = (baseType.getBasicType() == EbtBlock && baseType.getQualifier().storage == EvqBuffer);
264
265 // process the part of the dereference chain that was explicit in the shader
266 TString name = baseName;
267 const TType* terminalType = &baseType;
268 for (; deref != derefs.end(); ++deref) {
269 TIntermBinary* visitNode = *deref;
270 terminalType = &visitNode->getType();
271 int index;
272 switch (visitNode->getOp()) {
273 case EOpIndexIndirect: {
274 int stride = getArrayStride(baseType, visitNode->getLeft()->getType());
275
276 if (topLevelArrayStride == 0)
277 topLevelArrayStride = stride;
278
279 // Visit all the indices of this array, and for each one add on the remaining dereferencing
280 for (int i = 0; i < std::max(visitNode->getLeft()->getType().getOuterArraySize(), 1); ++i) {
281 TString newBaseName = name;
282 if (terminalType->getBasicType() == EbtBlock) {}
283 else if (strictArraySuffix && blockParent)
284 newBaseName.append(TString("[0]"));
285 else if (strictArraySuffix || baseType.getBasicType() != EbtBlock)
286 newBaseName.append(TString("[") + String(i) + "]");
287 TList<TIntermBinary*>::const_iterator nextDeref = deref;
288 ++nextDeref;
289 blowUpActiveAggregate(*terminalType, newBaseName, derefs, nextDeref, offset, blockIndex, arraySize,
290 topLevelArraySize, topLevelArrayStride, baseStorage, active);
291
292 if (offset >= 0)
293 offset += stride;
294 }
295
296 // it was all completed in the recursive calls above
297 return;
298 }
299 case EOpIndexDirect: {
300 int stride = getArrayStride(baseType, visitNode->getLeft()->getType());
301
302 index = visitNode->getRight()->getAsConstantUnion()->getConstArray()[0].getIConst();
303 if (terminalType->getBasicType() == EbtBlock) {}
304 else if (strictArraySuffix && blockParent)
305 name.append(TString("[0]"));
306 else if (strictArraySuffix || baseType.getBasicType() != EbtBlock) {
307 name.append(TString("[") + String(index) + "]");
308
309 if (offset >= 0)
310 offset += stride * index;
311 }
312
313 if (topLevelArrayStride == 0)
314 topLevelArrayStride = stride;
315
316 // expand top-level arrays in blocks with [0] suffix
317 if (topLevelArrayStride != 0 && visitNode->getLeft()->getType().isArray()) {
318 blockParent = false;
319 }
320 break;
321 }
322 case EOpIndexDirectStruct:
323 index = visitNode->getRight()->getAsConstantUnion()->getConstArray()[0].getIConst();
324 if (offset >= 0)
325 offset += intermediate.getOffset(visitNode->getLeft()->getType(), index);
326 if (name.size() > 0)
327 name.append(".");
328 name.append((*visitNode->getLeft()->getType().getStruct())[index].type->getFieldName());
329
330 // expand non top-level arrays with [x] suffix
331 if (visitNode->getLeft()->getType().getBasicType() != EbtBlock && terminalType->isArray())
332 {
333 blockParent = false;
334 }
335 break;
336 default:
337 break;
338 }
339 }
340
341 // if the terminalType is still too coarse a granularity, this is still an aggregate to expand, expand it...
342 if (! isReflectionGranularity(*terminalType)) {
343 // the base offset of this node, that children are relative to
344 int baseOffset = offset;
345
346 if (terminalType->isArray()) {
347 // Visit all the indices of this array, and for each one,
348 // fully explode the remaining aggregate to dereference
349
350 int stride = 0;
351 if (offset >= 0)
352 stride = getArrayStride(baseType, *terminalType);
353
354 int arrayIterateSize = std::max(terminalType->getOuterArraySize(), 1);
355
356 // for top-level arrays in blocks, only expand [0] to avoid explosion of items
357 if ((strictArraySuffix && blockParent) ||
358 ((topLevelArraySize == arrayIterateSize) && (topLevelArrayStride == 0))) {
359 arrayIterateSize = 1;
360 }
361
362 if (topLevelArrayStride == 0)
363 topLevelArrayStride = stride;
364
365 for (int i = 0; i < arrayIterateSize; ++i) {
366 TString newBaseName = name;
367 if (terminalType->getBasicType() != EbtBlock)
368 newBaseName.append(TString("[") + String(i) + "]");
369 TType derefType(*terminalType, 0);
370 if (offset >= 0)
371 offset = baseOffset + stride * i;
372
373 blowUpActiveAggregate(derefType, newBaseName, derefs, derefs.end(), offset, blockIndex, 0,
374 topLevelArraySize, topLevelArrayStride, baseStorage, active);
375 }
376 } else {
377 // Visit all members of this aggregate, and for each one,
378 // fully explode the remaining aggregate to dereference
379 const TTypeList& typeList = *terminalType->getStruct();
380
381 TVector<int> memberOffsets;
382
383 if (baseOffset >= 0) {
384 memberOffsets.resize(typeList.size());
385 getOffsets(*terminalType, memberOffsets);
386 }
387
388 for (int i = 0; i < (int)typeList.size(); ++i) {
389 TString newBaseName = name;
390 if (newBaseName.size() > 0)
391 newBaseName.append(".");
392 newBaseName.append(typeList[i].type->getFieldName());
393 TType derefType(*terminalType, i);
394 if (offset >= 0)
395 offset = baseOffset + memberOffsets[i];
396
397 int arrayStride = topLevelArrayStride;
398 if (terminalType->getBasicType() == EbtBlock && terminalType->getQualifier().storage == EvqBuffer &&
399 derefType.isArray()) {
400 arrayStride = getArrayStride(baseType, derefType);
401 }
402
403 if (topLevelArraySize == -1 && arrayStride == 0 && blockParent)
404 topLevelArraySize = 1;
405
406 if (strictArraySuffix && blockParent) {
407 // if this member is an array, store the top-level array stride but start the explosion from
408 // the inner struct type.
409 if (derefType.isArray() && derefType.isStruct()) {
410 newBaseName.append("[0]");
411 auto dimSize = derefType.isUnsizedArray() ? 0 : derefType.getArraySizes()->getDimSize(0);
412 blowUpActiveAggregate(TType(derefType, 0), newBaseName, derefs, derefs.end(), memberOffsets[i],
413 blockIndex, 0, dimSize, arrayStride, terminalType->getQualifier().storage, false);
414 }
415 else if (derefType.isArray()) {
416 auto dimSize = derefType.isUnsizedArray() ? 0 : derefType.getArraySizes()->getDimSize(0);
417 blowUpActiveAggregate(derefType, newBaseName, derefs, derefs.end(), memberOffsets[i], blockIndex,
418 0, dimSize, 0, terminalType->getQualifier().storage, false);
419 }
420 else {
421 blowUpActiveAggregate(derefType, newBaseName, derefs, derefs.end(), memberOffsets[i], blockIndex,
422 0, 1, 0, terminalType->getQualifier().storage, false);
423 }
424 } else {
425 blowUpActiveAggregate(derefType, newBaseName, derefs, derefs.end(), offset, blockIndex, 0,
426 topLevelArraySize, arrayStride, baseStorage, active);
427 }
428 }
429 }
430
431 // it was all completed in the recursive calls above
432 return;
433 }
434
435 if ((reflection.options & EShReflectionBasicArraySuffix) && terminalType->isArray()) {
436 name.append(TString("[0]"));
437 }
438
439 // Finally, add a full string to the reflection database, and update the array size if necessary.
440 // If the dereferenced entity to record is an array, compute the size and update the maximum size.
441
442 // there might not be a final array dereference, it could have been copied as an array object
443 if (arraySize == 0)
444 arraySize = mapToGlArraySize(*terminalType);
445
446 TReflection::TMapIndexToReflection& variables = reflection.GetVariableMapForStorage(baseStorage);
447
448 TReflection::TNameToIndex::const_iterator it = reflection.nameToIndex.find(name.c_str());
449 if (it == reflection.nameToIndex.end()) {
450 int uniformIndex = (int)variables.size();
451 reflection.nameToIndex[name.c_str()] = uniformIndex;
452 variables.push_back(TObjectReflection(name.c_str(), *terminalType, offset, mapToGlType(*terminalType),
453 arraySize, blockIndex));
454 if (terminalType->isArray()) {
455 variables.back().arrayStride = getArrayStride(baseType, *terminalType);
456 if (topLevelArrayStride == 0)
457 topLevelArrayStride = variables.back().arrayStride;
458 }
459
460 if ((reflection.options & EShReflectionSeparateBuffers) && terminalType->isAtomic())
461 reflection.atomicCounterUniformIndices.push_back(uniformIndex);
462
463 variables.back().topLevelArraySize = topLevelArraySize;
464 variables.back().topLevelArrayStride = topLevelArrayStride;
465
466 if ((reflection.options & EShReflectionAllBlockVariables) && active) {
467 EShLanguageMask& stages = variables.back().stages;
468 stages = static_cast<EShLanguageMask>(stages | 1 << intermediate.getStage());
469 }
470 } else {
471 if (arraySize > 1) {
472 int& reflectedArraySize = variables[it->second].size;
473 reflectedArraySize = std::max(arraySize, reflectedArraySize);
474 }
475
476 if ((reflection.options & EShReflectionAllBlockVariables) && active) {
477 EShLanguageMask& stages = variables[it->second].stages;
478 stages = static_cast<EShLanguageMask>(stages | 1 << intermediate.getStage());
479 }
480 }
481 }
482
483 // similar to blowUpActiveAggregate, but with simpler rules and no dereferences to follow.
blowUpIOAggregate(bool input,const TString & baseName,const TType & type)484 void blowUpIOAggregate(bool input, const TString &baseName, const TType &type)
485 {
486 TString name = baseName;
487
488 // if the type is still too coarse a granularity, this is still an aggregate to expand, expand it...
489 if (! isReflectionGranularity(type)) {
490 if (type.isArray()) {
491 // Visit all the indices of this array, and for each one,
492 // fully explode the remaining aggregate to dereference
493 for (int i = 0; i < std::max(type.getOuterArraySize(), 1); ++i) {
494 TString newBaseName = name;
495 newBaseName.append(TString("[") + String(i) + "]");
496 TType derefType(type, 0);
497
498 blowUpIOAggregate(input, newBaseName, derefType);
499 }
500 } else {
501 // Visit all members of this aggregate, and for each one,
502 // fully explode the remaining aggregate to dereference
503 const TTypeList& typeList = *type.getStruct();
504
505 for (int i = 0; i < (int)typeList.size(); ++i) {
506 TString newBaseName = name;
507 if (newBaseName.size() > 0)
508 newBaseName.append(".");
509 newBaseName.append(typeList[i].type->getFieldName());
510 TType derefType(type, i);
511
512 blowUpIOAggregate(input, newBaseName, derefType);
513 }
514 }
515
516 // it was all completed in the recursive calls above
517 return;
518 }
519
520 if ((reflection.options & EShReflectionBasicArraySuffix) && type.isArray()) {
521 name.append(TString("[0]"));
522 }
523
524 TReflection::TMapIndexToReflection &ioItems =
525 input ? reflection.indexToPipeInput : reflection.indexToPipeOutput;
526
527 std::string namespacedName = input ? "in " : "out ";
528 namespacedName += name.c_str();
529
530 TReflection::TNameToIndex::const_iterator it = reflection.nameToIndex.find(namespacedName);
531 if (it == reflection.nameToIndex.end()) {
532 reflection.nameToIndex[namespacedName] = (int)ioItems.size();
533 ioItems.push_back(
534 TObjectReflection(name.c_str(), type, 0, mapToGlType(type), mapToGlArraySize(type), 0));
535
536 EShLanguageMask& stages = ioItems.back().stages;
537 stages = static_cast<EShLanguageMask>(stages | 1 << intermediate.getStage());
538 } else {
539 EShLanguageMask& stages = ioItems[it->second].stages;
540 stages = static_cast<EShLanguageMask>(stages | 1 << intermediate.getStage());
541 }
542 }
543
544 // Add a uniform dereference where blocks/struct/arrays are involved in the access.
545 // Handles the situation where the left node is at the correct or too coarse a
546 // granularity for reflection. (That is, further dereferences up the tree will be
547 // skipped.) Earlier dereferences, down the tree, will be handled
548 // at the same time, and logged to prevent reprocessing as the tree is traversed.
549 //
550 // Note: Other things like the following must be caught elsewhere:
551 // - a simple non-array, non-struct variable (no dereference even conceivable)
552 // - an aggregrate consumed en masse, without a dereference
553 //
554 // So, this code is for cases like
555 // - a struct/block dereferencing a member (whether the member is array or not)
556 // - an array of struct
557 // - structs/arrays containing the above
558 //
addDereferencedUniform(TIntermBinary * topNode)559 void addDereferencedUniform(TIntermBinary* topNode)
560 {
561 // See if too fine-grained to process (wait to get further down the tree)
562 const TType& leftType = topNode->getLeft()->getType();
563 if ((leftType.isVector() || leftType.isMatrix()) && ! leftType.isArray())
564 return;
565
566 // We have an array or structure or block dereference, see if it's a uniform
567 // based dereference (if not, skip it).
568 TIntermSymbol* base = findBase(topNode);
569 if (! base || ! base->getQualifier().isUniformOrBuffer())
570 return;
571
572 // See if we've already processed this (e.g., in the middle of something
573 // we did earlier), and if so skip it
574 if (processedDerefs.find(topNode) != processedDerefs.end())
575 return;
576
577 // Process this uniform dereference
578
579 int offset = -1;
580 int blockIndex = -1;
581 bool anonymous = false;
582
583 // See if we need to record the block itself
584 bool block = base->getBasicType() == EbtBlock;
585 if (block) {
586 offset = 0;
587 anonymous = IsAnonymous(base->getName());
588
589 const TString& blockName = base->getType().getTypeName();
590 TString baseName;
591
592 if (! anonymous)
593 baseName = blockName;
594
595 blockIndex = addBlockName(blockName, base->getType(), intermediate.getBlockSize(base->getType()));
596
597 if (reflection.options & EShReflectionAllBlockVariables) {
598 // Use a degenerate (empty) set of dereferences to immediately put as at the end of
599 // the dereference change expected by blowUpActiveAggregate.
600 TList<TIntermBinary*> derefs;
601
602 // otherwise - if we're not using strict array suffix rules, or this isn't a block so we are
603 // expanding root arrays anyway, just start the iteration from the base block type.
604 blowUpActiveAggregate(base->getType(), baseName, derefs, derefs.end(), 0, blockIndex, 0, -1, 0,
605 base->getQualifier().storage, false);
606 }
607 }
608
609 // Process the dereference chain, backward, accumulating the pieces for later forward traversal.
610 // If the topNode is a reflection-granularity-array dereference, don't include that last dereference.
611 TList<TIntermBinary*> derefs;
612 for (TIntermBinary* visitNode = topNode; visitNode; visitNode = visitNode->getLeft()->getAsBinaryNode()) {
613 if (isReflectionGranularity(visitNode->getLeft()->getType()))
614 continue;
615
616 derefs.push_front(visitNode);
617 processedDerefs.insert(visitNode);
618 }
619 processedDerefs.insert(base);
620
621 // See if we have a specific array size to stick to while enumerating the explosion of the aggregate
622 int arraySize = 0;
623 if (isReflectionGranularity(topNode->getLeft()->getType()) && topNode->getLeft()->isArray()) {
624 if (topNode->getOp() == EOpIndexDirect)
625 arraySize = topNode->getRight()->getAsConstantUnion()->getConstArray()[0].getIConst() + 1;
626 }
627
628 // Put the dereference chain together, forward
629 TString baseName;
630 if (! anonymous) {
631 if (block)
632 baseName = base->getType().getTypeName();
633 else
634 baseName = base->getName();
635 }
636 blowUpActiveAggregate(base->getType(), baseName, derefs, derefs.begin(), offset, blockIndex, arraySize, -1, 0,
637 base->getQualifier().storage, true);
638 }
639
addBlockName(const TString & name,const TType & type,int size)640 int addBlockName(const TString& name, const TType& type, int size)
641 {
642 int blockIndex = 0;
643 if (type.isArray()) {
644 TType derefType(type, 0);
645 for (int e = 0; e < type.getOuterArraySize(); ++e) {
646 int memberBlockIndex = addBlockName(name + "[" + String(e) + "]", derefType, size);
647 if (e == 0)
648 blockIndex = memberBlockIndex;
649 }
650 } else {
651 TReflection::TMapIndexToReflection& blocks = reflection.GetBlockMapForStorage(type.getQualifier().storage);
652
653 TReflection::TNameToIndex::const_iterator it = reflection.nameToIndex.find(name.c_str());
654 if (reflection.nameToIndex.find(name.c_str()) == reflection.nameToIndex.end()) {
655 blockIndex = (int)blocks.size();
656 reflection.nameToIndex[name.c_str()] = blockIndex;
657 blocks.push_back(TObjectReflection(name.c_str(), type, -1, -1, size, blockIndex));
658
659 blocks.back().numMembers = countAggregateMembers(type);
660
661 if (updateStageMasks) {
662 EShLanguageMask& stages = blocks.back().stages;
663 stages = static_cast<EShLanguageMask>(stages | 1 << intermediate.getStage());
664 }
665 }
666 else {
667 blockIndex = it->second;
668 if (updateStageMasks) {
669 EShLanguageMask& stages = blocks[blockIndex].stages;
670 stages = static_cast<EShLanguageMask>(stages | 1 << intermediate.getStage());
671 }
672 }
673 }
674
675 return blockIndex;
676 }
677
678 // Are we at a level in a dereference chain at which individual active uniform queries are made?
isReflectionGranularity(const TType & type)679 bool isReflectionGranularity(const TType& type)
680 {
681 return type.getBasicType() != EbtBlock && type.getBasicType() != EbtStruct && !type.isArrayOfArrays();
682 }
683
684 // For a binary operation indexing into an aggregate, chase down the base of the aggregate.
685 // Return 0 if the topology does not fit this situation.
findBase(const TIntermBinary * node)686 TIntermSymbol* findBase(const TIntermBinary* node)
687 {
688 TIntermSymbol *base = node->getLeft()->getAsSymbolNode();
689 if (base)
690 return base;
691 TIntermBinary* left = node->getLeft()->getAsBinaryNode();
692 if (! left)
693 return nullptr;
694
695 return findBase(left);
696 }
697
698 //
699 // Translate a glslang sampler type into the GL API #define number.
700 //
mapSamplerToGlType(TSampler sampler)701 int mapSamplerToGlType(TSampler sampler)
702 {
703 if (! sampler.image) {
704 // a sampler...
705 switch (sampler.type) {
706 case EbtFloat:
707 switch ((int)sampler.dim) {
708 case Esd1D:
709 switch ((int)sampler.shadow) {
710 case false: return sampler.arrayed ? GL_SAMPLER_1D_ARRAY : GL_SAMPLER_1D;
711 case true: return sampler.arrayed ? GL_SAMPLER_1D_ARRAY_SHADOW : GL_SAMPLER_1D_SHADOW;
712 }
713 case Esd2D:
714 switch ((int)sampler.ms) {
715 case false:
716 switch ((int)sampler.shadow) {
717 case false: return sampler.arrayed ? GL_SAMPLER_2D_ARRAY : GL_SAMPLER_2D;
718 case true: return sampler.arrayed ? GL_SAMPLER_2D_ARRAY_SHADOW : GL_SAMPLER_2D_SHADOW;
719 }
720 case true: return sampler.arrayed ? GL_SAMPLER_2D_MULTISAMPLE_ARRAY : GL_SAMPLER_2D_MULTISAMPLE;
721 }
722 case Esd3D:
723 return GL_SAMPLER_3D;
724 case EsdCube:
725 switch ((int)sampler.shadow) {
726 case false: return sampler.arrayed ? GL_SAMPLER_CUBE_MAP_ARRAY : GL_SAMPLER_CUBE;
727 case true: return sampler.arrayed ? GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW : GL_SAMPLER_CUBE_SHADOW;
728 }
729 case EsdRect:
730 return sampler.shadow ? GL_SAMPLER_2D_RECT_SHADOW : GL_SAMPLER_2D_RECT;
731 case EsdBuffer:
732 return GL_SAMPLER_BUFFER;
733 }
734 case EbtFloat16:
735 switch ((int)sampler.dim) {
736 case Esd1D:
737 switch ((int)sampler.shadow) {
738 case false: return sampler.arrayed ? GL_FLOAT16_SAMPLER_1D_ARRAY_AMD : GL_FLOAT16_SAMPLER_1D_AMD;
739 case true: return sampler.arrayed ? GL_FLOAT16_SAMPLER_1D_ARRAY_SHADOW_AMD : GL_FLOAT16_SAMPLER_1D_SHADOW_AMD;
740 }
741 case Esd2D:
742 switch ((int)sampler.ms) {
743 case false:
744 switch ((int)sampler.shadow) {
745 case false: return sampler.arrayed ? GL_FLOAT16_SAMPLER_2D_ARRAY_AMD : GL_FLOAT16_SAMPLER_2D_AMD;
746 case true: return sampler.arrayed ? GL_FLOAT16_SAMPLER_2D_ARRAY_SHADOW_AMD : GL_FLOAT16_SAMPLER_2D_SHADOW_AMD;
747 }
748 case true: return sampler.arrayed ? GL_FLOAT16_SAMPLER_2D_MULTISAMPLE_ARRAY_AMD : GL_FLOAT16_SAMPLER_2D_MULTISAMPLE_AMD;
749 }
750 case Esd3D:
751 return GL_FLOAT16_SAMPLER_3D_AMD;
752 case EsdCube:
753 switch ((int)sampler.shadow) {
754 case false: return sampler.arrayed ? GL_FLOAT16_SAMPLER_CUBE_MAP_ARRAY_AMD : GL_FLOAT16_SAMPLER_CUBE_AMD;
755 case true: return sampler.arrayed ? GL_FLOAT16_SAMPLER_CUBE_MAP_ARRAY_SHADOW_AMD : GL_FLOAT16_SAMPLER_CUBE_SHADOW_AMD;
756 }
757 case EsdRect:
758 return sampler.shadow ? GL_FLOAT16_SAMPLER_2D_RECT_SHADOW_AMD : GL_FLOAT16_SAMPLER_2D_RECT_AMD;
759 case EsdBuffer:
760 return GL_FLOAT16_SAMPLER_BUFFER_AMD;
761 }
762 case EbtInt:
763 switch ((int)sampler.dim) {
764 case Esd1D:
765 return sampler.arrayed ? GL_INT_SAMPLER_1D_ARRAY : GL_INT_SAMPLER_1D;
766 case Esd2D:
767 switch ((int)sampler.ms) {
768 case false: return sampler.arrayed ? GL_INT_SAMPLER_2D_ARRAY : GL_INT_SAMPLER_2D;
769 case true: return sampler.arrayed ? GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY
770 : GL_INT_SAMPLER_2D_MULTISAMPLE;
771 }
772 case Esd3D:
773 return GL_INT_SAMPLER_3D;
774 case EsdCube:
775 return sampler.arrayed ? GL_INT_SAMPLER_CUBE_MAP_ARRAY : GL_INT_SAMPLER_CUBE;
776 case EsdRect:
777 return GL_INT_SAMPLER_2D_RECT;
778 case EsdBuffer:
779 return GL_INT_SAMPLER_BUFFER;
780 }
781 case EbtUint:
782 switch ((int)sampler.dim) {
783 case Esd1D:
784 return sampler.arrayed ? GL_UNSIGNED_INT_SAMPLER_1D_ARRAY : GL_UNSIGNED_INT_SAMPLER_1D;
785 case Esd2D:
786 switch ((int)sampler.ms) {
787 case false: return sampler.arrayed ? GL_UNSIGNED_INT_SAMPLER_2D_ARRAY : GL_UNSIGNED_INT_SAMPLER_2D;
788 case true: return sampler.arrayed ? GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY
789 : GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE;
790 }
791 case Esd3D:
792 return GL_UNSIGNED_INT_SAMPLER_3D;
793 case EsdCube:
794 return sampler.arrayed ? GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY : GL_UNSIGNED_INT_SAMPLER_CUBE;
795 case EsdRect:
796 return GL_UNSIGNED_INT_SAMPLER_2D_RECT;
797 case EsdBuffer:
798 return GL_UNSIGNED_INT_SAMPLER_BUFFER;
799 }
800 default:
801 return 0;
802 }
803 } else {
804 // an image...
805 switch (sampler.type) {
806 case EbtFloat:
807 switch ((int)sampler.dim) {
808 case Esd1D:
809 return sampler.arrayed ? GL_IMAGE_1D_ARRAY : GL_IMAGE_1D;
810 case Esd2D:
811 switch ((int)sampler.ms) {
812 case false: return sampler.arrayed ? GL_IMAGE_2D_ARRAY : GL_IMAGE_2D;
813 case true: return sampler.arrayed ? GL_IMAGE_2D_MULTISAMPLE_ARRAY : GL_IMAGE_2D_MULTISAMPLE;
814 }
815 case Esd3D:
816 return GL_IMAGE_3D;
817 case EsdCube:
818 return sampler.arrayed ? GL_IMAGE_CUBE_MAP_ARRAY : GL_IMAGE_CUBE;
819 case EsdRect:
820 return GL_IMAGE_2D_RECT;
821 case EsdBuffer:
822 return GL_IMAGE_BUFFER;
823 }
824 case EbtFloat16:
825 switch ((int)sampler.dim) {
826 case Esd1D:
827 return sampler.arrayed ? GL_FLOAT16_IMAGE_1D_ARRAY_AMD : GL_FLOAT16_IMAGE_1D_AMD;
828 case Esd2D:
829 switch ((int)sampler.ms) {
830 case false: return sampler.arrayed ? GL_FLOAT16_IMAGE_2D_ARRAY_AMD : GL_FLOAT16_IMAGE_2D_AMD;
831 case true: return sampler.arrayed ? GL_FLOAT16_IMAGE_2D_MULTISAMPLE_ARRAY_AMD : GL_FLOAT16_IMAGE_2D_MULTISAMPLE_AMD;
832 }
833 case Esd3D:
834 return GL_FLOAT16_IMAGE_3D_AMD;
835 case EsdCube:
836 return sampler.arrayed ? GL_FLOAT16_IMAGE_CUBE_MAP_ARRAY_AMD : GL_FLOAT16_IMAGE_CUBE_AMD;
837 case EsdRect:
838 return GL_FLOAT16_IMAGE_2D_RECT_AMD;
839 case EsdBuffer:
840 return GL_FLOAT16_IMAGE_BUFFER_AMD;
841 }
842 case EbtInt:
843 switch ((int)sampler.dim) {
844 case Esd1D:
845 return sampler.arrayed ? GL_INT_IMAGE_1D_ARRAY : GL_INT_IMAGE_1D;
846 case Esd2D:
847 switch ((int)sampler.ms) {
848 case false: return sampler.arrayed ? GL_INT_IMAGE_2D_ARRAY : GL_INT_IMAGE_2D;
849 case true: return sampler.arrayed ? GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY : GL_INT_IMAGE_2D_MULTISAMPLE;
850 }
851 case Esd3D:
852 return GL_INT_IMAGE_3D;
853 case EsdCube:
854 return sampler.arrayed ? GL_INT_IMAGE_CUBE_MAP_ARRAY : GL_INT_IMAGE_CUBE;
855 case EsdRect:
856 return GL_INT_IMAGE_2D_RECT;
857 case EsdBuffer:
858 return GL_INT_IMAGE_BUFFER;
859 }
860 case EbtUint:
861 switch ((int)sampler.dim) {
862 case Esd1D:
863 return sampler.arrayed ? GL_UNSIGNED_INT_IMAGE_1D_ARRAY : GL_UNSIGNED_INT_IMAGE_1D;
864 case Esd2D:
865 switch ((int)sampler.ms) {
866 case false: return sampler.arrayed ? GL_UNSIGNED_INT_IMAGE_2D_ARRAY : GL_UNSIGNED_INT_IMAGE_2D;
867 case true: return sampler.arrayed ? GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY
868 : GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE;
869 }
870 case Esd3D:
871 return GL_UNSIGNED_INT_IMAGE_3D;
872 case EsdCube:
873 return sampler.arrayed ? GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY : GL_UNSIGNED_INT_IMAGE_CUBE;
874 case EsdRect:
875 return GL_UNSIGNED_INT_IMAGE_2D_RECT;
876 case EsdBuffer:
877 return GL_UNSIGNED_INT_IMAGE_BUFFER;
878 }
879 default:
880 return 0;
881 }
882 }
883 }
884
885 //
886 // Translate a glslang type into the GL API #define number.
887 // Ignores arrayness.
888 //
mapToGlType(const TType & type)889 int mapToGlType(const TType& type)
890 {
891 switch (type.getBasicType()) {
892 case EbtSampler:
893 return mapSamplerToGlType(type.getSampler());
894 case EbtStruct:
895 case EbtBlock:
896 case EbtVoid:
897 return 0;
898 default:
899 break;
900 }
901
902 if (type.isVector()) {
903 int offset = type.getVectorSize() - 2;
904 switch (type.getBasicType()) {
905 case EbtFloat: return GL_FLOAT_VEC2 + offset;
906 case EbtDouble: return GL_DOUBLE_VEC2 + offset;
907 case EbtFloat16: return GL_FLOAT16_VEC2_NV + offset;
908 case EbtInt: return GL_INT_VEC2 + offset;
909 case EbtUint: return GL_UNSIGNED_INT_VEC2 + offset;
910 case EbtInt64: return GL_INT64_ARB + offset;
911 case EbtUint64: return GL_UNSIGNED_INT64_ARB + offset;
912 case EbtBool: return GL_BOOL_VEC2 + offset;
913 case EbtAtomicUint: return GL_UNSIGNED_INT_ATOMIC_COUNTER + offset;
914 default: return 0;
915 }
916 }
917 if (type.isMatrix()) {
918 switch (type.getBasicType()) {
919 case EbtFloat:
920 switch (type.getMatrixCols()) {
921 case 2:
922 switch (type.getMatrixRows()) {
923 case 2: return GL_FLOAT_MAT2;
924 case 3: return GL_FLOAT_MAT2x3;
925 case 4: return GL_FLOAT_MAT2x4;
926 default: return 0;
927 }
928 case 3:
929 switch (type.getMatrixRows()) {
930 case 2: return GL_FLOAT_MAT3x2;
931 case 3: return GL_FLOAT_MAT3;
932 case 4: return GL_FLOAT_MAT3x4;
933 default: return 0;
934 }
935 case 4:
936 switch (type.getMatrixRows()) {
937 case 2: return GL_FLOAT_MAT4x2;
938 case 3: return GL_FLOAT_MAT4x3;
939 case 4: return GL_FLOAT_MAT4;
940 default: return 0;
941 }
942 }
943 case EbtDouble:
944 switch (type.getMatrixCols()) {
945 case 2:
946 switch (type.getMatrixRows()) {
947 case 2: return GL_DOUBLE_MAT2;
948 case 3: return GL_DOUBLE_MAT2x3;
949 case 4: return GL_DOUBLE_MAT2x4;
950 default: return 0;
951 }
952 case 3:
953 switch (type.getMatrixRows()) {
954 case 2: return GL_DOUBLE_MAT3x2;
955 case 3: return GL_DOUBLE_MAT3;
956 case 4: return GL_DOUBLE_MAT3x4;
957 default: return 0;
958 }
959 case 4:
960 switch (type.getMatrixRows()) {
961 case 2: return GL_DOUBLE_MAT4x2;
962 case 3: return GL_DOUBLE_MAT4x3;
963 case 4: return GL_DOUBLE_MAT4;
964 default: return 0;
965 }
966 }
967 case EbtFloat16:
968 switch (type.getMatrixCols()) {
969 case 2:
970 switch (type.getMatrixRows()) {
971 case 2: return GL_FLOAT16_MAT2_AMD;
972 case 3: return GL_FLOAT16_MAT2x3_AMD;
973 case 4: return GL_FLOAT16_MAT2x4_AMD;
974 default: return 0;
975 }
976 case 3:
977 switch (type.getMatrixRows()) {
978 case 2: return GL_FLOAT16_MAT3x2_AMD;
979 case 3: return GL_FLOAT16_MAT3_AMD;
980 case 4: return GL_FLOAT16_MAT3x4_AMD;
981 default: return 0;
982 }
983 case 4:
984 switch (type.getMatrixRows()) {
985 case 2: return GL_FLOAT16_MAT4x2_AMD;
986 case 3: return GL_FLOAT16_MAT4x3_AMD;
987 case 4: return GL_FLOAT16_MAT4_AMD;
988 default: return 0;
989 }
990 }
991 default:
992 return 0;
993 }
994 }
995 if (type.getVectorSize() == 1) {
996 switch (type.getBasicType()) {
997 case EbtFloat: return GL_FLOAT;
998 case EbtDouble: return GL_DOUBLE;
999 case EbtFloat16: return GL_FLOAT16_NV;
1000 case EbtInt: return GL_INT;
1001 case EbtUint: return GL_UNSIGNED_INT;
1002 case EbtInt64: return GL_INT64_ARB;
1003 case EbtUint64: return GL_UNSIGNED_INT64_ARB;
1004 case EbtBool: return GL_BOOL;
1005 case EbtAtomicUint: return GL_UNSIGNED_INT_ATOMIC_COUNTER;
1006 default: return 0;
1007 }
1008 }
1009
1010 return 0;
1011 }
1012
mapToGlArraySize(const TType & type)1013 int mapToGlArraySize(const TType& type)
1014 {
1015 return type.isArray() ? type.getOuterArraySize() : 1;
1016 }
1017
1018 const TIntermediate& intermediate;
1019 TReflection& reflection;
1020 std::set<const TIntermNode*> processedDerefs;
1021 bool updateStageMasks;
1022
1023 protected:
1024 TReflectionTraverser(TReflectionTraverser&);
1025 TReflectionTraverser& operator=(TReflectionTraverser&);
1026 };
1027
1028 //
1029 // Implement the traversal functions of interest.
1030 //
1031
1032 // To catch dereferenced aggregates that must be reflected.
1033 // This catches them at the highest level possible in the tree.
visitBinary(TVisit,TIntermBinary * node)1034 bool TReflectionTraverser::visitBinary(TVisit /* visit */, TIntermBinary* node)
1035 {
1036 switch (node->getOp()) {
1037 case EOpIndexDirect:
1038 case EOpIndexIndirect:
1039 case EOpIndexDirectStruct:
1040 addDereferencedUniform(node);
1041 break;
1042 default:
1043 break;
1044 }
1045
1046 // still need to visit everything below, which could contain sub-expressions
1047 // containing different uniforms
1048 return true;
1049 }
1050
1051 // To reflect non-dereferenced objects.
visitSymbol(TIntermSymbol * base)1052 void TReflectionTraverser::visitSymbol(TIntermSymbol* base)
1053 {
1054 if (base->getQualifier().storage == EvqUniform) {
1055 if (base->getBasicType() == EbtBlock) {
1056 if (reflection.options & EShReflectionSharedStd140UBO) {
1057 addUniform(*base);
1058 }
1059 } else {
1060 addUniform(*base);
1061 }
1062 }
1063
1064 // #TODO add std140/layout active rules for ssbo, same with ubo.
1065 // Storage buffer blocks will be collected and expanding in this part.
1066 if((reflection.options & EShReflectionSharedStd140SSBO) &&
1067 (base->getQualifier().storage == EvqBuffer && base->getBasicType() == EbtBlock &&
1068 (base->getQualifier().layoutPacking == ElpStd140 || base->getQualifier().layoutPacking == ElpShared)))
1069 addUniform(*base);
1070
1071 if ((intermediate.getStage() == reflection.firstStage && base->getQualifier().isPipeInput()) ||
1072 (intermediate.getStage() == reflection.lastStage && base->getQualifier().isPipeOutput()))
1073 addPipeIOVariable(*base);
1074 }
1075
1076 //
1077 // Implement TObjectReflection methods.
1078 //
1079
TObjectReflection(const std::string & pName,const TType & pType,int pOffset,int pGLDefineType,int pSize,int pIndex)1080 TObjectReflection::TObjectReflection(const std::string &pName, const TType &pType, int pOffset, int pGLDefineType,
1081 int pSize, int pIndex)
1082 : name(pName), offset(pOffset), glDefineType(pGLDefineType), size(pSize), index(pIndex), counterIndex(-1),
1083 numMembers(-1), arrayStride(0), topLevelArrayStride(0), stages(EShLanguageMask(0)), type(pType.clone())
1084 {
1085 }
1086
getBinding() const1087 int TObjectReflection::getBinding() const
1088 {
1089 if (type == nullptr || !type->getQualifier().hasBinding())
1090 return -1;
1091 return type->getQualifier().layoutBinding;
1092 }
1093
dump() const1094 void TObjectReflection::dump() const
1095 {
1096 printf("%s: offset %d, type %x, size %d, index %d, binding %d, stages %d", name.c_str(), offset, glDefineType, size,
1097 index, getBinding(), stages);
1098
1099 if (counterIndex != -1)
1100 printf(", counter %d", counterIndex);
1101
1102 if (numMembers != -1)
1103 printf(", numMembers %d", numMembers);
1104
1105 if (arrayStride != 0)
1106 printf(", arrayStride %d", arrayStride);
1107
1108 if (topLevelArrayStride != 0)
1109 printf(", topLevelArrayStride %d", topLevelArrayStride);
1110
1111 printf("\n");
1112 }
1113
1114 //
1115 // Implement TReflection methods.
1116 //
1117
1118 // Track any required attribute reflection, such as compute shader numthreads.
1119 //
buildAttributeReflection(EShLanguage stage,const TIntermediate & intermediate)1120 void TReflection::buildAttributeReflection(EShLanguage stage, const TIntermediate& intermediate)
1121 {
1122 if (stage == EShLangCompute) {
1123 // Remember thread dimensions
1124 for (int dim=0; dim<3; ++dim)
1125 localSize[dim] = intermediate.getLocalSize(dim);
1126 }
1127 }
1128
1129 // build counter block index associations for buffers
buildCounterIndices(const TIntermediate & intermediate)1130 void TReflection::buildCounterIndices(const TIntermediate& intermediate)
1131 {
1132 #ifdef ENABLE_HLSL
1133 // search for ones that have counters
1134 for (int i = 0; i < int(indexToUniformBlock.size()); ++i) {
1135 const TString counterName(intermediate.addCounterBufferName(indexToUniformBlock[i].name).c_str());
1136 const int index = getIndex(counterName);
1137
1138 if (index >= 0)
1139 indexToUniformBlock[i].counterIndex = index;
1140 }
1141 #else
1142 (void)intermediate;
1143 #endif
1144 }
1145
1146 // build Shader Stages mask for all uniforms
buildUniformStageMask(const TIntermediate & intermediate)1147 void TReflection::buildUniformStageMask(const TIntermediate& intermediate)
1148 {
1149 if (options & EShReflectionAllBlockVariables)
1150 return;
1151
1152 for (int i = 0; i < int(indexToUniform.size()); ++i) {
1153 indexToUniform[i].stages = static_cast<EShLanguageMask>(indexToUniform[i].stages | 1 << intermediate.getStage());
1154 }
1155
1156 for (int i = 0; i < int(indexToBufferVariable.size()); ++i) {
1157 indexToBufferVariable[i].stages =
1158 static_cast<EShLanguageMask>(indexToBufferVariable[i].stages | 1 << intermediate.getStage());
1159 }
1160 }
1161
1162 // Merge live symbols from 'intermediate' into the existing reflection database.
1163 //
1164 // Returns false if the input is too malformed to do this.
addStage(EShLanguage stage,const TIntermediate & intermediate)1165 bool TReflection::addStage(EShLanguage stage, const TIntermediate& intermediate)
1166 {
1167 if (intermediate.getTreeRoot() == nullptr ||
1168 intermediate.getNumEntryPoints() != 1 ||
1169 intermediate.isRecursive())
1170 return false;
1171
1172 buildAttributeReflection(stage, intermediate);
1173
1174 TReflectionTraverser it(intermediate, *this);
1175
1176 for (auto& sequnence : intermediate.getTreeRoot()->getAsAggregate()->getSequence()) {
1177 if (sequnence->getAsAggregate() != nullptr) {
1178 if (sequnence->getAsAggregate()->getOp() == glslang::EOpLinkerObjects) {
1179 it.updateStageMasks = false;
1180 TIntermAggregate* linkerObjects = sequnence->getAsAggregate();
1181 for (auto& sequnence : linkerObjects->getSequence()) {
1182 auto pNode = sequnence->getAsSymbolNode();
1183 if (pNode != nullptr) {
1184 if ((pNode->getQualifier().storage == EvqUniform &&
1185 (options & EShReflectionSharedStd140UBO)) ||
1186 (pNode->getQualifier().storage == EvqBuffer &&
1187 (options & EShReflectionSharedStd140SSBO))) {
1188 // collect std140 and shared uniform block form AST
1189 if ((pNode->getBasicType() == EbtBlock) &&
1190 ((pNode->getQualifier().layoutPacking == ElpStd140) ||
1191 (pNode->getQualifier().layoutPacking == ElpShared))) {
1192 pNode->traverse(&it);
1193 }
1194 }
1195 else if ((options & EShReflectionAllIOVariables) &&
1196 (pNode->getQualifier().isPipeInput() || pNode->getQualifier().isPipeOutput()))
1197 {
1198 pNode->traverse(&it);
1199 }
1200 }
1201 }
1202 } else {
1203 // This traverser will travers all function in AST.
1204 // If we want reflect uncalled function, we need set linke message EShMsgKeepUncalled.
1205 // When EShMsgKeepUncalled been set to true, all function will be keep in AST, even it is a uncalled function.
1206 // This will keep some uniform variables in reflection, if those uniform variables is used in these uncalled function.
1207 //
1208 // If we just want reflect only live node, we can use a default link message or set EShMsgKeepUncalled false.
1209 // When linke message not been set EShMsgKeepUncalled, linker won't keep uncalled function in AST.
1210 // So, travers all function node can equivalent to travers live function.
1211 it.updateStageMasks = true;
1212 sequnence->getAsAggregate()->traverse(&it);
1213 }
1214 }
1215 }
1216 it.updateStageMasks = true;
1217
1218 buildCounterIndices(intermediate);
1219 buildUniformStageMask(intermediate);
1220
1221 return true;
1222 }
1223
dump()1224 void TReflection::dump()
1225 {
1226 printf("Uniform reflection:\n");
1227 for (size_t i = 0; i < indexToUniform.size(); ++i)
1228 indexToUniform[i].dump();
1229 printf("\n");
1230
1231 printf("Uniform block reflection:\n");
1232 for (size_t i = 0; i < indexToUniformBlock.size(); ++i)
1233 indexToUniformBlock[i].dump();
1234 printf("\n");
1235
1236 printf("Buffer variable reflection:\n");
1237 for (size_t i = 0; i < indexToBufferVariable.size(); ++i)
1238 indexToBufferVariable[i].dump();
1239 printf("\n");
1240
1241 printf("Buffer block reflection:\n");
1242 for (size_t i = 0; i < indexToBufferBlock.size(); ++i)
1243 indexToBufferBlock[i].dump();
1244 printf("\n");
1245
1246 printf("Pipeline input reflection:\n");
1247 for (size_t i = 0; i < indexToPipeInput.size(); ++i)
1248 indexToPipeInput[i].dump();
1249 printf("\n");
1250
1251 printf("Pipeline output reflection:\n");
1252 for (size_t i = 0; i < indexToPipeOutput.size(); ++i)
1253 indexToPipeOutput[i].dump();
1254 printf("\n");
1255
1256 if (getLocalSize(0) > 1) {
1257 static const char* axis[] = { "X", "Y", "Z" };
1258
1259 for (int dim=0; dim<3; ++dim)
1260 if (getLocalSize(dim) > 1)
1261 printf("Local size %s: %u\n", axis[dim], getLocalSize(dim));
1262
1263 printf("\n");
1264 }
1265
1266 // printf("Live names\n");
1267 // for (TNameToIndex::const_iterator it = nameToIndex.begin(); it != nameToIndex.end(); ++it)
1268 // printf("%s: %d\n", it->first.c_str(), it->second);
1269 // printf("\n");
1270 }
1271
1272 } // end namespace glslang
1273
1274 #endif // !GLSLANG_WEB && !GLSLANG_ANGLE
1275