Skip to content

G
glslang
Commit 5a839069 by John Kessenich Committed by GitHub
Options

Merge pull request #782 from steve-lunarg/builtin-methods-prefix

HLSL: use prefix for builtin functions names to avoid namespace colli…
parents 1dd65ca3 e7d0752a
Showing with 338 additions and 309 deletions
hlsl/hlslGrammar.cpp
...@@ -2792,11 +2792,13 @@ bool HlslGrammar::acceptFunctionCall(HlslToken callToken, TIntermTyped*& node, T ...@@ -2792,11 +2792,13 @@ bool HlslGrammar::acceptFunctionCall(HlslToken callToken, TIntermTyped*& node, T
{ {
// name // name
TString* functionName = nullptr; TString* functionName = nullptr;
if ((baseObject == nullptr && scope == nullptr) || if ((baseObject == nullptr && scope == nullptr)) {
parseContext.isBuiltInMethod(callToken.loc, baseObject, *callToken.string)) { functionName = callToken.string;
} else if (parseContext.isBuiltInMethod(callToken.loc, baseObject, *callToken.string)) {
// Built-in methods are not in the symbol table as methods, but as global functions // Built-in methods are not in the symbol table as methods, but as global functions
// taking an explicit 'this' as the first argument. // taking an explicit 'this' as the first argument.
functionName = callToken.string; functionName = NewPoolTString(BUILTIN_PREFIX);
functionName->append(*callToken.string);
} else { } else {
functionName = NewPoolTString(""); functionName = NewPoolTString("");
if (baseObject != nullptr) if (baseObject != nullptr)
......
hlsl/hlslParseHelper.cpp
...@@ -956,7 +956,7 @@ TIntermTyped* HlslParseContext::handleDotDereference(const TSourceLoc& loc, TInt ...@@ -956,7 +956,7 @@ TIntermTyped* HlslParseContext::handleDotDereference(const TSourceLoc& loc, TInt
// Return true if the field should be treated as a built-in method. // Return true if the field should be treated as a built-in method.
// Return false otherwise. // Return false otherwise.
// //
bool HlslParseContext::isBuiltInMethod(const TSourceLoc& loc, TIntermTyped* base, const TString& field) bool HlslParseContext::isBuiltInMethod(const TSourceLoc&, TIntermTyped* base, const TString& field)
{ {
if (base == nullptr) if (base == nullptr)
return false; return false;
...@@ -3734,7 +3734,10 @@ TIntermTyped* HlslParseContext::handleFunctionCall(const TSourceLoc& loc, TFunct ...@@ -3734,7 +3734,10 @@ TIntermTyped* HlslParseContext::handleFunctionCall(const TSourceLoc& loc, TFunct
// It will have false positives, since it doesn't check arg counts or types. // It will have false positives, since it doesn't check arg counts or types.
if (arguments && arguments->getAsAggregate()) { if (arguments && arguments->getAsAggregate()) {
if (isStructBufferType(arguments->getAsAggregate()->getSequence()[0]->getAsTyped()->getType())) { if (isStructBufferType(arguments->getAsAggregate()->getSequence()[0]->getAsTyped()->getType())) {
if (isStructBufferMethod(function->getName())) { static const int methodPrefixSize = sizeof(BUILTIN_PREFIX)-1;
if (function->getName().length() > methodPrefixSize &&
isStructBufferMethod(function->getName().substr(methodPrefixSize))) {
const TString mangle = function->getName() + "("; const TString mangle = function->getName() + "(";
TSymbol* symbol = symbolTable.find(mangle, &builtIn); TSymbol* symbol = symbolTable.find(mangle, &builtIn);
......
hlsl/hlslParseHelper.h
...@@ -390,6 +390,12 @@ protected: ...@@ -390,6 +390,12 @@ protected:
TVector<TString> currentTypePrefix; TVector<TString> currentTypePrefix;
}; };
// This is the prefix we use for builtin methods to avoid namespace collisions with
// global scope user functions.
// TODO: this would be better as a nonparseable character, but that would
// require changing the scanner.
#define BUILTIN_PREFIX "__BI_"
} // end namespace glslang } // end namespace glslang
#endif // HLSL_PARSE_INCLUDED_ #endif // HLSL_PARSE_INCLUDED_
hlsl/hlslParseables.cpp
...@@ -49,6 +49,7 @@ ...@@ -49,6 +49,7 @@
// //
#include "hlslParseables.h" #include "hlslParseables.h"
#include "hlslParseHelper.h"
#include <cctype> #include <cctype>
#include <utility> #include <utility>
#include <algorithm> #include <algorithm>
...@@ -543,335 +544,336 @@ void TBuiltInParseablesHlsl::initialize(int /*version*/, EProfile /*profile*/, c ...@@ -543,335 +544,336 @@ void TBuiltInParseablesHlsl::initialize(int /*version*/, EProfile /*profile*/, c
const char* argOrder; // argument order key const char* argOrder; // argument order key
const char* argType; // argument type key const char* argType; // argument type key
unsigned int stage; // stage mask unsigned int stage; // stage mask
bool method; // true if it's a method.
} hlslIntrinsics[] = { } hlslIntrinsics[] = {
// name retOrd retType argOrder argType stage mask // name retOrd retType argOrder argType stage mask
// ----------------------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------------------
{ "abort", nullptr, nullptr, "-", "-", EShLangAll }, { "abort", nullptr, nullptr, "-", "-", EShLangAll, false },
{ "abs", nullptr, nullptr, "SVM", "DFUI", EShLangAll }, { "abs", nullptr, nullptr, "SVM", "DFUI", EShLangAll, false },
{ "acos", nullptr, nullptr, "SVM", "F", EShLangAll }, { "acos", nullptr, nullptr, "SVM", "F", EShLangAll, false },
{ "all", "S", "B", "SVM", "BFIU", EShLangAll }, { "all", "S", "B", "SVM", "BFIU", EShLangAll, false },
{ "AllMemoryBarrier", nullptr, nullptr, "-", "-", EShLangCS }, { "AllMemoryBarrier", nullptr, nullptr, "-", "-", EShLangCS, false },
{ "AllMemoryBarrierWithGroupSync", nullptr, nullptr, "-", "-", EShLangCS }, { "AllMemoryBarrierWithGroupSync", nullptr, nullptr, "-", "-", EShLangCS, false },
{ "any", "S", "B", "SVM", "BFIU", EShLangAll }, { "any", "S", "B", "SVM", "BFIU", EShLangAll, false },
{ "asdouble", "S", "D", "S,", "UI,", EShLangAll }, { "asdouble", "S", "D", "S,", "UI,", EShLangAll, false },
{ "asdouble", "V2", "D", "V2,", "UI,", EShLangAll }, { "asdouble", "V2", "D", "V2,", "UI,", EShLangAll, false },
{ "asfloat", nullptr, "F", "SVM", "BFIU", EShLangAll }, { "asfloat", nullptr, "F", "SVM", "BFIU", EShLangAll, false },
{ "asin", nullptr, nullptr, "SVM", "F", EShLangAll }, { "asin", nullptr, nullptr, "SVM", "F", EShLangAll, false },
{ "asint", nullptr, "I", "SVM", "FU", EShLangAll }, { "asint", nullptr, "I", "SVM", "FU", EShLangAll, false },
{ "asuint", nullptr, "U", "SVM", "FU", EShLangAll }, { "asuint", nullptr, "U", "SVM", "FU", EShLangAll, false },
{ "atan", nullptr, nullptr, "SVM", "F", EShLangAll }, { "atan", nullptr, nullptr, "SVM", "F", EShLangAll, false },
{ "atan2", nullptr, nullptr, "SVM,", "F,", EShLangAll }, { "atan2", nullptr, nullptr, "SVM,", "F,", EShLangAll, false },
{ "ceil", nullptr, nullptr, "SVM", "F", EShLangAll }, { "ceil", nullptr, nullptr, "SVM", "F", EShLangAll, false },
{ "CheckAccessFullyMapped", "S", "B" , "S", "U", EShLangPSCS }, { "CheckAccessFullyMapped", "S", "B" , "S", "U", EShLangPSCS, false },
{ "clamp", nullptr, nullptr, "SVM,,", "FUI,,", EShLangAll }, { "clamp", nullptr, nullptr, "SVM,,", "FUI,,", EShLangAll, false },
{ "clip", "-", "-", "SVM", "F", EShLangPS }, { "clip", "-", "-", "SVM", "F", EShLangPS, false },
{ "cos", nullptr, nullptr, "SVM", "F", EShLangAll }, { "cos", nullptr, nullptr, "SVM", "F", EShLangAll, false },
{ "cosh", nullptr, nullptr, "SVM", "F", EShLangAll }, { "cosh", nullptr, nullptr, "SVM", "F", EShLangAll, false },
{ "countbits", nullptr, nullptr, "SV", "UI", EShLangAll }, { "countbits", nullptr, nullptr, "SV", "UI", EShLangAll, false },
{ "cross", nullptr, nullptr, "V3,", "F,", EShLangAll }, { "cross", nullptr, nullptr, "V3,", "F,", EShLangAll, false },
{ "D3DCOLORtoUBYTE4", "V4", "I", "V4", "F", EShLangAll }, { "D3DCOLORtoUBYTE4", "V4", "I", "V4", "F", EShLangAll, false },
{ "ddx", nullptr, nullptr, "SVM", "F", EShLangPS }, { "ddx", nullptr, nullptr, "SVM", "F", EShLangPS, false },
{ "ddx_coarse", nullptr, nullptr, "SVM", "F", EShLangPS }, { "ddx_coarse", nullptr, nullptr, "SVM", "F", EShLangPS, false },
{ "ddx_fine", nullptr, nullptr, "SVM", "F", EShLangPS }, { "ddx_fine", nullptr, nullptr, "SVM", "F", EShLangPS, false },
{ "ddy", nullptr, nullptr, "SVM", "F", EShLangPS }, { "ddy", nullptr, nullptr, "SVM", "F", EShLangPS, false },
{ "ddy_coarse", nullptr, nullptr, "SVM", "F", EShLangPS }, { "ddy_coarse", nullptr, nullptr, "SVM", "F", EShLangPS, false },
{ "ddy_fine", nullptr, nullptr, "SVM", "F", EShLangPS }, { "ddy_fine", nullptr, nullptr, "SVM", "F", EShLangPS, false },
{ "degrees", nullptr, nullptr, "SVM", "F", EShLangAll }, { "degrees", nullptr, nullptr, "SVM", "F", EShLangAll, false },
{ "determinant", "S", "F", "M", "F", EShLangAll }, { "determinant", "S", "F", "M", "F", EShLangAll, false },
{ "DeviceMemoryBarrier", nullptr, nullptr, "-", "-", EShLangPSCS }, { "DeviceMemoryBarrier", nullptr, nullptr, "-", "-", EShLangPSCS, false },
{ "DeviceMemoryBarrierWithGroupSync", nullptr, nullptr, "-", "-", EShLangCS }, { "DeviceMemoryBarrierWithGroupSync", nullptr, nullptr, "-", "-", EShLangCS, false },
{ "distance", "S", "F", "V,", "F,", EShLangAll }, { "distance", "S", "F", "V,", "F,", EShLangAll, false },
{ "dot", "S", nullptr, "SV,", "FI,", EShLangAll }, { "dot", "S", nullptr, "SV,", "FI,", EShLangAll, false },
{ "dst", nullptr, nullptr, "V4,", "F,", EShLangAll }, { "dst", nullptr, nullptr, "V4,", "F,", EShLangAll, false },
// { "errorf", "-", "-", "", "", EShLangAll }, TODO: varargs // { "errorf", "-", "-", "", "", EShLangAll, false }, TODO: varargs
{ "EvaluateAttributeAtCentroid", nullptr, nullptr, "SVM", "F", EShLangPS }, { "EvaluateAttributeAtCentroid", nullptr, nullptr, "SVM", "F", EShLangPS, false },
{ "EvaluateAttributeAtSample", nullptr, nullptr, "SVM,S", "F,U", EShLangPS }, { "EvaluateAttributeAtSample", nullptr, nullptr, "SVM,S", "F,U", EShLangPS, false },
{ "EvaluateAttributeSnapped", nullptr, nullptr, "SVM,V2", "F,I", EShLangPS }, { "EvaluateAttributeSnapped", nullptr, nullptr, "SVM,V2", "F,I", EShLangPS, false },
{ "exp", nullptr, nullptr, "SVM", "F", EShLangAll }, { "exp", nullptr, nullptr, "SVM", "F", EShLangAll, false },
{ "exp2", nullptr, nullptr, "SVM", "F", EShLangAll }, { "exp2", nullptr, nullptr, "SVM", "F", EShLangAll, false },
{ "f16tof32", nullptr, "F", "SV", "U", EShLangAll }, { "f16tof32", nullptr, "F", "SV", "U", EShLangAll, false },
{ "f32tof16", nullptr, "U", "SV", "F", EShLangAll }, { "f32tof16", nullptr, "U", "SV", "F", EShLangAll, false },
{ "faceforward", nullptr, nullptr, "V,,", "F,,", EShLangAll }, { "faceforward", nullptr, nullptr, "V,,", "F,,", EShLangAll, false },
{ "firstbithigh", nullptr, nullptr, "SV", "UI", EShLangAll }, { "firstbithigh", nullptr, nullptr, "SV", "UI", EShLangAll, false },
{ "firstbitlow", nullptr, nullptr, "SV", "UI", EShLangAll }, { "firstbitlow", nullptr, nullptr, "SV", "UI", EShLangAll, false },
{ "floor", nullptr, nullptr, "SVM", "F", EShLangAll }, { "floor", nullptr, nullptr, "SVM", "F", EShLangAll, false },
{ "fma", nullptr, nullptr, "SVM,,", "D,,", EShLangAll }, { "fma", nullptr, nullptr, "SVM,,", "D,,", EShLangAll, false },
{ "fmod", nullptr, nullptr, "SVM,", "F,", EShLangAll }, { "fmod", nullptr, nullptr, "SVM,", "F,", EShLangAll, false },
{ "frac", nullptr, nullptr, "SVM", "F", EShLangAll }, { "frac", nullptr, nullptr, "SVM", "F", EShLangAll, false },
{ "frexp", nullptr, nullptr, "SVM,", "F,", EShLangAll }, { "frexp", nullptr, nullptr, "SVM,", "F,", EShLangAll, false },
{ "fwidth", nullptr, nullptr, "SVM", "F", EShLangPS }, { "fwidth", nullptr, nullptr, "SVM", "F", EShLangPS, false },
{ "GetRenderTargetSampleCount", "S", "U", "-", "-", EShLangAll }, { "GetRenderTargetSampleCount", "S", "U", "-", "-", EShLangAll, false },
{ "GetRenderTargetSamplePosition", "V2", "F", "V1", "I", EShLangAll }, { "GetRenderTargetSamplePosition", "V2", "F", "V1", "I", EShLangAll, false },
{ "GroupMemoryBarrier", nullptr, nullptr, "-", "-", EShLangCS }, { "GroupMemoryBarrier", nullptr, nullptr, "-", "-", EShLangCS, false },
{ "GroupMemoryBarrierWithGroupSync", nullptr, nullptr, "-", "-", EShLangCS }, { "GroupMemoryBarrierWithGroupSync", nullptr, nullptr, "-", "-", EShLangCS, false },
{ "InterlockedAdd", "-", "-", "SVM,,>", "UI,,", EShLangPSCS }, { "InterlockedAdd", "-", "-", "SVM,,>", "UI,,", EShLangPSCS, false },
{ "InterlockedAdd", "-", "-", "SVM,", "UI,", EShLangPSCS }, { "InterlockedAdd", "-", "-", "SVM,", "UI,", EShLangPSCS, false },
{ "InterlockedAnd", "-", "-", "SVM,,>", "UI,,", EShLangPSCS }, { "InterlockedAnd", "-", "-", "SVM,,>", "UI,,", EShLangPSCS, false },
{ "InterlockedAnd", "-", "-", "SVM,", "UI,", EShLangPSCS }, { "InterlockedAnd", "-", "-", "SVM,", "UI,", EShLangPSCS, false },
{ "InterlockedCompareExchange", "-", "-", "SVM,,,>", "UI,,,", EShLangPSCS }, { "InterlockedCompareExchange", "-", "-", "SVM,,,>", "UI,,,", EShLangPSCS, false },
{ "InterlockedCompareStore", "-", "-", "SVM,,", "UI,,", EShLangPSCS }, { "InterlockedCompareStore", "-", "-", "SVM,,", "UI,,", EShLangPSCS, false },
{ "InterlockedExchange", "-", "-", "SVM,,>", "UI,,", EShLangPSCS }, { "InterlockedExchange", "-", "-", "SVM,,>", "UI,,", EShLangPSCS, false },
{ "InterlockedMax", "-", "-", "SVM,,>", "UI,,", EShLangPSCS }, { "InterlockedMax", "-", "-", "SVM,,>", "UI,,", EShLangPSCS, false },
{ "InterlockedMax", "-", "-", "SVM,", "UI,", EShLangPSCS }, { "InterlockedMax", "-", "-", "SVM,", "UI,", EShLangPSCS, false },
{ "InterlockedMin", "-", "-", "SVM,,>", "UI,,", EShLangPSCS }, { "InterlockedMin", "-", "-", "SVM,,>", "UI,,", EShLangPSCS, false },
{ "InterlockedMin", "-", "-", "SVM,", "UI,", EShLangPSCS }, { "InterlockedMin", "-", "-", "SVM,", "UI,", EShLangPSCS, false },
{ "InterlockedOr", "-", "-", "SVM,,>", "UI,,", EShLangPSCS }, { "InterlockedOr", "-", "-", "SVM,,>", "UI,,", EShLangPSCS, false },
{ "InterlockedOr", "-", "-", "SVM,", "UI,", EShLangPSCS }, { "InterlockedOr", "-", "-", "SVM,", "UI,", EShLangPSCS, false },
{ "InterlockedXor", "-", "-", "SVM,,>", "UI,,", EShLangPSCS }, { "InterlockedXor", "-", "-", "SVM,,>", "UI,,", EShLangPSCS, false },
{ "InterlockedXor", "-", "-", "SVM,", "UI,", EShLangPSCS }, { "InterlockedXor", "-", "-", "SVM,", "UI,", EShLangPSCS, false },
{ "isfinite", nullptr, "B" , "SVM", "F", EShLangAll }, { "isfinite", nullptr, "B" , "SVM", "F", EShLangAll, false },
{ "isinf", nullptr, "B" , "SVM", "F", EShLangAll }, { "isinf", nullptr, "B" , "SVM", "F", EShLangAll, false },
{ "isnan", nullptr, "B" , "SVM", "F", EShLangAll }, { "isnan", nullptr, "B" , "SVM", "F", EShLangAll, false },
{ "ldexp", nullptr, nullptr, "SVM,", "F,", EShLangAll }, { "ldexp", nullptr, nullptr, "SVM,", "F,", EShLangAll, false },
{ "length", "S", "F", "V", "F", EShLangAll }, { "length", "S", "F", "V", "F", EShLangAll, false },
{ "lerp", nullptr, nullptr, "VM,,", "F,,", EShLangAll }, { "lerp", nullptr, nullptr, "VM,,", "F,,", EShLangAll, false },
{ "lerp", nullptr, nullptr, "SVM,,S", "F,,", EShLangAll }, { "lerp", nullptr, nullptr, "SVM,,S", "F,,", EShLangAll, false },
{ "lit", "V4", "F", "S,,", "F,,", EShLangAll }, { "lit", "V4", "F", "S,,", "F,,", EShLangAll, false },
{ "log", nullptr, nullptr, "SVM", "F", EShLangAll }, { "log", nullptr, nullptr, "SVM", "F", EShLangAll, false },
{ "log10", nullptr, nullptr, "SVM", "F", EShLangAll }, { "log10", nullptr, nullptr, "SVM", "F", EShLangAll, false },
{ "log2", nullptr, nullptr, "SVM", "F", EShLangAll }, { "log2", nullptr, nullptr, "SVM", "F", EShLangAll, false },
{ "mad", nullptr, nullptr, "SVM,,", "DFUI,,", EShLangAll }, { "mad", nullptr, nullptr, "SVM,,", "DFUI,,", EShLangAll, false },
{ "max", nullptr, nullptr, "SVM,", "FIU,", EShLangAll }, { "max", nullptr, nullptr, "SVM,", "FIU,", EShLangAll, false },
{ "min", nullptr, nullptr, "SVM,", "FIU,", EShLangAll }, { "min", nullptr, nullptr, "SVM,", "FIU,", EShLangAll, false },
{ "modf", nullptr, nullptr, "SVM,>", "FIU,", EShLangAll }, { "modf", nullptr, nullptr, "SVM,>", "FIU,", EShLangAll, false },
{ "msad4", "V4", "U", "S,V2,V4", "U,,", EShLangAll }, { "msad4", "V4", "U", "S,V2,V4", "U,,", EShLangAll, false },
{ "mul", "S", nullptr, "S,S", "FI,", EShLangAll }, { "mul", "S", nullptr, "S,S", "FI,", EShLangAll, false },
{ "mul", "V", nullptr, "S,V", "FI,", EShLangAll }, { "mul", "V", nullptr, "S,V", "FI,", EShLangAll, false },
{ "mul", "M", nullptr, "S,M", "FI,", EShLangAll }, { "mul", "M", nullptr, "S,M", "FI,", EShLangAll, false },
{ "mul", "V", nullptr, "V,S", "FI,", EShLangAll }, { "mul", "V", nullptr, "V,S", "FI,", EShLangAll, false },
{ "mul", "S", nullptr, "V,V", "FI,", EShLangAll }, { "mul", "S", nullptr, "V,V", "FI,", EShLangAll, false },
{ "mul", "M", nullptr, "M,S", "FI,", EShLangAll }, { "mul", "M", nullptr, "M,S", "FI,", EShLangAll, false },
// mat*mat form of mul is handled in createMatTimesMat() // mat*mat form of mul is handled in createMatTimesMat()
{ "noise", "S", "F", "V", "F", EShLangPS }, { "noise", "S", "F", "V", "F", EShLangPS, false },
{ "normalize", nullptr, nullptr, "V", "F", EShLangAll }, { "normalize", nullptr, nullptr, "V", "F", EShLangAll, false },
{ "pow", nullptr, nullptr, "SVM,", "F,", EShLangAll }, { "pow", nullptr, nullptr, "SVM,", "F,", EShLangAll, false },
// { "printf", "-", "-", "", "", EShLangAll }, TODO: varargs // { "printf", "-", "-", "", "", EShLangAll, false }, TODO: varargs
{ "Process2DQuadTessFactorsAvg", "-", "-", "V4,V2,>V4,>V2,", "F,,,,", EShLangHS }, { "Process2DQuadTessFactorsAvg", "-", "-", "V4,V2,>V4,>V2,", "F,,,,", EShLangHS, false },
{ "Process2DQuadTessFactorsMax", "-", "-", "V4,V2,>V4,>V2,", "F,,,,", EShLangHS }, { "Process2DQuadTessFactorsMax", "-", "-", "V4,V2,>V4,>V2,", "F,,,,", EShLangHS, false },
{ "Process2DQuadTessFactorsMin", "-", "-", "V4,V2,>V4,>V2,", "F,,,,", EShLangHS }, { "Process2DQuadTessFactorsMin", "-", "-", "V4,V2,>V4,>V2,", "F,,,,", EShLangHS, false },
{ "ProcessIsolineTessFactors", "-", "-", "S,,>,>", "F,,,", EShLangHS }, { "ProcessIsolineTessFactors", "-", "-", "S,,>,>", "F,,,", EShLangHS, false },
{ "ProcessQuadTessFactorsAvg", "-", "-", "V4,S,>V4,>V2,", "F,,,,", EShLangHS }, { "ProcessQuadTessFactorsAvg", "-", "-", "V4,S,>V4,>V2,", "F,,,,", EShLangHS, false },
{ "ProcessQuadTessFactorsMax", "-", "-", "V4,S,>V4,>V2,", "F,,,,", EShLangHS }, { "ProcessQuadTessFactorsMax", "-", "-", "V4,S,>V4,>V2,", "F,,,,", EShLangHS, false },
{ "ProcessQuadTessFactorsMin", "-", "-", "V4,S,>V4,>V2,", "F,,,,", EShLangHS }, { "ProcessQuadTessFactorsMin", "-", "-", "V4,S,>V4,>V2,", "F,,,,", EShLangHS, false },
{ "ProcessTriTessFactorsAvg", "-", "-", "V3,S,>V3,>S,", "F,,,,", EShLangHS }, { "ProcessTriTessFactorsAvg", "-", "-", "V3,S,>V3,>S,", "F,,,,", EShLangHS, false },
{ "ProcessTriTessFactorsMax", "-", "-", "V3,S,>V3,>S,", "F,,,,", EShLangHS }, { "ProcessTriTessFactorsMax", "-", "-", "V3,S,>V3,>S,", "F,,,,", EShLangHS, false },
{ "ProcessTriTessFactorsMin", "-", "-", "V3,S,>V3,>S,", "F,,,,", EShLangHS }, { "ProcessTriTessFactorsMin", "-", "-", "V3,S,>V3,>S,", "F,,,,", EShLangHS, false },
{ "radians", nullptr, nullptr, "SVM", "F", EShLangAll }, { "radians", nullptr, nullptr, "SVM", "F", EShLangAll, false },
{ "rcp", nullptr, nullptr, "SVM", "FD", EShLangAll }, { "rcp", nullptr, nullptr, "SVM", "FD", EShLangAll, false },
{ "reflect", nullptr, nullptr, "V,", "F,", EShLangAll }, { "reflect", nullptr, nullptr, "V,", "F,", EShLangAll, false },
{ "refract", nullptr, nullptr, "V,V,S", "F,,", EShLangAll }, { "refract", nullptr, nullptr, "V,V,S", "F,,", EShLangAll, false },
{ "reversebits", nullptr, nullptr, "SV", "UI", EShLangAll }, { "reversebits", nullptr, nullptr, "SV", "UI", EShLangAll, false },
{ "round", nullptr, nullptr, "SVM", "F", EShLangAll }, { "round", nullptr, nullptr, "SVM", "F", EShLangAll, false },
{ "rsqrt", nullptr, nullptr, "SVM", "F", EShLangAll }, { "rsqrt", nullptr, nullptr, "SVM", "F", EShLangAll, false },
{ "saturate", nullptr, nullptr , "SVM", "F", EShLangAll }, { "saturate", nullptr, nullptr , "SVM", "F", EShLangAll, false },
{ "sign", nullptr, nullptr, "SVM", "FI", EShLangAll }, { "sign", nullptr, nullptr, "SVM", "FI", EShLangAll, false },
{ "sin", nullptr, nullptr, "SVM", "F", EShLangAll }, { "sin", nullptr, nullptr, "SVM", "F", EShLangAll, false },
{ "sincos", "-", "-", "SVM,>,>", "F,,", EShLangAll }, { "sincos", "-", "-", "SVM,>,>", "F,,", EShLangAll, false },
{ "sinh", nullptr, nullptr, "SVM", "F", EShLangAll }, { "sinh", nullptr, nullptr, "SVM", "F", EShLangAll, false },
{ "smoothstep", nullptr, nullptr, "SVM,,", "F,,", EShLangAll }, { "smoothstep", nullptr, nullptr, "SVM,,", "F,,", EShLangAll, false },
{ "sqrt", nullptr, nullptr, "SVM", "F", EShLangAll }, { "sqrt", nullptr, nullptr, "SVM", "F", EShLangAll, false },
{ "step", nullptr, nullptr, "SVM,", "F,", EShLangAll }, { "step", nullptr, nullptr, "SVM,", "F,", EShLangAll, false },
{ "tan", nullptr, nullptr, "SVM", "F", EShLangAll }, { "tan", nullptr, nullptr, "SVM", "F", EShLangAll, false },
{ "tanh", nullptr, nullptr, "SVM", "F", EShLangAll }, { "tanh", nullptr, nullptr, "SVM", "F", EShLangAll, false },
{ "tex1D", "V4", "F", "V1,S", "S,F", EShLangPS }, { "tex1D", "V4", "F", "V1,S", "S,F", EShLangPS, false },
{ "tex1D", "V4", "F", "V1,S,V1,", "S,F,,", EShLangPS }, { "tex1D", "V4", "F", "V1,S,V1,", "S,F,,", EShLangPS, false },
{ "tex1Dbias", "V4", "F", "V1,V4", "S,F", EShLangPS }, { "tex1Dbias", "V4", "F", "V1,V4", "S,F", EShLangPS, false },
{ "tex1Dgrad", "V4", "F", "V1,,,", "S,F,,", EShLangPS }, { "tex1Dgrad", "V4", "F", "V1,,,", "S,F,,", EShLangPS, false },
{ "tex1Dlod", "V4", "F", "V1,V4", "S,F", EShLangPS }, { "tex1Dlod", "V4", "F", "V1,V4", "S,F", EShLangPS, false },
{ "tex1Dproj", "V4", "F", "V1,V4", "S,F", EShLangPS }, { "tex1Dproj", "V4", "F", "V1,V4", "S,F", EShLangPS, false },
{ "tex2D", "V4", "F", "V2,", "S,F", EShLangPS }, { "tex2D", "V4", "F", "V2,", "S,F", EShLangPS, false },
{ "tex2D", "V4", "F", "V2,,,", "S,F,,", EShLangPS }, { "tex2D", "V4", "F", "V2,,,", "S,F,,", EShLangPS, false },
{ "tex2Dbias", "V4", "F", "V2,V4", "S,F", EShLangPS }, { "tex2Dbias", "V4", "F", "V2,V4", "S,F", EShLangPS, false },
{ "tex2Dgrad", "V4", "F", "V2,,,", "S,F,,", EShLangPS }, { "tex2Dgrad", "V4", "F", "V2,,,", "S,F,,", EShLangPS, false },
{ "tex2Dlod", "V4", "F", "V2,V4", "S,F", EShLangPS }, { "tex2Dlod", "V4", "F", "V2,V4", "S,F", EShLangPS, false },
{ "tex2Dproj", "V4", "F", "V2,V4", "S,F", EShLangPS }, { "tex2Dproj", "V4", "F", "V2,V4", "S,F", EShLangPS, false },
{ "tex3D", "V4", "F", "V3,", "S,F", EShLangPS }, { "tex3D", "V4", "F", "V3,", "S,F", EShLangPS, false },
{ "tex3D", "V4", "F", "V3,,,", "S,F,,", EShLangPS }, { "tex3D", "V4", "F", "V3,,,", "S,F,,", EShLangPS, false },
{ "tex3Dbias", "V4", "F", "V3,V4", "S,F", EShLangPS }, { "tex3Dbias", "V4", "F", "V3,V4", "S,F", EShLangPS, false },
{ "tex3Dgrad", "V4", "F", "V3,,,", "S,F,,", EShLangPS }, { "tex3Dgrad", "V4", "F", "V3,,,", "S,F,,", EShLangPS, false },
{ "tex3Dlod", "V4", "F", "V3,V4", "S,F", EShLangPS }, { "tex3Dlod", "V4", "F", "V3,V4", "S,F", EShLangPS, false },
{ "tex3Dproj", "V4", "F", "V3,V4", "S,F", EShLangPS }, { "tex3Dproj", "V4", "F", "V3,V4", "S,F", EShLangPS, false },
{ "texCUBE", "V4", "F", "V4,V3", "S,F", EShLangPS }, { "texCUBE", "V4", "F", "V4,V3", "S,F", EShLangPS, false },
{ "texCUBE", "V4", "F", "V4,V3,,", "S,F,,", EShLangPS }, { "texCUBE", "V4", "F", "V4,V3,,", "S,F,,", EShLangPS, false },
{ "texCUBEbias", "V4", "F", "V4,", "S,F", EShLangPS }, { "texCUBEbias", "V4", "F", "V4,", "S,F", EShLangPS, false },
{ "texCUBEgrad", "V4", "F", "V4,V3,,", "S,F,,", EShLangPS }, { "texCUBEgrad", "V4", "F", "V4,V3,,", "S,F,,", EShLangPS, false },
{ "texCUBElod", "V4", "F", "V4,", "S,F", EShLangPS }, { "texCUBElod", "V4", "F", "V4,", "S,F", EShLangPS, false },
{ "texCUBEproj", "V4", "F", "V4,", "S,F", EShLangPS }, { "texCUBEproj", "V4", "F", "V4,", "S,F", EShLangPS, false },
{ "transpose", "^M", nullptr, "M", "FUIB", EShLangAll }, { "transpose", "^M", nullptr, "M", "FUIB", EShLangAll, false },
{ "trunc", nullptr, nullptr, "SVM", "F", EShLangAll }, { "trunc", nullptr, nullptr, "SVM", "F", EShLangAll, false },
// Texture object methods. Return type can be overridden by shader declaration. // Texture object methods. Return type can be overridden by shader declaration.
// !O = no offset, O = offset // !O = no offset, O = offset
{ "Sample", /*!O*/ "V4", nullptr, "%@,S,V", "FIU,S,F", EShLangPS }, { "Sample", /*!O*/ "V4", nullptr, "%@,S,V", "FIU,S,F", EShLangPS, true },
{ "Sample", /* O*/ "V4", nullptr, "%@,S,V,", "FIU,S,F,I", EShLangPS }, { "Sample", /* O*/ "V4", nullptr, "%@,S,V,", "FIU,S,F,I", EShLangPS, true },
{ "SampleBias", /*!O*/ "V4", nullptr, "%@,S,V,S", "FIU,S,F,", EShLangPS }, { "SampleBias", /*!O*/ "V4", nullptr, "%@,S,V,S", "FIU,S,F,", EShLangPS, true },
{ "SampleBias", /* O*/ "V4", nullptr, "%@,S,V,S,V", "FIU,S,F,,I", EShLangPS }, { "SampleBias", /* O*/ "V4", nullptr, "%@,S,V,S,V", "FIU,S,F,,I", EShLangPS, true },
// TODO: FXC accepts int/uint samplers here. unclear what that means. // TODO: FXC accepts int/uint samplers here. unclear what that means.
{ "SampleCmp", /*!O*/ "S", "F", "%@,S,V,S", "FIU,s,F,", EShLangPS }, { "SampleCmp", /*!O*/ "S", "F", "%@,S,V,S", "FIU,s,F,", EShLangPS, true },
{ "SampleCmp", /* O*/ "S", "F", "%@,S,V,S,V", "FIU,s,F,,I", EShLangPS }, { "SampleCmp", /* O*/ "S", "F", "%@,S,V,S,V", "FIU,s,F,,I", EShLangPS, true },
// TODO: FXC accepts int/uint samplers here. unclear what that means. // TODO: FXC accepts int/uint samplers here. unclear what that means.
{ "SampleCmpLevelZero", /*!O*/ "S", "F", "%@,S,V,S", "FIU,s,F,F", EShLangPS }, { "SampleCmpLevelZero", /*!O*/ "S", "F", "%@,S,V,S", "FIU,s,F,F", EShLangPS, true },
{ "SampleCmpLevelZero", /* O*/ "S", "F", "%@,S,V,S,V", "FIU,s,F,F,I", EShLangPS }, { "SampleCmpLevelZero", /* O*/ "S", "F", "%@,S,V,S,V", "FIU,s,F,F,I", EShLangPS, true },
{ "SampleGrad", /*!O*/ "V4", nullptr, "%@,S,V,,", "FIU,S,F,,", EShLangAll }, { "SampleGrad", /*!O*/ "V4", nullptr, "%@,S,V,,", "FIU,S,F,,", EShLangAll, true },
{ "SampleGrad", /* O*/ "V4", nullptr, "%@,S,V,,,", "FIU,S,F,,,I", EShLangAll }, { "SampleGrad", /* O*/ "V4", nullptr, "%@,S,V,,,", "FIU,S,F,,,I", EShLangAll, true },
{ "SampleLevel", /*!O*/ "V4", nullptr, "%@,S,V,S", "FIU,S,F,", EShLangAll }, { "SampleLevel", /*!O*/ "V4", nullptr, "%@,S,V,S", "FIU,S,F,", EShLangAll, true },
{ "SampleLevel", /* O*/ "V4", nullptr, "%@,S,V,S,V", "FIU,S,F,,I", EShLangAll }, { "SampleLevel", /* O*/ "V4", nullptr, "%@,S,V,S,V", "FIU,S,F,,I", EShLangAll, true },
{ "Load", /*!O*/ "V4", nullptr, "%@,V", "FIU,I", EShLangAll }, { "Load", /*!O*/ "V4", nullptr, "%@,V", "FIU,I", EShLangAll, true },
{ "Load", /* O*/ "V4", nullptr, "%@,V,V", "FIU,I,I", EShLangAll }, { "Load", /* O*/ "V4", nullptr, "%@,V,V", "FIU,I,I", EShLangAll, true },
{ "Load", /* +sampleidex*/ "V4", nullptr, "$&,V,S", "FIU,I,I", EShLangAll }, { "Load", /* +sampleidex*/ "V4", nullptr, "$&,V,S", "FIU,I,I", EShLangAll, true },
{ "Load", /* +samplindex, offset*/ "V4", nullptr, "$&,V,S,V", "FIU,I,I,I", EShLangAll }, { "Load", /* +samplindex, offset*/ "V4", nullptr, "$&,V,S,V", "FIU,I,I,I", EShLangAll, true },
// RWTexture loads // RWTexture loads
{ "Load", "V4", nullptr, "!#,V", "FIU,I", EShLangAll }, { "Load", "V4", nullptr, "!#,V", "FIU,I", EShLangAll, true },
// (RW)Buffer loads // (RW)Buffer loads
{ "Load", "V4", nullptr, "~*1,V", "FIU,I", EShLangAll }, { "Load", "V4", nullptr, "~*1,V", "FIU,I", EShLangAll, true },
{ "Gather", /*!O*/ "V4", nullptr, "%@,S,V", "FIU,S,F", EShLangAll }, { "Gather", /*!O*/ "V4", nullptr, "%@,S,V", "FIU,S,F", EShLangAll, true },
{ "Gather", /* O*/ "V4", nullptr, "%@,S,V,V", "FIU,S,F,I", EShLangAll }, { "Gather", /* O*/ "V4", nullptr, "%@,S,V,V", "FIU,S,F,I", EShLangAll, true },
{ "CalculateLevelOfDetail", "S", "F", "%@,S,V", "FUI,S,F", EShLangPS }, { "CalculateLevelOfDetail", "S", "F", "%@,S,V", "FUI,S,F", EShLangPS, true },
{ "CalculateLevelOfDetailUnclamped", "S", "F", "%@,S,V", "FUI,S,F", EShLangPS }, { "CalculateLevelOfDetailUnclamped", "S", "F", "%@,S,V", "FUI,S,F", EShLangPS, true },
{ "GetSamplePosition", "V2", "F", "$&2,S", "FUI,I", EShLangVSPSGS }, { "GetSamplePosition", "V2", "F", "$&2,S", "FUI,I", EShLangVSPSGS,true },
// //
// UINT Width // UINT Width
// UINT MipLevel, UINT Width, UINT NumberOfLevels // UINT MipLevel, UINT Width, UINT NumberOfLevels
{ "GetDimensions", /* 1D */ "-", "-", "%!~1,>S", "FUI,U", EShLangAll }, { "GetDimensions", /* 1D */ "-", "-", "%!~1,>S", "FUI,U", EShLangAll, true },
{ "GetDimensions", /* 1D */ "-", "-", "%!~1,>S", "FUI,F", EShLangAll }, { "GetDimensions", /* 1D */ "-", "-", "%!~1,>S", "FUI,F", EShLangAll, true },
{ "GetDimensions", /* 1D */ "-", "-", "%1,S,>S,", "FUI,U,,", EShLangAll }, { "GetDimensions", /* 1D */ "-", "-", "%1,S,>S,", "FUI,U,,", EShLangAll, true },
{ "GetDimensions", /* 1D */ "-", "-", "%1,S,>S,", "FUI,U,F,", EShLangAll }, { "GetDimensions", /* 1D */ "-", "-", "%1,S,>S,", "FUI,U,F,", EShLangAll, true },
// UINT Width, UINT Elements // UINT Width, UINT Elements
// UINT MipLevel, UINT Width, UINT Elements, UINT NumberOfLevels // UINT MipLevel, UINT Width, UINT Elements, UINT NumberOfLevels
{ "GetDimensions", /* 1DArray */ "-", "-", "@#1,>S,", "FUI,U,", EShLangAll }, { "GetDimensions", /* 1DArray */ "-", "-", "@#1,>S,", "FUI,U,", EShLangAll, true },
{ "GetDimensions", /* 1DArray */ "-", "-", "@#1,>S,", "FUI,F,", EShLangAll }, { "GetDimensions", /* 1DArray */ "-", "-", "@#1,>S,", "FUI,F,", EShLangAll, true },
{ "GetDimensions", /* 1DArray */ "-", "-", "@1,S,>S,,", "FUI,U,,,", EShLangAll }, { "GetDimensions", /* 1DArray */ "-", "-", "@1,S,>S,,", "FUI,U,,,", EShLangAll, true },
{ "GetDimensions", /* 1DArray */ "-", "-", "@1,S,>S,,", "FUI,U,F,,", EShLangAll }, { "GetDimensions", /* 1DArray */ "-", "-", "@1,S,>S,,", "FUI,U,F,,", EShLangAll, true },
// UINT Width, UINT Height // UINT Width, UINT Height
// UINT MipLevel, UINT Width, UINT Height, UINT NumberOfLevels // UINT MipLevel, UINT Width, UINT Height, UINT NumberOfLevels
{ "GetDimensions", /* 2D */ "-", "-", "%!2,>S,", "FUI,U,", EShLangAll }, { "GetDimensions", /* 2D */ "-", "-", "%!2,>S,", "FUI,U,", EShLangAll, true },
{ "GetDimensions", /* 2D */ "-", "-", "%!2,>S,", "FUI,F,", EShLangAll }, { "GetDimensions", /* 2D */ "-", "-", "%!2,>S,", "FUI,F,", EShLangAll, true },
{ "GetDimensions", /* 2D */ "-", "-", "%2,S,>S,,", "FUI,U,,,", EShLangAll }, { "GetDimensions", /* 2D */ "-", "-", "%2,S,>S,,", "FUI,U,,,", EShLangAll, true },
{ "GetDimensions", /* 2D */ "-", "-", "%2,S,>S,,", "FUI,U,F,,", EShLangAll }, { "GetDimensions", /* 2D */ "-", "-", "%2,S,>S,,", "FUI,U,F,,", EShLangAll, true },
// UINT Width, UINT Height, UINT Elements // UINT Width, UINT Height, UINT Elements
// UINT MipLevel, UINT Width, UINT Height, UINT Elements, UINT NumberOfLevels // UINT MipLevel, UINT Width, UINT Height, UINT Elements, UINT NumberOfLevels
{ "GetDimensions", /* 2DArray */ "-", "-", "@#2,>S,,", "FUI,U,,", EShLangAll }, { "GetDimensions", /* 2DArray */ "-", "-", "@#2,>S,,", "FUI,U,,", EShLangAll, true },
{ "GetDimensions", /* 2DArray */ "-", "-", "@#2,>S,,", "FUI,F,F,F", EShLangAll }, { "GetDimensions", /* 2DArray */ "-", "-", "@#2,>S,,", "FUI,F,F,F", EShLangAll, true },
{ "GetDimensions", /* 2DArray */ "-", "-", "@2,S,>S,,,", "FUI,U,,,,", EShLangAll }, { "GetDimensions", /* 2DArray */ "-", "-", "@2,S,>S,,,", "FUI,U,,,,", EShLangAll, true },
{ "GetDimensions", /* 2DArray */ "-", "-", "@2,S,>S,,,", "FUI,U,F,,,", EShLangAll }, { "GetDimensions", /* 2DArray */ "-", "-", "@2,S,>S,,,", "FUI,U,F,,,", EShLangAll, true },
// UINT Width, UINT Height, UINT Depth // UINT Width, UINT Height, UINT Depth
// UINT MipLevel, UINT Width, UINT Height, UINT Depth, UINT NumberOfLevels // UINT MipLevel, UINT Width, UINT Height, UINT Depth, UINT NumberOfLevels
{ "GetDimensions", /* 3D */ "-", "-", "%!3,>S,,", "FUI,U,,", EShLangAll }, { "GetDimensions", /* 3D */ "-", "-", "%!3,>S,,", "FUI,U,,", EShLangAll, true },
{ "GetDimensions", /* 3D */ "-", "-", "%!3,>S,,", "FUI,F,,", EShLangAll }, { "GetDimensions", /* 3D */ "-", "-", "%!3,>S,,", "FUI,F,,", EShLangAll, true },
{ "GetDimensions", /* 3D */ "-", "-", "%3,S,>S,,,", "FUI,U,,,,", EShLangAll }, { "GetDimensions", /* 3D */ "-", "-", "%3,S,>S,,,", "FUI,U,,,,", EShLangAll, true },
{ "GetDimensions", /* 3D */ "-", "-", "%3,S,>S,,,", "FUI,U,F,,,", EShLangAll }, { "GetDimensions", /* 3D */ "-", "-", "%3,S,>S,,,", "FUI,U,F,,,", EShLangAll, true },
// UINT Width, UINT Height // UINT Width, UINT Height
// UINT MipLevel, UINT Width, UINT Height, UINT NumberOfLevels // UINT MipLevel, UINT Width, UINT Height, UINT NumberOfLevels
{ "GetDimensions", /* Cube */ "-", "-", "%4,>S,", "FUI,U,", EShLangAll }, { "GetDimensions", /* Cube */ "-", "-", "%4,>S,", "FUI,U,", EShLangAll, true },
{ "GetDimensions", /* Cube */ "-", "-", "%4,>S,", "FUI,F,", EShLangAll }, { "GetDimensions", /* Cube */ "-", "-", "%4,>S,", "FUI,F,", EShLangAll, true },
{ "GetDimensions", /* Cube */ "-", "-", "%4,S,>S,,", "FUI,U,,,", EShLangAll }, { "GetDimensions", /* Cube */ "-", "-", "%4,S,>S,,", "FUI,U,,,", EShLangAll, true },
{ "GetDimensions", /* Cube */ "-", "-", "%4,S,>S,,", "FUI,U,F,,", EShLangAll }, { "GetDimensions", /* Cube */ "-", "-", "%4,S,>S,,", "FUI,U,F,,", EShLangAll, true },
// UINT Width, UINT Height, UINT Elements // UINT Width, UINT Height, UINT Elements
// UINT MipLevel, UINT Width, UINT Height, UINT Elements, UINT NumberOfLevels // UINT MipLevel, UINT Width, UINT Height, UINT Elements, UINT NumberOfLevels
{ "GetDimensions", /* CubeArray */ "-", "-", "@4,>S,,", "FUI,U,,", EShLangAll }, { "GetDimensions", /* CubeArray */ "-", "-", "@4,>S,,", "FUI,U,,", EShLangAll, true },
{ "GetDimensions", /* CubeArray */ "-", "-", "@4,>S,,", "FUI,F,,", EShLangAll }, { "GetDimensions", /* CubeArray */ "-", "-", "@4,>S,,", "FUI,F,,", EShLangAll, true },
{ "GetDimensions", /* CubeArray */ "-", "-", "@4,S,>S,,,", "FUI,U,,,,", EShLangAll }, { "GetDimensions", /* CubeArray */ "-", "-", "@4,S,>S,,,", "FUI,U,,,,", EShLangAll, true },
{ "GetDimensions", /* CubeArray */ "-", "-", "@4,S,>S,,,", "FUI,U,F,,,", EShLangAll }, { "GetDimensions", /* CubeArray */ "-", "-", "@4,S,>S,,,", "FUI,U,F,,,", EShLangAll, true },
// UINT Width, UINT Height, UINT Samples // UINT Width, UINT Height, UINT Samples
// UINT Width, UINT Height, UINT Elements, UINT Samples // UINT Width, UINT Height, UINT Elements, UINT Samples
{ "GetDimensions", /* 2DMS */ "-", "-", "$2,>S,,", "FUI,U,,", EShLangAll }, { "GetDimensions", /* 2DMS */ "-", "-", "$2,>S,,", "FUI,U,,", EShLangAll, true },
{ "GetDimensions", /* 2DMS */ "-", "-", "$2,>S,,", "FUI,U,,", EShLangAll }, { "GetDimensions", /* 2DMS */ "-", "-", "$2,>S,,", "FUI,U,,", EShLangAll, true },
{ "GetDimensions", /* 2DMSArray */ "-", "-", "&2,>S,,,", "FUI,U,,,", EShLangAll }, { "GetDimensions", /* 2DMSArray */ "-", "-", "&2,>S,,,", "FUI,U,,,", EShLangAll, true },
{ "GetDimensions", /* 2DMSArray */ "-", "-", "&2,>S,,,", "FUI,U,,,", EShLangAll }, { "GetDimensions", /* 2DMSArray */ "-", "-", "&2,>S,,,", "FUI,U,,,", EShLangAll, true },
// SM5 texture methods // SM5 texture methods
{ "GatherRed", /*!O*/ "V4", nullptr, "%@,S,V", "FIU,S,F", EShLangAll }, { "GatherRed", /*!O*/ "V4", nullptr, "%@,S,V", "FIU,S,F", EShLangAll, true },
{ "GatherRed", /* O*/ "V4", nullptr, "%@,S,V,", "FIU,S,F,I", EShLangAll }, { "GatherRed", /* O*/ "V4", nullptr, "%@,S,V,", "FIU,S,F,I", EShLangAll, true },
{ "GatherRed", /* O, status*/ "V4", nullptr, "%@,S,V,,>S", "FIU,S,F,I,U", EShLangAll }, { "GatherRed", /* O, status*/ "V4", nullptr, "%@,S,V,,>S", "FIU,S,F,I,U", EShLangAll, true },
{ "GatherRed", /* O-4 */ "V4", nullptr, "%@,S,V,,,,", "FIU,S,F,I,,,", EShLangAll }, { "GatherRed", /* O-4 */ "V4", nullptr, "%@,S,V,,,,", "FIU,S,F,I,,,", EShLangAll, true },
{ "GatherRed", /* O-4, status */"V4", nullptr, "%@,S,V,,,,,S", "FIU,S,F,I,,,,U",EShLangAll }, { "GatherRed", /* O-4, status */"V4", nullptr, "%@,S,V,,,,,S", "FIU,S,F,I,,,,U", EShLangAll, true },
{ "GatherGreen", /*!O*/ "V4", nullptr, "%@,S,V", "FIU,S,F", EShLangAll }, { "GatherGreen", /*!O*/ "V4", nullptr, "%@,S,V", "FIU,S,F", EShLangAll, true },
{ "GatherGreen", /* O*/ "V4", nullptr, "%@,S,V,", "FIU,S,F,I", EShLangAll }, { "GatherGreen", /* O*/ "V4", nullptr, "%@,S,V,", "FIU,S,F,I", EShLangAll, true },
{ "GatherGreen", /* O, status*/ "V4", nullptr, "%@,S,V,,>S", "FIU,S,F,I,U", EShLangAll }, { "GatherGreen", /* O, status*/ "V4", nullptr, "%@,S,V,,>S", "FIU,S,F,I,U", EShLangAll, true },
{ "GatherGreen", /* O-4 */ "V4", nullptr, "%@,S,V,,,,", "FIU,S,F,I,,,", EShLangAll }, { "GatherGreen", /* O-4 */ "V4", nullptr, "%@,S,V,,,,", "FIU,S,F,I,,,", EShLangAll, true },
{ "GatherGreen", /* O-4, status */"V4", nullptr, "%@,S,V,,,,,S", "FIU,S,F,I,,,,U",EShLangAll }, { "GatherGreen", /* O-4, status */"V4", nullptr, "%@,S,V,,,,,S", "FIU,S,F,I,,,,U", EShLangAll, true },
{ "GatherBlue", /*!O*/ "V4", nullptr, "%@,S,V", "FIU,S,F", EShLangAll }, { "GatherBlue", /*!O*/ "V4", nullptr, "%@,S,V", "FIU,S,F", EShLangAll, true },
{ "GatherBlue", /* O*/ "V4", nullptr, "%@,S,V,", "FIU,S,F,I", EShLangAll }, { "GatherBlue", /* O*/ "V4", nullptr, "%@,S,V,", "FIU,S,F,I", EShLangAll, true },
{ "GatherBlue", /* O, status*/ "V4", nullptr, "%@,S,V,,>S", "FIU,S,F,I,U", EShLangAll }, { "GatherBlue", /* O, status*/ "V4", nullptr, "%@,S,V,,>S", "FIU,S,F,I,U", EShLangAll, true },
{ "GatherBlue", /* O-4 */ "V4", nullptr, "%@,S,V,,,,", "FIU,S,F,I,,,", EShLangAll }, { "GatherBlue", /* O-4 */ "V4", nullptr, "%@,S,V,,,,", "FIU,S,F,I,,,", EShLangAll, true },
{ "GatherBlue", /* O-4, status */"V4", nullptr, "%@,S,V,,,,,S", "FIU,S,F,I,,,,U",EShLangAll }, { "GatherBlue", /* O-4, status */"V4", nullptr, "%@,S,V,,,,,S", "FIU,S,F,I,,,,U", EShLangAll, true },
{ "GatherAlpha", /*!O*/ "V4", nullptr, "%@,S,V", "FIU,S,F", EShLangAll }, { "GatherAlpha", /*!O*/ "V4", nullptr, "%@,S,V", "FIU,S,F", EShLangAll, true },
{ "GatherAlpha", /* O*/ "V4", nullptr, "%@,S,V,", "FIU,S,F,I", EShLangAll }, { "GatherAlpha", /* O*/ "V4", nullptr, "%@,S,V,", "FIU,S,F,I", EShLangAll, true },
{ "GatherAlpha", /* O, status*/ "V4", nullptr, "%@,S,V,,>S", "FIU,S,F,I,U", EShLangAll }, { "GatherAlpha", /* O, status*/ "V4", nullptr, "%@,S,V,,>S", "FIU,S,F,I,U", EShLangAll, true },
{ "GatherAlpha", /* O-4 */ "V4", nullptr, "%@,S,V,,,,", "FIU,S,F,I,,,", EShLangAll }, { "GatherAlpha", /* O-4 */ "V4", nullptr, "%@,S,V,,,,", "FIU,S,F,I,,,", EShLangAll, true },
{ "GatherAlpha", /* O-4, status */"V4", nullptr, "%@,S,V,,,,,S", "FIU,S,F,I,,,,U",EShLangAll }, { "GatherAlpha", /* O-4, status */"V4", nullptr, "%@,S,V,,,,,S", "FIU,S,F,I,,,,U", EShLangAll, true },
{ "GatherCmpRed", /*!O*/ "V4", nullptr, "%@,S,V,S", "FIU,s,F,", EShLangAll }, { "GatherCmpRed", /*!O*/ "V4", nullptr, "%@,S,V,S", "FIU,s,F,", EShLangAll, true },
{ "GatherCmpRed", /* O*/ "V4", nullptr, "%@,S,V,S,V", "FIU,s,F,,I", EShLangAll }, { "GatherCmpRed", /* O*/ "V4", nullptr, "%@,S,V,S,V", "FIU,s,F,,I", EShLangAll, true },
{ "GatherCmpRed", /* O, status*/ "V4", nullptr, "%@,S,V,S,V,>S", "FIU,s,F,,I,U", EShLangAll }, { "GatherCmpRed", /* O, status*/ "V4", nullptr, "%@,S,V,S,V,>S", "FIU,s,F,,I,U", EShLangAll, true },
{ "GatherCmpRed", /* O-4 */ "V4", nullptr, "%@,S,V,S,V,,,", "FIU,s,F,,I,,,", EShLangAll }, { "GatherCmpRed", /* O-4 */ "V4", nullptr, "%@,S,V,S,V,,,", "FIU,s,F,,I,,,", EShLangAll, true },
{ "GatherCmpRed", /* O-4, status */"V4", nullptr, "%@,S,V,S,V,,V,S","FIU,s,F,,I,,,,U",EShLangAll }, { "GatherCmpRed", /* O-4, status */"V4", nullptr, "%@,S,V,S,V,,V,S","FIU,s,F,,I,,,,U",EShLangAll, true },
{ "GatherCmpGreen", /*!O*/ "V4", nullptr, "%@,S,V,S", "FIU,s,F,", EShLangAll }, { "GatherCmpGreen", /*!O*/ "V4", nullptr, "%@,S,V,S", "FIU,s,F,", EShLangAll, true },
{ "GatherCmpGreen", /* O*/ "V4", nullptr, "%@,S,V,S,V", "FIU,s,F,,I", EShLangAll }, { "GatherCmpGreen", /* O*/ "V4", nullptr, "%@,S,V,S,V", "FIU,s,F,,I", EShLangAll, true },
{ "GatherCmpGreen", /* O, status*/ "V4", nullptr, "%@,S,V,S,V,>S", "FIU,s,F,,I,U", EShLangAll }, { "GatherCmpGreen", /* O, status*/ "V4", nullptr, "%@,S,V,S,V,>S", "FIU,s,F,,I,U", EShLangAll, true },
{ "GatherCmpGreen", /* O-4 */ "V4", nullptr, "%@,S,V,S,V,,,", "FIU,s,F,,I,,,", EShLangAll }, { "GatherCmpGreen", /* O-4 */ "V4", nullptr, "%@,S,V,S,V,,,", "FIU,s,F,,I,,,", EShLangAll, true },
{ "GatherCmpGreen", /* O-4, status */"V4", nullptr, "%@,S,V,S,V,,,,S","FIU,s,F,,I,,,,U",EShLangAll }, { "GatherCmpGreen", /* O-4, status */"V4", nullptr, "%@,S,V,S,V,,,,S","FIU,s,F,,I,,,,U",EShLangAll, true },
{ "GatherCmpBlue", /*!O*/ "V4", nullptr, "%@,S,V,S", "FIU,s,F,", EShLangAll }, { "GatherCmpBlue", /*!O*/ "V4", nullptr, "%@,S,V,S", "FIU,s,F,", EShLangAll, true },
{ "GatherCmpBlue", /* O*/ "V4", nullptr, "%@,S,V,S,V", "FIU,s,F,,I", EShLangAll }, { "GatherCmpBlue", /* O*/ "V4", nullptr, "%@,S,V,S,V", "FIU,s,F,,I", EShLangAll, true },
{ "GatherCmpBlue", /* O, status*/ "V4", nullptr, "%@,S,V,S,V,>S", "FIU,s,F,,I,U", EShLangAll }, { "GatherCmpBlue", /* O, status*/ "V4", nullptr, "%@,S,V,S,V,>S", "FIU,s,F,,I,U", EShLangAll, true },
{ "GatherCmpBlue", /* O-4 */ "V4", nullptr, "%@,S,V,S,V,,,", "FIU,s,F,,I,,,", EShLangAll }, { "GatherCmpBlue", /* O-4 */ "V4", nullptr, "%@,S,V,S,V,,,", "FIU,s,F,,I,,,", EShLangAll, true },
{ "GatherCmpBlue", /* O-4, status */"V4", nullptr, "%@,S,V,S,V,,,,S","FIU,s,F,,I,,,,U",EShLangAll }, { "GatherCmpBlue", /* O-4, status */"V4", nullptr, "%@,S,V,S,V,,,,S","FIU,s,F,,I,,,,U",EShLangAll, true },
{ "GatherCmpAlpha", /*!O*/ "V4", nullptr, "%@,S,V,S", "FIU,s,F,", EShLangAll }, { "GatherCmpAlpha", /*!O*/ "V4", nullptr, "%@,S,V,S", "FIU,s,F,", EShLangAll, true },
{ "GatherCmpAlpha", /* O*/ "V4", nullptr, "%@,S,V,S,V", "FIU,s,F,,I", EShLangAll }, { "GatherCmpAlpha", /* O*/ "V4", nullptr, "%@,S,V,S,V", "FIU,s,F,,I", EShLangAll, true },
{ "GatherCmpAlpha", /* O, status*/ "V4", nullptr, "%@,S,V,S,V,>S", "FIU,s,F,,I,U", EShLangAll }, { "GatherCmpAlpha", /* O, status*/ "V4", nullptr, "%@,S,V,S,V,>S", "FIU,s,F,,I,U", EShLangAll, true },
{ "GatherCmpAlpha", /* O-4 */ "V4", nullptr, "%@,S,V,S,V,,,", "FIU,s,F,,I,,,", EShLangAll }, { "GatherCmpAlpha", /* O-4 */ "V4", nullptr, "%@,S,V,S,V,,,", "FIU,s,F,,I,,,", EShLangAll, true },
{ "GatherCmpAlpha", /* O-4, status */"V4", nullptr, "%@,S,V,S,V,,,,S","FIU,s,F,,I,,,,U",EShLangAll }, { "GatherCmpAlpha", /* O-4, status */"V4", nullptr, "%@,S,V,S,V,,,,S","FIU,s,F,,I,,,,U",EShLangAll, true },
// geometry methods // geometry methods
{ "Append", "-", "-", "-", "-", EShLangGS }, { "Append", "-", "-", "-", "-", EShLangGS , true },
{ "RestartStrip", "-", "-", "-", "-", EShLangGS }, { "RestartStrip", "-", "-", "-", "-", EShLangGS , true },
// Methods for structurebuffers. TODO: wildcard type matching. // Methods for structurebuffers. TODO: wildcard type matching.
{ "Load", nullptr, nullptr, "-", "-", EShLangAll }, { "Load", nullptr, nullptr, "-", "-", EShLangAll, true },
{ "Load2", nullptr, nullptr, "-", "-", EShLangAll }, { "Load2", nullptr, nullptr, "-", "-", EShLangAll, true },
{ "Load3", nullptr, nullptr, "-", "-", EShLangAll }, { "Load3", nullptr, nullptr, "-", "-", EShLangAll, true },
{ "Load4", nullptr, nullptr, "-", "-", EShLangAll }, { "Load4", nullptr, nullptr, "-", "-", EShLangAll, true },
{ "Store", nullptr, nullptr, "-", "-", EShLangAll }, { "Store", nullptr, nullptr, "-", "-", EShLangAll, true },
{ "Store2", nullptr, nullptr, "-", "-", EShLangAll }, { "Store2", nullptr, nullptr, "-", "-", EShLangAll, true },
{ "Store3", nullptr, nullptr, "-", "-", EShLangAll }, { "Store3", nullptr, nullptr, "-", "-", EShLangAll, true },
{ "Store4", nullptr, nullptr, "-", "-", EShLangAll }, { "Store4", nullptr, nullptr, "-", "-", EShLangAll, true },
{ "GetDimensions", nullptr, nullptr, "-", "-", EShLangAll }, { "GetDimensions", nullptr, nullptr, "-", "-", EShLangAll, true },
{ "InterlockedAdd", nullptr, nullptr, "-", "-", EShLangAll }, { "InterlockedAdd", nullptr, nullptr, "-", "-", EShLangAll, true },
{ "InterlockedAnd", nullptr, nullptr, "-", "-", EShLangAll }, { "InterlockedAnd", nullptr, nullptr, "-", "-", EShLangAll, true },
{ "InterlockedCompareExchange", nullptr, nullptr, "-", "-", EShLangAll }, { "InterlockedCompareExchange", nullptr, nullptr, "-", "-", EShLangAll, true },
{ "InterlockedCompareStore", nullptr, nullptr, "-", "-", EShLangAll }, { "InterlockedCompareStore", nullptr, nullptr, "-", "-", EShLangAll, true },
{ "InterlockedExchange", nullptr, nullptr, "-", "-", EShLangAll }, { "InterlockedExchange", nullptr, nullptr, "-", "-", EShLangAll, true },
{ "InterlockedMax", nullptr, nullptr, "-", "-", EShLangAll }, { "InterlockedMax", nullptr, nullptr, "-", "-", EShLangAll, true },
{ "InterlockedMin", nullptr, nullptr, "-", "-", EShLangAll }, { "InterlockedMin", nullptr, nullptr, "-", "-", EShLangAll, true },
{ "InterlockedOr", nullptr, nullptr, "-", "-", EShLangAll }, { "InterlockedOr", nullptr, nullptr, "-", "-", EShLangAll, true },
{ "InterlockedXor", nullptr, nullptr, "-", "-", EShLangAll }, { "InterlockedXor", nullptr, nullptr, "-", "-", EShLangAll, true },
// Mark end of list, since we want to avoid a range-based for, as some compilers don't handle it yet. // Mark end of list, since we want to avoid a range-based for, as some compilers don't handle it yet.
{ nullptr, nullptr, nullptr, nullptr, nullptr, 0 }, { nullptr, nullptr, nullptr, nullptr, nullptr, 0, false },
}; };
// Create prototypes for the intrinsics. TODO: Avoid ranged based for until all compilers can handle it. // Create prototypes for the intrinsics. TODO: Avoid ranged based for until all compilers can handle it.
...@@ -918,6 +920,12 @@ void TBuiltInParseablesHlsl::initialize(int /*version*/, EProfile /*profile*/, c ...@@ -918,6 +920,12 @@ void TBuiltInParseablesHlsl::initialize(int /*version*/, EProfile /*profile*/, c
AppendTypeName(s, retOrder, retType, dim0, dim1); // add return type AppendTypeName(s, retOrder, retType, dim0, dim1); // add return type
s.append(" "); // space between type and name s.append(" "); // space between type and name
// methods have a prefix. TODO: it would be better as an invalid identifier character,
// but that requires a scanner change.
if (intrinsic.method)
s.append(BUILTIN_PREFIX);
s.append(intrinsic.name); // intrinsic name s.append(intrinsic.name); // intrinsic name
s.append("("); // open paren s.append("("); // open paren
...@@ -1151,41 +1159,51 @@ void TBuiltInParseablesHlsl::identifyBuiltIns(int /*version*/, EProfile /*profil ...@@ -1151,41 +1159,51 @@ void TBuiltInParseablesHlsl::identifyBuiltIns(int /*version*/, EProfile /*profil
symbolTable.relateToOperator("trunc", EOpTrunc); symbolTable.relateToOperator("trunc", EOpTrunc);
// Texture methods // Texture methods
symbolTable.relateToOperator("Sample", EOpMethodSample); symbolTable.relateToOperator(BUILTIN_PREFIX "Sample", EOpMethodSample);
symbolTable.relateToOperator("SampleBias", EOpMethodSampleBias); symbolTable.relateToOperator(BUILTIN_PREFIX "SampleBias", EOpMethodSampleBias);
symbolTable.relateToOperator("SampleCmp", EOpMethodSampleCmp); symbolTable.relateToOperator(BUILTIN_PREFIX "SampleCmp", EOpMethodSampleCmp);
symbolTable.relateToOperator("SampleCmpLevelZero", EOpMethodSampleCmpLevelZero); symbolTable.relateToOperator(BUILTIN_PREFIX "SampleCmpLevelZero", EOpMethodSampleCmpLevelZero);
symbolTable.relateToOperator("SampleGrad", EOpMethodSampleGrad); symbolTable.relateToOperator(BUILTIN_PREFIX "SampleGrad", EOpMethodSampleGrad);
symbolTable.relateToOperator("SampleLevel", EOpMethodSampleLevel); symbolTable.relateToOperator(BUILTIN_PREFIX "SampleLevel", EOpMethodSampleLevel);
symbolTable.relateToOperator("Load", EOpMethodLoad); symbolTable.relateToOperator(BUILTIN_PREFIX "Load", EOpMethodLoad);
symbolTable.relateToOperator("GetDimensions", EOpMethodGetDimensions); symbolTable.relateToOperator(BUILTIN_PREFIX "GetDimensions", EOpMethodGetDimensions);
symbolTable.relateToOperator("GetSamplePosition", EOpMethodGetSamplePosition); symbolTable.relateToOperator(BUILTIN_PREFIX "GetSamplePosition", EOpMethodGetSamplePosition);
symbolTable.relateToOperator("Gather", EOpMethodGather); symbolTable.relateToOperator(BUILTIN_PREFIX "Gather", EOpMethodGather);
symbolTable.relateToOperator("CalculateLevelOfDetail", EOpMethodCalculateLevelOfDetail); symbolTable.relateToOperator(BUILTIN_PREFIX "CalculateLevelOfDetail", EOpMethodCalculateLevelOfDetail);
symbolTable.relateToOperator("CalculateLevelOfDetailUnclamped", EOpMethodCalculateLevelOfDetailUnclamped); symbolTable.relateToOperator(BUILTIN_PREFIX "CalculateLevelOfDetailUnclamped", EOpMethodCalculateLevelOfDetailUnclamped);
// Structure buffer methods (excluding associations already made above for texture methods w/ same name) // Structure buffer methods (excluding associations already made above for texture methods w/ same name)
symbolTable.relateToOperator("Load2", EOpMethodLoad2); symbolTable.relateToOperator(BUILTIN_PREFIX "Load2", EOpMethodLoad2);
symbolTable.relateToOperator("Load3", EOpMethodLoad3); symbolTable.relateToOperator(BUILTIN_PREFIX "Load3", EOpMethodLoad3);
symbolTable.relateToOperator("Load4", EOpMethodLoad4); symbolTable.relateToOperator(BUILTIN_PREFIX "Load4", EOpMethodLoad4);
symbolTable.relateToOperator("Store", EOpMethodStore); symbolTable.relateToOperator(BUILTIN_PREFIX "Store", EOpMethodStore);
symbolTable.relateToOperator("Store2", EOpMethodStore2); symbolTable.relateToOperator(BUILTIN_PREFIX "Store2", EOpMethodStore2);
symbolTable.relateToOperator("Store3", EOpMethodStore3); symbolTable.relateToOperator(BUILTIN_PREFIX "Store3", EOpMethodStore3);
symbolTable.relateToOperator("Store4", EOpMethodStore4); symbolTable.relateToOperator(BUILTIN_PREFIX "Store4", EOpMethodStore4);
symbolTable.relateToOperator(BUILTIN_PREFIX "InterlockedAdd", EOpInterlockedAdd);
symbolTable.relateToOperator(BUILTIN_PREFIX "InterlockedAnd", EOpInterlockedAnd);
symbolTable.relateToOperator(BUILTIN_PREFIX "InterlockedCompareExchange", EOpInterlockedCompareExchange);
symbolTable.relateToOperator(BUILTIN_PREFIX "InterlockedCompareStore", EOpInterlockedCompareStore);
symbolTable.relateToOperator(BUILTIN_PREFIX "InterlockedExchange", EOpInterlockedExchange);
symbolTable.relateToOperator(BUILTIN_PREFIX "InterlockedMax", EOpInterlockedMax);
symbolTable.relateToOperator(BUILTIN_PREFIX "InterlockedMin", EOpInterlockedMin);
symbolTable.relateToOperator(BUILTIN_PREFIX "InterlockedOr", EOpInterlockedOr);
symbolTable.relateToOperator(BUILTIN_PREFIX "InterlockedXor", EOpInterlockedXor);
// SM5 Texture methods // SM5 Texture methods
symbolTable.relateToOperator("GatherRed", EOpMethodGatherRed); symbolTable.relateToOperator(BUILTIN_PREFIX "GatherRed", EOpMethodGatherRed);
symbolTable.relateToOperator("GatherGreen", EOpMethodGatherGreen); symbolTable.relateToOperator(BUILTIN_PREFIX "GatherGreen", EOpMethodGatherGreen);
symbolTable.relateToOperator("GatherBlue", EOpMethodGatherBlue); symbolTable.relateToOperator(BUILTIN_PREFIX "GatherBlue", EOpMethodGatherBlue);
symbolTable.relateToOperator("GatherAlpha", EOpMethodGatherAlpha); symbolTable.relateToOperator(BUILTIN_PREFIX "GatherAlpha", EOpMethodGatherAlpha);
symbolTable.relateToOperator("GatherCmpRed", EOpMethodGatherCmpRed); symbolTable.relateToOperator(BUILTIN_PREFIX "GatherCmpRed", EOpMethodGatherCmpRed);
symbolTable.relateToOperator("GatherCmpGreen", EOpMethodGatherCmpGreen); symbolTable.relateToOperator(BUILTIN_PREFIX "GatherCmpGreen", EOpMethodGatherCmpGreen);
symbolTable.relateToOperator("GatherCmpBlue", EOpMethodGatherCmpBlue); symbolTable.relateToOperator(BUILTIN_PREFIX "GatherCmpBlue", EOpMethodGatherCmpBlue);
symbolTable.relateToOperator("GatherCmpAlpha", EOpMethodGatherCmpAlpha); symbolTable.relateToOperator(BUILTIN_PREFIX "GatherCmpAlpha", EOpMethodGatherCmpAlpha);
// GS methods // GS methods
symbolTable.relateToOperator("Append", EOpMethodAppend); symbolTable.relateToOperator(BUILTIN_PREFIX "Append", EOpMethodAppend);
symbolTable.relateToOperator("RestartStrip", EOpMethodRestartStrip); symbolTable.relateToOperator(BUILTIN_PREFIX "RestartStrip", EOpMethodRestartStrip);
} }
// //
......
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