mirror of
https://github.com/encounter/dawn-cmake.git
synced 2025-08-24 20:52:19 +00:00
9543f74739
This CL moves `sem::BuiltinType` to `builtin::Function`. This makes it available for use in the IR. The `Function` name better maps to the usage in that it contains the builtin functions. Bug: tint:1834 Change-Id: Ic1a26525d7845d79eb6239bdeb2b73e05f586c24 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/122606 Reviewed-by: Ben Clayton <bclayton@google.com> Kokoro: Kokoro <noreply+kokoro@google.com> Commit-Queue: Dan Sinclair <dsinclair@chromium.org>
615 lines
17 KiB
C++
615 lines
17 KiB
C++
// Copyright 2023 The Tint Authors.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// File generated by tools/src/cmd/gen
|
|
// using the template:
|
|
// src/tint/builtin/function.cc.tmpl
|
|
//
|
|
// Do not modify this file directly
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include "src/tint/builtin/function.h"
|
|
|
|
namespace tint::builtin {
|
|
|
|
Function ParseFunction(const std::string& name) {
|
|
if (name == "abs") {
|
|
return Function::kAbs;
|
|
}
|
|
if (name == "acos") {
|
|
return Function::kAcos;
|
|
}
|
|
if (name == "acosh") {
|
|
return Function::kAcosh;
|
|
}
|
|
if (name == "all") {
|
|
return Function::kAll;
|
|
}
|
|
if (name == "any") {
|
|
return Function::kAny;
|
|
}
|
|
if (name == "arrayLength") {
|
|
return Function::kArrayLength;
|
|
}
|
|
if (name == "asin") {
|
|
return Function::kAsin;
|
|
}
|
|
if (name == "asinh") {
|
|
return Function::kAsinh;
|
|
}
|
|
if (name == "atan") {
|
|
return Function::kAtan;
|
|
}
|
|
if (name == "atan2") {
|
|
return Function::kAtan2;
|
|
}
|
|
if (name == "atanh") {
|
|
return Function::kAtanh;
|
|
}
|
|
if (name == "ceil") {
|
|
return Function::kCeil;
|
|
}
|
|
if (name == "clamp") {
|
|
return Function::kClamp;
|
|
}
|
|
if (name == "cos") {
|
|
return Function::kCos;
|
|
}
|
|
if (name == "cosh") {
|
|
return Function::kCosh;
|
|
}
|
|
if (name == "countLeadingZeros") {
|
|
return Function::kCountLeadingZeros;
|
|
}
|
|
if (name == "countOneBits") {
|
|
return Function::kCountOneBits;
|
|
}
|
|
if (name == "countTrailingZeros") {
|
|
return Function::kCountTrailingZeros;
|
|
}
|
|
if (name == "cross") {
|
|
return Function::kCross;
|
|
}
|
|
if (name == "degrees") {
|
|
return Function::kDegrees;
|
|
}
|
|
if (name == "determinant") {
|
|
return Function::kDeterminant;
|
|
}
|
|
if (name == "distance") {
|
|
return Function::kDistance;
|
|
}
|
|
if (name == "dot") {
|
|
return Function::kDot;
|
|
}
|
|
if (name == "dot4I8Packed") {
|
|
return Function::kDot4I8Packed;
|
|
}
|
|
if (name == "dot4U8Packed") {
|
|
return Function::kDot4U8Packed;
|
|
}
|
|
if (name == "dpdx") {
|
|
return Function::kDpdx;
|
|
}
|
|
if (name == "dpdxCoarse") {
|
|
return Function::kDpdxCoarse;
|
|
}
|
|
if (name == "dpdxFine") {
|
|
return Function::kDpdxFine;
|
|
}
|
|
if (name == "dpdy") {
|
|
return Function::kDpdy;
|
|
}
|
|
if (name == "dpdyCoarse") {
|
|
return Function::kDpdyCoarse;
|
|
}
|
|
if (name == "dpdyFine") {
|
|
return Function::kDpdyFine;
|
|
}
|
|
if (name == "exp") {
|
|
return Function::kExp;
|
|
}
|
|
if (name == "exp2") {
|
|
return Function::kExp2;
|
|
}
|
|
if (name == "extractBits") {
|
|
return Function::kExtractBits;
|
|
}
|
|
if (name == "faceForward") {
|
|
return Function::kFaceForward;
|
|
}
|
|
if (name == "firstLeadingBit") {
|
|
return Function::kFirstLeadingBit;
|
|
}
|
|
if (name == "firstTrailingBit") {
|
|
return Function::kFirstTrailingBit;
|
|
}
|
|
if (name == "floor") {
|
|
return Function::kFloor;
|
|
}
|
|
if (name == "fma") {
|
|
return Function::kFma;
|
|
}
|
|
if (name == "fract") {
|
|
return Function::kFract;
|
|
}
|
|
if (name == "frexp") {
|
|
return Function::kFrexp;
|
|
}
|
|
if (name == "fwidth") {
|
|
return Function::kFwidth;
|
|
}
|
|
if (name == "fwidthCoarse") {
|
|
return Function::kFwidthCoarse;
|
|
}
|
|
if (name == "fwidthFine") {
|
|
return Function::kFwidthFine;
|
|
}
|
|
if (name == "insertBits") {
|
|
return Function::kInsertBits;
|
|
}
|
|
if (name == "inverseSqrt") {
|
|
return Function::kInverseSqrt;
|
|
}
|
|
if (name == "ldexp") {
|
|
return Function::kLdexp;
|
|
}
|
|
if (name == "length") {
|
|
return Function::kLength;
|
|
}
|
|
if (name == "log") {
|
|
return Function::kLog;
|
|
}
|
|
if (name == "log2") {
|
|
return Function::kLog2;
|
|
}
|
|
if (name == "max") {
|
|
return Function::kMax;
|
|
}
|
|
if (name == "min") {
|
|
return Function::kMin;
|
|
}
|
|
if (name == "mix") {
|
|
return Function::kMix;
|
|
}
|
|
if (name == "modf") {
|
|
return Function::kModf;
|
|
}
|
|
if (name == "normalize") {
|
|
return Function::kNormalize;
|
|
}
|
|
if (name == "pack2x16float") {
|
|
return Function::kPack2X16Float;
|
|
}
|
|
if (name == "pack2x16snorm") {
|
|
return Function::kPack2X16Snorm;
|
|
}
|
|
if (name == "pack2x16unorm") {
|
|
return Function::kPack2X16Unorm;
|
|
}
|
|
if (name == "pack4x8snorm") {
|
|
return Function::kPack4X8Snorm;
|
|
}
|
|
if (name == "pack4x8unorm") {
|
|
return Function::kPack4X8Unorm;
|
|
}
|
|
if (name == "pow") {
|
|
return Function::kPow;
|
|
}
|
|
if (name == "quantizeToF16") {
|
|
return Function::kQuantizeToF16;
|
|
}
|
|
if (name == "radians") {
|
|
return Function::kRadians;
|
|
}
|
|
if (name == "reflect") {
|
|
return Function::kReflect;
|
|
}
|
|
if (name == "refract") {
|
|
return Function::kRefract;
|
|
}
|
|
if (name == "reverseBits") {
|
|
return Function::kReverseBits;
|
|
}
|
|
if (name == "round") {
|
|
return Function::kRound;
|
|
}
|
|
if (name == "saturate") {
|
|
return Function::kSaturate;
|
|
}
|
|
if (name == "select") {
|
|
return Function::kSelect;
|
|
}
|
|
if (name == "sign") {
|
|
return Function::kSign;
|
|
}
|
|
if (name == "sin") {
|
|
return Function::kSin;
|
|
}
|
|
if (name == "sinh") {
|
|
return Function::kSinh;
|
|
}
|
|
if (name == "smoothstep") {
|
|
return Function::kSmoothstep;
|
|
}
|
|
if (name == "sqrt") {
|
|
return Function::kSqrt;
|
|
}
|
|
if (name == "step") {
|
|
return Function::kStep;
|
|
}
|
|
if (name == "storageBarrier") {
|
|
return Function::kStorageBarrier;
|
|
}
|
|
if (name == "tan") {
|
|
return Function::kTan;
|
|
}
|
|
if (name == "tanh") {
|
|
return Function::kTanh;
|
|
}
|
|
if (name == "transpose") {
|
|
return Function::kTranspose;
|
|
}
|
|
if (name == "trunc") {
|
|
return Function::kTrunc;
|
|
}
|
|
if (name == "unpack2x16float") {
|
|
return Function::kUnpack2X16Float;
|
|
}
|
|
if (name == "unpack2x16snorm") {
|
|
return Function::kUnpack2X16Snorm;
|
|
}
|
|
if (name == "unpack2x16unorm") {
|
|
return Function::kUnpack2X16Unorm;
|
|
}
|
|
if (name == "unpack4x8snorm") {
|
|
return Function::kUnpack4X8Snorm;
|
|
}
|
|
if (name == "unpack4x8unorm") {
|
|
return Function::kUnpack4X8Unorm;
|
|
}
|
|
if (name == "workgroupBarrier") {
|
|
return Function::kWorkgroupBarrier;
|
|
}
|
|
if (name == "workgroupUniformLoad") {
|
|
return Function::kWorkgroupUniformLoad;
|
|
}
|
|
if (name == "textureDimensions") {
|
|
return Function::kTextureDimensions;
|
|
}
|
|
if (name == "textureGather") {
|
|
return Function::kTextureGather;
|
|
}
|
|
if (name == "textureGatherCompare") {
|
|
return Function::kTextureGatherCompare;
|
|
}
|
|
if (name == "textureNumLayers") {
|
|
return Function::kTextureNumLayers;
|
|
}
|
|
if (name == "textureNumLevels") {
|
|
return Function::kTextureNumLevels;
|
|
}
|
|
if (name == "textureNumSamples") {
|
|
return Function::kTextureNumSamples;
|
|
}
|
|
if (name == "textureSample") {
|
|
return Function::kTextureSample;
|
|
}
|
|
if (name == "textureSampleBias") {
|
|
return Function::kTextureSampleBias;
|
|
}
|
|
if (name == "textureSampleCompare") {
|
|
return Function::kTextureSampleCompare;
|
|
}
|
|
if (name == "textureSampleCompareLevel") {
|
|
return Function::kTextureSampleCompareLevel;
|
|
}
|
|
if (name == "textureSampleGrad") {
|
|
return Function::kTextureSampleGrad;
|
|
}
|
|
if (name == "textureSampleLevel") {
|
|
return Function::kTextureSampleLevel;
|
|
}
|
|
if (name == "textureSampleBaseClampToEdge") {
|
|
return Function::kTextureSampleBaseClampToEdge;
|
|
}
|
|
if (name == "textureStore") {
|
|
return Function::kTextureStore;
|
|
}
|
|
if (name == "textureLoad") {
|
|
return Function::kTextureLoad;
|
|
}
|
|
if (name == "atomicLoad") {
|
|
return Function::kAtomicLoad;
|
|
}
|
|
if (name == "atomicStore") {
|
|
return Function::kAtomicStore;
|
|
}
|
|
if (name == "atomicAdd") {
|
|
return Function::kAtomicAdd;
|
|
}
|
|
if (name == "atomicSub") {
|
|
return Function::kAtomicSub;
|
|
}
|
|
if (name == "atomicMax") {
|
|
return Function::kAtomicMax;
|
|
}
|
|
if (name == "atomicMin") {
|
|
return Function::kAtomicMin;
|
|
}
|
|
if (name == "atomicAnd") {
|
|
return Function::kAtomicAnd;
|
|
}
|
|
if (name == "atomicOr") {
|
|
return Function::kAtomicOr;
|
|
}
|
|
if (name == "atomicXor") {
|
|
return Function::kAtomicXor;
|
|
}
|
|
if (name == "atomicExchange") {
|
|
return Function::kAtomicExchange;
|
|
}
|
|
if (name == "atomicCompareExchangeWeak") {
|
|
return Function::kAtomicCompareExchangeWeak;
|
|
}
|
|
if (name == "_tint_materialize") {
|
|
return Function::kTintMaterialize;
|
|
}
|
|
return Function::kNone;
|
|
}
|
|
|
|
const char* str(Function i) {
|
|
switch (i) {
|
|
case Function::kNone:
|
|
return "<none>";
|
|
case Function::kAbs:
|
|
return "abs";
|
|
case Function::kAcos:
|
|
return "acos";
|
|
case Function::kAcosh:
|
|
return "acosh";
|
|
case Function::kAll:
|
|
return "all";
|
|
case Function::kAny:
|
|
return "any";
|
|
case Function::kArrayLength:
|
|
return "arrayLength";
|
|
case Function::kAsin:
|
|
return "asin";
|
|
case Function::kAsinh:
|
|
return "asinh";
|
|
case Function::kAtan:
|
|
return "atan";
|
|
case Function::kAtan2:
|
|
return "atan2";
|
|
case Function::kAtanh:
|
|
return "atanh";
|
|
case Function::kCeil:
|
|
return "ceil";
|
|
case Function::kClamp:
|
|
return "clamp";
|
|
case Function::kCos:
|
|
return "cos";
|
|
case Function::kCosh:
|
|
return "cosh";
|
|
case Function::kCountLeadingZeros:
|
|
return "countLeadingZeros";
|
|
case Function::kCountOneBits:
|
|
return "countOneBits";
|
|
case Function::kCountTrailingZeros:
|
|
return "countTrailingZeros";
|
|
case Function::kCross:
|
|
return "cross";
|
|
case Function::kDegrees:
|
|
return "degrees";
|
|
case Function::kDeterminant:
|
|
return "determinant";
|
|
case Function::kDistance:
|
|
return "distance";
|
|
case Function::kDot:
|
|
return "dot";
|
|
case Function::kDot4I8Packed:
|
|
return "dot4I8Packed";
|
|
case Function::kDot4U8Packed:
|
|
return "dot4U8Packed";
|
|
case Function::kDpdx:
|
|
return "dpdx";
|
|
case Function::kDpdxCoarse:
|
|
return "dpdxCoarse";
|
|
case Function::kDpdxFine:
|
|
return "dpdxFine";
|
|
case Function::kDpdy:
|
|
return "dpdy";
|
|
case Function::kDpdyCoarse:
|
|
return "dpdyCoarse";
|
|
case Function::kDpdyFine:
|
|
return "dpdyFine";
|
|
case Function::kExp:
|
|
return "exp";
|
|
case Function::kExp2:
|
|
return "exp2";
|
|
case Function::kExtractBits:
|
|
return "extractBits";
|
|
case Function::kFaceForward:
|
|
return "faceForward";
|
|
case Function::kFirstLeadingBit:
|
|
return "firstLeadingBit";
|
|
case Function::kFirstTrailingBit:
|
|
return "firstTrailingBit";
|
|
case Function::kFloor:
|
|
return "floor";
|
|
case Function::kFma:
|
|
return "fma";
|
|
case Function::kFract:
|
|
return "fract";
|
|
case Function::kFrexp:
|
|
return "frexp";
|
|
case Function::kFwidth:
|
|
return "fwidth";
|
|
case Function::kFwidthCoarse:
|
|
return "fwidthCoarse";
|
|
case Function::kFwidthFine:
|
|
return "fwidthFine";
|
|
case Function::kInsertBits:
|
|
return "insertBits";
|
|
case Function::kInverseSqrt:
|
|
return "inverseSqrt";
|
|
case Function::kLdexp:
|
|
return "ldexp";
|
|
case Function::kLength:
|
|
return "length";
|
|
case Function::kLog:
|
|
return "log";
|
|
case Function::kLog2:
|
|
return "log2";
|
|
case Function::kMax:
|
|
return "max";
|
|
case Function::kMin:
|
|
return "min";
|
|
case Function::kMix:
|
|
return "mix";
|
|
case Function::kModf:
|
|
return "modf";
|
|
case Function::kNormalize:
|
|
return "normalize";
|
|
case Function::kPack2X16Float:
|
|
return "pack2x16float";
|
|
case Function::kPack2X16Snorm:
|
|
return "pack2x16snorm";
|
|
case Function::kPack2X16Unorm:
|
|
return "pack2x16unorm";
|
|
case Function::kPack4X8Snorm:
|
|
return "pack4x8snorm";
|
|
case Function::kPack4X8Unorm:
|
|
return "pack4x8unorm";
|
|
case Function::kPow:
|
|
return "pow";
|
|
case Function::kQuantizeToF16:
|
|
return "quantizeToF16";
|
|
case Function::kRadians:
|
|
return "radians";
|
|
case Function::kReflect:
|
|
return "reflect";
|
|
case Function::kRefract:
|
|
return "refract";
|
|
case Function::kReverseBits:
|
|
return "reverseBits";
|
|
case Function::kRound:
|
|
return "round";
|
|
case Function::kSaturate:
|
|
return "saturate";
|
|
case Function::kSelect:
|
|
return "select";
|
|
case Function::kSign:
|
|
return "sign";
|
|
case Function::kSin:
|
|
return "sin";
|
|
case Function::kSinh:
|
|
return "sinh";
|
|
case Function::kSmoothstep:
|
|
return "smoothstep";
|
|
case Function::kSqrt:
|
|
return "sqrt";
|
|
case Function::kStep:
|
|
return "step";
|
|
case Function::kStorageBarrier:
|
|
return "storageBarrier";
|
|
case Function::kTan:
|
|
return "tan";
|
|
case Function::kTanh:
|
|
return "tanh";
|
|
case Function::kTranspose:
|
|
return "transpose";
|
|
case Function::kTrunc:
|
|
return "trunc";
|
|
case Function::kUnpack2X16Float:
|
|
return "unpack2x16float";
|
|
case Function::kUnpack2X16Snorm:
|
|
return "unpack2x16snorm";
|
|
case Function::kUnpack2X16Unorm:
|
|
return "unpack2x16unorm";
|
|
case Function::kUnpack4X8Snorm:
|
|
return "unpack4x8snorm";
|
|
case Function::kUnpack4X8Unorm:
|
|
return "unpack4x8unorm";
|
|
case Function::kWorkgroupBarrier:
|
|
return "workgroupBarrier";
|
|
case Function::kWorkgroupUniformLoad:
|
|
return "workgroupUniformLoad";
|
|
case Function::kTextureDimensions:
|
|
return "textureDimensions";
|
|
case Function::kTextureGather:
|
|
return "textureGather";
|
|
case Function::kTextureGatherCompare:
|
|
return "textureGatherCompare";
|
|
case Function::kTextureNumLayers:
|
|
return "textureNumLayers";
|
|
case Function::kTextureNumLevels:
|
|
return "textureNumLevels";
|
|
case Function::kTextureNumSamples:
|
|
return "textureNumSamples";
|
|
case Function::kTextureSample:
|
|
return "textureSample";
|
|
case Function::kTextureSampleBias:
|
|
return "textureSampleBias";
|
|
case Function::kTextureSampleCompare:
|
|
return "textureSampleCompare";
|
|
case Function::kTextureSampleCompareLevel:
|
|
return "textureSampleCompareLevel";
|
|
case Function::kTextureSampleGrad:
|
|
return "textureSampleGrad";
|
|
case Function::kTextureSampleLevel:
|
|
return "textureSampleLevel";
|
|
case Function::kTextureSampleBaseClampToEdge:
|
|
return "textureSampleBaseClampToEdge";
|
|
case Function::kTextureStore:
|
|
return "textureStore";
|
|
case Function::kTextureLoad:
|
|
return "textureLoad";
|
|
case Function::kAtomicLoad:
|
|
return "atomicLoad";
|
|
case Function::kAtomicStore:
|
|
return "atomicStore";
|
|
case Function::kAtomicAdd:
|
|
return "atomicAdd";
|
|
case Function::kAtomicSub:
|
|
return "atomicSub";
|
|
case Function::kAtomicMax:
|
|
return "atomicMax";
|
|
case Function::kAtomicMin:
|
|
return "atomicMin";
|
|
case Function::kAtomicAnd:
|
|
return "atomicAnd";
|
|
case Function::kAtomicOr:
|
|
return "atomicOr";
|
|
case Function::kAtomicXor:
|
|
return "atomicXor";
|
|
case Function::kAtomicExchange:
|
|
return "atomicExchange";
|
|
case Function::kAtomicCompareExchangeWeak:
|
|
return "atomicCompareExchangeWeak";
|
|
case Function::kTintMaterialize:
|
|
return "_tint_materialize";
|
|
}
|
|
return "<unknown>";
|
|
}
|
|
|
|
utils::StringStream& operator<<(utils::StringStream& out, Function i) {
|
|
out << str(i);
|
|
return out;
|
|
}
|
|
|
|
} // namespace tint::builtin
|