mewin/glslang
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

HLSL: Non-functional; make flatten semantics be about aggregates, not just structures.

Browse Source
This commit is contained in:
John Kessenich 2016-09-18 23:10:22 -06:00
parent fcea302dbc
commit f911500db8
3 changed files with 18 additions and 18 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
glslang/Include/revision.h
View File

@ -2,5 +2,5 @@
// For the version, it uses the latest git tag followed by the number of commits. // For the version, it uses the latest git tag followed by the number of commits.
// For the date, it uses the current date (when then script is run). // For the date, it uses the current date (when then script is run).
#define GLSLANG_REVISION "Overload400-PrecQual.1491" #define GLSLANG_REVISION "Overload400-PrecQual.1493"
#define GLSLANG_DATE "16-Sep-2016" #define GLSLANG_DATE "18-Sep-2016"

26
hlsl/hlslParseHelper.cpp
View File

@ -700,9 +700,9 @@ TIntermTyped* HlslParseContext::handleDotDereference(const TSourceLoc& loc, TInt
return result; return result;
} }
// Is this a structure that can't be passed down the stack? // Is this an aggregate that can't be passed down the stack?
// E.g., pipeline inputs to the vertex stage and outputs from the fragment stage. // E.g., pipeline inputs to the vertex stage and outputs from the fragment stage.
bool HlslParseContext::shouldFlatten(const TType& type) bool HlslParseContext::shouldFlatten(const TType& type) const
{ {
if (! inEntrypoint) if (! inEntrypoint)
return false; return false;
@ -714,13 +714,13 @@ bool HlslParseContext::shouldFlatten(const TType& type)
qualifier == EvqVaryingOut); qualifier == EvqVaryingOut);
} }
// Figure out the mapping between a structure's top members and an // Figure out the mapping between an aggregate's top members and an
// equivalent set of individual variables. // equivalent set of individual variables.
// //
// Assumes shouldFlatten() or equivalent was called first. // Assumes shouldFlatten() or equivalent was called first.
// //
// TODO: generalize this to arbitrary nesting? // TODO: generalize this to arbitrary nesting?
void HlslParseContext::flattenStruct(const TVariable& variable) void HlslParseContext::flatten(const TVariable& variable)
{ {
TVector<TVariable*> memberVariables; TVector<TVariable*> memberVariables;
@ -735,8 +735,8 @@ void HlslParseContext::flattenStruct(const TVariable& variable)
flattenMap[variable.getUniqueId()] = memberVariables; flattenMap[variable.getUniqueId()] = memberVariables;
} }
// Turn an access into structure that was flattened to instead be // Turn an access into aggregate that was flattened to instead be
// an access to the individual variable the member was flattened to. // an access to the individual variable the element/member was flattened to.
// Assumes shouldFlatten() or equivalent was called first. // Assumes shouldFlatten() or equivalent was called first.
TIntermTyped* HlslParseContext::flattenAccess(TIntermTyped* base, int member) TIntermTyped* HlslParseContext::flattenAccess(TIntermTyped* base, int member)
{ {
@ -855,7 +855,7 @@ TIntermAggregate* HlslParseContext::handleFunctionDefinition(const TSourceLoc& l
remapEntrypointIO(function); remapEntrypointIO(function);
if (entryPointOutput) { if (entryPointOutput) {
if (shouldFlatten(entryPointOutput->getType())) if (shouldFlatten(entryPointOutput->getType()))
flattenStruct(*entryPointOutput); flatten(*entryPointOutput);
assignLocations(*entryPointOutput); assignLocations(*entryPointOutput);
} }
} else } else
@ -887,7 +887,7 @@ TIntermAggregate* HlslParseContext::handleFunctionDefinition(const TSourceLoc& l
// get IO straightened out // get IO straightened out
if (inEntrypoint) { if (inEntrypoint) {
if (shouldFlatten(*param.type)) if (shouldFlatten(*param.type))
flattenStruct(*variable); flatten(*variable);
assignLocations(*variable); assignLocations(*variable);
} }
@ -1035,7 +1035,7 @@ void HlslParseContext::handleFunctionArgument(TFunction* function, TIntermTyped*
// Some simple source assignments need to be flattened to a sequence // Some simple source assignments need to be flattened to a sequence
// of AST assignments. Catch these and flatten, otherwise, pass through // of AST assignments. Catch these and flatten, otherwise, pass through
// to intermediate.addAssign(). // to intermediate.addAssign().
TIntermTyped* HlslParseContext::handleAssign(const TSourceLoc& loc, TOperator op, TIntermTyped* left, TIntermTyped* right) TIntermTyped* HlslParseContext::handleAssign(const TSourceLoc& loc, TOperator op, TIntermTyped* left, TIntermTyped* right) const
{ {
const auto mustFlatten = [&](const TIntermTyped& node) { const auto mustFlatten = [&](const TIntermTyped& node) {
return shouldFlatten(node.getType()) && node.getAsSymbolNode() && return shouldFlatten(node.getType()) && node.getAsSymbolNode() &&
@ -1064,12 +1064,12 @@ TIntermTyped* HlslParseContext::handleAssign(const TSourceLoc& loc, TOperator op
return subTree; return subTree;
}; };
TVector<TVariable*>* leftVariables = nullptr; const TVector<TVariable*>* leftVariables = nullptr;
TVector<TVariable*>* rightVariables = nullptr; const TVector<TVariable*>* rightVariables = nullptr;
if (flattenLeft) if (flattenLeft)
leftVariables = &flattenMap[left->getAsSymbolNode()->getId()]; leftVariables = &flattenMap.find(left->getAsSymbolNode()->getId())->second;
if (flattenRight) if (flattenRight)
rightVariables = &flattenMap[right->getAsSymbolNode()->getId()]; rightVariables = &flattenMap.find(right->getAsSymbolNode()->getId())->second;
TIntermAggregate* assignList = nullptr; TIntermAggregate* assignList = nullptr;
for (int member = 0; member < (int)members.size(); ++member) { for (int member = 0; member < (int)members.size(); ++member) {
TIntermTyped* subRight = getMember(flattenRight, right, *rightVariables, member); TIntermTyped* subRight = getMember(flattenRight, right, *rightVariables, member);

6
hlsl/hlslParseHelper.h
View File

@ -83,8 +83,8 @@ public:
TIntermTyped* handleBinaryMath(const TSourceLoc&, const char* str, TOperator op, TIntermTyped* left, TIntermTyped* right); TIntermTyped* handleBinaryMath(const TSourceLoc&, const char* str, TOperator op, TIntermTyped* left, TIntermTyped* right);
TIntermTyped* handleUnaryMath(const TSourceLoc&, const char* str, TOperator op, TIntermTyped* childNode); TIntermTyped* handleUnaryMath(const TSourceLoc&, const char* str, TOperator op, TIntermTyped* childNode);
TIntermTyped* handleDotDereference(const TSourceLoc&, TIntermTyped* base, const TString& field); TIntermTyped* handleDotDereference(const TSourceLoc&, TIntermTyped* base, const TString& field);
bool shouldFlatten(const TType&); bool shouldFlatten(const TType&) const;
void flattenStruct(const TVariable& variable); void flatten(const TVariable& variable);
TIntermTyped* flattenAccess(TIntermTyped* base, int member); TIntermTyped* flattenAccess(TIntermTyped* base, int member);
void assignLocations(TVariable& variable); void assignLocations(TVariable& variable);
TFunction& handleFunctionDeclarator(const TSourceLoc&, TFunction& function, bool prototype); TFunction& handleFunctionDeclarator(const TSourceLoc&, TFunction& function, bool prototype);
@ -94,7 +94,7 @@ public:
void remapNonEntrypointIO(TFunction& function); void remapNonEntrypointIO(TFunction& function);
TIntermNode* handleReturnValue(const TSourceLoc&, TIntermTyped*); TIntermNode* handleReturnValue(const TSourceLoc&, TIntermTyped*);
void handleFunctionArgument(TFunction*, TIntermTyped*& arguments, TIntermTyped* newArg); void handleFunctionArgument(TFunction*, TIntermTyped*& arguments, TIntermTyped* newArg);
TIntermTyped* handleAssign(const TSourceLoc&, TOperator, TIntermTyped* left, TIntermTyped* right); TIntermTyped* handleAssign(const TSourceLoc&, TOperator, TIntermTyped* left, TIntermTyped* right) const;
TIntermTyped* handleFunctionCall(const TSourceLoc&, TFunction*, TIntermNode*); TIntermTyped* handleFunctionCall(const TSourceLoc&, TFunction*, TIntermNode*);
void decomposeIntrinsic(const TSourceLoc&, TIntermTyped*& node, TIntermNode* arguments); void decomposeIntrinsic(const TSourceLoc&, TIntermTyped*& node, TIntermNode* arguments);
void decomposeSampleMethods(const TSourceLoc&, TIntermTyped*& node, TIntermNode* arguments); void decomposeSampleMethods(const TSourceLoc&, TIntermTyped*& node, TIntermNode* arguments);