Skip to content

G
glslang
Commit d49d524b by John Kessenich
Options

Add .gitattributes and normalize a few stray file's line endings

parent 0e7674af
Showing with 766 additions and 752 deletions
.gitattributes 0 → 100755
# test files have a mix of lf/crlf, and that's a good thing, for testing, don't mess with it
# bash scripts need lines ending with lf, and that's correct for Windows too, e.g., under Cygwin
# (scripts often don't have a suffix)
* -text
*.sh text eof=lf
# txt files should be native and normalized
*.txt text
# source code can be native and normalized, but simpler if lf everywhere; will try that way
*.h text eof=lf
*.c text eof=lf
*.cpp text eof=lf
*.y text eof=lf
CMakeLists.txt
cmake_minimum_required(VERSION 2.8) cmake_minimum_required(VERSION 2.8)
set(CMAKE_INSTALL_PREFIX "install" CACHE STRING "prefix" FORCE) set(CMAKE_INSTALL_PREFIX "install" CACHE STRING "prefix" FORCE)
project(glslang) project(glslang)
if(WIN32) if(WIN32)
set(CMAKE_GENERATOR_TOOLSET "v110" CACHE STRING "Platform Toolset" FORCE) set(CMAKE_GENERATOR_TOOLSET "v110" CACHE STRING "Platform Toolset" FORCE)
include(ChooseMSVCCRT.cmake) include(ChooseMSVCCRT.cmake)
elseif(UNIX) elseif(UNIX)
add_definitions(-fPIC) add_definitions(-fPIC)
else(WIN32) else(WIN32)
message("unkown platform") message("unkown platform")
endif(WIN32) endif(WIN32)
if(CMAKE_COMPILER_IS_GNUCXX) if(CMAKE_COMPILER_IS_GNUCXX)
add_definitions(-std=c++11) add_definitions(-std=c++11)
elseif(${CMAKE_CXX_COMPILER_ID} MATCHES "Clang") elseif(${CMAKE_CXX_COMPILER_ID} MATCHES "Clang")
add_definitions(-std=c++11) add_definitions(-std=c++11)
endif() endif()
add_subdirectory(glslang) add_subdirectory(glslang)
add_subdirectory(OGLCompilersDLL) add_subdirectory(OGLCompilersDLL)
add_subdirectory(StandAlone) add_subdirectory(StandAlone)
add_subdirectory(SPIRV) add_subdirectory(SPIRV)
glslang/MachineIndependent/glslang.y
This source diff could not be displayed because it is too large. You can view the blob instead.
glslang/MachineIndependent/reflection.cpp
// //
//Copyright (C) 2013 LunarG, Inc. //Copyright (C) 2013 LunarG, Inc.
// //
//All rights reserved. //All rights reserved.
// //
//Redistribution and use in source and binary forms, with or without //Redistribution and use in source and binary forms, with or without
//modification, are permitted provided that the following conditions //modification, are permitted provided that the following conditions
//are met: //are met:
// //
// Redistributions of source code must retain the above copyright // Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer. // notice, this list of conditions and the following disclaimer.
// //
// Redistributions in binary form must reproduce the above // Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following // copyright notice, this list of conditions and the following
// disclaimer in the documentation and/or other materials provided // disclaimer in the documentation and/or other materials provided
// with the distribution. // with the distribution.
// //
// Neither the name of 3Dlabs Inc. Ltd. nor the names of its // Neither the name of 3Dlabs Inc. Ltd. nor the names of its
// contributors may be used to endorse or promote products derived // contributors may be used to endorse or promote products derived
// from this software without specific prior written permission. // from this software without specific prior written permission.
// //
//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS //THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
//"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT //"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
//LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS //LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
//FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE //FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
//COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, //COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, //INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
//BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; //BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
//LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER //LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
//CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT //CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
//LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN //LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
//ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE //ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
//POSSIBILITY OF SUCH DAMAGE. //POSSIBILITY OF SUCH DAMAGE.
// //
#include "../Include/Common.h" #include "../Include/Common.h"
#include "reflection.h" #include "reflection.h"
#include "localintermediate.h" #include "localintermediate.h"
#include "gl_types.h" #include "gl_types.h"
// //
// Grow the reflection database through a friend traverser class of TReflection and a // Grow the reflection database through a friend traverser class of TReflection and a
// collection of functions to do a liveness traversal that note what uniforms are used // collection of functions to do a liveness traversal that note what uniforms are used
// in semantically non-dead code. // in semantically non-dead code.
// //
// Can be used multiple times, once per stage, to grow a program reflection. // Can be used multiple times, once per stage, to grow a program reflection.
// //
// High-level algorithm for one stage: // High-level algorithm for one stage:
// //
// 1. Put main() on list of live functions. // 1. Put main() on list of live functions.
// //
// 2. Traverse any live function, while skipping if-tests with a compile-time constant // 2. Traverse any live function, while skipping if-tests with a compile-time constant
// condition of false, and while adding any encountered function calls to the live // condition of false, and while adding any encountered function calls to the live
// function list. // function list.
// //
// Repeat until the live function list is empty. // Repeat until the live function list is empty.
// //
// 3. Add any encountered uniform variables and blocks to the reflection database. // 3. Add any encountered uniform variables and blocks to the reflection database.
// //
// Can be attempted with a failed link, but will return false if recursion had been detected, or // Can be attempted with a failed link, but will return false if recursion had been detected, or
// there wasn't exactly one main. // there wasn't exactly one main.
// //
namespace glslang { namespace glslang {
// //
// The traverser: mostly pass through, except // The traverser: mostly pass through, except
// - processing function-call nodes to push live functions onto the stack of functions to process // - processing function-call nodes to push live functions onto the stack of functions to process
// - processing binary nodes to see if they are dereferences of an aggregates to track // - processing binary nodes to see if they are dereferences of an aggregates to track
// - processing symbol nodes to see if they are non-aggregate objects to track // - processing symbol nodes to see if they are non-aggregate objects to track
// - processing selection nodes to trim semantically dead code // - processing selection nodes to trim semantically dead code
// //
// This is in the glslang namespace directly so it can be a friend of TReflection. // This is in the glslang namespace directly so it can be a friend of TReflection.
// //
class TLiveTraverser : public TIntermTraverser { class TLiveTraverser : public TIntermTraverser {
public: public:
TLiveTraverser(const TIntermediate& i, TReflection& r) : intermediate(i), reflection(r) { } TLiveTraverser(const TIntermediate& i, TReflection& r) : intermediate(i), reflection(r) { }
virtual bool visitAggregate(TVisit, TIntermAggregate* node); virtual bool visitAggregate(TVisit, TIntermAggregate* node);
virtual bool visitBinary(TVisit, TIntermBinary* node); virtual bool visitBinary(TVisit, TIntermBinary* node);
virtual void visitSymbol(TIntermSymbol* base); virtual void visitSymbol(TIntermSymbol* base);
virtual bool visitSelection(TVisit, TIntermSelection* node); virtual bool visitSelection(TVisit, TIntermSelection* node);
// Track live funtions as well as uniforms, so that we don't visit dead functions // Track live funtions as well as uniforms, so that we don't visit dead functions
// and only visit each function once. // and only visit each function once.
void addFunctionCall(TIntermAggregate* call) void addFunctionCall(TIntermAggregate* call)
{ {
// just use the map to ensure we process each function at most once // just use the map to ensure we process each function at most once
if (reflection.nameToIndex.find(call->getName()) == reflection.nameToIndex.end()) { if (reflection.nameToIndex.find(call->getName()) == reflection.nameToIndex.end()) {
reflection.nameToIndex[call->getName()] = -1; reflection.nameToIndex[call->getName()] = -1;
pushFunction(call->getName()); pushFunction(call->getName());
} }
} }
// Add a simple reference to a uniform variable to the uniform database, no dereference involved. // Add a simple reference to a uniform variable to the uniform database, no dereference involved.
// However, no dereference doesn't mean simple... it could be a complex aggregate. // However, no dereference doesn't mean simple... it could be a complex aggregate.
void addUniform(const TIntermSymbol& base) void addUniform(const TIntermSymbol& base)
{ {
if (processedDerefs.find(&base) == processedDerefs.end()) { if (processedDerefs.find(&base) == processedDerefs.end()) {
processedDerefs.insert(&base); processedDerefs.insert(&base);
// Use a degenerate (empty) set of dereferences to immediately put as at the end of // Use a degenerate (empty) set of dereferences to immediately put as at the end of
// the dereference change expected by blowUpActiveAggregate. // the dereference change expected by blowUpActiveAggregate.
TList<TIntermBinary*> derefs; TList<TIntermBinary*> derefs;
blowUpActiveAggregate(base.getType(), base.getName(), derefs, derefs.end(), -1, -1, 0); blowUpActiveAggregate(base.getType(), base.getName(), derefs, derefs.end(), -1, -1, 0);
} }
} }
// Lookup or calculate the offset of a block member, using the recursively // Lookup or calculate the offset of a block member, using the recursively
// defined block offset rules. // defined block offset rules.
int getOffset(const TType& type, int index) int getOffset(const TType& type, int index)
{ {
const TTypeList& memberList = *type.getStruct(); const TTypeList& memberList = *type.getStruct();
// Don't calculate offset if one is present, it could be user supplied // Don't calculate offset if one is present, it could be user supplied
// and different than what would be calculated. That is, this is faster, // and different than what would be calculated. That is, this is faster,
// but not just an optimization. // but not just an optimization.
if (memberList[index].type->getQualifier().hasOffset()) if (memberList[index].type->getQualifier().hasOffset())
return memberList[index].type->getQualifier().layoutOffset; return memberList[index].type->getQualifier().layoutOffset;
int memberSize; int memberSize;
int offset = 0; int offset = 0;
for (int m = 0; m <= index; ++m) { for (int m = 0; m <= index; ++m) {
int memberAlignment = intermediate.getBaseAlignment(*memberList[m].type, memberSize, type.getQualifier().layoutPacking == ElpStd140); int memberAlignment = intermediate.getBaseAlignment(*memberList[m].type, memberSize, type.getQualifier().layoutPacking == ElpStd140);
RoundToPow2(offset, memberAlignment); RoundToPow2(offset, memberAlignment);
if (m < index) if (m < index)
offset += memberSize; offset += memberSize;
} }
return offset; return offset;
} }
// Calculate the block data size. // Calculate the block data size.
// Block arrayness is not taken into account, each element is backed by a separate buffer. // Block arrayness is not taken into account, each element is backed by a separate buffer.
int getBlockSize(const TType& blockType) int getBlockSize(const TType& blockType)
{ {
const TTypeList& memberList = *blockType.getStruct(); const TTypeList& memberList = *blockType.getStruct();
int lastIndex = (int)memberList.size() - 1; int lastIndex = (int)memberList.size() - 1;
int lastOffset = getOffset(blockType, lastIndex); int lastOffset = getOffset(blockType, lastIndex);
int lastMemberSize; int lastMemberSize;
intermediate.getBaseAlignment(*memberList[lastIndex].type, lastMemberSize, blockType.getQualifier().layoutPacking == ElpStd140); intermediate.getBaseAlignment(*memberList[lastIndex].type, lastMemberSize, blockType.getQualifier().layoutPacking == ElpStd140);
return lastOffset + lastMemberSize; return lastOffset + lastMemberSize;
} }
// Traverse the provided deref chain, including the base, and // Traverse the provided deref chain, including the base, and
// - build a full reflection-granularity name, array size, etc. entry out of it, if it goes down to that granularity // - build a full reflection-granularity name, array size, etc. entry out of it, if it goes down to that granularity
// - recursively expand any variable array index in the middle of that traversal // - recursively expand any variable array index in the middle of that traversal
// - recursively expand what's left at the end if the deref chain did not reach down to reflection granularity // - recursively expand what's left at the end if the deref chain did not reach down to reflection granularity
// //
// arraySize tracks, just for the final dereference in the chain, if there was a specific known size. // arraySize tracks, just for the final dereference in the chain, if there was a specific known size.
// A value of 0 for arraySize will mean to use the full array's size. // A value of 0 for arraySize will mean to use the full array's size.
void blowUpActiveAggregate(const TType& baseType, const TString& baseName, const TList<TIntermBinary*>& derefs, void blowUpActiveAggregate(const TType& baseType, const TString& baseName, const TList<TIntermBinary*>& derefs,
TList<TIntermBinary*>::const_iterator deref, int offset, int blockIndex, int arraySize) TList<TIntermBinary*>::const_iterator deref, int offset, int blockIndex, int arraySize)
{ {
// process the part of the derefence chain that was explicit in the shader // process the part of the derefence chain that was explicit in the shader
TString name = baseName; TString name = baseName;
const TType* terminalType = &baseType; const TType* terminalType = &baseType;
for (; deref != derefs.end(); ++deref) { for (; deref != derefs.end(); ++deref) {
TIntermBinary* visitNode = *deref; TIntermBinary* visitNode = *deref;
terminalType = &visitNode->getType(); terminalType = &visitNode->getType();
int index; int index;
switch (visitNode->getOp()) { switch (visitNode->getOp()) {
case EOpIndexIndirect: case EOpIndexIndirect:
// Visit all the indices of this array, and for each one add on the remaining dereferencing // Visit all the indices of this array, and for each one add on the remaining dereferencing
for (int i = 0; i < visitNode->getLeft()->getType().getArraySize(); ++i) { for (int i = 0; i < visitNode->getLeft()->getType().getArraySize(); ++i) {
TString newBaseName = name; TString newBaseName = name;
if (baseType.getBasicType() != EbtBlock) if (baseType.getBasicType() != EbtBlock)
newBaseName.append(TString("[") + String(i) + "]"); newBaseName.append(TString("[") + String(i) + "]");
TList<TIntermBinary*>::const_iterator nextDeref = deref; TList<TIntermBinary*>::const_iterator nextDeref = deref;
++nextDeref; ++nextDeref;
TType derefType(*terminalType, 0); TType derefType(*terminalType, 0);
blowUpActiveAggregate(derefType, newBaseName, derefs, nextDeref, offset, blockIndex, arraySize); blowUpActiveAggregate(derefType, newBaseName, derefs, nextDeref, offset, blockIndex, arraySize);
} }
// it was all completed in the recursive calls above // it was all completed in the recursive calls above
return; return;
case EOpIndexDirect: case EOpIndexDirect:
index = visitNode->getRight()->getAsConstantUnion()->getConstArray()[0].getIConst(); index = visitNode->getRight()->getAsConstantUnion()->getConstArray()[0].getIConst();
if (baseType.getBasicType() != EbtBlock) if (baseType.getBasicType() != EbtBlock)
name.append(TString("[") + String(index) + "]"); name.append(TString("[") + String(index) + "]");
break; break;
case EOpIndexDirectStruct: case EOpIndexDirectStruct:
index = visitNode->getRight()->getAsConstantUnion()->getConstArray()[0].getIConst(); index = visitNode->getRight()->getAsConstantUnion()->getConstArray()[0].getIConst();
if (offset >= 0) if (offset >= 0)
offset += getOffset(visitNode->getLeft()->getType(), index); offset += getOffset(visitNode->getLeft()->getType(), index);
if (name.size() > 0) if (name.size() > 0)
name.append("."); name.append(".");
name.append((*visitNode->getLeft()->getType().getStruct())[index].type->getFieldName()); name.append((*visitNode->getLeft()->getType().getStruct())[index].type->getFieldName());
break; break;
default: default:
break; break;
} }
} }
// if the terminalType is still too coarse a granularity, this is still an aggregate to expand, expand it... // if the terminalType is still too coarse a granularity, this is still an aggregate to expand, expand it...
if (! isReflectionGranularity(*terminalType)) { if (! isReflectionGranularity(*terminalType)) {
if (terminalType->isArray()) { if (terminalType->isArray()) {
// Visit all the indices of this array, and for each one, // Visit all the indices of this array, and for each one,
// fully explode the remaining aggregate to dereference // fully explode the remaining aggregate to dereference
for (int i = 0; i < terminalType->getArraySize(); ++i) { for (int i = 0; i < terminalType->getArraySize(); ++i) {
TString newBaseName = name; TString newBaseName = name;
newBaseName.append(TString("[") + String(i) + "]"); newBaseName.append(TString("[") + String(i) + "]");
TType derefType(*terminalType, 0); TType derefType(*terminalType, 0);
blowUpActiveAggregate(derefType, newBaseName, derefs, derefs.end(), offset, blockIndex, 0); blowUpActiveAggregate(derefType, newBaseName, derefs, derefs.end(), offset, blockIndex, 0);
} }
} else { } else {
// Visit all members of this aggregate, and for each one, // Visit all members of this aggregate, and for each one,
// fully explode the remaining aggregate to dereference // fully explode the remaining aggregate to dereference
const TTypeList& typeList = *terminalType->getStruct(); const TTypeList& typeList = *terminalType->getStruct();
for (int i = 0; i < (int)typeList.size(); ++i) { for (int i = 0; i < (int)typeList.size(); ++i) {
TString newBaseName = name; TString newBaseName = name;
newBaseName.append(TString(".") + typeList[i].type->getFieldName()); newBaseName.append(TString(".") + typeList[i].type->getFieldName());
TType derefType(*terminalType, i); TType derefType(*terminalType, i);
blowUpActiveAggregate(derefType, newBaseName, derefs, derefs.end(), offset, blockIndex, 0); blowUpActiveAggregate(derefType, newBaseName, derefs, derefs.end(), offset, blockIndex, 0);
} }
} }
// it was all completed in the recursive calls above // it was all completed in the recursive calls above
return; return;
} }
// Finally, add a full string to the reflection database, and update the array size if necessary. // Finally, add a full string to the reflection database, and update the array size if necessary.
// If the derefenced entity to record is an array, compute the size and update the maximum size. // If the derefenced entity to record is an array, compute the size and update the maximum size.
// there might not be a final array dereference, it could have been copied as an array object // there might not be a final array dereference, it could have been copied as an array object
if (arraySize == 0) if (arraySize == 0)
arraySize = mapToGlArraySize(*terminalType); arraySize = mapToGlArraySize(*terminalType);
TReflection::TNameToIndex::const_iterator it = reflection.nameToIndex.find(name); TReflection::TNameToIndex::const_iterator it = reflection.nameToIndex.find(name);
if (it == reflection.nameToIndex.end()) { if (it == reflection.nameToIndex.end()) {
reflection.nameToIndex[name] = (int)reflection.indexToUniform.size(); reflection.nameToIndex[name] = (int)reflection.indexToUniform.size();
reflection.indexToUniform.push_back(TObjectReflection(name, offset, mapToGlType(*terminalType), arraySize, blockIndex)); reflection.indexToUniform.push_back(TObjectReflection(name, offset, mapToGlType(*terminalType), arraySize, blockIndex));
} else if (arraySize > 1) { } else if (arraySize > 1) {
int& reflectedArraySize = reflection.indexToUniform[it->second].size; int& reflectedArraySize = reflection.indexToUniform[it->second].size;
reflectedArraySize = std::max(arraySize, reflectedArraySize); reflectedArraySize = std::max(arraySize, reflectedArraySize);
} }
} }
// Add a uniform dereference where blocks/struct/arrays are involved in the access. // Add a uniform dereference where blocks/struct/arrays are involved in the access.
// Handles the situation where the left node is at the correct or too coarse a // Handles the situation where the left node is at the correct or too coarse a
// granularity for reflection. (That is, further dereferences up the tree will be // granularity for reflection. (That is, further dereferences up the tree will be
// skipped.) Earlier dereferences, down the tree, will be handled // skipped.) Earlier dereferences, down the tree, will be handled
// at the same time, and logged to prevent reprocessing as the tree is traversed. // at the same time, and logged to prevent reprocessing as the tree is traversed.
// //
// Note: Other things like the following must be caught elsewhere: // Note: Other things like the following must be caught elsewhere:
// - a simple non-array, non-struct variable (no dereference even conceivable) // - a simple non-array, non-struct variable (no dereference even conceivable)
// - an aggregrate consumed en masse, without a dereference // - an aggregrate consumed en masse, without a dereference
// //
// So, this code is for cases like // So, this code is for cases like
// - a struct/block dereferencing a member (whether the member is array or not) // - a struct/block dereferencing a member (whether the member is array or not)
// - an array of struct // - an array of struct
// - structs/arrays containing the above // - structs/arrays containing the above
// //
void addDereferencedUniform(TIntermBinary* topNode) void addDereferencedUniform(TIntermBinary* topNode)
{ {
// See if too fine-grained to process (wait to get further down the tree) // See if too fine-grained to process (wait to get further down the tree)
const TType& leftType = topNode->getLeft()->getType(); const TType& leftType = topNode->getLeft()->getType();
if ((leftType.isVector() || leftType.isMatrix()) && ! leftType.isArray()) if ((leftType.isVector() || leftType.isMatrix()) && ! leftType.isArray())
return; return;
// We have an array or structure or block dereference, see if it's a uniform // We have an array or structure or block dereference, see if it's a uniform
// based dereference (if not, skip it). // based dereference (if not, skip it).
TIntermSymbol* base = findBase(topNode); TIntermSymbol* base = findBase(topNode);
if (! base || ! base->getQualifier().isUniformOrBuffer()) if (! base || ! base->getQualifier().isUniformOrBuffer())
return; return;
// See if we've already processed this (e.g., in the middle of something // See if we've already processed this (e.g., in the middle of something
// we did earlier), and if so skip it // we did earlier), and if so skip it
if (processedDerefs.find(topNode) != processedDerefs.end()) if (processedDerefs.find(topNode) != processedDerefs.end())
return; return;
// Process this uniform dereference // Process this uniform dereference
int offset = -1; int offset = -1;
int blockIndex = -1; int blockIndex = -1;
bool anonymous = false; bool anonymous = false;
// See if we need to record the block itself // See if we need to record the block itself
bool block = base->getBasicType() == EbtBlock; bool block = base->getBasicType() == EbtBlock;
if (block) { if (block) {
offset = 0; offset = 0;
anonymous = IsAnonymous(base->getName()); anonymous = IsAnonymous(base->getName());
if (base->getType().isArray()) { if (base->getType().isArray()) {
assert(! anonymous); assert(! anonymous);
for (int e = 0; e < base->getType().getArraySize(); ++e) for (int e = 0; e < base->getType().getArraySize(); ++e)
blockIndex = addBlockName(base->getType().getTypeName() + "[" + String(e) + "]", getBlockSize(base->getType())); blockIndex = addBlockName(base->getType().getTypeName() + "[" + String(e) + "]", getBlockSize(base->getType()));
} else } else
blockIndex = addBlockName(base->getType().getTypeName(), getBlockSize(base->getType())); blockIndex = addBlockName(base->getType().getTypeName(), getBlockSize(base->getType()));
} }
// Process the dereference chain, backward, accumulating the pieces for later forward traversal. // Process the dereference chain, backward, accumulating the pieces for later forward traversal.
// If the topNode is a reflection-granularity-array dereference, don't include that last dereference. // If the topNode is a reflection-granularity-array dereference, don't include that last dereference.
TList<TIntermBinary*> derefs; TList<TIntermBinary*> derefs;
for (TIntermBinary* visitNode = topNode; visitNode; visitNode = visitNode->getLeft()->getAsBinaryNode()) { for (TIntermBinary* visitNode = topNode; visitNode; visitNode = visitNode->getLeft()->getAsBinaryNode()) {
if (isReflectionGranularity(visitNode->getLeft()->getType())) if (isReflectionGranularity(visitNode->getLeft()->getType()))
continue; continue;
derefs.push_front(visitNode); derefs.push_front(visitNode);
processedDerefs.insert(visitNode); processedDerefs.insert(visitNode);
} }
processedDerefs.insert(base); processedDerefs.insert(base);
// See if we have a specific array size to stick to while enumerating the explosion of the aggregate // See if we have a specific array size to stick to while enumerating the explosion of the aggregate
int arraySize = 0; int arraySize = 0;
if (isReflectionGranularity(topNode->getLeft()->getType()) && topNode->getLeft()->isArray()) { if (isReflectionGranularity(topNode->getLeft()->getType()) && topNode->getLeft()->isArray()) {
if (topNode->getOp() == EOpIndexDirect) if (topNode->getOp() == EOpIndexDirect)
arraySize = topNode->getRight()->getAsConstantUnion()->getConstArray()[0].getIConst() + 1; arraySize = topNode->getRight()->getAsConstantUnion()->getConstArray()[0].getIConst() + 1;
} }
// Put the dereference chain together, forward // Put the dereference chain together, forward
TString baseName; TString baseName;
if (! anonymous) { if (! anonymous) {
if (block) if (block)
baseName = base->getType().getTypeName(); baseName = base->getType().getTypeName();
else else
baseName = base->getName(); baseName = base->getName();
} }
blowUpActiveAggregate(base->getType(), baseName, derefs, derefs.begin(), offset, blockIndex, arraySize); blowUpActiveAggregate(base->getType(), baseName, derefs, derefs.begin(), offset, blockIndex, arraySize);
} }
int addBlockName(const TString& name, int size) int addBlockName(const TString& name, int size)
{ {
int blockIndex; int blockIndex;
TReflection::TNameToIndex::const_iterator it = reflection.nameToIndex.find(name); TReflection::TNameToIndex::const_iterator it = reflection.nameToIndex.find(name);
if (reflection.nameToIndex.find(name) == reflection.nameToIndex.end()) { if (reflection.nameToIndex.find(name) == reflection.nameToIndex.end()) {
blockIndex = (int)reflection.indexToUniformBlock.size(); blockIndex = (int)reflection.indexToUniformBlock.size();
reflection.nameToIndex[name] = blockIndex; reflection.nameToIndex[name] = blockIndex;
reflection.indexToUniformBlock.push_back(TObjectReflection(name, -1, -1, size, -1)); reflection.indexToUniformBlock.push_back(TObjectReflection(name, -1, -1, size, -1));
} else } else
blockIndex = it->second; blockIndex = it->second;
return blockIndex; return blockIndex;
} }
// //
// Given a function name, find its subroot in the tree, and push it onto the stack of // Given a function name, find its subroot in the tree, and push it onto the stack of
// functions left to process. // functions left to process.
// //
void pushFunction(const TString& name) void pushFunction(const TString& name)
{ {
TIntermSequence& globals = intermediate.getTreeRoot()->getAsAggregate()->getSequence(); TIntermSequence& globals = intermediate.getTreeRoot()->getAsAggregate()->getSequence();
for (unsigned int f = 0; f < globals.size(); ++f) { for (unsigned int f = 0; f < globals.size(); ++f) {
TIntermAggregate* candidate = globals[f]->getAsAggregate(); TIntermAggregate* candidate = globals[f]->getAsAggregate();
if (candidate && candidate->getOp() == EOpFunction && candidate->getName() == name) { if (candidate && candidate->getOp() == EOpFunction && candidate->getName() == name) {
functions.push_back(candidate); functions.push_back(candidate);
break; break;
} }
} }
} }
// Are we at a level in a dereference chain at which individual active uniform queries are made? // Are we at a level in a dereference chain at which individual active uniform queries are made?
bool isReflectionGranularity(const TType& type) bool isReflectionGranularity(const TType& type)
{ {
return type.getBasicType() != EbtBlock && type.getBasicType() != EbtStruct; return type.getBasicType() != EbtBlock && type.getBasicType() != EbtStruct;
} }
// For a binary operation indexing into an aggregate, chase down the base of the aggregate. // For a binary operation indexing into an aggregate, chase down the base of the aggregate.
// Return 0 if the topology does not fit this situation. // Return 0 if the topology does not fit this situation.
TIntermSymbol* findBase(const TIntermBinary* node) TIntermSymbol* findBase(const TIntermBinary* node)
{ {
TIntermSymbol *base = node->getLeft()->getAsSymbolNode(); TIntermSymbol *base = node->getLeft()->getAsSymbolNode();
if (base) if (base)
return base; return base;
TIntermBinary* left = node->getLeft()->getAsBinaryNode(); TIntermBinary* left = node->getLeft()->getAsBinaryNode();
if (! left) if (! left)
return nullptr; return nullptr;
return findBase(left); return findBase(left);
} }
// //
// Translate a glslang sampler type into the GL API #define number. // Translate a glslang sampler type into the GL API #define number.
// //
int mapSamplerToGlType(TSampler sampler) int mapSamplerToGlType(TSampler sampler)
{ {
if (! sampler.image) { if (! sampler.image) {
// a sampler... // a sampler...
switch (sampler.type) { switch (sampler.type) {
case EbtFloat: case EbtFloat:
switch ((int)sampler.dim) { switch ((int)sampler.dim) {
case Esd1D: case Esd1D:
switch ((int)sampler.shadow) { switch ((int)sampler.shadow) {
case false: return sampler.arrayed ? GL_SAMPLER_1D_ARRAY : GL_SAMPLER_1D; case false: return sampler.arrayed ? GL_SAMPLER_1D_ARRAY : GL_SAMPLER_1D;
case true: return sampler.arrayed ? GL_SAMPLER_1D_ARRAY_SHADOW : GL_SAMPLER_1D_SHADOW; case true: return sampler.arrayed ? GL_SAMPLER_1D_ARRAY_SHADOW : GL_SAMPLER_1D_SHADOW;
} }
case Esd2D: case Esd2D:
switch ((int)sampler.ms) { switch ((int)sampler.ms) {
case false: case false:
switch ((int)sampler.shadow) { switch ((int)sampler.shadow) {
case false: return sampler.arrayed ? GL_SAMPLER_2D_ARRAY : GL_SAMPLER_2D; case false: return sampler.arrayed ? GL_SAMPLER_2D_ARRAY : GL_SAMPLER_2D;
case true: return sampler.arrayed ? GL_SAMPLER_2D_ARRAY_SHADOW : GL_SAMPLER_2D_SHADOW; case true: return sampler.arrayed ? GL_SAMPLER_2D_ARRAY_SHADOW : GL_SAMPLER_2D_SHADOW;
} }
case true: return sampler.arrayed ? GL_SAMPLER_2D_MULTISAMPLE_ARRAY : GL_SAMPLER_2D_MULTISAMPLE; case true: return sampler.arrayed ? GL_SAMPLER_2D_MULTISAMPLE_ARRAY : GL_SAMPLER_2D_MULTISAMPLE;
} }
case Esd3D: case Esd3D:
return GL_SAMPLER_3D; return GL_SAMPLER_3D;
case EsdCube: case EsdCube:
switch ((int)sampler.shadow) { switch ((int)sampler.shadow) {
case false: return sampler.arrayed ? GL_SAMPLER_CUBE_MAP_ARRAY : GL_SAMPLER_CUBE; case false: return sampler.arrayed ? GL_SAMPLER_CUBE_MAP_ARRAY : GL_SAMPLER_CUBE;
case true: return sampler.arrayed ? GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW : GL_SAMPLER_CUBE_SHADOW; case true: return sampler.arrayed ? GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW : GL_SAMPLER_CUBE_SHADOW;
} }
case EsdRect: case EsdRect:
return sampler.shadow ? GL_SAMPLER_2D_RECT_SHADOW : GL_SAMPLER_2D_RECT; return sampler.shadow ? GL_SAMPLER_2D_RECT_SHADOW : GL_SAMPLER_2D_RECT;
case EsdBuffer: case EsdBuffer:
return GL_SAMPLER_BUFFER; return GL_SAMPLER_BUFFER;
} }
case EbtInt: case EbtInt:
switch ((int)sampler.dim) { switch ((int)sampler.dim) {
case Esd1D: case Esd1D:
return sampler.arrayed ? GL_INT_SAMPLER_1D_ARRAY : GL_INT_SAMPLER_1D; return sampler.arrayed ? GL_INT_SAMPLER_1D_ARRAY : GL_INT_SAMPLER_1D;
case Esd2D: case Esd2D:
switch ((int)sampler.ms) { switch ((int)sampler.ms) {
case false: return sampler.arrayed ? GL_INT_SAMPLER_2D_ARRAY : GL_INT_SAMPLER_2D; case false: return sampler.arrayed ? GL_INT_SAMPLER_2D_ARRAY : GL_INT_SAMPLER_2D;
case true: return sampler.arrayed ? GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY : GL_INT_SAMPLER_2D_MULTISAMPLE; case true: return sampler.arrayed ? GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY : GL_INT_SAMPLER_2D_MULTISAMPLE;
} }
case Esd3D: case Esd3D:
return GL_INT_SAMPLER_3D; return GL_INT_SAMPLER_3D;
case EsdCube: case EsdCube:
return sampler.arrayed ? GL_INT_SAMPLER_CUBE_MAP_ARRAY : GL_INT_SAMPLER_CUBE; return sampler.arrayed ? GL_INT_SAMPLER_CUBE_MAP_ARRAY : GL_INT_SAMPLER_CUBE;
case EsdRect: case EsdRect:
return GL_INT_SAMPLER_2D_RECT; return GL_INT_SAMPLER_2D_RECT;
case EsdBuffer: case EsdBuffer:
return GL_INT_SAMPLER_BUFFER; return GL_INT_SAMPLER_BUFFER;
} }
case EbtUint: case EbtUint:
switch ((int)sampler.dim) { switch ((int)sampler.dim) {
case Esd1D: case Esd1D:
return sampler.arrayed ? GL_UNSIGNED_INT_SAMPLER_1D_ARRAY : GL_UNSIGNED_INT_SAMPLER_1D; return sampler.arrayed ? GL_UNSIGNED_INT_SAMPLER_1D_ARRAY : GL_UNSIGNED_INT_SAMPLER_1D;
case Esd2D: case Esd2D:
switch ((int)sampler.ms) { switch ((int)sampler.ms) {
case false: return sampler.arrayed ? GL_UNSIGNED_INT_SAMPLER_2D_ARRAY : GL_UNSIGNED_INT_SAMPLER_2D; case false: return sampler.arrayed ? GL_UNSIGNED_INT_SAMPLER_2D_ARRAY : GL_UNSIGNED_INT_SAMPLER_2D;
case true: return sampler.arrayed ? GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY : GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE; case true: return sampler.arrayed ? GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY : GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE;
} }
case Esd3D: case Esd3D:
return GL_UNSIGNED_INT_SAMPLER_3D; return GL_UNSIGNED_INT_SAMPLER_3D;
case EsdCube: case EsdCube:
return sampler.arrayed ? GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY : GL_UNSIGNED_INT_SAMPLER_CUBE; return sampler.arrayed ? GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY : GL_UNSIGNED_INT_SAMPLER_CUBE;
case EsdRect: case EsdRect:
return GL_UNSIGNED_INT_SAMPLER_2D_RECT; return GL_UNSIGNED_INT_SAMPLER_2D_RECT;
case EsdBuffer: case EsdBuffer:
return GL_UNSIGNED_INT_SAMPLER_BUFFER; return GL_UNSIGNED_INT_SAMPLER_BUFFER;
} }
default: default:
return 0; return 0;
} }
} else { } else {
// an image... // an image...
switch (sampler.type) { switch (sampler.type) {
case EbtFloat: case EbtFloat:
switch ((int)sampler.dim) { switch ((int)sampler.dim) {
case Esd1D: case Esd1D:
return sampler.arrayed ? GL_IMAGE_1D_ARRAY : GL_IMAGE_1D; return sampler.arrayed ? GL_IMAGE_1D_ARRAY : GL_IMAGE_1D;
case Esd2D: case Esd2D:
switch ((int)sampler.ms) { switch ((int)sampler.ms) {
case false: return sampler.arrayed ? GL_IMAGE_2D_ARRAY : GL_IMAGE_2D; case false: return sampler.arrayed ? GL_IMAGE_2D_ARRAY : GL_IMAGE_2D;
case true: return sampler.arrayed ? GL_IMAGE_2D_MULTISAMPLE_ARRAY : GL_IMAGE_2D_MULTISAMPLE; case true: return sampler.arrayed ? GL_IMAGE_2D_MULTISAMPLE_ARRAY : GL_IMAGE_2D_MULTISAMPLE;
} }
case Esd3D: case Esd3D:
return GL_IMAGE_3D; return GL_IMAGE_3D;
case EsdCube: case EsdCube:
return sampler.arrayed ? GL_IMAGE_CUBE_MAP_ARRAY : GL_IMAGE_CUBE; return sampler.arrayed ? GL_IMAGE_CUBE_MAP_ARRAY : GL_IMAGE_CUBE;
case EsdRect: case EsdRect:
return GL_IMAGE_2D_RECT; return GL_IMAGE_2D_RECT;
case EsdBuffer: case EsdBuffer:
return GL_IMAGE_BUFFER; return GL_IMAGE_BUFFER;
} }
case EbtInt: case EbtInt:
switch ((int)sampler.dim) { switch ((int)sampler.dim) {
case Esd1D: case Esd1D:
return sampler.arrayed ? GL_INT_IMAGE_1D_ARRAY : GL_INT_IMAGE_1D; return sampler.arrayed ? GL_INT_IMAGE_1D_ARRAY : GL_INT_IMAGE_1D;
case Esd2D: case Esd2D:
switch ((int)sampler.ms) { switch ((int)sampler.ms) {
case false: return sampler.arrayed ? GL_INT_IMAGE_2D_ARRAY : GL_INT_IMAGE_2D; case false: return sampler.arrayed ? GL_INT_IMAGE_2D_ARRAY : GL_INT_IMAGE_2D;
case true: return sampler.arrayed ? GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY : GL_INT_IMAGE_2D_MULTISAMPLE; case true: return sampler.arrayed ? GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY : GL_INT_IMAGE_2D_MULTISAMPLE;
} }
case Esd3D: case Esd3D:
return GL_INT_IMAGE_3D; return GL_INT_IMAGE_3D;
case EsdCube: case EsdCube:
return sampler.arrayed ? GL_INT_IMAGE_CUBE_MAP_ARRAY : GL_INT_IMAGE_CUBE; return sampler.arrayed ? GL_INT_IMAGE_CUBE_MAP_ARRAY : GL_INT_IMAGE_CUBE;
case EsdRect: case EsdRect:
return GL_INT_IMAGE_2D_RECT; return GL_INT_IMAGE_2D_RECT;
case EsdBuffer: case EsdBuffer:
return GL_INT_IMAGE_BUFFER; return GL_INT_IMAGE_BUFFER;
} }
case EbtUint: case EbtUint:
switch ((int)sampler.dim) { switch ((int)sampler.dim) {
case Esd1D: case Esd1D:
return sampler.arrayed ? GL_UNSIGNED_INT_IMAGE_1D_ARRAY : GL_UNSIGNED_INT_IMAGE_1D; return sampler.arrayed ? GL_UNSIGNED_INT_IMAGE_1D_ARRAY : GL_UNSIGNED_INT_IMAGE_1D;
case Esd2D: case Esd2D:
switch ((int)sampler.ms) { switch ((int)sampler.ms) {
case false: return sampler.arrayed ? GL_UNSIGNED_INT_IMAGE_2D_ARRAY : GL_UNSIGNED_INT_IMAGE_2D; case false: return sampler.arrayed ? GL_UNSIGNED_INT_IMAGE_2D_ARRAY : GL_UNSIGNED_INT_IMAGE_2D;
case true: return sampler.arrayed ? GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY : GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE; case true: return sampler.arrayed ? GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY : GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE;
} }
case Esd3D: case Esd3D:
return GL_UNSIGNED_INT_IMAGE_3D; return GL_UNSIGNED_INT_IMAGE_3D;
case EsdCube: case EsdCube:
return sampler.arrayed ? GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY : GL_UNSIGNED_INT_IMAGE_CUBE; return sampler.arrayed ? GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY : GL_UNSIGNED_INT_IMAGE_CUBE;
case EsdRect: case EsdRect:
return GL_UNSIGNED_INT_IMAGE_2D_RECT; return GL_UNSIGNED_INT_IMAGE_2D_RECT;
case EsdBuffer: case EsdBuffer:
return GL_UNSIGNED_INT_IMAGE_BUFFER; return GL_UNSIGNED_INT_IMAGE_BUFFER;
} }
default: default:
return 0; return 0;
} }
} }
} }
// //
// Translate a glslang type into the GL API #define number. // Translate a glslang type into the GL API #define number.
// Ignores arrayness. // Ignores arrayness.
// //
int mapToGlType(const TType& type) int mapToGlType(const TType& type)
{ {
switch (type.getBasicType()) { switch (type.getBasicType()) {
case EbtSampler: case EbtSampler:
return mapSamplerToGlType(type.getSampler()); return mapSamplerToGlType(type.getSampler());
case EbtStruct: case EbtStruct:
case EbtBlock: case EbtBlock:
case EbtVoid: case EbtVoid:
return 0; return 0;
default: default:
break; break;
} }
if (type.isVector()) { if (type.isVector()) {
int offset = type.getVectorSize() - 2; int offset = type.getVectorSize() - 2;
switch (type.getBasicType()) { switch (type.getBasicType()) {
case EbtFloat: return GL_FLOAT_VEC2 + offset; case EbtFloat: return GL_FLOAT_VEC2 + offset;
case EbtDouble: return GL_DOUBLE_VEC2 + offset; case EbtDouble: return GL_DOUBLE_VEC2 + offset;
case EbtInt: return GL_INT_VEC2 + offset; case EbtInt: return GL_INT_VEC2 + offset;
case EbtUint: return GL_UNSIGNED_INT_VEC2 + offset; case EbtUint: return GL_UNSIGNED_INT_VEC2 + offset;
case EbtBool: return GL_BOOL_VEC2 + offset; case EbtBool: return GL_BOOL_VEC2 + offset;
case EbtAtomicUint: return GL_UNSIGNED_INT_ATOMIC_COUNTER + offset; case EbtAtomicUint: return GL_UNSIGNED_INT_ATOMIC_COUNTER + offset;
default: return 0; default: return 0;
} }
} }
if (type.isMatrix()) { if (type.isMatrix()) {
switch (type.getBasicType()) { switch (type.getBasicType()) {
case EbtFloat: case EbtFloat:
switch (type.getMatrixCols()) { switch (type.getMatrixCols()) {
case 2: case 2:
switch (type.getMatrixRows()) { switch (type.getMatrixRows()) {
case 2: return GL_FLOAT_MAT2; case 2: return GL_FLOAT_MAT2;
case 3: return GL_FLOAT_MAT2x3; case 3: return GL_FLOAT_MAT2x3;
case 4: return GL_FLOAT_MAT2x4; case 4: return GL_FLOAT_MAT2x4;
default: return 0; default: return 0;
} }
case 3: case 3:
switch (type.getMatrixRows()) { switch (type.getMatrixRows()) {
case 2: return GL_FLOAT_MAT3x2; case 2: return GL_FLOAT_MAT3x2;
case 3: return GL_FLOAT_MAT3; case 3: return GL_FLOAT_MAT3;
case 4: return GL_FLOAT_MAT3x4; case 4: return GL_FLOAT_MAT3x4;
default: return 0; default: return 0;
} }
case 4: case 4:
switch (type.getMatrixRows()) { switch (type.getMatrixRows()) {
case 2: return GL_FLOAT_MAT4x2; case 2: return GL_FLOAT_MAT4x2;
case 3: return GL_FLOAT_MAT4x3; case 3: return GL_FLOAT_MAT4x3;
case 4: return GL_FLOAT_MAT4; case 4: return GL_FLOAT_MAT4;
default: return 0; default: return 0;
} }
} }
case EbtDouble: case EbtDouble:
switch (type.getMatrixCols()) { switch (type.getMatrixCols()) {
case 2: case 2:
switch (type.getMatrixRows()) { switch (type.getMatrixRows()) {
case 2: return GL_DOUBLE_MAT2; case 2: return GL_DOUBLE_MAT2;
case 3: return GL_DOUBLE_MAT2x3; case 3: return GL_DOUBLE_MAT2x3;
case 4: return GL_DOUBLE_MAT2x4; case 4: return GL_DOUBLE_MAT2x4;
default: return 0; default: return 0;
} }
case 3: case 3:
switch (type.getMatrixRows()) { switch (type.getMatrixRows()) {
case 2: return GL_DOUBLE_MAT3x2; case 2: return GL_DOUBLE_MAT3x2;
case 3: return GL_DOUBLE_MAT3; case 3: return GL_DOUBLE_MAT3;
case 4: return GL_DOUBLE_MAT3x4; case 4: return GL_DOUBLE_MAT3x4;
default: return 0; default: return 0;
} }
case 4: case 4:
switch (type.getMatrixRows()) { switch (type.getMatrixRows()) {
case 2: return GL_DOUBLE_MAT4x2; case 2: return GL_DOUBLE_MAT4x2;
case 3: return GL_DOUBLE_MAT4x3; case 3: return GL_DOUBLE_MAT4x3;
case 4: return GL_DOUBLE_MAT4; case 4: return GL_DOUBLE_MAT4;
default: return 0; default: return 0;
} }
} }
default: default:
return 0; return 0;
} }
} }
if (type.getVectorSize() == 1) { if (type.getVectorSize() == 1) {
switch (type.getBasicType()) { switch (type.getBasicType()) {
case EbtFloat: return GL_FLOAT; case EbtFloat: return GL_FLOAT;
case EbtDouble: return GL_DOUBLE; case EbtDouble: return GL_DOUBLE;
case EbtInt: return GL_INT; case EbtInt: return GL_INT;
case EbtUint: return GL_UNSIGNED_INT; case EbtUint: return GL_UNSIGNED_INT;
case EbtBool: return GL_BOOL; case EbtBool: return GL_BOOL;
case EbtAtomicUint: return GL_UNSIGNED_INT_ATOMIC_COUNTER; case EbtAtomicUint: return GL_UNSIGNED_INT_ATOMIC_COUNTER;
default: return 0; default: return 0;
} }
} }
return 0; return 0;
} }
int mapToGlArraySize(const TType& type) int mapToGlArraySize(const TType& type)
{ {
return type.isArray() ? type.getArraySize() : 1; return type.isArray() ? type.getArraySize() : 1;
} }
typedef std::list<TIntermAggregate*> TFunctionStack; typedef std::list<TIntermAggregate*> TFunctionStack;
TFunctionStack functions; TFunctionStack functions;
const TIntermediate& intermediate; const TIntermediate& intermediate;
TReflection& reflection; TReflection& reflection;
std::set<const TIntermNode*> processedDerefs; std::set<const TIntermNode*> processedDerefs;
protected: protected:
TLiveTraverser(TLiveTraverser&); TLiveTraverser(TLiveTraverser&);
TLiveTraverser& operator=(TLiveTraverser&); TLiveTraverser& operator=(TLiveTraverser&);
}; };
// //
// Implement the traversal functions of interest. // Implement the traversal functions of interest.
// //
// To catch which function calls are not dead, and hence which functions must be visited. // To catch which function calls are not dead, and hence which functions must be visited.
bool TLiveTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node) bool TLiveTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node)
{ {
if (node->getOp() == EOpFunctionCall) if (node->getOp() == EOpFunctionCall)
addFunctionCall(node); addFunctionCall(node);
return true; // traverse this subtree return true; // traverse this subtree
} }
// To catch dereferenced aggregates that must be reflected. // To catch dereferenced aggregates that must be reflected.
// This catches them at the highest level possible in the tree. // This catches them at the highest level possible in the tree.
bool TLiveTraverser::visitBinary(TVisit /* visit */, TIntermBinary* node) bool TLiveTraverser::visitBinary(TVisit /* visit */, TIntermBinary* node)
{ {
switch (node->getOp()) { switch (node->getOp()) {
case EOpIndexDirect: case EOpIndexDirect:
case EOpIndexIndirect: case EOpIndexIndirect:
case EOpIndexDirectStruct: case EOpIndexDirectStruct:
addDereferencedUniform(node); addDereferencedUniform(node);
break; break;
default: default:
break; break;
} }
// still need to visit everything below, which could contain sub-expressions // still need to visit everything below, which could contain sub-expressions
// containing different uniforms // containing different uniforms
return true; return true;
} }
// To reflect non-dereferenced objects. // To reflect non-dereferenced objects.
void TLiveTraverser::visitSymbol(TIntermSymbol* base) void TLiveTraverser::visitSymbol(TIntermSymbol* base)
{ {
if (base->getQualifier().storage == EvqUniform) if (base->getQualifier().storage == EvqUniform)
addUniform(*base); addUniform(*base);
} }
// To prune semantically dead paths. // To prune semantically dead paths.
bool TLiveTraverser::visitSelection(TVisit /* visit */, TIntermSelection* node) bool TLiveTraverser::visitSelection(TVisit /* visit */, TIntermSelection* node)
{ {
TIntermConstantUnion* constant = node->getCondition()->getAsConstantUnion(); TIntermConstantUnion* constant = node->getCondition()->getAsConstantUnion();
if (constant) { if (constant) {
// cull the path that is dead // cull the path that is dead
if (constant->getConstArray()[0].getBConst() == true && node->getTrueBlock()) if (constant->getConstArray()[0].getBConst() == true && node->getTrueBlock())
node->getTrueBlock()->traverse(this); node->getTrueBlock()->traverse(this);
if (constant->getConstArray()[0].getBConst() == false && node->getFalseBlock()) if (constant->getConstArray()[0].getBConst() == false && node->getFalseBlock())
node->getFalseBlock()->traverse(this); node->getFalseBlock()->traverse(this);
return false; // don't traverse any more, we did it all above return false; // don't traverse any more, we did it all above
} else } else
return true; // traverse the whole subtree return true; // traverse the whole subtree
} }
// //
// Implement TReflection methods. // Implement TReflection methods.
// //
// Merge live symbols from 'intermediate' into the existing reflection database. // Merge live symbols from 'intermediate' into the existing reflection database.
// //
// Returns false if the input is too malformed to do this. // Returns false if the input is too malformed to do this.
bool TReflection::addStage(EShLanguage, const TIntermediate& intermediate) bool TReflection::addStage(EShLanguage, const TIntermediate& intermediate)
{ {
if (intermediate.getNumMains() != 1 || intermediate.isRecursive()) if (intermediate.getNumMains() != 1 || intermediate.isRecursive())
return false; return false;
TLiveTraverser it(intermediate, *this); TLiveTraverser it(intermediate, *this);
// put main() on functions to process // put main() on functions to process
it.pushFunction("main("); it.pushFunction("main(");
// process all the functions // process all the functions
while (! it.functions.empty()) { while (! it.functions.empty()) {
TIntermNode* function = it.functions.back(); TIntermNode* function = it.functions.back();
it.functions.pop_back(); it.functions.pop_back();
function->traverse(&it); function->traverse(&it);
} }
return true; return true;
} }
void TReflection::dump() void TReflection::dump()
{ {
printf("Uniform reflection:\n"); printf("Uniform reflection:\n");
for (size_t i = 0; i < indexToUniform.size(); ++i) for (size_t i = 0; i < indexToUniform.size(); ++i)
indexToUniform[i].dump(); indexToUniform[i].dump();
printf("\n"); printf("\n");
printf("Uniform block reflection:\n"); printf("Uniform block reflection:\n");
for (size_t i = 0; i < indexToUniformBlock.size(); ++i) for (size_t i = 0; i < indexToUniformBlock.size(); ++i)
indexToUniformBlock[i].dump(); indexToUniformBlock[i].dump();
printf("\n"); printf("\n");
//printf("Live names\n"); //printf("Live names\n");
//for (TNameToIndex::const_iterator it = nameToIndex.begin(); it != nameToIndex.end(); ++it) //for (TNameToIndex::const_iterator it = nameToIndex.begin(); it != nameToIndex.end(); ++it)
// printf("%s: %d\n", it->first.c_str(), it->second); // printf("%s: %d\n", it->first.c_str(), it->second);
//printf("\n"); //printf("\n");
} }
} // end namespace glslang } // end namespace glslang
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment