diff options
Diffstat (limited to 'chromium/third_party/glslang/src/hlsl/hlslParseables.cpp')
| -rwxr-xr-x | chromium/third_party/glslang/src/hlsl/hlslParseables.cpp | 663 |
1 files changed, 663 insertions, 0 deletions
diff --git a/chromium/third_party/glslang/src/hlsl/hlslParseables.cpp b/chromium/third_party/glslang/src/hlsl/hlslParseables.cpp new file mode 100755 index 00000000000..b676a8efd2c --- /dev/null +++ b/chromium/third_party/glslang/src/hlsl/hlslParseables.cpp @@ -0,0 +1,663 @@ +// +//Copyright (C) 2016 LunarG, Inc. +// +//All rights reserved. +// +//Redistribution and use in source and binary forms, with or without +//modification, are permitted provided that the following conditions +//are met: +// +// Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// +// Neither the name of 3Dlabs Inc. Ltd. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +//"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +//LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +//FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +//COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +//INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +//BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +//LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +//CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +//LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +//ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +//POSSIBILITY OF SUCH DAMAGE. +// + +// +// Create strings that declare built-in definitions, add built-ins programmatically +// that cannot be expressed in the strings, and establish mappings between +// built-in functions and operators. +// +// Where to put a built-in: +// TBuiltInParseablesHlsl::initialize(version,profile) context-independent textual built-ins; add them to the right string +// TBuiltInParseablesHlsl::initialize(resources,...) context-dependent textual built-ins; add them to the right string +// TBuiltInParseablesHlsl::identifyBuiltIns(...,symbolTable) context-independent programmatic additions/mappings to the symbol table, +// including identifying what extensions are needed if a version does not allow a symbol +// TBuiltInParseablesHlsl::identifyBuiltIns(...,symbolTable, resources) context-dependent programmatic additions/mappings to the +// symbol table, including identifying what extensions are needed if a version does +// not allow a symbol +// + +#include "hlslParseables.h" +#include <cctype> +#include <utility> + +namespace { // anonymous namespace functions + +const char* BaseTypeName(const char* argOrder, const char* scalarName, const char* vecName, const char* matName) +{ + switch (*argOrder) { + case 'S': return scalarName; + case 'V': return vecName; + case 'M': return matName; + default: return "UNKNOWN_TYPE"; + } +} + +// Create and return a type name. This is done in GLSL, not HLSL conventions, until such +// time as builtins are parsed using the HLSL parser. +// +// order: S = scalar, V = vector, M = matrix +// argType: F = float, D = double, I = int, U = uint, B = bool, S = sampler +// dim0 = vector dimension, or matrix 1st dimension +// dim1 = matrix 2nd dimension +glslang::TString& AppendTypeName(glslang::TString& s, const char* argOrder, const char* argType, int dim0, int dim1) +{ + const bool transpose = (argOrder[0] == '^'); + + // Take transpose of matrix dimensions + if (transpose) { + std::swap(dim0, dim1); + ++argOrder; + } + + switch (*argType) { + case '-': s += "void"; break; + case 'F': s += BaseTypeName(argOrder, "float", "vec", "mat"); break; + case 'D': s += BaseTypeName(argOrder, "double", "dvec", "dmat"); break; + case 'I': s += BaseTypeName(argOrder, "int", "ivec", "imat"); break; + case 'U': s += BaseTypeName(argOrder, "uint", "uvec", "umat"); break; + case 'B': s += BaseTypeName(argOrder, "bool", "bvec", "bmat"); break; + case 'S': s += BaseTypeName(argOrder, "sampler", "sampler", "sampler"); break; // TODO: + default: s += "UNKNOWN_TYPE"; break; + } + + // handle fixed vector sizes, such as float3, and only ever 3. + const int fixedVecSize = isdigit(argOrder[1]) ? (argOrder[1] - '0') : 0; + if (fixedVecSize != 0) + dim0 = dim1 = fixedVecSize; + + // Add sampler dimensions + if (*argType == 'S') { + switch (dim0) { + case 1: s += "1D"; break; + case 2: s += "2D"; break; + case 3: s += "3D"; break; + case 4: s += "Cube"; break; + default: s += "UNKNOWN_SAMPLER"; break; + } + } + + // verify dimensions + if ((*argOrder == 'V' || *argOrder == 'M') && (dim0 < 1 || dim0 > 4) || + (*argOrder == 'M' && (dim1 < 1 || dim1 > 4))) { + s += "UNKNOWN_DIMENSION"; + return s; + } + + switch (*argOrder) { + case '-': break; // no dimensions for voids + case 'S': break; // no dimensions on scalars + case 'V': s += ('0' + dim0); break; + case 'M': s += ('0' + dim0); s += 'x'; s += ('0' + dim1); break; + } + + return s; +} + +// TODO: the GLSL parser is currently used to parse HLSL prototypes. However, many valid HLSL prototypes +// are not valid GLSL prototypes. This rejects the invalid ones. Thus, there is a single switch below +// to enable creation of the entire HLSL space. +inline bool IsValidGlsl(const char* cname, char retOrder, char retType, char argOrder, char argType, + int dim0, int dim1, int dim0Max, int dim1Max) +{ + const bool isVec = dim0Max > 1 || argType == 'V'; + const bool isMat = dim1Max > 1 || argType == 'M'; + + if (argType == 'D' || // avoid double args + retType == 'D' || // avoid double return + (isVec && dim0 == 1) || // avoid vec1 + (isMat && dim0 == 1 && dim1 == 1)) // avoid mat1x1 + return false; + + const std::string name(cname); // for ease of comparison. slow, but temporary, until HLSL parser is online. + + if (isMat && dim0 != dim1) // TODO: avoid mats until we find the right GLSL profile + return false; + + if (isMat && (argType == 'I' || argType == 'U' || argType == 'B') || + retOrder == 'M' && (retType == 'I' || retType == 'U' || retType == 'B')) + return false; + + if (name == "GetRenderTargetSamplePosition" || + name == "tex1D" || + name == "tex1Dgrad") + return false; + + return true; +} + + +// Return true for the end of a single argument key, which can be the end of the string, or +// the comma separator. +inline bool IsEndOfArg(const char* arg) +{ + return arg == nullptr || *arg == '\0' || *arg == ','; +} + + +// return position of end of argument specifier +inline const char* FindEndOfArg(const char* arg) +{ + while (!IsEndOfArg(arg)) + ++arg; + + return *arg == '\0' ? nullptr : arg; +} + + +// Return pointer to beginning of Nth argument specifier in the string. +inline const char* NthArg(const char* arg, int n) +{ + for (int x=0; x<n && arg; ++x) + if ((arg = FindEndOfArg(arg)) != nullptr) + ++arg; // skip arg separator + + return arg; +} + +inline void FindVectorMatrixBounds(const char* argOrder, int fixedVecSize, int& dim0Min, int& dim0Max, int& dim1Min, int& dim1Max) +{ + for (int arg = 0; ; ++arg) { + const char* nthArgOrder(NthArg(argOrder, arg)); + if (nthArgOrder == nullptr) + break; + else if (*nthArgOrder == 'V') + dim0Max = 4; + else if (*nthArgOrder == 'M') + dim0Max = dim1Max = 4; + } + + if (fixedVecSize > 0) // handle fixed sized vectors + dim0Min = dim0Max = fixedVecSize; +} + +} // end anonymous namespace + +namespace glslang { + +TBuiltInParseablesHlsl::TBuiltInParseablesHlsl() +{ +} + +// +// Add all context-independent built-in functions and variables that are present +// for the given version and profile. Share common ones across stages, otherwise +// make stage-specific entries. +// +// Most built-ins variables can be added as simple text strings. Some need to +// be added programmatically, which is done later in IdentifyBuiltIns() below. +// +void TBuiltInParseablesHlsl::initialize(int version, EProfile profile, int spv, int vulkan) +{ + static const EShLanguageMask EShLangAll = EShLanguageMask(EShLangCount - 1); + + // This structure encodes the prototype information for each HLSL intrinsic. + // Because explicit enumeration would be cumbersome, it's procedurally generated. + // orderKey can be: + // S = scalar, V = vector, M = matrix, - = void + // typekey can be: + // D = double, F = float, U = uint, I = int, B = bool, S = sampler, - = void + // An empty order or type key repeats the first one. E.g: SVM,, means 3 args each of SVM. + // '>' as first letter of order creates an output paremeter + // '<' as first letter of order creates an input paremeter + // '^' as first letter of order takes transpose dimensions + + static const struct { + const char* name; // intrinsic name + const char* retOrder; // return type key: empty matches order of 1st argument + const char* retType; // return type key: empty matches type of 1st argument + const char* argOrder; // argument order key + const char* argType; // argument type key + unsigned int stage; // stage mask + } hlslIntrinsics[] = { + // name retOrd retType argOrder argType stage mask + // ----------------------------------------------------------------------------------------------- + { "abort", nullptr, nullptr, "-", "-", EShLangAll }, + { "abs", nullptr, nullptr, "SVM", "DFUI", EShLangAll }, + { "acos", nullptr, nullptr, "SVM", "F", EShLangAll }, + { "all", "S", "B", "SVM", "BFI", EShLangAll }, + { "AllMemoryBarrier", nullptr, nullptr, "-", "-", EShLangComputeMask }, + { "AllMemoryBarrierWithGroupSync", nullptr, nullptr, "-", "-", EShLangComputeMask }, + { "any", "S", "B", "SVM", "BFI", EShLangAll }, + { "asdouble", "S", "D", "S,", "U,", EShLangAll }, + { "asdouble", "V2", "D", "V2,", "U,", EShLangAll }, + { "asfloat", nullptr, "F", "SVM", "BFIU", EShLangAll }, + { "asin", nullptr, nullptr, "SVM", "F", EShLangAll }, + { "asint", nullptr, "I", "SVM", "FU", EShLangAll }, + { "asuint", nullptr, "U", "SVM", "FU", EShLangAll }, + { "atan", nullptr, nullptr, "SVM", "F", EShLangAll }, + { "atan2", nullptr, nullptr, "SVM,", "F,", EShLangAll }, + { "ceil", nullptr, nullptr, "SVM", "F", EShLangAll }, + { "CheckAccessFullyMapped", "S", "B" , "S", "U", EShLangFragmentMask | EShLangComputeMask }, + { "clamp", nullptr, nullptr, "SVM,,", "FUI,,", EShLangAll }, + { "clip", "-", "-", "SVM", "F", EShLangFragmentMask }, + { "cos", nullptr, nullptr, "SVM", "F", EShLangAll }, + { "cosh", nullptr, nullptr, "SVM", "F", EShLangAll }, + { "countbits", nullptr, nullptr, "SV", "U", EShLangAll }, + { "cross", nullptr, nullptr, "V3,", "F,", EShLangAll }, + { "D3DCOLORtoUBYTE4", "V4", "I", "V4", "F", EShLangAll }, + { "ddx", nullptr, nullptr, "SVM", "F", EShLangFragmentMask }, + { "ddx_coarse", nullptr, nullptr, "SVM", "F", EShLangFragmentMask }, + { "ddx_fine", nullptr, nullptr, "SVM", "F", EShLangFragmentMask }, + { "ddy", nullptr, nullptr, "SVM", "F", EShLangFragmentMask }, + { "ddy_coarse", nullptr, nullptr, "SVM", "F", EShLangFragmentMask }, + { "ddy_fine", nullptr, nullptr, "SVM", "F", EShLangFragmentMask }, + { "degrees", nullptr, nullptr, "SVM", "F", EShLangAll }, + { "determinant", "S", "F", "M", "F", EShLangAll }, + { "DeviceMemoryBarrier", nullptr, nullptr, "-", "-", EShLangFragmentMask | EShLangComputeMask }, + { "DeviceMemoryBarrierWithGroupSync", nullptr, nullptr, "-", "-", EShLangComputeMask }, + { "distance", "S", "F", "V,", "F,", EShLangAll }, + { "dot", "S", nullptr, "V,", "FI,", EShLangAll }, + { "dst", nullptr, nullptr, "V4,V4", "F,", EShLangAll }, + // { "errorf", "-", "-", "", "", EShLangAll }, TODO: varargs + { "EvaluateAttributeAtCentroid", nullptr, nullptr, "SVM", "F", EShLangFragmentMask }, + { "EvaluateAttributeAtSample", nullptr, nullptr, "SVM,S", "F,U", EShLangFragmentMask }, + { "EvaluateAttributeSnapped", nullptr, nullptr, "SVM,V2", "F,F", EShLangFragmentMask }, + { "exp", nullptr, nullptr, "SVM", "F", EShLangAll }, + { "exp2", nullptr, nullptr, "SVM", "F", EShLangAll }, + { "f16tof32", nullptr, "F", "SV", "U", EShLangAll }, + { "f32tof16", nullptr, "U", "SV", "F", EShLangAll }, + { "faceforward", nullptr, nullptr, "V,,", "F,,", EShLangAll }, + { "firstbithigh", nullptr, nullptr, "SV", "UI", EShLangAll }, + { "firstbitlow", nullptr, nullptr, "SV", "UI", EShLangAll }, + { "floor", nullptr, nullptr, "SVM", "F", EShLangAll }, + { "fma", nullptr, nullptr, "SVM,,", "D,,", EShLangAll }, + { "fmod", nullptr, nullptr, "SVM,", "F,", EShLangAll }, + { "frac", nullptr, nullptr, "SVM", "F", EShLangAll }, + { "frexp", nullptr, nullptr, "SVM,", "F,", EShLangAll }, + { "fwidth", nullptr, nullptr, "SVM", "F", EShLangAll }, + { "GetRenderTargetSampleCount", "S", "U", "-", "-", EShLangAll }, + { "GetRenderTargetSamplePosition", "V2", "F", "V1", "I", EShLangAll }, + { "GroupMemoryBarrier", nullptr, nullptr, "-", "-", EShLangComputeMask }, + { "GroupMemoryBarrierWithGroupSync", nullptr, nullptr, "-", "-", EShLangComputeMask }, + { "InterlockedAdd", "-", "-", "SVM,,>", "UI,,", EShLangFragmentMask | EShLangComputeMask }, + { "InterlockedAnd", "-", "-", "SVM,,>", "UI,,", EShLangFragmentMask | EShLangComputeMask }, + { "InterlockedCompareExchange", "-", "-", "SVM,,,>", "UI,,,", EShLangFragmentMask | EShLangComputeMask }, + { "InterlockedCompareStore", "-", "-", "SVM,,", "UI,,", EShLangFragmentMask | EShLangComputeMask }, + { "InterlockedExchange", "-", "-", "SVM,,>", "UI,,", EShLangFragmentMask | EShLangComputeMask }, + { "InterlockedMax", "-", "-", "SVM,,>", "UI,,", EShLangFragmentMask | EShLangComputeMask }, + { "InterlockedMin", "-", "-", "SVM,,>", "UI,,", EShLangFragmentMask | EShLangComputeMask }, + { "InterlockedOr", "-", "-", "SVM,,>", "UI,,", EShLangFragmentMask | EShLangComputeMask }, + { "InterlockedXor", "-", "-", "SVM,,>", "UI,,", EShLangFragmentMask | EShLangComputeMask }, + { "isfinite", nullptr, "B" , "SVM", "F", EShLangAll }, + { "isinf", nullptr, "B" , "SVM", "F", EShLangAll }, + { "isnan", nullptr, "B" , "SVM", "F", EShLangAll }, + { "ldexp", nullptr, nullptr, "SVM,", "F,", EShLangAll }, + { "length", "S", "F", "V", "F", EShLangAll }, + { "lit", "V4", "F", "S,,", "F,,", EShLangAll }, + { "log", nullptr, nullptr, "SVM", "F", EShLangAll }, + { "log10", nullptr, nullptr, "SVM", "F", EShLangAll }, + { "log2", nullptr, nullptr, "SVM", "F", EShLangAll }, + { "mad", nullptr, nullptr, "SVM,,", "DFUI,,", EShLangAll }, + { "max", nullptr, nullptr, "SVM,", "FI,", EShLangAll }, + { "min", nullptr, nullptr, "SVM,", "FI,", EShLangAll }, + { "modf", nullptr, nullptr, "SVM,>", "FI,", EShLangAll }, + { "msad4", "V4", "U", "S,V2,V4", "U,,", EShLangAll }, + // TODO: fix matrix return size for non-square mats used with mul opcode + { "mul", "S", nullptr, "S,S", "FI,", EShLangAll }, + { "mul", "V", nullptr, "S,V", "FI,", EShLangAll }, + { "mul", "M", nullptr, "S,M", "FI,", EShLangAll }, + { "mul", "V", nullptr, "V,S", "FI,", EShLangAll }, + { "mul", "S", nullptr, "V,V", "FI,", EShLangAll }, + { "mul", "V", nullptr, "V,M", "FI,", EShLangAll }, + { "mul", "M", nullptr, "M,S", "FI,", EShLangAll }, + { "mul", "V", nullptr, "M,V", "FI,", EShLangAll }, + { "mul", "M", nullptr, "M,M", "FI,", EShLangAll }, + { "noise", "S", "F", "V", "F", EShLangFragmentMask }, + { "normalize", nullptr, nullptr, "V", "F", EShLangAll }, + { "pow", nullptr, nullptr, "SVM,", "F,", EShLangAll }, + // { "printf", "-", "-", "", "", EShLangAll }, TODO: varargs + { "Process2DQuadTessFactorsAvg", "-", "-", "V4,V2,>V4,>V2,>V2", "F,,,,", EShLangTessControlMask }, + { "Process2DQuadTessFactorsMax", "-", "-", "V4,V2,>V4,>V2,>V2", "F,,,,", EShLangTessControlMask }, + { "Process2DQuadTessFactorsMin", "-", "-", "V4,V2,>V4,>V2,>V2", "F,,,,", EShLangTessControlMask }, + { "ProcessIsolineTessFactors", "-", "-", "S,,>,>", "F,,,", EShLangTessControlMask }, + { "ProcessQuadTessFactorsAvg", "-", "-", "V4,S,>V4,>V2,>V2", "F,,,,", EShLangTessControlMask }, + { "ProcessQuadTessFactorsMax", "-", "-", "V4,S,>V4,>V2,>V2", "F,,,,", EShLangTessControlMask }, + { "ProcessQuadTessFactorsMin", "-", "-", "V4,S,>V4,>V2,>V2", "F,,,,", EShLangTessControlMask }, + { "ProcessTriTessFactorsAvg", "-", "-", "V3,S,>V3,>S,>S", "F,,,,", EShLangTessControlMask }, + { "ProcessTriTessFactorsMax", "-", "-", "V3,S,>V3,>S,>S", "F,,,,", EShLangTessControlMask }, + { "ProcessTriTessFactorsMin", "-", "-", "V3,S,>V3,>S,>S", "F,,,,", EShLangTessControlMask }, + { "radians", nullptr, nullptr, "SVM", "F", EShLangAll }, + { "rcp", nullptr, nullptr, "SVM", "FD", EShLangAll }, + { "reflect", nullptr, nullptr, "V,", "F,", EShLangAll }, + { "refract", nullptr, nullptr, "V,V,S", "F,,", EShLangAll }, + { "reversebits", nullptr, nullptr, "SV", "U", EShLangAll }, + { "round", nullptr, nullptr, "SVM", "F", EShLangAll }, + { "rsqrt", nullptr, nullptr, "SVM", "F", EShLangAll }, + { "saturate", nullptr, nullptr , "SVM", "F", EShLangAll }, + { "sign", nullptr, nullptr, "SVM", "FI", EShLangAll }, + { "sin", nullptr, nullptr, "SVM", "F", EShLangAll }, + { "sincos", "-", "-", "SVM,>,>", "F,,", EShLangAll }, + { "sinh", nullptr, nullptr, "SVM", "F", EShLangAll }, + { "smoothstep", nullptr, nullptr, "SVM,,", "F,,", EShLangAll }, + { "sqrt", nullptr, nullptr, "SVM", "F", EShLangAll }, + { "step", nullptr, nullptr, "SVM,", "F,", EShLangAll }, + { "tan", nullptr, nullptr, "SVM", "F", EShLangAll }, + { "tanh", nullptr, nullptr, "SVM", "F", EShLangAll }, + { "tex1D", "V4", "F", "S1,S", "S,F", EShLangFragmentMask }, + { "tex1D", "V4", "F", "S1,S,V1,V1", "S,F,F,F",EShLangFragmentMask }, + { "tex1Dbias", "V4", "F", "S1,V4", "S,F", EShLangFragmentMask }, + { "tex1Dgrad", "V4", "F", "S1,V1,V1,V1","S,F,F,F",EShLangFragmentMask }, + { "tex1Dlod", "V4", "F", "S1,V4", "S,F", EShLangFragmentMask }, + { "tex1Dproj", "V4", "F", "S1,V4", "S,F", EShLangFragmentMask }, + { "tex2D", "V4", "F", "S2,V2", "S,F", EShLangFragmentMask }, + { "tex2D", "V4", "F", "S2,V2,V2,V2","S,F,F,F",EShLangFragmentMask }, + { "tex2Dbias", "V4", "F", "S2,V4", "S,F", EShLangFragmentMask }, + { "tex2Dgrad", "V4", "F", "S2,V2,V2,V2","S,F,F,F",EShLangFragmentMask }, + { "tex2Dlod", "V4", "F", "S2,V4", "S,F", EShLangFragmentMask }, + { "tex2Dproj", "V4", "F", "S2,V4", "S,F", EShLangFragmentMask }, + { "tex3D", "V4", "F", "S3,V3", "S,F", EShLangFragmentMask }, + { "tex3D", "V4", "F", "S3,V3,V3,V3","S,F,F,F",EShLangFragmentMask }, + { "tex3Dbias", "V4", "F", "S3,V4", "S,F", EShLangFragmentMask }, + { "tex3Dgrad", "V4", "F", "S3,V3,V3,V3","S,F,F,F",EShLangFragmentMask }, + { "tex3Dlod", "V4", "F", "S3,V4", "S,F", EShLangFragmentMask }, + { "tex3Dproj", "V4", "F", "S3,V4", "S,F", EShLangFragmentMask }, + { "texCUBE", "V4", "F", "S4,V3", "S,F", EShLangFragmentMask }, + { "texCUBE", "V4", "F", "S4,V3,V3,V3","S,F,F,F",EShLangFragmentMask }, + { "texCUBEbias", "V4", "F", "S4,V4", "S,F", EShLangFragmentMask }, + { "texCUBEgrad", "V4", "F", "S4,V3,V3,V3","S,F,F,F",EShLangFragmentMask }, + { "texCUBElod", "V4", "F", "S4,V4", "S,F", EShLangFragmentMask }, + { "texCUBEproj", "V4", "F", "S4,V4", "S,F", EShLangFragmentMask }, + { "transpose", "^M", nullptr, "M", "F", EShLangAll }, + { "trunc", nullptr, nullptr, "SVM", "F", EShLangAll }, + + // 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 }, + }; + + // Set this to true to avoid generating prototypes that will be invalid for the GLSL parser. + // TODO: turn it off (and remove the code) when the HLSL parser can be used to parse builtins. + static const bool skipInvalidGlsl = true; + + // Create prototypes for the intrinsics. TODO: Avoid ranged based for until all compilers can handle it. + for (int icount = 0; hlslIntrinsics[icount].name; ++icount) { + const auto& intrinsic = hlslIntrinsics[icount]; + + for (int stage = 0; stage < EShLangCount; ++stage) { // for each stage... + if ((intrinsic.stage & (1<<stage)) == 0) // skip inapplicable stages + continue; + + // reference to either the common builtins, or stage specific builtins. + TString& s = (intrinsic.stage == EShLangAll) ? commonBuiltins : stageBuiltins[stage]; + + for (const char* argOrder = intrinsic.argOrder; !IsEndOfArg(argOrder); ++argOrder) { // for each order... + const int fixedVecSize = isdigit(argOrder[1]) ? (argOrder[1] - '0') : 0; + + // calculate min and max vector and matrix dimensions + int dim0Min = 1; + int dim0Max = 1; + int dim1Min = 1; + int dim1Max = 1; + + FindVectorMatrixBounds(argOrder, fixedVecSize, dim0Min, dim0Max, dim1Min, dim1Max); + + for (const char* argType = intrinsic.argType; !IsEndOfArg(argType); ++argType) { // for each type... + for (int dim0 = dim0Min; dim0 <= dim0Max; ++dim0) { // for each dim 0... + for (int dim1 = dim1Min; dim1 <= dim1Max; ++dim1) { // for each dim 1... + const char* retOrder = intrinsic.retOrder ? intrinsic.retOrder : argOrder; + const char* retType = intrinsic.retType ? intrinsic.retType : argType; + + if (skipInvalidGlsl && !IsValidGlsl(intrinsic.name, *retOrder, *retType, *argOrder, *argType, + dim0, dim1, dim0Max, dim1Max)) + continue; + + AppendTypeName(s, retOrder, retType, dim0, dim1); // add return type + s.append(" "); // space between type and name + s.append(intrinsic.name); // intrinsic name + s.append("("); // open paren + + // Append argument types, if any. + for (int arg = 0; ; ++arg) { + const char* nthArgOrder(NthArg(argOrder, arg)); + const char* nthArgType(NthArg(argType, arg)); + + if (nthArgOrder == nullptr || nthArgType == nullptr) + break; + + s.append(arg > 0 ? ", ": ""); // comma separator if needed + + if (*nthArgOrder == '>') { // output params + ++nthArgOrder; + s.append("out "); + } else if (*nthArgOrder == '<') { // input params + ++nthArgOrder; + s.append("in "); + } + + // Comma means use the 1st argument order and type. + if (*nthArgOrder == ',' || *nthArgOrder == '\0') nthArgOrder = argOrder; + if (*nthArgType == ',' || *nthArgType == '\0') nthArgType = argType; + + AppendTypeName(s, nthArgOrder, nthArgType, dim0, dim1); // Add first argument + } + + s.append(");\n"); // close paren and trailing semicolon + } + } + } + + if (fixedVecSize > 0) // skip over number for fixed size vectors + ++argOrder; + } + + if (intrinsic.stage == EShLangAll) // common builtins are only added once. + break; + } + } + + // printf("Common:\n%s\n", getCommonString().c_str()); + // printf("Frag:\n%s\n", getStageString(EShLangFragment).c_str()); + // printf("Vertex:\n%s\n", getStageString(EShLangVertex).c_str()); + // printf("Geo:\n%s\n", getStageString(EShLangGeometry).c_str()); + // printf("TessCtrl:\n%s\n", getStageString(EShLangTessControl).c_str()); + // printf("TessEval:\n%s\n", getStageString(EShLangTessEvaluation).c_str()); + // printf("Compute:\n%s\n", getStageString(EShLangCompute).c_str()); +} + +// +// Add context-dependent built-in functions and variables that are present +// for the given version and profile. All the results are put into just the +// commonBuiltins, because it is called for just a specific stage. So, +// add stage-specific entries to the commonBuiltins, and only if that stage +// was requested. +// +void TBuiltInParseablesHlsl::initialize(const TBuiltInResource &resources, int version, EProfile profile, int spv, + int vulkan, EShLanguage language) +{ +} + + +// +// Finish adding/processing context-independent built-in symbols. +// 1) Programmatically add symbols that could not be added by simple text strings above. +// 2) Map built-in functions to operators, for those that will turn into an operation node +// instead of remaining a function call. +// 3) Tag extension-related symbols added to their base version with their extensions, so +// that if an early version has the extension turned off, there is an error reported on use. +// +void TBuiltInParseablesHlsl::identifyBuiltIns(int version, EProfile profile, int spv, int vulkan, EShLanguage language, + TSymbolTable& symbolTable) +{ + // symbolTable.relateToOperator("abort", EOpAbort); + symbolTable.relateToOperator("abs", EOpAbs); + symbolTable.relateToOperator("acos", EOpAcos); + symbolTable.relateToOperator("all", EOpAll); + // symbolTable.relateToOperator("AllMemoryBarrier"); + // symbolTable.relateToOperator("AllMemoryBarrierWithGroupSync"); + symbolTable.relateToOperator("any", EOpAny); + // symbolTable.relateToOperator("asdouble"); + // symbolTable.relateToOperator("asfloat"); + symbolTable.relateToOperator("asin", EOpAsin); + // symbolTable.relateToOperator("asint"); + // symbolTable.relateToOperator("asuint"); + symbolTable.relateToOperator("atan", EOpAtan); + symbolTable.relateToOperator("atan2", EOpAtan); + symbolTable.relateToOperator("ceil", EOpCeil); + // symbolTable.relateToOperator("CheckAccessFullyMapped"); + symbolTable.relateToOperator("clamp", EOpClamp); + symbolTable.relateToOperator("clip", EOpClip); + symbolTable.relateToOperator("cos", EOpCos); + symbolTable.relateToOperator("cosh", EOpCosh); + symbolTable.relateToOperator("countbits", EOpBitCount); + symbolTable.relateToOperator("cross", EOpCross); + // symbolTable.relateToOperator("D3DCOLORtoUBYTE4", EOpD3DCOLORtoUBYTE4); + symbolTable.relateToOperator("ddx", EOpDPdx); + symbolTable.relateToOperator("ddx_coarse", EOpDPdxCoarse); + symbolTable.relateToOperator("ddx_fine", EOpDPdxFine); + symbolTable.relateToOperator("ddy", EOpDPdy); + symbolTable.relateToOperator("ddy_coarse", EOpDPdyCoarse); + symbolTable.relateToOperator("ddy_fine", EOpDPdyFine); + symbolTable.relateToOperator("degrees", EOpDegrees); + symbolTable.relateToOperator("determinant", EOpDeterminant); + // symbolTable.relateToOperator("DeviceMemoryBarrier"); + // symbolTable.relateToOperator("DeviceMemoryBarrierWithGroupSync"); + symbolTable.relateToOperator("distance", EOpDistance); + symbolTable.relateToOperator("dot", EOpDot); + symbolTable.relateToOperator("dst", EOpDst); + // symbolTable.relateToOperator("errorf"); + symbolTable.relateToOperator("EvaluateAttributeAtCentroid", EOpInterpolateAtCentroid); + symbolTable.relateToOperator("EvaluateAttributeAtSample", EOpInterpolateAtSample); + // symbolTable.relateToOperator("EvaluateAttributeSnapped"); // TODO: hsnflr positions. new op? + symbolTable.relateToOperator("exp", EOpExp); + symbolTable.relateToOperator("exp2", EOpExp2); + // symbolTable.relateToOperator("f16tof32"); + // symbolTable.relateToOperator("f32tof16"); + symbolTable.relateToOperator("faceforward", EOpFaceForward); + symbolTable.relateToOperator("firstbithigh", EOpFindMSB); + symbolTable.relateToOperator("firstbitlow", EOpFindLSB); + symbolTable.relateToOperator("floor", EOpFloor); + symbolTable.relateToOperator("fma", EOpFma); + symbolTable.relateToOperator("fmod", EOpMod); + symbolTable.relateToOperator("frac", EOpFract); + symbolTable.relateToOperator("frexp", EOpFrexp); + symbolTable.relateToOperator("fwidth", EOpFwidth); + // symbolTable.relateToOperator("GetRenderTargetSampleCount"); + // symbolTable.relateToOperator("GetRenderTargetSamplePosition"); + // symbolTable.relateToOperator("GroupMemoryBarrier"); + // symbolTable.relateToOperator("GroupMemoryBarrierWithGroupSync"); + // symbolTable.relateToOperator("InterlockedAdd"); + // symbolTable.relateToOperator("InterlockedAnd"); + // symbolTable.relateToOperator("InterlockedCompareExchange"); + // symbolTable.relateToOperator("InterlockedCompareStore"); + // symbolTable.relateToOperator("InterlockedExchange"); + // symbolTable.relateToOperator("InterlockedMax"); + // symbolTable.relateToOperator("InterlockedMin"); + // symbolTable.relateToOperator("InterlockedOr"); + // symbolTable.relateToOperator("InterlockedXor"); + symbolTable.relateToOperator("isfinite", EOpIsFinite); + symbolTable.relateToOperator("isinf", EOpIsInf); + symbolTable.relateToOperator("isnan", EOpIsNan); + symbolTable.relateToOperator("ldexp", EOpLdexp); + symbolTable.relateToOperator("length", EOpLength); + // symbolTable.relateToOperator("lit"); + symbolTable.relateToOperator("log", EOpLog); + symbolTable.relateToOperator("log10", EOpLog10); + symbolTable.relateToOperator("log2", EOpLog2); + // symbolTable.relateToOperator("mad"); + symbolTable.relateToOperator("max", EOpMax); + symbolTable.relateToOperator("min", EOpMin); + symbolTable.relateToOperator("modf", EOpModf); + // symbolTable.relateToOperator("msad4", EOpMsad4); + symbolTable.relateToOperator("mul", EOpGenMul); + // symbolTable.relateToOperator("noise", EOpNoise); // TODO: check return type + symbolTable.relateToOperator("normalize", EOpNormalize); + symbolTable.relateToOperator("pow", EOpPow); + // symbolTable.relateToOperator("printf"); + // symbolTable.relateToOperator("Process2DQuadTessFactorsAvg"); + // symbolTable.relateToOperator("Process2DQuadTessFactorsMax"); + // symbolTable.relateToOperator("Process2DQuadTessFactorsMin"); + // symbolTable.relateToOperator("ProcessIsolineTessFactors"); + // symbolTable.relateToOperator("ProcessQuadTessFactorsAvg"); + // symbolTable.relateToOperator("ProcessQuadTessFactorsMax"); + // symbolTable.relateToOperator("ProcessQuadTessFactorsMin"); + // symbolTable.relateToOperator("ProcessTriTessFactorsAvg"); + // symbolTable.relateToOperator("ProcessTriTessFactorsMax"); + // symbolTable.relateToOperator("ProcessTriTessFactorsMin"); + symbolTable.relateToOperator("radians", EOpRadians); + symbolTable.relateToOperator("rcp", EOpRcp); + symbolTable.relateToOperator("reflect", EOpReflect); + symbolTable.relateToOperator("refract", EOpRefract); + symbolTable.relateToOperator("reversebits", EOpBitFieldReverse); + symbolTable.relateToOperator("round", EOpRoundEven); + symbolTable.relateToOperator("rsqrt", EOpInverseSqrt); + symbolTable.relateToOperator("saturate", EOpSaturate); + symbolTable.relateToOperator("sign", EOpSign); + symbolTable.relateToOperator("sin", EOpSin); + symbolTable.relateToOperator("sincos", EOpSinCos); + symbolTable.relateToOperator("sinh", EOpSinh); + symbolTable.relateToOperator("smoothstep", EOpSmoothStep); + symbolTable.relateToOperator("sqrt", EOpSqrt); + symbolTable.relateToOperator("step", EOpStep); + symbolTable.relateToOperator("tan", EOpTan); + symbolTable.relateToOperator("tanh", EOpTanh); + symbolTable.relateToOperator("tex1D", EOpTexture); + // symbolTable.relateToOperator("tex1Dbias", // TODO: + symbolTable.relateToOperator("tex1Dgrad", EOpTextureGrad); + symbolTable.relateToOperator("tex1Dlod", EOpTextureLod); + symbolTable.relateToOperator("tex1Dproj", EOpTextureProj); + symbolTable.relateToOperator("tex2D", EOpTexture); + // symbolTable.relateToOperator("tex2Dbias", // TODO: + symbolTable.relateToOperator("tex2Dgrad", EOpTextureGrad); + symbolTable.relateToOperator("tex2Dlod", EOpTextureLod); + // symbolTable.relateToOperator("tex2Dproj", EOpTextureProj); + symbolTable.relateToOperator("tex3D", EOpTexture); + // symbolTable.relateToOperator("tex3Dbias"); // TODO + symbolTable.relateToOperator("tex3Dgrad", EOpTextureGrad); + symbolTable.relateToOperator("tex3Dlod", EOpTextureLod); + // symbolTable.relateToOperator("tex3Dproj", EOpTextureProj); + symbolTable.relateToOperator("texCUBE", EOpTexture); + // symbolTable.relateToOperator("texCUBEbias", // TODO + symbolTable.relateToOperator("texCUBEgrad", EOpTextureGrad); + symbolTable.relateToOperator("texCUBElod", EOpTextureLod); + // symbolTable.relateToOperator("texCUBEproj", EOpTextureProj); + symbolTable.relateToOperator("transpose", EOpTranspose); + symbolTable.relateToOperator("trunc", EOpTrunc); +} + +// +// Add context-dependent (resource-specific) built-ins not handled by the above. These +// would be ones that need to be programmatically added because they cannot +// be added by simple text strings. For these, also +// 1) Map built-in functions to operators, for those that will turn into an operation node +// instead of remaining a function call. +// 2) Tag extension-related symbols added to their base version with their extensions, so +// that if an early version has the extension turned off, there is an error reported on use. +// +void TBuiltInParseablesHlsl::identifyBuiltIns(int version, EProfile profile, int spv, int /*vulkan*/, EShLanguage language, + TSymbolTable& symbolTable, const TBuiltInResource &resources) +{ +} + + +} // end namespace glslang |