Move sem::BuiltinType to builtin::Function.
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>
diff --git a/src/tint/BUILD.gn b/src/tint/BUILD.gn
index 3b801f4..4c02044 100644
--- a/src/tint/BUILD.gn
+++ b/src/tint/BUILD.gn
@@ -651,8 +651,6 @@
"sem/builtin.h",
"sem/builtin_enum_expression.cc",
"sem/builtin_enum_expression.h",
- "sem/builtin_type.cc",
- "sem/builtin_type.h",
"sem/call.cc",
"sem/call.h",
"sem/call_target.cc",
@@ -736,6 +734,8 @@
"builtin/diagnostic_severity.h",
"builtin/extension.cc",
"builtin/extension.h",
+ "builtin/function.cc",
+ "builtin/function.h",
"builtin/interpolation_sampling.cc",
"builtin/interpolation_sampling.h",
"builtin/interpolation_type.cc",
diff --git a/src/tint/CMakeLists.txt b/src/tint/CMakeLists.txt
index 4ea36bb..bbaaa9f 100644
--- a/src/tint/CMakeLists.txt
+++ b/src/tint/CMakeLists.txt
@@ -564,12 +564,12 @@
tint_generated(builtin/diagnostic_rule BENCH TEST)
tint_generated(builtin/diagnostic_severity BENCH TEST)
tint_generated(builtin/extension BENCH TEST)
+tint_generated(builtin/function)
tint_generated(builtin/interpolation_sampling BENCH TEST)
tint_generated(builtin/interpolation_type BENCH TEST)
tint_generated(builtin/texel_format BENCH TEST)
tint_generated(resolver/ctor_conv_intrinsic)
-tint_generated(sem/builtin_type)
tint_generated(sem/parameter_usage)
if(UNIX)
diff --git a/src/tint/builtin/function.cc b/src/tint/builtin/function.cc
new file mode 100644
index 0000000..88e86b6
--- /dev/null
+++ b/src/tint/builtin/function.cc
@@ -0,0 +1,614 @@
+// 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
diff --git a/src/tint/builtin/function.cc.tmpl b/src/tint/builtin/function.cc.tmpl
new file mode 100644
index 0000000..e2729dc
--- /dev/null
+++ b/src/tint/builtin/function.cc.tmpl
@@ -0,0 +1,44 @@
+{{- /*
+--------------------------------------------------------------------------------
+Template file for use with tools/src/cmd/gen to generate function.cc
+
+To update the generated file, run:
+ ./tools/run gen
+
+See:
+* tools/src/cmd/gen for structures used by this template
+* https://golang.org/pkg/text/template/ for documentation on the template syntax
+--------------------------------------------------------------------------------
+*/ -}}
+
+#include "src/tint/builtin/function.h"
+
+namespace tint::builtin {
+
+Function ParseFunction(const std::string& name) {
+{{- range Sem.Builtins }}
+ if (name == "{{.Name}}") {
+ return Function::k{{PascalCase .Name}};
+ }
+{{- end }}
+ return Function::kNone;
+}
+
+const char* str(Function i) {
+ switch (i) {
+ case Function::kNone:
+ return "<none>";
+{{- range Sem.Builtins }}
+ case Function::k{{PascalCase .Name}}:
+ return "{{.Name}}";
+{{- end }}
+ }
+ return "<unknown>";
+}
+
+utils::StringStream& operator<<(utils::StringStream& out, Function i) {
+ out << str(i);
+ return out;
+}
+
+} // namespace tint::builtin
diff --git a/src/tint/builtin/function.h b/src/tint/builtin/function.h
new file mode 100644
index 0000000..3ccb341
--- /dev/null
+++ b/src/tint/builtin/function.h
@@ -0,0 +1,405 @@
+// 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.h.tmpl
+//
+// Do not modify this file directly
+////////////////////////////////////////////////////////////////////////////////
+
+#ifndef SRC_TINT_BUILTIN_FUNCTION_H_
+#define SRC_TINT_BUILTIN_FUNCTION_H_
+
+#include <string>
+
+#include "src/tint/utils/string_stream.h"
+
+// \cond DO_NOT_DOCUMENT
+namespace tint::builtin {
+
+/// Enumerator of all builtin functions
+enum class Function {
+ kNone = -1,
+ kAbs,
+ kAcos,
+ kAcosh,
+ kAll,
+ kAny,
+ kArrayLength,
+ kAsin,
+ kAsinh,
+ kAtan,
+ kAtan2,
+ kAtanh,
+ kCeil,
+ kClamp,
+ kCos,
+ kCosh,
+ kCountLeadingZeros,
+ kCountOneBits,
+ kCountTrailingZeros,
+ kCross,
+ kDegrees,
+ kDeterminant,
+ kDistance,
+ kDot,
+ kDot4I8Packed,
+ kDot4U8Packed,
+ kDpdx,
+ kDpdxCoarse,
+ kDpdxFine,
+ kDpdy,
+ kDpdyCoarse,
+ kDpdyFine,
+ kExp,
+ kExp2,
+ kExtractBits,
+ kFaceForward,
+ kFirstLeadingBit,
+ kFirstTrailingBit,
+ kFloor,
+ kFma,
+ kFract,
+ kFrexp,
+ kFwidth,
+ kFwidthCoarse,
+ kFwidthFine,
+ kInsertBits,
+ kInverseSqrt,
+ kLdexp,
+ kLength,
+ kLog,
+ kLog2,
+ kMax,
+ kMin,
+ kMix,
+ kModf,
+ kNormalize,
+ kPack2X16Float,
+ kPack2X16Snorm,
+ kPack2X16Unorm,
+ kPack4X8Snorm,
+ kPack4X8Unorm,
+ kPow,
+ kQuantizeToF16,
+ kRadians,
+ kReflect,
+ kRefract,
+ kReverseBits,
+ kRound,
+ kSaturate,
+ kSelect,
+ kSign,
+ kSin,
+ kSinh,
+ kSmoothstep,
+ kSqrt,
+ kStep,
+ kStorageBarrier,
+ kTan,
+ kTanh,
+ kTranspose,
+ kTrunc,
+ kUnpack2X16Float,
+ kUnpack2X16Snorm,
+ kUnpack2X16Unorm,
+ kUnpack4X8Snorm,
+ kUnpack4X8Unorm,
+ kWorkgroupBarrier,
+ kWorkgroupUniformLoad,
+ kTextureDimensions,
+ kTextureGather,
+ kTextureGatherCompare,
+ kTextureNumLayers,
+ kTextureNumLevels,
+ kTextureNumSamples,
+ kTextureSample,
+ kTextureSampleBias,
+ kTextureSampleCompare,
+ kTextureSampleCompareLevel,
+ kTextureSampleGrad,
+ kTextureSampleLevel,
+ kTextureSampleBaseClampToEdge,
+ kTextureStore,
+ kTextureLoad,
+ kAtomicLoad,
+ kAtomicStore,
+ kAtomicAdd,
+ kAtomicSub,
+ kAtomicMax,
+ kAtomicMin,
+ kAtomicAnd,
+ kAtomicOr,
+ kAtomicXor,
+ kAtomicExchange,
+ kAtomicCompareExchangeWeak,
+ kTintMaterialize,
+};
+
+/// Matches the Function by name
+/// @param name the builtin name to parse
+/// @returns the parsed Function, or Function::kNone if `name` did not
+/// match any builtin function.
+Function ParseFunction(const std::string& name);
+
+/// @returns the name of the builtin function type. The spelling, including
+/// case, matches the name in the WGSL spec.
+const char* str(Function i);
+
+/// Emits the name of the builtin function type. The spelling, including case,
+/// matches the name in the WGSL spec.
+utils::StringStream& operator<<(utils::StringStream& out, Function i);
+
+/// All builtin functions
+constexpr Function kFunctions[] = {
+ Function::kAbs,
+ Function::kAcos,
+ Function::kAcosh,
+ Function::kAll,
+ Function::kAny,
+ Function::kArrayLength,
+ Function::kAsin,
+ Function::kAsinh,
+ Function::kAtan,
+ Function::kAtan2,
+ Function::kAtanh,
+ Function::kCeil,
+ Function::kClamp,
+ Function::kCos,
+ Function::kCosh,
+ Function::kCountLeadingZeros,
+ Function::kCountOneBits,
+ Function::kCountTrailingZeros,
+ Function::kCross,
+ Function::kDegrees,
+ Function::kDeterminant,
+ Function::kDistance,
+ Function::kDot,
+ Function::kDot4I8Packed,
+ Function::kDot4U8Packed,
+ Function::kDpdx,
+ Function::kDpdxCoarse,
+ Function::kDpdxFine,
+ Function::kDpdy,
+ Function::kDpdyCoarse,
+ Function::kDpdyFine,
+ Function::kExp,
+ Function::kExp2,
+ Function::kExtractBits,
+ Function::kFaceForward,
+ Function::kFirstLeadingBit,
+ Function::kFirstTrailingBit,
+ Function::kFloor,
+ Function::kFma,
+ Function::kFract,
+ Function::kFrexp,
+ Function::kFwidth,
+ Function::kFwidthCoarse,
+ Function::kFwidthFine,
+ Function::kInsertBits,
+ Function::kInverseSqrt,
+ Function::kLdexp,
+ Function::kLength,
+ Function::kLog,
+ Function::kLog2,
+ Function::kMax,
+ Function::kMin,
+ Function::kMix,
+ Function::kModf,
+ Function::kNormalize,
+ Function::kPack2X16Float,
+ Function::kPack2X16Snorm,
+ Function::kPack2X16Unorm,
+ Function::kPack4X8Snorm,
+ Function::kPack4X8Unorm,
+ Function::kPow,
+ Function::kQuantizeToF16,
+ Function::kRadians,
+ Function::kReflect,
+ Function::kRefract,
+ Function::kReverseBits,
+ Function::kRound,
+ Function::kSaturate,
+ Function::kSelect,
+ Function::kSign,
+ Function::kSin,
+ Function::kSinh,
+ Function::kSmoothstep,
+ Function::kSqrt,
+ Function::kStep,
+ Function::kStorageBarrier,
+ Function::kTan,
+ Function::kTanh,
+ Function::kTranspose,
+ Function::kTrunc,
+ Function::kUnpack2X16Float,
+ Function::kUnpack2X16Snorm,
+ Function::kUnpack2X16Unorm,
+ Function::kUnpack4X8Snorm,
+ Function::kUnpack4X8Unorm,
+ Function::kWorkgroupBarrier,
+ Function::kWorkgroupUniformLoad,
+ Function::kTextureDimensions,
+ Function::kTextureGather,
+ Function::kTextureGatherCompare,
+ Function::kTextureNumLayers,
+ Function::kTextureNumLevels,
+ Function::kTextureNumSamples,
+ Function::kTextureSample,
+ Function::kTextureSampleBias,
+ Function::kTextureSampleCompare,
+ Function::kTextureSampleCompareLevel,
+ Function::kTextureSampleGrad,
+ Function::kTextureSampleLevel,
+ Function::kTextureSampleBaseClampToEdge,
+ Function::kTextureStore,
+ Function::kTextureLoad,
+ Function::kAtomicLoad,
+ Function::kAtomicStore,
+ Function::kAtomicAdd,
+ Function::kAtomicSub,
+ Function::kAtomicMax,
+ Function::kAtomicMin,
+ Function::kAtomicAnd,
+ Function::kAtomicOr,
+ Function::kAtomicXor,
+ Function::kAtomicExchange,
+ Function::kAtomicCompareExchangeWeak,
+ Function::kTintMaterialize,
+};
+
+/// All builtin function names
+constexpr const char* kFunctionStrings[] = {
+ "abs",
+ "acos",
+ "acosh",
+ "all",
+ "any",
+ "arrayLength",
+ "asin",
+ "asinh",
+ "atan",
+ "atan2",
+ "atanh",
+ "ceil",
+ "clamp",
+ "cos",
+ "cosh",
+ "countLeadingZeros",
+ "countOneBits",
+ "countTrailingZeros",
+ "cross",
+ "degrees",
+ "determinant",
+ "distance",
+ "dot",
+ "dot4I8Packed",
+ "dot4U8Packed",
+ "dpdx",
+ "dpdxCoarse",
+ "dpdxFine",
+ "dpdy",
+ "dpdyCoarse",
+ "dpdyFine",
+ "exp",
+ "exp2",
+ "extractBits",
+ "faceForward",
+ "firstLeadingBit",
+ "firstTrailingBit",
+ "floor",
+ "fma",
+ "fract",
+ "frexp",
+ "fwidth",
+ "fwidthCoarse",
+ "fwidthFine",
+ "insertBits",
+ "inverseSqrt",
+ "ldexp",
+ "length",
+ "log",
+ "log2",
+ "max",
+ "min",
+ "mix",
+ "modf",
+ "normalize",
+ "pack2x16float",
+ "pack2x16snorm",
+ "pack2x16unorm",
+ "pack4x8snorm",
+ "pack4x8unorm",
+ "pow",
+ "quantizeToF16",
+ "radians",
+ "reflect",
+ "refract",
+ "reverseBits",
+ "round",
+ "saturate",
+ "select",
+ "sign",
+ "sin",
+ "sinh",
+ "smoothstep",
+ "sqrt",
+ "step",
+ "storageBarrier",
+ "tan",
+ "tanh",
+ "transpose",
+ "trunc",
+ "unpack2x16float",
+ "unpack2x16snorm",
+ "unpack2x16unorm",
+ "unpack4x8snorm",
+ "unpack4x8unorm",
+ "workgroupBarrier",
+ "workgroupUniformLoad",
+ "textureDimensions",
+ "textureGather",
+ "textureGatherCompare",
+ "textureNumLayers",
+ "textureNumLevels",
+ "textureNumSamples",
+ "textureSample",
+ "textureSampleBias",
+ "textureSampleCompare",
+ "textureSampleCompareLevel",
+ "textureSampleGrad",
+ "textureSampleLevel",
+ "textureSampleBaseClampToEdge",
+ "textureStore",
+ "textureLoad",
+ "atomicLoad",
+ "atomicStore",
+ "atomicAdd",
+ "atomicSub",
+ "atomicMax",
+ "atomicMin",
+ "atomicAnd",
+ "atomicOr",
+ "atomicXor",
+ "atomicExchange",
+ "atomicCompareExchangeWeak",
+ "_tint_materialize",
+};
+
+} // namespace tint::builtin
+// \endcond
+
+#endif // SRC_TINT_BUILTIN_FUNCTION_H_
diff --git a/src/tint/builtin/function.h.tmpl b/src/tint/builtin/function.h.tmpl
new file mode 100644
index 0000000..d9109bf
--- /dev/null
+++ b/src/tint/builtin/function.h.tmpl
@@ -0,0 +1,63 @@
+{{- /*
+--------------------------------------------------------------------------------
+Template file for use with tools/src/cmd/gen to generate function.h
+
+To update the generated file, run:
+ ./tools/run gen
+
+See:
+* tools/src/cmd/gen for structures used by this template
+* https://golang.org/pkg/text/template/ for documentation on the template syntax
+--------------------------------------------------------------------------------
+*/ -}}
+
+#ifndef SRC_TINT_BUILTIN_FUNCTION_H_
+#define SRC_TINT_BUILTIN_FUNCTION_H_
+
+#include <string>
+
+#include "src/tint/utils/string_stream.h"
+
+// \cond DO_NOT_DOCUMENT
+namespace tint::builtin {
+
+/// Enumerator of all builtin functions
+enum class Function {
+ kNone = -1,
+{{- range Sem.Builtins }}
+ k{{PascalCase .Name}},
+{{- end }}
+};
+
+/// Matches the Function by name
+/// @param name the builtin name to parse
+/// @returns the parsed Function, or Function::kNone if `name` did not
+/// match any builtin function.
+Function ParseFunction(const std::string& name);
+
+/// @returns the name of the builtin function type. The spelling, including
+/// case, matches the name in the WGSL spec.
+const char* str(Function i);
+
+/// Emits the name of the builtin function type. The spelling, including case,
+/// matches the name in the WGSL spec.
+utils::StringStream& operator<<(utils::StringStream& out, Function i);
+
+/// All builtin functions
+constexpr Function kFunctions[] = {
+{{- range Sem.Builtins }}
+ Function::k{{PascalCase .Name}},
+{{- end }}
+};
+
+/// All builtin function names
+constexpr const char* kFunctionStrings[] = {
+{{- range Sem.Builtins }}
+ "{{.Name}}",
+{{- end }}
+};
+
+} // namespace tint::builtin
+// \endcond
+
+#endif // SRC_TINT_BUILTIN_FUNCTION_H_
diff --git a/src/tint/reader/spirv/function.cc b/src/tint/reader/spirv/function.cc
index 49d4e83..873ffe6 100644
--- a/src/tint/reader/spirv/function.cc
+++ b/src/tint/reader/spirv/function.cc
@@ -32,7 +32,7 @@
#include "src/tint/ast/unary_op_expression.h"
#include "src/tint/ast/variable_decl_statement.h"
#include "src/tint/builtin/builtin_value.h"
-#include "src/tint/sem/builtin_type.h"
+#include "src/tint/builtin/function.h"
#include "src/tint/transform/spirv_atomic.h"
#include "src/tint/type/depth_texture.h"
#include "src/tint/type/sampled_texture.h"
@@ -452,42 +452,42 @@
}
// Returns the WGSL standard library function builtin for the
-// given instruction, or sem::BuiltinType::kNone
-sem::BuiltinType GetBuiltin(spv::Op opcode) {
+// given instruction, or builtin::Function::kNone
+builtin::Function GetBuiltin(spv::Op opcode) {
switch (opcode) {
case spv::Op::OpBitCount:
- return sem::BuiltinType::kCountOneBits;
+ return builtin::Function::kCountOneBits;
case spv::Op::OpBitFieldInsert:
- return sem::BuiltinType::kInsertBits;
+ return builtin::Function::kInsertBits;
case spv::Op::OpBitFieldSExtract:
case spv::Op::OpBitFieldUExtract:
- return sem::BuiltinType::kExtractBits;
+ return builtin::Function::kExtractBits;
case spv::Op::OpBitReverse:
- return sem::BuiltinType::kReverseBits;
+ return builtin::Function::kReverseBits;
case spv::Op::OpDot:
- return sem::BuiltinType::kDot;
+ return builtin::Function::kDot;
case spv::Op::OpDPdx:
- return sem::BuiltinType::kDpdx;
+ return builtin::Function::kDpdx;
case spv::Op::OpDPdy:
- return sem::BuiltinType::kDpdy;
+ return builtin::Function::kDpdy;
case spv::Op::OpFwidth:
- return sem::BuiltinType::kFwidth;
+ return builtin::Function::kFwidth;
case spv::Op::OpDPdxFine:
- return sem::BuiltinType::kDpdxFine;
+ return builtin::Function::kDpdxFine;
case spv::Op::OpDPdyFine:
- return sem::BuiltinType::kDpdyFine;
+ return builtin::Function::kDpdyFine;
case spv::Op::OpFwidthFine:
- return sem::BuiltinType::kFwidthFine;
+ return builtin::Function::kFwidthFine;
case spv::Op::OpDPdxCoarse:
- return sem::BuiltinType::kDpdxCoarse;
+ return builtin::Function::kDpdxCoarse;
case spv::Op::OpDPdyCoarse:
- return sem::BuiltinType::kDpdyCoarse;
+ return builtin::Function::kDpdyCoarse;
case spv::Op::OpFwidthCoarse:
- return sem::BuiltinType::kFwidthCoarse;
+ return builtin::Function::kFwidthCoarse;
default:
break;
}
- return sem::BuiltinType::kNone;
+ return builtin::Function::kNone;
}
// @param opcode a SPIR-V opcode
@@ -3816,7 +3816,7 @@
}
const auto builtin = GetBuiltin(op);
- if (builtin != sem::BuiltinType::kNone) {
+ if (builtin != builtin::Function::kNone) {
return MakeBuiltinCall(inst);
}
@@ -5250,7 +5250,7 @@
TypedExpression FunctionEmitter::MakeBuiltinCall(const spvtools::opt::Instruction& inst) {
const auto builtin = GetBuiltin(opcode(inst));
- auto* name = sem::str(builtin);
+ auto* name = builtin::str(builtin);
auto* ident = create<ast::Identifier>(Source{}, builder_.Symbols().Register(name));
ExpressionList params;
@@ -5741,7 +5741,7 @@
}
bool FunctionEmitter::EmitAtomicOp(const spvtools::opt::Instruction& inst) {
- auto emit_atomic = [&](sem::BuiltinType builtin, std::initializer_list<TypedExpression> args) {
+ auto emit_atomic = [&](builtin::Function builtin, std::initializer_list<TypedExpression> args) {
// Split args into params and expressions
ParameterList params;
params.Reserve(args.size());
@@ -5763,7 +5763,7 @@
// Emit stub, will be removed by transform::SpirvAtomic
auto* stub = builder_.Func(
- Source{}, builder_.Symbols().New(std::string("stub_") + sem::str(builtin)),
+ Source{}, builder_.Symbols().New(std::string("stub_") + builtin::str(builtin)),
std::move(params), ret_type,
/* body */ nullptr,
utils::Vector{
@@ -5800,39 +5800,39 @@
switch (opcode(inst)) {
case spv::Op::OpAtomicLoad:
- return emit_atomic(sem::BuiltinType::kAtomicLoad, {oper(/*ptr*/ 0)});
+ return emit_atomic(builtin::Function::kAtomicLoad, {oper(/*ptr*/ 0)});
case spv::Op::OpAtomicStore:
- return emit_atomic(sem::BuiltinType::kAtomicStore,
+ return emit_atomic(builtin::Function::kAtomicStore,
{oper(/*ptr*/ 0), oper(/*value*/ 3)});
case spv::Op::OpAtomicExchange:
- return emit_atomic(sem::BuiltinType::kAtomicExchange,
+ return emit_atomic(builtin::Function::kAtomicExchange,
{oper(/*ptr*/ 0), oper(/*value*/ 3)});
case spv::Op::OpAtomicCompareExchange:
case spv::Op::OpAtomicCompareExchangeWeak:
- return emit_atomic(sem::BuiltinType::kAtomicCompareExchangeWeak,
+ return emit_atomic(builtin::Function::kAtomicCompareExchangeWeak,
{oper(/*ptr*/ 0), /*value*/ oper(5), /*comparator*/ oper(4)});
case spv::Op::OpAtomicIIncrement:
- return emit_atomic(sem::BuiltinType::kAtomicAdd, {oper(/*ptr*/ 0), lit(1)});
+ return emit_atomic(builtin::Function::kAtomicAdd, {oper(/*ptr*/ 0), lit(1)});
case spv::Op::OpAtomicIDecrement:
- return emit_atomic(sem::BuiltinType::kAtomicSub, {oper(/*ptr*/ 0), lit(1)});
+ return emit_atomic(builtin::Function::kAtomicSub, {oper(/*ptr*/ 0), lit(1)});
case spv::Op::OpAtomicIAdd:
- return emit_atomic(sem::BuiltinType::kAtomicAdd, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
+ return emit_atomic(builtin::Function::kAtomicAdd, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
case spv::Op::OpAtomicISub:
- return emit_atomic(sem::BuiltinType::kAtomicSub, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
+ return emit_atomic(builtin::Function::kAtomicSub, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
case spv::Op::OpAtomicSMin:
- return emit_atomic(sem::BuiltinType::kAtomicMin, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
+ return emit_atomic(builtin::Function::kAtomicMin, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
case spv::Op::OpAtomicUMin:
- return emit_atomic(sem::BuiltinType::kAtomicMin, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
+ return emit_atomic(builtin::Function::kAtomicMin, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
case spv::Op::OpAtomicSMax:
- return emit_atomic(sem::BuiltinType::kAtomicMax, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
+ return emit_atomic(builtin::Function::kAtomicMax, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
case spv::Op::OpAtomicUMax:
- return emit_atomic(sem::BuiltinType::kAtomicMax, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
+ return emit_atomic(builtin::Function::kAtomicMax, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
case spv::Op::OpAtomicAnd:
- return emit_atomic(sem::BuiltinType::kAtomicAnd, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
+ return emit_atomic(builtin::Function::kAtomicAnd, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
case spv::Op::OpAtomicOr:
- return emit_atomic(sem::BuiltinType::kAtomicOr, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
+ return emit_atomic(builtin::Function::kAtomicOr, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
case spv::Op::OpAtomicXor:
- return emit_atomic(sem::BuiltinType::kAtomicXor, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
+ return emit_atomic(builtin::Function::kAtomicXor, {oper(/*ptr*/ 0), oper(/*value*/ 3)});
case spv::Op::OpAtomicFlagTestAndSet:
case spv::Op::OpAtomicFlagClear:
case spv::Op::OpAtomicFMinEXT:
diff --git a/src/tint/reader/spirv/parser_impl_barrier_test.cc b/src/tint/reader/spirv/parser_impl_barrier_test.cc
index a594098..ef8e5af 100644
--- a/src/tint/reader/spirv/parser_impl_barrier_test.cc
+++ b/src/tint/reader/spirv/parser_impl_barrier_test.cc
@@ -73,7 +73,7 @@
ASSERT_NE(sem_call, nullptr);
auto* builtin = sem_call->Target()->As<sem::Builtin>();
ASSERT_NE(builtin, nullptr);
- EXPECT_EQ(builtin->Type(), sem::BuiltinType::kWorkgroupBarrier);
+ EXPECT_EQ(builtin->Type(), builtin::Function::kWorkgroupBarrier);
}
TEST_F(SpvParserTest, StorageBarrier) {
@@ -106,7 +106,7 @@
ASSERT_NE(sem_call, nullptr);
auto* builtin = sem_call->Target()->As<sem::Builtin>();
ASSERT_NE(builtin, nullptr);
- EXPECT_EQ(builtin->Type(), sem::BuiltinType::kStorageBarrier);
+ EXPECT_EQ(builtin->Type(), builtin::Function::kStorageBarrier);
}
TEST_F(SpvParserTest, ErrBarrierInvalidExecution) {
diff --git a/src/tint/resolver/builtin_test.cc b/src/tint/resolver/builtin_test.cc
index 4e9e4bd..80df98f 100644
--- a/src/tint/resolver/builtin_test.cc
+++ b/src/tint/resolver/builtin_test.cc
@@ -50,13 +50,11 @@
using ExpressionList = utils::Vector<const ast::Expression*, 8>;
-using BuiltinType = sem::BuiltinType;
-
using ResolverBuiltinTest = ResolverTest;
struct BuiltinData {
const char* name;
- BuiltinType builtin;
+ builtin::Function builtin;
};
inline std::ostream& operator<<(std::ostream& out, BuiltinData data) {
@@ -253,7 +251,7 @@
struct BuiltinDataWithParamNum {
uint32_t args_number;
const char* name;
- BuiltinType builtin;
+ builtin::Function builtin;
};
inline std::ostream& operator<<(std::ostream& out, BuiltinDataWithParamNum data) {
@@ -680,55 +678,55 @@
INSTANTIATE_TEST_SUITE_P(
ResolverTest,
ResolverBuiltinTest_FloatBuiltin_IdenticalType,
- testing::Values(BuiltinDataWithParamNum{1, "abs", BuiltinType::kAbs},
- BuiltinDataWithParamNum{1, "acos", BuiltinType::kAcos},
- BuiltinDataWithParamNum{1, "acosh", BuiltinType::kAcos},
- BuiltinDataWithParamNum{1, "asin", BuiltinType::kAsin},
- BuiltinDataWithParamNum{1, "asinh", BuiltinType::kAsin},
- BuiltinDataWithParamNum{1, "atan", BuiltinType::kAtan},
- BuiltinDataWithParamNum{1, "atanh", BuiltinType::kAtan},
- BuiltinDataWithParamNum{2, "atan2", BuiltinType::kAtan2},
- BuiltinDataWithParamNum{1, "ceil", BuiltinType::kCeil},
- BuiltinDataWithParamNum{3, "clamp", BuiltinType::kClamp},
- BuiltinDataWithParamNum{1, "cos", BuiltinType::kCos},
- BuiltinDataWithParamNum{1, "cosh", BuiltinType::kCosh},
+ testing::Values(BuiltinDataWithParamNum{1, "abs", builtin::Function::kAbs},
+ BuiltinDataWithParamNum{1, "acos", builtin::Function::kAcos},
+ BuiltinDataWithParamNum{1, "acosh", builtin::Function::kAcos},
+ BuiltinDataWithParamNum{1, "asin", builtin::Function::kAsin},
+ BuiltinDataWithParamNum{1, "asinh", builtin::Function::kAsin},
+ BuiltinDataWithParamNum{1, "atan", builtin::Function::kAtan},
+ BuiltinDataWithParamNum{1, "atanh", builtin::Function::kAtan},
+ BuiltinDataWithParamNum{2, "atan2", builtin::Function::kAtan2},
+ BuiltinDataWithParamNum{1, "ceil", builtin::Function::kCeil},
+ BuiltinDataWithParamNum{3, "clamp", builtin::Function::kClamp},
+ BuiltinDataWithParamNum{1, "cos", builtin::Function::kCos},
+ BuiltinDataWithParamNum{1, "cosh", builtin::Function::kCosh},
// cross: (vec3<T>, vec3<T>) -> vec3<T>
- BuiltinDataWithParamNum{1, "degrees", BuiltinType::kDegrees},
+ BuiltinDataWithParamNum{1, "degrees", builtin::Function::kDegrees},
// distance: (T, T) -> T, (vecN<T>, vecN<T>) -> T
- BuiltinDataWithParamNum{1, "exp", BuiltinType::kExp},
- BuiltinDataWithParamNum{1, "exp2", BuiltinType::kExp2},
+ BuiltinDataWithParamNum{1, "exp", builtin::Function::kExp},
+ BuiltinDataWithParamNum{1, "exp2", builtin::Function::kExp2},
// faceForward: (vecN<T>, vecN<T>, vecN<T>) -> vecN<T>
- BuiltinDataWithParamNum{1, "floor", BuiltinType::kFloor},
- BuiltinDataWithParamNum{3, "fma", BuiltinType::kFma},
- BuiltinDataWithParamNum{1, "fract", BuiltinType::kFract},
+ BuiltinDataWithParamNum{1, "floor", builtin::Function::kFloor},
+ BuiltinDataWithParamNum{3, "fma", builtin::Function::kFma},
+ BuiltinDataWithParamNum{1, "fract", builtin::Function::kFract},
// frexp
- BuiltinDataWithParamNum{1, "inverseSqrt", BuiltinType::kInverseSqrt},
+ BuiltinDataWithParamNum{1, "inverseSqrt", builtin::Function::kInverseSqrt},
// ldexp: (T, i32) -> T, (vecN<T>, vecN<i32>) -> vecN<T>
// length: (vecN<T>) -> T
- BuiltinDataWithParamNum{1, "log", BuiltinType::kLog},
- BuiltinDataWithParamNum{1, "log2", BuiltinType::kLog2},
- BuiltinDataWithParamNum{2, "max", BuiltinType::kMax},
- BuiltinDataWithParamNum{2, "min", BuiltinType::kMin},
+ BuiltinDataWithParamNum{1, "log", builtin::Function::kLog},
+ BuiltinDataWithParamNum{1, "log2", builtin::Function::kLog2},
+ BuiltinDataWithParamNum{2, "max", builtin::Function::kMax},
+ BuiltinDataWithParamNum{2, "min", builtin::Function::kMin},
// Note that `mix(vecN<f32>, vecN<f32>, f32) -> vecN<f32>` is not tested here.
- BuiltinDataWithParamNum{3, "mix", BuiltinType::kMix},
+ BuiltinDataWithParamNum{3, "mix", builtin::Function::kMix},
// modf
// normalize: (vecN<T>) -> vecN<T>
- BuiltinDataWithParamNum{2, "pow", BuiltinType::kPow},
+ BuiltinDataWithParamNum{2, "pow", builtin::Function::kPow},
// quantizeToF16 is not implemented yet.
- BuiltinDataWithParamNum{1, "radians", BuiltinType::kRadians},
+ BuiltinDataWithParamNum{1, "radians", builtin::Function::kRadians},
// reflect: (vecN<T>, vecN<T>) -> vecN<T>
// refract: (vecN<T>, vecN<T>, T) -> vecN<T>
- BuiltinDataWithParamNum{1, "round", BuiltinType::kRound},
+ BuiltinDataWithParamNum{1, "round", builtin::Function::kRound},
// saturate not implemented yet.
- BuiltinDataWithParamNum{1, "sign", BuiltinType::kSign},
- BuiltinDataWithParamNum{1, "sin", BuiltinType::kSin},
- BuiltinDataWithParamNum{1, "sinh", BuiltinType::kSinh},
- BuiltinDataWithParamNum{3, "smoothstep", BuiltinType::kSmoothstep},
- BuiltinDataWithParamNum{1, "sqrt", BuiltinType::kSqrt},
- BuiltinDataWithParamNum{2, "step", BuiltinType::kStep},
- BuiltinDataWithParamNum{1, "tan", BuiltinType::kTan},
- BuiltinDataWithParamNum{1, "tanh", BuiltinType::kTanh},
- BuiltinDataWithParamNum{1, "trunc", BuiltinType::kTrunc}));
+ BuiltinDataWithParamNum{1, "sign", builtin::Function::kSign},
+ BuiltinDataWithParamNum{1, "sin", builtin::Function::kSin},
+ BuiltinDataWithParamNum{1, "sinh", builtin::Function::kSinh},
+ BuiltinDataWithParamNum{3, "smoothstep", builtin::Function::kSmoothstep},
+ BuiltinDataWithParamNum{1, "sqrt", builtin::Function::kSqrt},
+ BuiltinDataWithParamNum{2, "step", builtin::Function::kStep},
+ BuiltinDataWithParamNum{1, "tan", builtin::Function::kTan},
+ BuiltinDataWithParamNum{1, "tanh", builtin::Function::kTanh},
+ BuiltinDataWithParamNum{1, "trunc", builtin::Function::kTrunc}));
using ResolverBuiltinFloatTest = ResolverTest;
@@ -1409,7 +1407,7 @@
struct BuiltinDataWithParamNum {
uint32_t args_number;
const char* name;
- BuiltinType builtin;
+ builtin::Function builtin;
};
inline std::ostream& operator<<(std::ostream& out, BuiltinDataWithParamNum data) {
@@ -1805,18 +1803,18 @@
ResolverTest,
ResolverBuiltinTest_IntegerBuiltin_IdenticalType,
testing::Values(
- BuiltinDataWithParamNum{1, "abs", BuiltinType::kAbs},
- BuiltinDataWithParamNum{3, "clamp", BuiltinType::kClamp},
- BuiltinDataWithParamNum{1, "countLeadingZeros", BuiltinType::kCountLeadingZeros},
- BuiltinDataWithParamNum{1, "countOneBits", BuiltinType::kCountOneBits},
- BuiltinDataWithParamNum{1, "countTrailingZeros", BuiltinType::kCountTrailingZeros},
+ BuiltinDataWithParamNum{1, "abs", builtin::Function::kAbs},
+ BuiltinDataWithParamNum{3, "clamp", builtin::Function::kClamp},
+ BuiltinDataWithParamNum{1, "countLeadingZeros", builtin::Function::kCountLeadingZeros},
+ BuiltinDataWithParamNum{1, "countOneBits", builtin::Function::kCountOneBits},
+ BuiltinDataWithParamNum{1, "countTrailingZeros", builtin::Function::kCountTrailingZeros},
// extractBits: (T, u32, u32) -> T
- BuiltinDataWithParamNum{1, "firstLeadingBit", BuiltinType::kFirstLeadingBit},
- BuiltinDataWithParamNum{1, "firstTrailingBit", BuiltinType::kFirstTrailingBit},
+ BuiltinDataWithParamNum{1, "firstLeadingBit", builtin::Function::kFirstLeadingBit},
+ BuiltinDataWithParamNum{1, "firstTrailingBit", builtin::Function::kFirstTrailingBit},
// insertBits: (T, T, u32, u32) -> T
- BuiltinDataWithParamNum{2, "max", BuiltinType::kMax},
- BuiltinDataWithParamNum{2, "min", BuiltinType::kMin},
- BuiltinDataWithParamNum{1, "reverseBits", BuiltinType::kReverseBits}));
+ BuiltinDataWithParamNum{2, "max", builtin::Function::kMax},
+ BuiltinDataWithParamNum{2, "min", builtin::Function::kMin},
+ BuiltinDataWithParamNum{1, "reverseBits", builtin::Function::kReverseBits}));
} // namespace integer_builtin_tests
@@ -2555,8 +2553,8 @@
TEST_P(ResolverBuiltinTest_DataPacking, InferType) {
auto param = GetParam();
- bool pack4 =
- param.builtin == BuiltinType::kPack4X8Snorm || param.builtin == BuiltinType::kPack4X8Unorm;
+ bool pack4 = param.builtin == builtin::Function::kPack4X8Snorm ||
+ param.builtin == builtin::Function::kPack4X8Unorm;
auto* call = pack4 ? Call(param.name, vec4<f32>(1_f, 2_f, 3_f, 4_f))
: Call(param.name, vec2<f32>(1_f, 2_f));
@@ -2570,8 +2568,8 @@
TEST_P(ResolverBuiltinTest_DataPacking, Error_IncorrectParamType) {
auto param = GetParam();
- bool pack4 =
- param.builtin == BuiltinType::kPack4X8Snorm || param.builtin == BuiltinType::kPack4X8Unorm;
+ bool pack4 = param.builtin == builtin::Function::kPack4X8Snorm ||
+ param.builtin == builtin::Function::kPack4X8Unorm;
auto* call = pack4 ? Call(param.name, vec4<i32>(1_i, 2_i, 3_i, 4_i))
: Call(param.name, vec2<i32>(1_i, 2_i));
@@ -2596,8 +2594,8 @@
TEST_P(ResolverBuiltinTest_DataPacking, Error_TooManyParams) {
auto param = GetParam();
- bool pack4 =
- param.builtin == BuiltinType::kPack4X8Snorm || param.builtin == BuiltinType::kPack4X8Unorm;
+ bool pack4 = param.builtin == builtin::Function::kPack4X8Snorm ||
+ param.builtin == builtin::Function::kPack4X8Unorm;
auto* call = pack4 ? Call(param.name, vec4<f32>(1_f, 2_f, 3_f, 4_f), 1_f)
: Call(param.name, vec2<f32>(1_f, 2_f), 1_f);
@@ -2608,14 +2606,14 @@
EXPECT_THAT(r()->error(), HasSubstr("error: no matching call to " + std::string(param.name)));
}
-INSTANTIATE_TEST_SUITE_P(ResolverTest,
- ResolverBuiltinTest_DataPacking,
- testing::Values(BuiltinData{"pack4x8snorm", BuiltinType::kPack4X8Snorm},
- BuiltinData{"pack4x8unorm", BuiltinType::kPack4X8Unorm},
- BuiltinData{"pack2x16snorm", BuiltinType::kPack2X16Snorm},
- BuiltinData{"pack2x16unorm", BuiltinType::kPack2X16Unorm},
- BuiltinData{"pack2x16float",
- BuiltinType::kPack2X16Float}));
+INSTANTIATE_TEST_SUITE_P(
+ ResolverTest,
+ ResolverBuiltinTest_DataPacking,
+ testing::Values(BuiltinData{"pack4x8snorm", builtin::Function::kPack4X8Snorm},
+ BuiltinData{"pack4x8unorm", builtin::Function::kPack4X8Unorm},
+ BuiltinData{"pack2x16snorm", builtin::Function::kPack2X16Snorm},
+ BuiltinData{"pack2x16unorm", builtin::Function::kPack2X16Unorm},
+ BuiltinData{"pack2x16float", builtin::Function::kPack2X16Float}));
} // namespace data_packing_builtin_tests
@@ -2626,8 +2624,8 @@
TEST_P(ResolverBuiltinTest_DataUnpacking, InferType) {
auto param = GetParam();
- bool pack4 = param.builtin == BuiltinType::kUnpack4X8Snorm ||
- param.builtin == BuiltinType::kUnpack4X8Unorm;
+ bool pack4 = param.builtin == builtin::Function::kUnpack4X8Snorm ||
+ param.builtin == builtin::Function::kUnpack4X8Unorm;
auto* call = Call(param.name, 1_u);
WrapInFunction(call);
@@ -2645,11 +2643,11 @@
INSTANTIATE_TEST_SUITE_P(
ResolverTest,
ResolverBuiltinTest_DataUnpacking,
- testing::Values(BuiltinData{"unpack4x8snorm", BuiltinType::kUnpack4X8Snorm},
- BuiltinData{"unpack4x8unorm", BuiltinType::kUnpack4X8Unorm},
- BuiltinData{"unpack2x16snorm", BuiltinType::kUnpack2X16Snorm},
- BuiltinData{"unpack2x16unorm", BuiltinType::kUnpack2X16Unorm},
- BuiltinData{"unpack2x16float", BuiltinType::kUnpack2X16Float}));
+ testing::Values(BuiltinData{"unpack4x8snorm", builtin::Function::kUnpack4X8Snorm},
+ BuiltinData{"unpack4x8unorm", builtin::Function::kUnpack4X8Unorm},
+ BuiltinData{"unpack2x16snorm", builtin::Function::kUnpack2X16Snorm},
+ BuiltinData{"unpack2x16unorm", builtin::Function::kUnpack2X16Unorm},
+ BuiltinData{"unpack2x16float", builtin::Function::kUnpack2X16Float}));
} // namespace data_unpacking_builtin_tests
@@ -2682,8 +2680,8 @@
INSTANTIATE_TEST_SUITE_P(
ResolverTest,
ResolverBuiltinTest_Barrier,
- testing::Values(BuiltinData{"storageBarrier", BuiltinType::kStorageBarrier},
- BuiltinData{"workgroupBarrier", BuiltinType::kWorkgroupBarrier}));
+ testing::Values(BuiltinData{"storageBarrier", builtin::Function::kStorageBarrier},
+ BuiltinData{"workgroupBarrier", builtin::Function::kWorkgroupBarrier}));
} // namespace synchronization_builtin_tests
diff --git a/src/tint/resolver/const_eval_builtin_test.cc b/src/tint/resolver/const_eval_builtin_test.cc
index bd32779..2cef1d1 100644
--- a/src/tint/resolver/const_eval_builtin_test.cc
+++ b/src/tint/resolver/const_eval_builtin_test.cc
@@ -139,7 +139,7 @@
return Case{std::move(args), std::move(err)};
}
-using ResolverConstEvalBuiltinTest = ResolverTestWithParam<std::tuple<sem::BuiltinType, Case>>;
+using ResolverConstEvalBuiltinTest = ResolverTestWithParam<std::tuple<builtin::Function, Case>>;
TEST_P(ResolverConstEvalBuiltinTest, Test) {
Enable(builtin::Extension::kF16);
@@ -152,7 +152,7 @@
args.Push(a.Expr(*this));
}
- auto* expr = Call(Source{{12, 34}}, sem::str(builtin), std::move(args));
+ auto* expr = Call(Source{{12, 34}}, builtin::str(builtin), std::move(args));
GlobalConst("C", expr);
if (c.expected) {
@@ -187,7 +187,7 @@
INSTANTIATE_TEST_SUITE_P( //
MixedAbstractArgs,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kAtan2),
+ testing::Combine(testing::Values(builtin::Function::kAtan2),
testing::ValuesIn(std::vector{
C({0_a, -0.0_a}, kPi<AFloat>),
C({1.0_a, 0_a}, kPiOver2<AFloat>),
@@ -222,7 +222,7 @@
INSTANTIATE_TEST_SUITE_P( //
Abs,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kAbs),
+ testing::Combine(testing::Values(builtin::Function::kAbs),
testing::ValuesIn(Concat(AbsCases<AInt>(), //
AbsCases<i32>(),
AbsCases<u32>(),
@@ -257,7 +257,7 @@
INSTANTIATE_TEST_SUITE_P( //
All,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kAll), testing::ValuesIn(AllCases())));
+ testing::Combine(testing::Values(builtin::Function::kAll), testing::ValuesIn(AllCases())));
static std::vector<Case> AnyCases() {
return {
@@ -286,7 +286,7 @@
INSTANTIATE_TEST_SUITE_P( //
Any,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kAny), testing::ValuesIn(AnyCases())));
+ testing::Combine(testing::Values(builtin::Function::kAny), testing::ValuesIn(AnyCases())));
template <typename T>
std::vector<Case> Atan2Cases() {
@@ -315,7 +315,7 @@
INSTANTIATE_TEST_SUITE_P( //
Atan2,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kAtan2),
+ testing::Combine(testing::Values(builtin::Function::kAtan2),
testing::ValuesIn(Concat(Atan2Cases<AFloat>(), //
Atan2Cases<f32>(),
Atan2Cases<f16>()))));
@@ -336,7 +336,7 @@
INSTANTIATE_TEST_SUITE_P( //
Atan,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kAtan),
+ testing::Combine(testing::Values(builtin::Function::kAtan),
testing::ValuesIn(Concat(AtanCases<AFloat>(), //
AtanCases<f32>(),
AtanCases<f16>()))));
@@ -361,7 +361,7 @@
INSTANTIATE_TEST_SUITE_P( //
Atanh,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kAtanh),
+ testing::Combine(testing::Values(builtin::Function::kAtanh),
testing::ValuesIn(Concat(AtanhCases<AFloat>(), //
AtanhCases<f32>(),
AtanhCases<f16>()))));
@@ -387,7 +387,7 @@
INSTANTIATE_TEST_SUITE_P( //
Acos,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kAcos),
+ testing::Combine(testing::Values(builtin::Function::kAcos),
testing::ValuesIn(Concat(AcosCases<AFloat>(), //
AcosCases<f32>(),
AcosCases<f16>()))));
@@ -409,7 +409,7 @@
INSTANTIATE_TEST_SUITE_P( //
Acosh,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kAcosh),
+ testing::Combine(testing::Values(builtin::Function::kAcosh),
testing::ValuesIn(Concat(AcoshCases<AFloat>(), //
AcoshCases<f32>(),
AcoshCases<f16>()))));
@@ -436,7 +436,7 @@
INSTANTIATE_TEST_SUITE_P( //
Asin,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kAsin),
+ testing::Combine(testing::Values(builtin::Function::kAsin),
testing::ValuesIn(Concat(AsinCases<AFloat>(), //
AsinCases<f32>(),
AsinCases<f16>()))));
@@ -460,7 +460,7 @@
INSTANTIATE_TEST_SUITE_P( //
Asinh,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kAsinh),
+ testing::Combine(testing::Values(builtin::Function::kAsinh),
testing::ValuesIn(Concat(AsinhCases<AFloat>(), //
AsinhCases<f32>(),
AsinhCases<f16>()))));
@@ -482,7 +482,7 @@
Ceil,
ResolverConstEvalBuiltinTest,
testing::Combine(
- testing::Values(sem::BuiltinType::kCeil),
+ testing::Values(builtin::Function::kCeil),
testing::ValuesIn(Concat(CeilCases<AFloat>(), CeilCases<f32>(), CeilCases<f16>()))));
template <typename T>
@@ -512,7 +512,7 @@
INSTANTIATE_TEST_SUITE_P( //
Clamp,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kClamp),
+ testing::Combine(testing::Values(builtin::Function::kClamp),
testing::ValuesIn(Concat(ClampCases<AInt>(), //
ClampCases<i32>(),
ClampCases<u32>(),
@@ -535,7 +535,7 @@
INSTANTIATE_TEST_SUITE_P( //
Cos,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kCos),
+ testing::Combine(testing::Values(builtin::Function::kCos),
testing::ValuesIn(Concat(CosCases<AFloat>(), //
CosCases<f32>(),
CosCases<f16>()))));
@@ -561,7 +561,7 @@
INSTANTIATE_TEST_SUITE_P( //
Cosh,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kCosh),
+ testing::Combine(testing::Values(builtin::Function::kCosh),
testing::ValuesIn(Concat(CoshCases<AFloat>(), //
CoshCases<f32>(),
CoshCases<f16>()))));
@@ -608,7 +608,7 @@
INSTANTIATE_TEST_SUITE_P( //
CountLeadingZeros,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kCountLeadingZeros),
+ testing::Combine(testing::Values(builtin::Function::kCountLeadingZeros),
testing::ValuesIn(Concat(CountLeadingZerosCases<i32>(), //
CountLeadingZerosCases<u32>()))));
@@ -654,7 +654,7 @@
INSTANTIATE_TEST_SUITE_P( //
CountTrailingZeros,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kCountTrailingZeros),
+ testing::Combine(testing::Values(builtin::Function::kCountTrailingZeros),
testing::ValuesIn(Concat(CountTrailingZerosCases<i32>(), //
CountTrailingZerosCases<u32>()))));
@@ -691,7 +691,7 @@
INSTANTIATE_TEST_SUITE_P( //
CountOneBits,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kCountOneBits),
+ testing::Combine(testing::Values(builtin::Function::kCountOneBits),
testing::ValuesIn(Concat(CountOneBitsCases<i32>(), //
CountOneBitsCases<u32>()))));
@@ -790,7 +790,7 @@
INSTANTIATE_TEST_SUITE_P( //
Cross,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kCross),
+ testing::Combine(testing::Values(builtin::Function::kCross),
testing::ValuesIn(Concat(CrossCases<AFloat>(), //
CrossCases<f32>(), //
CrossCases<f16>()))));
@@ -817,7 +817,7 @@
INSTANTIATE_TEST_SUITE_P( //
Distance,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kDistance),
+ testing::Combine(testing::Values(builtin::Function::kDistance),
testing::ValuesIn(Concat(DistanceCases<AFloat>(), //
DistanceCases<f32>(), //
DistanceCases<f16>()))));
@@ -865,7 +865,7 @@
INSTANTIATE_TEST_SUITE_P( //
Dot,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kDot),
+ testing::Combine(testing::Values(builtin::Function::kDot),
testing::ValuesIn(Concat(DotCases<AInt>(), //
DotCases<i32>(), //
DotCases<u32>(), //
@@ -945,7 +945,7 @@
INSTANTIATE_TEST_SUITE_P( //
Determinant,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kDeterminant),
+ testing::Combine(testing::Values(builtin::Function::kDeterminant),
testing::ValuesIn(Concat(DeterminantCases<AFloat>(), //
DeterminantCases<f32>(), //
DeterminantCases<f16>()))));
@@ -1027,7 +1027,7 @@
INSTANTIATE_TEST_SUITE_P( //
FaceForward,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kFaceForward),
+ testing::Combine(testing::Values(builtin::Function::kFaceForward),
testing::ValuesIn(Concat(FaceForwardCases<AFloat>(), //
FaceForwardCases<f32>(), //
FaceForwardCases<f16>()))));
@@ -1090,7 +1090,7 @@
INSTANTIATE_TEST_SUITE_P( //
FirstLeadingBit,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kFirstLeadingBit),
+ testing::Combine(testing::Values(builtin::Function::kFirstLeadingBit),
testing::ValuesIn(Concat(FirstLeadingBitCases<i32>(), //
FirstLeadingBitCases<u32>()))));
@@ -1123,7 +1123,7 @@
INSTANTIATE_TEST_SUITE_P( //
FirstTrailingBit,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kFirstTrailingBit),
+ testing::Combine(testing::Values(builtin::Function::kFirstTrailingBit),
testing::ValuesIn(Concat(FirstTrailingBitCases<i32>(), //
FirstTrailingBitCases<u32>()))));
@@ -1143,7 +1143,7 @@
INSTANTIATE_TEST_SUITE_P( //
Floor,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kFloor),
+ testing::Combine(testing::Values(builtin::Function::kFloor),
testing::ValuesIn(Concat(FloorCases<AFloat>(), //
FloorCases<f32>(),
FloorCases<f16>()))));
@@ -1167,7 +1167,7 @@
INSTANTIATE_TEST_SUITE_P( //
Fma,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kFma),
+ testing::Combine(testing::Values(builtin::Function::kFma),
testing::ValuesIn(Concat(FmaCases<AFloat>(), //
FmaCases<f32>(),
FmaCases<f16>()))));
@@ -1199,7 +1199,7 @@
INSTANTIATE_TEST_SUITE_P( //
Fract,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kFract),
+ testing::Combine(testing::Values(builtin::Function::kFract),
testing::ValuesIn(Concat(FractCases<AFloat>(), //
FractCases<f32>(),
FractCases<f16>()))));
@@ -1256,7 +1256,7 @@
INSTANTIATE_TEST_SUITE_P( //
Frexp,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kFrexp),
+ testing::Combine(testing::Values(builtin::Function::kFrexp),
testing::ValuesIn(Concat(FrexpCases<AFloat>(), //
FrexpCases<f32>(), //
FrexpCases<f16>()))));
@@ -1338,7 +1338,7 @@
INSTANTIATE_TEST_SUITE_P( //
InsertBits,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kInsertBits),
+ testing::Combine(testing::Values(builtin::Function::kInsertBits),
testing::ValuesIn(Concat(InsertBitsCases<i32>(), //
InsertBitsCases<u32>()))));
@@ -1358,7 +1358,7 @@
INSTANTIATE_TEST_SUITE_P( //
InverseSqrt,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kInverseSqrt),
+ testing::Combine(testing::Values(builtin::Function::kInverseSqrt),
testing::ValuesIn(Concat(InverseSqrtCases<AFloat>(), //
InverseSqrtCases<f32>(),
InverseSqrtCases<f16>()))));
@@ -1377,7 +1377,7 @@
INSTANTIATE_TEST_SUITE_P( //
DegreesAFloat,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kDegrees),
+ testing::Combine(testing::Values(builtin::Function::kDegrees),
testing::ValuesIn(DegreesAFloatCases<AFloat>())));
template <typename T>
@@ -1394,7 +1394,7 @@
INSTANTIATE_TEST_SUITE_P( //
DegreesF32,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kDegrees),
+ testing::Combine(testing::Values(builtin::Function::kDegrees),
testing::ValuesIn(DegreesF32Cases<f32>())));
template <typename T>
@@ -1411,7 +1411,7 @@
INSTANTIATE_TEST_SUITE_P( //
DegreesF16,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kDegrees),
+ testing::Combine(testing::Values(builtin::Function::kDegrees),
testing::ValuesIn(DegreesF16Cases<f16>())));
template <typename T>
@@ -1428,7 +1428,7 @@
INSTANTIATE_TEST_SUITE_P( //
Exp,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kExp),
+ testing::Combine(testing::Values(builtin::Function::kExp),
testing::ValuesIn(Concat(ExpCases<AFloat>(), //
ExpCases<f32>(),
ExpCases<f16>()))));
@@ -1449,7 +1449,7 @@
INSTANTIATE_TEST_SUITE_P( //
Exp2,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kExp2),
+ testing::Combine(testing::Values(builtin::Function::kExp2),
testing::ValuesIn(Concat(Exp2Cases<AFloat>(), //
Exp2Cases<f32>(),
Exp2Cases<f16>()))));
@@ -1546,7 +1546,7 @@
INSTANTIATE_TEST_SUITE_P( //
ExtractBits,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kExtractBits),
+ testing::Combine(testing::Values(builtin::Function::kExtractBits),
testing::ValuesIn(Concat(ExtractBitsCases<i32>(), //
ExtractBitsCases<u32>()))));
@@ -1610,7 +1610,7 @@
INSTANTIATE_TEST_SUITE_P( //
Ldexp,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kLdexp),
+ testing::Combine(testing::Values(builtin::Function::kLdexp),
testing::ValuesIn(Concat(LdexpCases<AFloat>(), //
LdexpCases<f32>(),
LdexpCases<f16>()))));
@@ -1669,7 +1669,7 @@
INSTANTIATE_TEST_SUITE_P( //
Length,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kLength),
+ testing::Combine(testing::Values(builtin::Function::kLength),
testing::ValuesIn(Concat(LengthCases<AFloat>(), //
LengthCases<f32>(),
LengthCases<f16>()))));
@@ -1685,7 +1685,7 @@
INSTANTIATE_TEST_SUITE_P( //
Log,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kLog),
+ testing::Combine(testing::Values(builtin::Function::kLog),
testing::ValuesIn(Concat(LogCases<AFloat>(), //
LogCases<f32>(),
LogCases<f16>()))));
@@ -1698,7 +1698,7 @@
INSTANTIATE_TEST_SUITE_P( //
LogF16,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kLog),
+ testing::Combine(testing::Values(builtin::Function::kLog),
testing::ValuesIn(LogF16Cases<f16>())));
template <typename T>
std::vector<Case> LogF32Cases() {
@@ -1709,7 +1709,7 @@
INSTANTIATE_TEST_SUITE_P( //
LogF32,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kLog),
+ testing::Combine(testing::Values(builtin::Function::kLog),
testing::ValuesIn(LogF32Cases<f32>())));
template <typename T>
@@ -1721,7 +1721,7 @@
INSTANTIATE_TEST_SUITE_P( //
LogAbstract,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kLog),
+ testing::Combine(testing::Values(builtin::Function::kLog),
testing::ValuesIn(LogAbstractCases<AFloat>())));
template <typename T>
@@ -1739,7 +1739,7 @@
INSTANTIATE_TEST_SUITE_P( //
Log2,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kLog2),
+ testing::Combine(testing::Values(builtin::Function::kLog2),
testing::ValuesIn(Concat(Log2Cases<AFloat>(), //
Log2Cases<f32>(),
Log2Cases<f16>()))));
@@ -1752,7 +1752,7 @@
INSTANTIATE_TEST_SUITE_P( //
Log2F16,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kLog2),
+ testing::Combine(testing::Values(builtin::Function::kLog2),
testing::ValuesIn(Log2F16Cases<f16>())));
template <typename T>
std::vector<Case> Log2F32Cases() {
@@ -1763,7 +1763,7 @@
INSTANTIATE_TEST_SUITE_P( //
Log2F32,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kLog2),
+ testing::Combine(testing::Values(builtin::Function::kLog2),
testing::ValuesIn(Log2F32Cases<f32>())));
template <typename T>
std::vector<Case> Log2AbstractCases() {
@@ -1774,7 +1774,7 @@
INSTANTIATE_TEST_SUITE_P( //
Log2Abstract,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kLog2),
+ testing::Combine(testing::Values(builtin::Function::kLog2),
testing::ValuesIn(Log2AbstractCases<AFloat>())));
template <typename T>
@@ -1797,7 +1797,7 @@
INSTANTIATE_TEST_SUITE_P( //
Max,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kMax),
+ testing::Combine(testing::Values(builtin::Function::kMax),
testing::ValuesIn(Concat(MaxCases<AInt>(), //
MaxCases<i32>(),
MaxCases<u32>(),
@@ -1823,7 +1823,7 @@
INSTANTIATE_TEST_SUITE_P( //
Min,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kMin),
+ testing::Combine(testing::Values(builtin::Function::kMin),
testing::ValuesIn(Concat(MinCases<AInt>(), //
MinCases<i32>(),
MinCases<u32>(),
@@ -1913,7 +1913,7 @@
INSTANTIATE_TEST_SUITE_P( //
Mix,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kMix),
+ testing::Combine(testing::Values(builtin::Function::kMix),
testing::ValuesIn(Concat(MixCases<AFloat>(), //
MixCases<f32>(), //
MixCases<f16>()))));
@@ -1947,7 +1947,7 @@
INSTANTIATE_TEST_SUITE_P( //
Modf,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kModf),
+ testing::Combine(testing::Values(builtin::Function::kModf),
testing::ValuesIn(Concat(ModfCases<AFloat>(), //
ModfCases<f32>(), //
ModfCases<f16>()))));
@@ -1977,7 +1977,7 @@
INSTANTIATE_TEST_SUITE_P( //
Normalize,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kNormalize),
+ testing::Combine(testing::Values(builtin::Function::kNormalize),
testing::ValuesIn(Concat(NormalizeCases<AFloat>(), //
NormalizeCases<f32>(), //
NormalizeCases<f16>()))));
@@ -1997,7 +1997,7 @@
INSTANTIATE_TEST_SUITE_P( //
Pack4x8snorm,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kPack4X8Snorm),
+ testing::Combine(testing::Values(builtin::Function::kPack4X8Snorm),
testing::ValuesIn(Pack4x8snormCases())));
std::vector<Case> Pack4x8unormCases() {
@@ -2014,7 +2014,7 @@
INSTANTIATE_TEST_SUITE_P( //
Pack4x8unorm,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kPack4X8Unorm),
+ testing::Combine(testing::Values(builtin::Function::kPack4X8Unorm),
testing::ValuesIn(Pack4x8unormCases())));
std::vector<Case> Pack2x16floatCases() {
@@ -2035,7 +2035,7 @@
INSTANTIATE_TEST_SUITE_P( //
Pack2x16float,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kPack2X16Float),
+ testing::Combine(testing::Values(builtin::Function::kPack2X16Float),
testing::ValuesIn(Pack2x16floatCases())));
std::vector<Case> Pack2x16snormCases() {
@@ -2053,7 +2053,7 @@
INSTANTIATE_TEST_SUITE_P( //
Pack2x16snorm,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kPack2X16Snorm),
+ testing::Combine(testing::Values(builtin::Function::kPack2X16Snorm),
testing::ValuesIn(Pack2x16snormCases())));
std::vector<Case> Pack2x16unormCases() {
@@ -2067,7 +2067,7 @@
INSTANTIATE_TEST_SUITE_P( //
Pack2x16unorm,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kPack2X16Unorm),
+ testing::Combine(testing::Values(builtin::Function::kPack2X16Unorm),
testing::ValuesIn(Pack2x16unormCases())));
template <typename T>
@@ -2113,7 +2113,7 @@
INSTANTIATE_TEST_SUITE_P( //
Pow,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kPow),
+ testing::Combine(testing::Values(builtin::Function::kPow),
testing::ValuesIn(Concat(PowCases<AFloat>(), //
PowCases<f32>(), //
PowCases<f16>()))));
@@ -2160,7 +2160,7 @@
INSTANTIATE_TEST_SUITE_P( //
ReverseBits,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kReverseBits),
+ testing::Combine(testing::Values(builtin::Function::kReverseBits),
testing::ValuesIn(Concat(ReverseBitsCases<i32>(), //
ReverseBitsCases<u32>()))));
@@ -2212,7 +2212,7 @@
INSTANTIATE_TEST_SUITE_P( //
Reflect,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kReflect),
+ testing::Combine(testing::Values(builtin::Function::kReflect),
testing::ValuesIn(Concat(ReflectCases<AFloat>(), //
ReflectCases<f32>(), //
ReflectCases<f16>()))));
@@ -2294,7 +2294,7 @@
INSTANTIATE_TEST_SUITE_P( //
Refract,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kRefract),
+ testing::Combine(testing::Values(builtin::Function::kRefract),
testing::ValuesIn(Concat(RefractCases<AFloat>(), //
RefractCases<f32>(), //
RefractCases<f16>()))));
@@ -2313,7 +2313,7 @@
INSTANTIATE_TEST_SUITE_P( //
Radians,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kRadians),
+ testing::Combine(testing::Values(builtin::Function::kRadians),
testing::ValuesIn(Concat(RadiansCases<AFloat>(), //
RadiansCases<f32>()))));
@@ -2331,7 +2331,7 @@
INSTANTIATE_TEST_SUITE_P( //
RadiansF16,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kRadians),
+ testing::Combine(testing::Values(builtin::Function::kRadians),
testing::ValuesIn(RadiansF16Cases<f16>())));
template <typename T>
@@ -2357,7 +2357,7 @@
INSTANTIATE_TEST_SUITE_P( //
Round,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kRound),
+ testing::Combine(testing::Values(builtin::Function::kRound),
testing::ValuesIn(Concat(RoundCases<AFloat>(), //
RoundCases<f32>(),
RoundCases<f16>()))));
@@ -2382,7 +2382,7 @@
INSTANTIATE_TEST_SUITE_P( //
Saturate,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kSaturate),
+ testing::Combine(testing::Values(builtin::Function::kSaturate),
testing::ValuesIn(Concat(SaturateCases<AFloat>(), //
SaturateCases<f32>(),
SaturateCases<f16>()))));
@@ -2424,7 +2424,7 @@
INSTANTIATE_TEST_SUITE_P( //
Select,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kSelect),
+ testing::Combine(testing::Values(builtin::Function::kSelect),
testing::ValuesIn(Concat(SelectCases<AInt>(), //
SelectCases<i32>(),
SelectCases<u32>(),
@@ -2465,7 +2465,7 @@
INSTANTIATE_TEST_SUITE_P( //
Sign,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kSign),
+ testing::Combine(testing::Values(builtin::Function::kSign),
testing::ValuesIn(Concat(SignCases<AInt>(), //
SignCases<i32>(),
SignCases<AFloat>(),
@@ -2487,7 +2487,7 @@
INSTANTIATE_TEST_SUITE_P( //
Sin,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kSin),
+ testing::Combine(testing::Values(builtin::Function::kSin),
testing::ValuesIn(Concat(SinCases<AFloat>(), //
SinCases<f32>(),
SinCases<f16>()))));
@@ -2512,7 +2512,7 @@
INSTANTIATE_TEST_SUITE_P( //
Sinh,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kSinh),
+ testing::Combine(testing::Values(builtin::Function::kSinh),
testing::ValuesIn(Concat(SinhCases<AFloat>(), //
SinhCases<f32>(),
SinhCases<f16>()))));
@@ -2545,7 +2545,7 @@
INSTANTIATE_TEST_SUITE_P( //
Smoothstep,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kSmoothstep),
+ testing::Combine(testing::Values(builtin::Function::kSmoothstep),
testing::ValuesIn(Concat(SmoothstepCases<AFloat>(), //
SmoothstepCases<f32>(),
SmoothstepCases<f16>()))));
@@ -2577,7 +2577,7 @@
INSTANTIATE_TEST_SUITE_P( //
Step,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kStep),
+ testing::Combine(testing::Values(builtin::Function::kStep),
testing::ValuesIn(Concat(StepCases<AFloat>(), //
StepCases<f32>(),
StepCases<f16>()))));
@@ -2598,7 +2598,7 @@
INSTANTIATE_TEST_SUITE_P( //
Sqrt,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kSqrt),
+ testing::Combine(testing::Values(builtin::Function::kSqrt),
testing::ValuesIn(Concat(SqrtCases<AFloat>(), //
SqrtCases<f32>(),
SqrtCases<f16>()))));
@@ -2617,7 +2617,7 @@
INSTANTIATE_TEST_SUITE_P( //
Tan,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kTan),
+ testing::Combine(testing::Values(builtin::Function::kTan),
testing::ValuesIn(Concat(TanCases<AFloat>(), //
TanCases<f32>(),
TanCases<f16>()))));
@@ -2637,7 +2637,7 @@
INSTANTIATE_TEST_SUITE_P( //
Tanh,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kTanh),
+ testing::Combine(testing::Values(builtin::Function::kTanh),
testing::ValuesIn(Concat(TanhCases<AFloat>(), //
TanhCases<f32>(),
TanhCases<f16>()))));
@@ -2703,7 +2703,7 @@
INSTANTIATE_TEST_SUITE_P( //
Transpose,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kTranspose),
+ testing::Combine(testing::Values(builtin::Function::kTranspose),
testing::ValuesIn(Concat(TransposeCases<AFloat>(), //
TransposeCases<f32>(),
TransposeCases<f16>()))));
@@ -2721,7 +2721,7 @@
INSTANTIATE_TEST_SUITE_P( //
Trunc,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kTrunc),
+ testing::Combine(testing::Values(builtin::Function::kTrunc),
testing::ValuesIn(Concat(TruncCases<AFloat>(), //
TruncCases<f32>(),
TruncCases<f16>()))));
@@ -2742,7 +2742,7 @@
INSTANTIATE_TEST_SUITE_P( //
Unpack4x8snorm,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kUnpack4X8Snorm),
+ testing::Combine(testing::Values(builtin::Function::kUnpack4X8Snorm),
testing::ValuesIn(Unpack4x8snormCases())));
std::vector<Case> Unpack4x8unormCases() {
@@ -2759,7 +2759,7 @@
INSTANTIATE_TEST_SUITE_P( //
Unpack4x8unorm,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kUnpack4X8Unorm),
+ testing::Combine(testing::Values(builtin::Function::kUnpack4X8Unorm),
testing::ValuesIn(Unpack4x8unormCases())));
std::vector<Case> Unpack2x16floatCases() {
@@ -2773,7 +2773,7 @@
INSTANTIATE_TEST_SUITE_P( //
Unpack2x16float,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kUnpack2X16Float),
+ testing::Combine(testing::Values(builtin::Function::kUnpack2X16Float),
testing::ValuesIn(Unpack2x16floatCases())));
std::vector<Case> Unpack2x16snormCases() {
@@ -2791,7 +2791,7 @@
INSTANTIATE_TEST_SUITE_P( //
Unpack2x16snorm,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kUnpack2X16Snorm),
+ testing::Combine(testing::Values(builtin::Function::kUnpack2X16Snorm),
testing::ValuesIn(Unpack2x16snormCases())));
std::vector<Case> Unpack2x16unormCases() {
@@ -2805,7 +2805,7 @@
INSTANTIATE_TEST_SUITE_P( //
Unpack2x16unorm,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kUnpack2X16Unorm),
+ testing::Combine(testing::Values(builtin::Function::kUnpack2X16Unorm),
testing::ValuesIn(Unpack2x16unormCases())));
std::vector<Case> QuantizeToF16Cases() {
@@ -2864,7 +2864,7 @@
INSTANTIATE_TEST_SUITE_P( //
QuantizeToF16,
ResolverConstEvalBuiltinTest,
- testing::Combine(testing::Values(sem::BuiltinType::kQuantizeToF16),
+ testing::Combine(testing::Values(builtin::Function::kQuantizeToF16),
testing::ValuesIn(QuantizeToF16Cases())));
} // namespace
diff --git a/src/tint/resolver/dependency_graph.cc b/src/tint/resolver/dependency_graph.cc
index f718a46..67eb430 100644
--- a/src/tint/resolver/dependency_graph.cc
+++ b/src/tint/resolver/dependency_graph.cc
@@ -440,7 +440,8 @@
auto* resolved = scope_stack_.Get(to);
if (!resolved) {
auto s = symbols_.NameFor(to);
- if (auto builtin_fn = sem::ParseBuiltinType(s); builtin_fn != sem::BuiltinType::kNone) {
+ if (auto builtin_fn = builtin::ParseFunction(s);
+ builtin_fn != builtin::Function::kNone) {
graph_.resolved_identifiers.Add(from, ResolvedIdentifier(builtin_fn));
return;
}
@@ -838,7 +839,7 @@
return "<unknown>";
});
}
- if (auto builtin_fn = BuiltinFunction(); builtin_fn != sem::BuiltinType::kNone) {
+ if (auto builtin_fn = BuiltinFunction(); builtin_fn != builtin::Function::kNone) {
return "builtin function '" + utils::ToString(builtin_fn) + "'";
}
if (auto builtin_ty = BuiltinType(); builtin_ty != builtin::Builtin::kUndefined) {
diff --git a/src/tint/resolver/dependency_graph.h b/src/tint/resolver/dependency_graph.h
index 429a47a..f58b2a2 100644
--- a/src/tint/resolver/dependency_graph.h
+++ b/src/tint/resolver/dependency_graph.h
@@ -22,11 +22,11 @@
#include "src/tint/builtin/access.h"
#include "src/tint/builtin/builtin.h"
#include "src/tint/builtin/builtin_value.h"
+#include "src/tint/builtin/function.h"
#include "src/tint/builtin/interpolation_sampling.h"
#include "src/tint/builtin/interpolation_type.h"
#include "src/tint/builtin/texel_format.h"
#include "src/tint/diagnostic/diagnostic.h"
-#include "src/tint/sem/builtin_type.h"
#include "src/tint/symbol_table.h"
#include "src/tint/utils/hashmap.h"
@@ -44,7 +44,7 @@
/// - const ast::TypeDecl* (as const ast::Node*)
/// - const ast::Variable* (as const ast::Node*)
/// - const ast::Function* (as const ast::Node*)
-/// - sem::BuiltinType
+/// - builtin::Function
/// - builtin::Access
/// - builtin::AddressSpace
/// - builtin::Builtin
@@ -75,13 +75,13 @@
return nullptr;
}
- /// @return the builtin function if the ResolvedIdentifier holds sem::BuiltinType, otherwise
- /// sem::BuiltinType::kNone
- sem::BuiltinType BuiltinFunction() const {
- if (auto n = std::get_if<sem::BuiltinType>(&value_)) {
+ /// @return the builtin function if the ResolvedIdentifier holds builtin::Function, otherwise
+ /// builtin::Function::kNone
+ builtin::Function BuiltinFunction() const {
+ if (auto n = std::get_if<builtin::Function>(&value_)) {
return *n;
}
- return sem::BuiltinType::kNone;
+ return builtin::Function::kNone;
}
/// @return the access if the ResolvedIdentifier holds builtin::Access, otherwise
@@ -172,7 +172,7 @@
private:
std::variant<UnresolvedIdentifier,
const ast::Node*,
- sem::BuiltinType,
+ builtin::Function,
builtin::Access,
builtin::AddressSpace,
builtin::Builtin,
diff --git a/src/tint/resolver/dependency_graph_test.cc b/src/tint/resolver/dependency_graph_test.cc
index c81c336..c9ce3b8 100644
--- a/src/tint/resolver/dependency_graph_test.cc
+++ b/src/tint/resolver/dependency_graph_test.cc
@@ -1181,7 +1181,7 @@
namespace resolve_to_builtin_func {
using ResolverDependencyGraphResolveToBuiltinFunc =
- ResolverDependencyGraphTestWithParam<std::tuple<SymbolUseKind, sem::BuiltinType>>;
+ ResolverDependencyGraphTestWithParam<std::tuple<SymbolUseKind, builtin::Function>>;
TEST_P(ResolverDependencyGraphResolveToBuiltinFunc, Resolve) {
const auto use = std::get<0>(GetParam());
@@ -1200,17 +1200,17 @@
INSTANTIATE_TEST_SUITE_P(Types,
ResolverDependencyGraphResolveToBuiltinFunc,
testing::Combine(testing::ValuesIn(kTypeUseKinds),
- testing::ValuesIn(sem::kBuiltinTypes)));
+ testing::ValuesIn(builtin::kFunctions)));
INSTANTIATE_TEST_SUITE_P(Values,
ResolverDependencyGraphResolveToBuiltinFunc,
testing::Combine(testing::ValuesIn(kValueUseKinds),
- testing::ValuesIn(sem::kBuiltinTypes)));
+ testing::ValuesIn(builtin::kFunctions)));
INSTANTIATE_TEST_SUITE_P(Functions,
ResolverDependencyGraphResolveToBuiltinFunc,
testing::Combine(testing::ValuesIn(kFuncUseKinds),
- testing::ValuesIn(sem::kBuiltinTypes)));
+ testing::ValuesIn(builtin::kFunctions)));
} // namespace resolve_to_builtin_func
diff --git a/src/tint/resolver/intrinsic_table.cc b/src/tint/resolver/intrinsic_table.cc
index e8fe271..8bd12e2 100644
--- a/src/tint/resolver/intrinsic_table.cc
+++ b/src/tint/resolver/intrinsic_table.cc
@@ -1096,7 +1096,7 @@
public:
explicit Impl(ProgramBuilder& builder);
- Builtin Lookup(sem::BuiltinType builtin_type,
+ Builtin Lookup(builtin::Function builtin_type,
utils::VectorRef<const type::Type*> args,
sem::EvaluationStage earliest_eval_stage,
const Source& source) override;
@@ -1264,11 +1264,11 @@
Impl::Impl(ProgramBuilder& b) : builder(b) {}
-Impl::Builtin Impl::Lookup(sem::BuiltinType builtin_type,
+Impl::Builtin Impl::Lookup(builtin::Function builtin_type,
utils::VectorRef<const type::Type*> args,
sem::EvaluationStage earliest_eval_stage,
const Source& source) {
- const char* intrinsic_name = sem::str(builtin_type);
+ const char* intrinsic_name = builtin::str(builtin_type);
// Generates an error when no overloads match the provided arguments
auto on_no_match = [&](utils::VectorRef<Candidate> candidates) {
diff --git a/src/tint/resolver/intrinsic_table.h b/src/tint/resolver/intrinsic_table.h
index 515e839..78e2e7a 100644
--- a/src/tint/resolver/intrinsic_table.h
+++ b/src/tint/resolver/intrinsic_table.h
@@ -92,7 +92,7 @@
/// after shader creation time (sem::EvaluationStage::kConstant).
/// @param source the source of the builtin call
/// @return the semantic builtin if found, otherwise nullptr
- virtual Builtin Lookup(sem::BuiltinType type,
+ virtual Builtin Lookup(builtin::Function type,
utils::VectorRef<const type::Type*> args,
sem::EvaluationStage earliest_eval_stage,
const Source& source) = 0;
diff --git a/src/tint/resolver/intrinsic_table_test.cc b/src/tint/resolver/intrinsic_table_test.cc
index 7f0399d..c842af5 100644
--- a/src/tint/resolver/intrinsic_table_test.cc
+++ b/src/tint/resolver/intrinsic_table_test.cc
@@ -37,7 +37,6 @@
using ::testing::HasSubstr;
-using BuiltinType = sem::BuiltinType;
using Parameter = sem::Parameter;
using ParameterUsage = sem::ParameterUsage;
@@ -54,11 +53,11 @@
TEST_F(IntrinsicTableTest, MatchF32) {
auto* f32 = create<type::F32>();
- auto result = table->Lookup(BuiltinType::kCos, utils::Vector{f32},
+ auto result = table->Lookup(builtin::Function::kCos, utils::Vector{f32},
sem::EvaluationStage::kConstant, Source{});
ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
- EXPECT_EQ(result.sem->Type(), BuiltinType::kCos);
+ EXPECT_EQ(result.sem->Type(), builtin::Function::kCos);
EXPECT_EQ(result.sem->ReturnType(), f32);
ASSERT_EQ(result.sem->Parameters().Length(), 1u);
EXPECT_EQ(result.sem->Parameters()[0]->Type(), f32);
@@ -66,7 +65,7 @@
TEST_F(IntrinsicTableTest, MismatchF32) {
auto* i32 = create<type::I32>();
- auto result = table->Lookup(BuiltinType::kCos, utils::Vector{i32},
+ auto result = table->Lookup(builtin::Function::kCos, utils::Vector{i32},
sem::EvaluationStage::kConstant, Source{});
ASSERT_EQ(result.sem, nullptr);
ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
@@ -76,11 +75,11 @@
auto* f32 = create<type::F32>();
auto* u32 = create<type::U32>();
auto* vec2_f32 = create<type::Vector>(f32, 2u);
- auto result = table->Lookup(BuiltinType::kUnpack2X16Float, utils::Vector{u32},
+ auto result = table->Lookup(builtin::Function::kUnpack2X16Float, utils::Vector{u32},
sem::EvaluationStage::kConstant, Source{});
ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
- EXPECT_EQ(result.sem->Type(), BuiltinType::kUnpack2X16Float);
+ EXPECT_EQ(result.sem->Type(), builtin::Function::kUnpack2X16Float);
EXPECT_EQ(result.sem->ReturnType(), vec2_f32);
ASSERT_EQ(result.sem->Parameters().Length(), 1u);
EXPECT_EQ(result.sem->Parameters()[0]->Type(), u32);
@@ -88,7 +87,7 @@
TEST_F(IntrinsicTableTest, MismatchU32) {
auto* f32 = create<type::F32>();
- auto result = table->Lookup(BuiltinType::kUnpack2X16Float, utils::Vector{f32},
+ auto result = table->Lookup(builtin::Function::kUnpack2X16Float, utils::Vector{f32},
sem::EvaluationStage::kConstant, Source{});
ASSERT_EQ(result.sem, nullptr);
ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
@@ -99,11 +98,11 @@
auto* i32 = create<type::I32>();
auto* vec4_f32 = create<type::Vector>(f32, 4u);
auto* tex = create<type::SampledTexture>(type::TextureDimension::k1d, f32);
- auto result = table->Lookup(BuiltinType::kTextureLoad, utils::Vector{tex, i32, i32},
+ auto result = table->Lookup(builtin::Function::kTextureLoad, utils::Vector{tex, i32, i32},
sem::EvaluationStage::kConstant, Source{});
ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
- EXPECT_EQ(result.sem->Type(), BuiltinType::kTextureLoad);
+ EXPECT_EQ(result.sem->Type(), builtin::Function::kTextureLoad);
EXPECT_EQ(result.sem->ReturnType(), vec4_f32);
ASSERT_EQ(result.sem->Parameters().Length(), 3u);
EXPECT_EQ(result.sem->Parameters()[0]->Type(), tex);
@@ -117,7 +116,7 @@
TEST_F(IntrinsicTableTest, MismatchI32) {
auto* f32 = create<type::F32>();
auto* tex = create<type::SampledTexture>(type::TextureDimension::k1d, f32);
- auto result = table->Lookup(BuiltinType::kTextureLoad, utils::Vector{tex, f32},
+ auto result = table->Lookup(builtin::Function::kTextureLoad, utils::Vector{tex, f32},
sem::EvaluationStage::kConstant, Source{});
ASSERT_EQ(result.sem, nullptr);
ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
@@ -125,11 +124,11 @@
TEST_F(IntrinsicTableTest, MatchIU32AsI32) {
auto* i32 = create<type::I32>();
- auto result = table->Lookup(BuiltinType::kCountOneBits, utils::Vector{i32},
+ auto result = table->Lookup(builtin::Function::kCountOneBits, utils::Vector{i32},
sem::EvaluationStage::kConstant, Source{});
ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
- EXPECT_EQ(result.sem->Type(), BuiltinType::kCountOneBits);
+ EXPECT_EQ(result.sem->Type(), builtin::Function::kCountOneBits);
EXPECT_EQ(result.sem->ReturnType(), i32);
ASSERT_EQ(result.sem->Parameters().Length(), 1u);
EXPECT_EQ(result.sem->Parameters()[0]->Type(), i32);
@@ -137,11 +136,11 @@
TEST_F(IntrinsicTableTest, MatchIU32AsU32) {
auto* u32 = create<type::U32>();
- auto result = table->Lookup(BuiltinType::kCountOneBits, utils::Vector{u32},
+ auto result = table->Lookup(builtin::Function::kCountOneBits, utils::Vector{u32},
sem::EvaluationStage::kConstant, Source{});
ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
- EXPECT_EQ(result.sem->Type(), BuiltinType::kCountOneBits);
+ EXPECT_EQ(result.sem->Type(), builtin::Function::kCountOneBits);
EXPECT_EQ(result.sem->ReturnType(), u32);
ASSERT_EQ(result.sem->Parameters().Length(), 1u);
EXPECT_EQ(result.sem->Parameters()[0]->Type(), u32);
@@ -149,7 +148,7 @@
TEST_F(IntrinsicTableTest, MismatchIU32) {
auto* f32 = create<type::F32>();
- auto result = table->Lookup(BuiltinType::kCountOneBits, utils::Vector{f32},
+ auto result = table->Lookup(builtin::Function::kCountOneBits, utils::Vector{f32},
sem::EvaluationStage::kConstant, Source{});
ASSERT_EQ(result.sem, nullptr);
ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
@@ -157,11 +156,11 @@
TEST_F(IntrinsicTableTest, MatchFIU32AsI32) {
auto* i32 = create<type::I32>();
- auto result = table->Lookup(BuiltinType::kClamp, utils::Vector{i32, i32, i32},
+ auto result = table->Lookup(builtin::Function::kClamp, utils::Vector{i32, i32, i32},
sem::EvaluationStage::kConstant, Source{});
ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
- EXPECT_EQ(result.sem->Type(), BuiltinType::kClamp);
+ EXPECT_EQ(result.sem->Type(), builtin::Function::kClamp);
EXPECT_EQ(result.sem->ReturnType(), i32);
ASSERT_EQ(result.sem->Parameters().Length(), 3u);
EXPECT_EQ(result.sem->Parameters()[0]->Type(), i32);
@@ -171,11 +170,11 @@
TEST_F(IntrinsicTableTest, MatchFIU32AsU32) {
auto* u32 = create<type::U32>();
- auto result = table->Lookup(BuiltinType::kClamp, utils::Vector{u32, u32, u32},
+ auto result = table->Lookup(builtin::Function::kClamp, utils::Vector{u32, u32, u32},
sem::EvaluationStage::kConstant, Source{});
ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
- EXPECT_EQ(result.sem->Type(), BuiltinType::kClamp);
+ EXPECT_EQ(result.sem->Type(), builtin::Function::kClamp);
EXPECT_EQ(result.sem->ReturnType(), u32);
ASSERT_EQ(result.sem->Parameters().Length(), 3u);
EXPECT_EQ(result.sem->Parameters()[0]->Type(), u32);
@@ -185,11 +184,11 @@
TEST_F(IntrinsicTableTest, MatchFIU32AsF32) {
auto* f32 = create<type::F32>();
- auto result = table->Lookup(BuiltinType::kClamp, utils::Vector{f32, f32, f32},
+ auto result = table->Lookup(builtin::Function::kClamp, utils::Vector{f32, f32, f32},
sem::EvaluationStage::kConstant, Source{});
ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
- EXPECT_EQ(result.sem->Type(), BuiltinType::kClamp);
+ EXPECT_EQ(result.sem->Type(), builtin::Function::kClamp);
EXPECT_EQ(result.sem->ReturnType(), f32);
ASSERT_EQ(result.sem->Parameters().Length(), 3u);
EXPECT_EQ(result.sem->Parameters()[0]->Type(), f32);
@@ -199,7 +198,7 @@
TEST_F(IntrinsicTableTest, MismatchFIU32) {
auto* bool_ = create<type::Bool>();
- auto result = table->Lookup(BuiltinType::kClamp, utils::Vector{bool_, bool_, bool_},
+ auto result = table->Lookup(builtin::Function::kClamp, utils::Vector{bool_, bool_, bool_},
sem::EvaluationStage::kConstant, Source{});
ASSERT_EQ(result.sem, nullptr);
ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
@@ -208,11 +207,11 @@
TEST_F(IntrinsicTableTest, MatchBool) {
auto* f32 = create<type::F32>();
auto* bool_ = create<type::Bool>();
- auto result = table->Lookup(BuiltinType::kSelect, utils::Vector{f32, f32, bool_},
+ auto result = table->Lookup(builtin::Function::kSelect, utils::Vector{f32, f32, bool_},
sem::EvaluationStage::kConstant, Source{});
ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
- EXPECT_EQ(result.sem->Type(), BuiltinType::kSelect);
+ EXPECT_EQ(result.sem->Type(), builtin::Function::kSelect);
EXPECT_EQ(result.sem->ReturnType(), f32);
ASSERT_EQ(result.sem->Parameters().Length(), 3u);
EXPECT_EQ(result.sem->Parameters()[0]->Type(), f32);
@@ -222,7 +221,7 @@
TEST_F(IntrinsicTableTest, MismatchBool) {
auto* f32 = create<type::F32>();
- auto result = table->Lookup(BuiltinType::kSelect, utils::Vector{f32, f32, f32},
+ auto result = table->Lookup(builtin::Function::kSelect, utils::Vector{f32, f32, f32},
sem::EvaluationStage::kConstant, Source{});
ASSERT_EQ(result.sem, nullptr);
ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
@@ -233,11 +232,11 @@
auto* atomicI32 = create<type::Atomic>(i32);
auto* ptr = create<type::Pointer>(atomicI32, builtin::AddressSpace::kWorkgroup,
builtin::Access::kReadWrite);
- auto result = table->Lookup(BuiltinType::kAtomicLoad, utils::Vector{ptr},
+ auto result = table->Lookup(builtin::Function::kAtomicLoad, utils::Vector{ptr},
sem::EvaluationStage::kConstant, Source{});
ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
- EXPECT_EQ(result.sem->Type(), BuiltinType::kAtomicLoad);
+ EXPECT_EQ(result.sem->Type(), builtin::Function::kAtomicLoad);
EXPECT_EQ(result.sem->ReturnType(), i32);
ASSERT_EQ(result.sem->Parameters().Length(), 1u);
EXPECT_EQ(result.sem->Parameters()[0]->Type(), ptr);
@@ -246,7 +245,7 @@
TEST_F(IntrinsicTableTest, MismatchPointer) {
auto* i32 = create<type::I32>();
auto* atomicI32 = create<type::Atomic>(i32);
- auto result = table->Lookup(BuiltinType::kAtomicLoad, utils::Vector{atomicI32},
+ auto result = table->Lookup(builtin::Function::kAtomicLoad, utils::Vector{atomicI32},
sem::EvaluationStage::kConstant, Source{});
ASSERT_EQ(result.sem, nullptr);
ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
@@ -257,11 +256,11 @@
create<type::Array>(create<type::U32>(), create<type::RuntimeArrayCount>(), 4u, 4u, 4u, 4u);
auto* arr_ptr =
create<type::Pointer>(arr, builtin::AddressSpace::kStorage, builtin::Access::kReadWrite);
- auto result = table->Lookup(BuiltinType::kArrayLength, utils::Vector{arr_ptr},
+ auto result = table->Lookup(builtin::Function::kArrayLength, utils::Vector{arr_ptr},
sem::EvaluationStage::kConstant, Source{});
ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
- EXPECT_EQ(result.sem->Type(), BuiltinType::kArrayLength);
+ EXPECT_EQ(result.sem->Type(), builtin::Function::kArrayLength);
EXPECT_TRUE(result.sem->ReturnType()->Is<type::U32>());
ASSERT_EQ(result.sem->Parameters().Length(), 1u);
auto* param_type = result.sem->Parameters()[0]->Type();
@@ -271,7 +270,7 @@
TEST_F(IntrinsicTableTest, MismatchArray) {
auto* f32 = create<type::F32>();
- auto result = table->Lookup(BuiltinType::kArrayLength, utils::Vector{f32},
+ auto result = table->Lookup(builtin::Function::kArrayLength, utils::Vector{f32},
sem::EvaluationStage::kConstant, Source{});
ASSERT_EQ(result.sem, nullptr);
ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
@@ -283,11 +282,12 @@
auto* vec4_f32 = create<type::Vector>(f32, 4u);
auto* tex = create<type::SampledTexture>(type::TextureDimension::k2d, f32);
auto* sampler = create<type::Sampler>(type::SamplerKind::kSampler);
- auto result = table->Lookup(BuiltinType::kTextureSample, utils::Vector{tex, sampler, vec2_f32},
- sem::EvaluationStage::kConstant, Source{});
+ auto result =
+ table->Lookup(builtin::Function::kTextureSample, utils::Vector{tex, sampler, vec2_f32},
+ sem::EvaluationStage::kConstant, Source{});
ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
- EXPECT_EQ(result.sem->Type(), BuiltinType::kTextureSample);
+ EXPECT_EQ(result.sem->Type(), builtin::Function::kTextureSample);
EXPECT_EQ(result.sem->ReturnType(), vec4_f32);
ASSERT_EQ(result.sem->Parameters().Length(), 3u);
EXPECT_EQ(result.sem->Parameters()[0]->Type(), tex);
@@ -302,8 +302,9 @@
auto* f32 = create<type::F32>();
auto* vec2_f32 = create<type::Vector>(f32, 2u);
auto* tex = create<type::SampledTexture>(type::TextureDimension::k2d, f32);
- auto result = table->Lookup(BuiltinType::kTextureSample, utils::Vector{tex, f32, vec2_f32},
- sem::EvaluationStage::kConstant, Source{});
+ auto result =
+ table->Lookup(builtin::Function::kTextureSample, utils::Vector{tex, f32, vec2_f32},
+ sem::EvaluationStage::kConstant, Source{});
ASSERT_EQ(result.sem, nullptr);
ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
}
@@ -314,11 +315,11 @@
auto* vec2_i32 = create<type::Vector>(i32, 2u);
auto* vec4_f32 = create<type::Vector>(f32, 4u);
auto* tex = create<type::SampledTexture>(type::TextureDimension::k2d, f32);
- auto result = table->Lookup(BuiltinType::kTextureLoad, utils::Vector{tex, vec2_i32, i32},
+ auto result = table->Lookup(builtin::Function::kTextureLoad, utils::Vector{tex, vec2_i32, i32},
sem::EvaluationStage::kConstant, Source{});
ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
- EXPECT_EQ(result.sem->Type(), BuiltinType::kTextureLoad);
+ EXPECT_EQ(result.sem->Type(), builtin::Function::kTextureLoad);
EXPECT_EQ(result.sem->ReturnType(), vec4_f32);
ASSERT_EQ(result.sem->Parameters().Length(), 3u);
EXPECT_EQ(result.sem->Parameters()[0]->Type(), tex);
@@ -335,11 +336,11 @@
auto* vec2_i32 = create<type::Vector>(i32, 2u);
auto* vec4_f32 = create<type::Vector>(f32, 4u);
auto* tex = create<type::MultisampledTexture>(type::TextureDimension::k2d, f32);
- auto result = table->Lookup(BuiltinType::kTextureLoad, utils::Vector{tex, vec2_i32, i32},
+ auto result = table->Lookup(builtin::Function::kTextureLoad, utils::Vector{tex, vec2_i32, i32},
sem::EvaluationStage::kConstant, Source{});
ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
- EXPECT_EQ(result.sem->Type(), BuiltinType::kTextureLoad);
+ EXPECT_EQ(result.sem->Type(), builtin::Function::kTextureLoad);
EXPECT_EQ(result.sem->ReturnType(), vec4_f32);
ASSERT_EQ(result.sem->Parameters().Length(), 3u);
EXPECT_EQ(result.sem->Parameters()[0]->Type(), tex);
@@ -355,11 +356,11 @@
auto* i32 = create<type::I32>();
auto* vec2_i32 = create<type::Vector>(i32, 2u);
auto* tex = create<type::DepthTexture>(type::TextureDimension::k2d);
- auto result = table->Lookup(BuiltinType::kTextureLoad, utils::Vector{tex, vec2_i32, i32},
+ auto result = table->Lookup(builtin::Function::kTextureLoad, utils::Vector{tex, vec2_i32, i32},
sem::EvaluationStage::kConstant, Source{});
ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
- EXPECT_EQ(result.sem->Type(), BuiltinType::kTextureLoad);
+ EXPECT_EQ(result.sem->Type(), builtin::Function::kTextureLoad);
EXPECT_EQ(result.sem->ReturnType(), f32);
ASSERT_EQ(result.sem->Parameters().Length(), 3u);
EXPECT_EQ(result.sem->Parameters()[0]->Type(), tex);
@@ -375,11 +376,11 @@
auto* i32 = create<type::I32>();
auto* vec2_i32 = create<type::Vector>(i32, 2u);
auto* tex = create<type::DepthMultisampledTexture>(type::TextureDimension::k2d);
- auto result = table->Lookup(BuiltinType::kTextureLoad, utils::Vector{tex, vec2_i32, i32},
+ auto result = table->Lookup(builtin::Function::kTextureLoad, utils::Vector{tex, vec2_i32, i32},
sem::EvaluationStage::kConstant, Source{});
ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
- EXPECT_EQ(result.sem->Type(), BuiltinType::kTextureLoad);
+ EXPECT_EQ(result.sem->Type(), builtin::Function::kTextureLoad);
EXPECT_EQ(result.sem->ReturnType(), f32);
ASSERT_EQ(result.sem->Parameters().Length(), 3u);
EXPECT_EQ(result.sem->Parameters()[0]->Type(), tex);
@@ -396,11 +397,11 @@
auto* vec2_i32 = create<type::Vector>(i32, 2u);
auto* vec4_f32 = create<type::Vector>(f32, 4u);
auto* tex = create<type::ExternalTexture>();
- auto result = table->Lookup(BuiltinType::kTextureLoad, utils::Vector{tex, vec2_i32},
+ auto result = table->Lookup(builtin::Function::kTextureLoad, utils::Vector{tex, vec2_i32},
sem::EvaluationStage::kConstant, Source{});
ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
- EXPECT_EQ(result.sem->Type(), BuiltinType::kTextureLoad);
+ EXPECT_EQ(result.sem->Type(), builtin::Function::kTextureLoad);
EXPECT_EQ(result.sem->ReturnType(), vec4_f32);
ASSERT_EQ(result.sem->Parameters().Length(), 2u);
EXPECT_EQ(result.sem->Parameters()[0]->Type(), tex);
@@ -419,11 +420,12 @@
create<type::StorageTexture>(type::TextureDimension::k2d, builtin::TexelFormat::kR32Float,
builtin::Access::kWrite, subtype);
- auto result = table->Lookup(BuiltinType::kTextureStore, utils::Vector{tex, vec2_i32, vec4_f32},
- sem::EvaluationStage::kConstant, Source{});
+ auto result =
+ table->Lookup(builtin::Function::kTextureStore, utils::Vector{tex, vec2_i32, vec4_f32},
+ sem::EvaluationStage::kConstant, Source{});
ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
- EXPECT_EQ(result.sem->Type(), BuiltinType::kTextureStore);
+ EXPECT_EQ(result.sem->Type(), builtin::Function::kTextureStore);
EXPECT_TRUE(result.sem->ReturnType()->Is<type::Void>());
ASSERT_EQ(result.sem->Parameters().Length(), 3u);
EXPECT_EQ(result.sem->Parameters()[0]->Type(), tex);
@@ -438,7 +440,7 @@
auto* f32 = create<type::F32>();
auto* i32 = create<type::I32>();
auto* vec2_i32 = create<type::Vector>(i32, 2u);
- auto result = table->Lookup(BuiltinType::kTextureLoad, utils::Vector{f32, vec2_i32},
+ auto result = table->Lookup(builtin::Function::kTextureLoad, utils::Vector{f32, vec2_i32},
sem::EvaluationStage::kConstant, Source{});
ASSERT_EQ(result.sem, nullptr);
ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
@@ -446,7 +448,7 @@
TEST_F(IntrinsicTableTest, ImplicitLoadOnReference) {
auto* f32 = create<type::F32>();
- auto result = table->Lookup(BuiltinType::kCos,
+ auto result = table->Lookup(builtin::Function::kCos,
utils::Vector{
create<type::Reference>(f32, builtin::AddressSpace::kFunction,
builtin::Access::kReadWrite),
@@ -454,7 +456,7 @@
sem::EvaluationStage::kConstant, Source{});
ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
- EXPECT_EQ(result.sem->Type(), BuiltinType::kCos);
+ EXPECT_EQ(result.sem->Type(), builtin::Function::kCos);
EXPECT_EQ(result.sem->ReturnType(), f32);
ASSERT_EQ(result.sem->Parameters().Length(), 1u);
EXPECT_EQ(result.sem->Parameters()[0]->Type(), f32);
@@ -462,11 +464,11 @@
TEST_F(IntrinsicTableTest, MatchTemplateType) {
auto* f32 = create<type::F32>();
- auto result = table->Lookup(BuiltinType::kClamp, utils::Vector{f32, f32, f32},
+ auto result = table->Lookup(builtin::Function::kClamp, utils::Vector{f32, f32, f32},
sem::EvaluationStage::kConstant, Source{});
ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
- EXPECT_EQ(result.sem->Type(), BuiltinType::kClamp);
+ EXPECT_EQ(result.sem->Type(), builtin::Function::kClamp);
EXPECT_EQ(result.sem->ReturnType(), f32);
EXPECT_EQ(result.sem->Parameters()[0]->Type(), f32);
EXPECT_EQ(result.sem->Parameters()[1]->Type(), f32);
@@ -476,7 +478,7 @@
TEST_F(IntrinsicTableTest, MismatchTemplateType) {
auto* f32 = create<type::F32>();
auto* u32 = create<type::U32>();
- auto result = table->Lookup(BuiltinType::kClamp, utils::Vector{f32, u32, f32},
+ auto result = table->Lookup(builtin::Function::kClamp, utils::Vector{f32, u32, f32},
sem::EvaluationStage::kConstant, Source{});
ASSERT_EQ(result.sem, nullptr);
ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
@@ -485,11 +487,12 @@
TEST_F(IntrinsicTableTest, MatchOpenSizeVector) {
auto* f32 = create<type::F32>();
auto* vec2_f32 = create<type::Vector>(f32, 2u);
- auto result = table->Lookup(BuiltinType::kClamp, utils::Vector{vec2_f32, vec2_f32, vec2_f32},
- sem::EvaluationStage::kConstant, Source{});
+ auto result =
+ table->Lookup(builtin::Function::kClamp, utils::Vector{vec2_f32, vec2_f32, vec2_f32},
+ sem::EvaluationStage::kConstant, Source{});
ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
- EXPECT_EQ(result.sem->Type(), BuiltinType::kClamp);
+ EXPECT_EQ(result.sem->Type(), builtin::Function::kClamp);
EXPECT_EQ(result.sem->ReturnType(), vec2_f32);
ASSERT_EQ(result.sem->Parameters().Length(), 3u);
EXPECT_EQ(result.sem->Parameters()[0]->Type(), vec2_f32);
@@ -501,7 +504,7 @@
auto* f32 = create<type::F32>();
auto* u32 = create<type::U32>();
auto* vec2_f32 = create<type::Vector>(f32, 2u);
- auto result = table->Lookup(BuiltinType::kClamp, utils::Vector{vec2_f32, u32, vec2_f32},
+ auto result = table->Lookup(builtin::Function::kClamp, utils::Vector{vec2_f32, u32, vec2_f32},
sem::EvaluationStage::kConstant, Source{});
ASSERT_EQ(result.sem, nullptr);
ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
@@ -511,11 +514,11 @@
auto* f32 = create<type::F32>();
auto* vec3_f32 = create<type::Vector>(f32, 3u);
auto* mat3_f32 = create<type::Matrix>(vec3_f32, 3u);
- auto result = table->Lookup(BuiltinType::kDeterminant, utils::Vector{mat3_f32},
+ auto result = table->Lookup(builtin::Function::kDeterminant, utils::Vector{mat3_f32},
sem::EvaluationStage::kConstant, Source{});
ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
- EXPECT_EQ(result.sem->Type(), BuiltinType::kDeterminant);
+ EXPECT_EQ(result.sem->Type(), builtin::Function::kDeterminant);
EXPECT_EQ(result.sem->ReturnType(), f32);
ASSERT_EQ(result.sem->Parameters().Length(), 1u);
EXPECT_EQ(result.sem->Parameters()[0]->Type(), mat3_f32);
@@ -525,7 +528,7 @@
auto* f32 = create<type::F32>();
auto* vec2_f32 = create<type::Vector>(f32, 2u);
auto* mat3x2_f32 = create<type::Matrix>(vec2_f32, 3u);
- auto result = table->Lookup(BuiltinType::kDeterminant, utils::Vector{mat3x2_f32},
+ auto result = table->Lookup(builtin::Function::kDeterminant, utils::Vector{mat3x2_f32},
sem::EvaluationStage::kConstant, Source{});
ASSERT_EQ(result.sem, nullptr);
ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
@@ -534,12 +537,12 @@
TEST_F(IntrinsicTableTest, MatchDifferentArgsElementType_Builtin_ConstantEval) {
auto* af = create<type::AbstractFloat>();
auto* bool_ = create<type::Bool>();
- auto result = table->Lookup(BuiltinType::kSelect, utils::Vector{af, af, bool_},
+ auto result = table->Lookup(builtin::Function::kSelect, utils::Vector{af, af, bool_},
sem::EvaluationStage::kConstant, Source{});
ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
EXPECT_EQ(result.sem->Stage(), sem::EvaluationStage::kConstant);
- EXPECT_EQ(result.sem->Type(), BuiltinType::kSelect);
+ EXPECT_EQ(result.sem->Type(), builtin::Function::kSelect);
EXPECT_EQ(result.sem->ReturnType(), af);
ASSERT_EQ(result.sem->Parameters().Length(), 3u);
EXPECT_EQ(result.sem->Parameters()[0]->Type(), af);
@@ -551,12 +554,12 @@
auto* af = create<type::AbstractFloat>();
auto* bool_ref = create<type::Reference>(create<type::Bool>(), builtin::AddressSpace::kFunction,
builtin::Access::kReadWrite);
- auto result = table->Lookup(BuiltinType::kSelect, utils::Vector{af, af, bool_ref},
+ auto result = table->Lookup(builtin::Function::kSelect, utils::Vector{af, af, bool_ref},
sem::EvaluationStage::kRuntime, Source{});
ASSERT_NE(result.sem, nullptr) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
EXPECT_EQ(result.sem->Stage(), sem::EvaluationStage::kConstant);
- EXPECT_EQ(result.sem->Type(), BuiltinType::kSelect);
+ EXPECT_EQ(result.sem->Type(), builtin::Function::kSelect);
EXPECT_TRUE(result.sem->ReturnType()->Is<type::F32>());
ASSERT_EQ(result.sem->Parameters().Length(), 3u);
EXPECT_TRUE(result.sem->Parameters()[0]->Type()->Is<type::F32>());
@@ -594,7 +597,7 @@
// None of the arguments match, so expect the overloads with 2 parameters to
// come first
auto* bool_ = create<type::Bool>();
- table->Lookup(BuiltinType::kTextureDimensions, utils::Vector{bool_, bool_},
+ table->Lookup(builtin::Function::kTextureDimensions, utils::Vector{bool_, bool_},
sem::EvaluationStage::kConstant, Source{});
ASSERT_EQ(Diagnostics().str(),
R"(error: no matching call to textureDimensions(bool, bool)
@@ -633,7 +636,7 @@
TEST_F(IntrinsicTableTest, OverloadOrderByMatchingParameter) {
auto* tex = create<type::DepthTexture>(type::TextureDimension::k2d);
auto* bool_ = create<type::Bool>();
- table->Lookup(BuiltinType::kTextureDimensions, utils::Vector{tex, bool_},
+ table->Lookup(builtin::Function::kTextureDimensions, utils::Vector{tex, bool_},
sem::EvaluationStage::kConstant, Source{});
ASSERT_EQ(Diagnostics().str(),
R"(error: no matching call to textureDimensions(texture_depth_2d, bool)
@@ -673,16 +676,16 @@
auto* f32 = create<type::F32>();
auto* vec2_f32 = create<type::Vector>(create<type::F32>(), 2u);
auto* bool_ = create<type::Bool>();
- auto a = table->Lookup(BuiltinType::kSelect, utils::Vector{f32, f32, bool_},
+ auto a = table->Lookup(builtin::Function::kSelect, utils::Vector{f32, f32, bool_},
sem::EvaluationStage::kConstant, Source{});
ASSERT_NE(a.sem, nullptr) << Diagnostics().str();
- auto b = table->Lookup(BuiltinType::kSelect, utils::Vector{f32, f32, bool_},
+ auto b = table->Lookup(builtin::Function::kSelect, utils::Vector{f32, f32, bool_},
sem::EvaluationStage::kConstant, Source{});
ASSERT_NE(b.sem, nullptr) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
- auto c = table->Lookup(BuiltinType::kSelect, utils::Vector{vec2_f32, vec2_f32, bool_},
+ auto c = table->Lookup(builtin::Function::kSelect, utils::Vector{vec2_f32, vec2_f32, bool_},
sem::EvaluationStage::kConstant, Source{});
ASSERT_NE(c.sem, nullptr) << Diagnostics().str();
ASSERT_EQ(Diagnostics().str(), "");
@@ -1022,7 +1025,7 @@
auto* f32 = create<type::F32>();
utils::Vector<const type::Type*, 0> arg_tys;
arg_tys.Resize(257, f32);
- auto result = table->Lookup(BuiltinType::kAbs, std::move(arg_tys),
+ auto result = table->Lookup(builtin::Function::kAbs, std::move(arg_tys),
sem::EvaluationStage::kConstant, Source{});
ASSERT_EQ(result.sem, nullptr);
ASSERT_THAT(Diagnostics().str(), HasSubstr("no matching call"));
@@ -1261,7 +1264,7 @@
auto* arg_a = GetParam().arg_a(*this);
auto* arg_b = GetParam().arg_b(*this);
auto* arg_c = GetParam().arg_c(*this);
- auto builtin = table->Lookup(sem::BuiltinType::kClamp, utils::Vector{arg_a, arg_b, arg_c},
+ auto builtin = table->Lookup(builtin::Function::kClamp, utils::Vector{arg_a, arg_b, arg_c},
sem::EvaluationStage::kConstant, Source{{12, 34}});
bool matched = builtin.sem != nullptr;
diff --git a/src/tint/resolver/materialize_test.cc b/src/tint/resolver/materialize_test.cc
index 839389a..115c4b8 100644
--- a/src/tint/resolver/materialize_test.cc
+++ b/src/tint/resolver/materialize_test.cc
@@ -939,7 +939,7 @@
break;
}
case Method::kTintMaterializeBuiltin: {
- auto* call = Call(sem::str(sem::BuiltinType::kTintMaterialize), abstract_expr());
+ auto* call = Call(builtin::str(builtin::Function::kTintMaterialize), abstract_expr());
WrapInFunction(Decl(Const("c", call)));
break;
}
diff --git a/src/tint/resolver/resolver.cc b/src/tint/resolver/resolver.cc
index f51e5cc..597821f 100644
--- a/src/tint/resolver/resolver.cc
+++ b/src/tint/resolver/resolver.cc
@@ -2167,7 +2167,7 @@
});
}
- if (auto f = resolved->BuiltinFunction(); f != sem::BuiltinType::kNone) {
+ if (auto f = resolved->BuiltinFunction(); f != builtin::Function::kNone) {
return BuiltinCall(expr, f, args);
}
@@ -2239,7 +2239,7 @@
template <size_t N>
sem::Call* Resolver::BuiltinCall(const ast::CallExpression* expr,
- sem::BuiltinType builtin_type,
+ builtin::Function builtin_type,
utils::Vector<const sem::ValueExpression*, N>& args) {
auto arg_stage = sem::EvaluationStage::kConstant;
for (auto* arg : args) {
@@ -2255,7 +2255,7 @@
}
}
- if (builtin_type == sem::BuiltinType::kTintMaterialize) {
+ if (builtin_type == builtin::Function::kTintMaterialize) {
args[0] = Materialize(args[0]);
if (!args[0]) {
return nullptr;
@@ -2307,14 +2307,14 @@
return nullptr;
}
- if (IsTextureBuiltin(builtin_type)) {
+ if (sem::IsTextureBuiltin(builtin_type)) {
if (!validator_.TextureBuiltinFunction(call)) {
return nullptr;
}
CollectTextureSamplerPairs(builtin.sem, call->Arguments());
}
- if (builtin_type == sem::BuiltinType::kWorkgroupUniformLoad) {
+ if (builtin_type == builtin::Function::kWorkgroupUniformLoad) {
if (!validator_.WorkgroupUniformLoad(call)) {
return nullptr;
}
@@ -3050,7 +3050,7 @@
return builder_->create<sem::TypeExpression>(expr, current_statement_, ty);
}
- if (resolved->BuiltinFunction() != sem::BuiltinType::kNone) {
+ if (resolved->BuiltinFunction() != builtin::Function::kNone) {
AddError("missing '(' for builtin function call", expr->source.End());
return nullptr;
}
diff --git a/src/tint/resolver/resolver.h b/src/tint/resolver/resolver.h
index 8acf602..cab7b37 100644
--- a/src/tint/resolver/resolver.h
+++ b/src/tint/resolver/resolver.h
@@ -204,7 +204,7 @@
sem::Expression* Identifier(const ast::IdentifierExpression*);
template <size_t N>
sem::Call* BuiltinCall(const ast::CallExpression*,
- sem::BuiltinType,
+ builtin::Function,
utils::Vector<const sem::ValueExpression*, N>& args);
sem::ValueExpression* Literal(const ast::LiteralExpression*);
sem::ValueExpression* MemberAccessor(const ast::MemberAccessorExpression*);
diff --git a/src/tint/resolver/uniformity.cc b/src/tint/resolver/uniformity.cc
index 673c1c0..4b63523 100644
--- a/src/tint/resolver/uniformity.cc
+++ b/src/tint/resolver/uniformity.cc
@@ -1538,12 +1538,12 @@
// some texture sampling builtins, and atomics.
if (builtin->IsBarrier()) {
callsite_tag = {CallSiteTag::CallSiteRequiredToBeUniform, default_severity};
- } else if (builtin->Type() == sem::BuiltinType::kWorkgroupUniformLoad) {
+ } else if (builtin->Type() == builtin::Function::kWorkgroupUniformLoad) {
callsite_tag = {CallSiteTag::CallSiteRequiredToBeUniform, default_severity};
} else if (builtin->IsDerivative() ||
- builtin->Type() == sem::BuiltinType::kTextureSample ||
- builtin->Type() == sem::BuiltinType::kTextureSampleBias ||
- builtin->Type() == sem::BuiltinType::kTextureSampleCompare) {
+ builtin->Type() == builtin::Function::kTextureSample ||
+ builtin->Type() == builtin::Function::kTextureSampleBias ||
+ builtin->Type() == builtin::Function::kTextureSampleCompare) {
// Get the severity of derivative uniformity violations in this context.
auto severity = sem_.DiagnosticSeverity(
call, builtin::DiagnosticRule::kDerivativeUniformity);
@@ -1650,7 +1650,7 @@
}
} else {
auto* builtin = sem->Target()->As<sem::Builtin>();
- if (builtin && builtin->Type() == sem::BuiltinType::kWorkgroupUniformLoad) {
+ if (builtin && builtin->Type() == builtin::Function::kWorkgroupUniformLoad) {
// The workgroupUniformLoad builtin requires its parameter to be uniform.
current_function_->RequiredToBeUniform(default_severity)->AddEdge(args[i]);
} else {
diff --git a/src/tint/sem/builtin.cc b/src/tint/sem/builtin.cc
index 4fd2c34..4f33ebb 100644
--- a/src/tint/sem/builtin.cc
+++ b/src/tint/sem/builtin.cc
@@ -27,74 +27,76 @@
namespace tint::sem {
const char* Builtin::str() const {
- return sem::str(type_);
+ return builtin::str(type_);
}
-bool IsCoarseDerivativeBuiltin(BuiltinType i) {
- return i == BuiltinType::kDpdxCoarse || i == BuiltinType::kDpdyCoarse ||
- i == BuiltinType::kFwidthCoarse;
+bool IsCoarseDerivativeBuiltin(builtin::Function i) {
+ return i == builtin::Function::kDpdxCoarse || i == builtin::Function::kDpdyCoarse ||
+ i == builtin::Function::kFwidthCoarse;
}
-bool IsFineDerivativeBuiltin(BuiltinType i) {
- return i == BuiltinType::kDpdxFine || i == BuiltinType::kDpdyFine ||
- i == BuiltinType::kFwidthFine;
+bool IsFineDerivativeBuiltin(builtin::Function i) {
+ return i == builtin::Function::kDpdxFine || i == builtin::Function::kDpdyFine ||
+ i == builtin::Function::kFwidthFine;
}
-bool IsDerivativeBuiltin(BuiltinType i) {
- return i == BuiltinType::kDpdx || i == BuiltinType::kDpdy || i == BuiltinType::kFwidth ||
- IsCoarseDerivativeBuiltin(i) || IsFineDerivativeBuiltin(i);
+bool IsDerivativeBuiltin(builtin::Function i) {
+ return i == builtin::Function::kDpdx || i == builtin::Function::kDpdy ||
+ i == builtin::Function::kFwidth || IsCoarseDerivativeBuiltin(i) ||
+ IsFineDerivativeBuiltin(i);
}
-bool IsTextureBuiltin(BuiltinType i) {
- return IsImageQueryBuiltin(i) || //
- i == BuiltinType::kTextureGather || //
- i == BuiltinType::kTextureGatherCompare || //
- i == BuiltinType::kTextureLoad || //
- i == BuiltinType::kTextureSample || //
- i == BuiltinType::kTextureSampleBaseClampToEdge || //
- i == BuiltinType::kTextureSampleBias || //
- i == BuiltinType::kTextureSampleCompare || //
- i == BuiltinType::kTextureSampleCompareLevel || //
- i == BuiltinType::kTextureSampleGrad || //
- i == BuiltinType::kTextureSampleLevel || //
- i == BuiltinType::kTextureStore;
+bool IsTextureBuiltin(builtin::Function i) {
+ return IsImageQueryBuiltin(i) || //
+ i == builtin::Function::kTextureGather || //
+ i == builtin::Function::kTextureGatherCompare || //
+ i == builtin::Function::kTextureLoad || //
+ i == builtin::Function::kTextureSample || //
+ i == builtin::Function::kTextureSampleBaseClampToEdge || //
+ i == builtin::Function::kTextureSampleBias || //
+ i == builtin::Function::kTextureSampleCompare || //
+ i == builtin::Function::kTextureSampleCompareLevel || //
+ i == builtin::Function::kTextureSampleGrad || //
+ i == builtin::Function::kTextureSampleLevel || //
+ i == builtin::Function::kTextureStore;
}
-bool IsImageQueryBuiltin(BuiltinType i) {
- return i == BuiltinType::kTextureDimensions || i == BuiltinType::kTextureNumLayers ||
- i == BuiltinType::kTextureNumLevels || i == BuiltinType::kTextureNumSamples;
+bool IsImageQueryBuiltin(builtin::Function i) {
+ return i == builtin::Function::kTextureDimensions ||
+ i == builtin::Function::kTextureNumLayers || i == builtin::Function::kTextureNumLevels ||
+ i == builtin::Function::kTextureNumSamples;
}
-bool IsDataPackingBuiltin(BuiltinType i) {
- return i == BuiltinType::kPack4X8Snorm || i == BuiltinType::kPack4X8Unorm ||
- i == BuiltinType::kPack2X16Snorm || i == BuiltinType::kPack2X16Unorm ||
- i == BuiltinType::kPack2X16Float;
+bool IsDataPackingBuiltin(builtin::Function i) {
+ return i == builtin::Function::kPack4X8Snorm || i == builtin::Function::kPack4X8Unorm ||
+ i == builtin::Function::kPack2X16Snorm || i == builtin::Function::kPack2X16Unorm ||
+ i == builtin::Function::kPack2X16Float;
}
-bool IsDataUnpackingBuiltin(BuiltinType i) {
- return i == BuiltinType::kUnpack4X8Snorm || i == BuiltinType::kUnpack4X8Unorm ||
- i == BuiltinType::kUnpack2X16Snorm || i == BuiltinType::kUnpack2X16Unorm ||
- i == BuiltinType::kUnpack2X16Float;
+bool IsDataUnpackingBuiltin(builtin::Function i) {
+ return i == builtin::Function::kUnpack4X8Snorm || i == builtin::Function::kUnpack4X8Unorm ||
+ i == builtin::Function::kUnpack2X16Snorm || i == builtin::Function::kUnpack2X16Unorm ||
+ i == builtin::Function::kUnpack2X16Float;
}
-bool IsBarrierBuiltin(BuiltinType i) {
- return i == BuiltinType::kWorkgroupBarrier || i == BuiltinType::kStorageBarrier;
+bool IsBarrierBuiltin(builtin::Function i) {
+ return i == builtin::Function::kWorkgroupBarrier || i == builtin::Function::kStorageBarrier;
}
-bool IsAtomicBuiltin(BuiltinType i) {
- return i == sem::BuiltinType::kAtomicLoad || i == sem::BuiltinType::kAtomicStore ||
- i == sem::BuiltinType::kAtomicAdd || i == sem::BuiltinType::kAtomicSub ||
- i == sem::BuiltinType::kAtomicMax || i == sem::BuiltinType::kAtomicMin ||
- i == sem::BuiltinType::kAtomicAnd || i == sem::BuiltinType::kAtomicOr ||
- i == sem::BuiltinType::kAtomicXor || i == sem::BuiltinType::kAtomicExchange ||
- i == sem::BuiltinType::kAtomicCompareExchangeWeak;
+bool IsAtomicBuiltin(builtin::Function i) {
+ return i == builtin::Function::kAtomicLoad || i == builtin::Function::kAtomicStore ||
+ i == builtin::Function::kAtomicAdd || i == builtin::Function::kAtomicSub ||
+ i == builtin::Function::kAtomicMax || i == builtin::Function::kAtomicMin ||
+ i == builtin::Function::kAtomicAnd || i == builtin::Function::kAtomicOr ||
+ i == builtin::Function::kAtomicXor || i == builtin::Function::kAtomicExchange ||
+ i == builtin::Function::kAtomicCompareExchangeWeak;
}
-bool IsDP4aBuiltin(BuiltinType i) {
- return i == sem::BuiltinType::kDot4I8Packed || i == sem::BuiltinType::kDot4U8Packed;
+bool IsDP4aBuiltin(builtin::Function i) {
+ return i == builtin::Function::kDot4I8Packed || i == builtin::Function::kDot4U8Packed;
}
-Builtin::Builtin(BuiltinType type,
+Builtin::Builtin(builtin::Function type,
const type::Type* return_type,
utils::VectorRef<Parameter*> parameters,
EvaluationStage eval_stage,
@@ -150,18 +152,18 @@
bool Builtin::HasSideEffects() const {
switch (type_) {
- case sem::BuiltinType::kAtomicAdd:
- case sem::BuiltinType::kAtomicAnd:
- case sem::BuiltinType::kAtomicCompareExchangeWeak:
- case sem::BuiltinType::kAtomicExchange:
- case sem::BuiltinType::kAtomicMax:
- case sem::BuiltinType::kAtomicMin:
- case sem::BuiltinType::kAtomicOr:
- case sem::BuiltinType::kAtomicStore:
- case sem::BuiltinType::kAtomicSub:
- case sem::BuiltinType::kAtomicXor:
- case sem::BuiltinType::kTextureStore:
- case sem::BuiltinType::kWorkgroupUniformLoad:
+ case builtin::Function::kAtomicAdd:
+ case builtin::Function::kAtomicAnd:
+ case builtin::Function::kAtomicCompareExchangeWeak:
+ case builtin::Function::kAtomicExchange:
+ case builtin::Function::kAtomicMax:
+ case builtin::Function::kAtomicMin:
+ case builtin::Function::kAtomicOr:
+ case builtin::Function::kAtomicStore:
+ case builtin::Function::kAtomicSub:
+ case builtin::Function::kAtomicXor:
+ case builtin::Function::kTextureStore:
+ case builtin::Function::kWorkgroupUniformLoad:
return true;
default:
break;
diff --git a/src/tint/sem/builtin.h b/src/tint/sem/builtin.h
index 55d882e..b535e72 100644
--- a/src/tint/sem/builtin.h
+++ b/src/tint/sem/builtin.h
@@ -19,7 +19,7 @@
#include <vector>
#include "src/tint/builtin/extension.h"
-#include "src/tint/sem/builtin_type.h"
+#include "src/tint/builtin/function.h"
#include "src/tint/sem/call_target.h"
#include "src/tint/sem/pipeline_stage_set.h"
#include "src/tint/utils/hash.h"
@@ -29,52 +29,52 @@
/// Determines if the given `i` is a coarse derivative
/// @param i the builtin type
/// @returns true if the given derivative is coarse.
-bool IsCoarseDerivativeBuiltin(BuiltinType i);
+bool IsCoarseDerivativeBuiltin(builtin::Function i);
/// Determines if the given `i` is a fine derivative
/// @param i the builtin type
/// @returns true if the given derivative is fine.
-bool IsFineDerivativeBuiltin(BuiltinType i);
+bool IsFineDerivativeBuiltin(builtin::Function i);
/// Determine if the given `i` is a derivative builtin
/// @param i the builtin type
/// @returns true if the given `i` is a derivative builtin
-bool IsDerivativeBuiltin(BuiltinType i);
+bool IsDerivativeBuiltin(builtin::Function i);
/// Determines if the given `i` is a texture operation builtin
/// @param i the builtin type
/// @returns true if the given `i` is a texture operation builtin
-bool IsTextureBuiltin(BuiltinType i);
+bool IsTextureBuiltin(builtin::Function i);
/// Determines if the given `i` is a image query builtin
/// @param i the builtin type
/// @returns true if the given `i` is a image query builtin
-bool IsImageQueryBuiltin(BuiltinType i);
+bool IsImageQueryBuiltin(builtin::Function i);
/// Determines if the given `i` is a data packing builtin
/// @param i the builtin
/// @returns true if the given `i` is a data packing builtin
-bool IsDataPackingBuiltin(BuiltinType i);
+bool IsDataPackingBuiltin(builtin::Function i);
/// Determines if the given `i` is a data unpacking builtin
/// @param i the builtin
/// @returns true if the given `i` is a data unpacking builtin
-bool IsDataUnpackingBuiltin(BuiltinType i);
+bool IsDataUnpackingBuiltin(builtin::Function i);
/// Determines if the given `i` is a barrier builtin
/// @param i the builtin
/// @returns true if the given `i` is a barrier builtin
-bool IsBarrierBuiltin(BuiltinType i);
+bool IsBarrierBuiltin(builtin::Function i);
/// Determines if the given `i` is a atomic builtin
/// @param i the builtin
/// @returns true if the given `i` is a atomic builtin
-bool IsAtomicBuiltin(BuiltinType i);
+bool IsAtomicBuiltin(builtin::Function i);
/// Determins if the given `i` is a DP4a builtin
/// @param i the builtin
/// @returns true if the given `i` is a DP4a builtin
-bool IsDP4aBuiltin(BuiltinType i);
+bool IsDP4aBuiltin(builtin::Function i);
/// Builtin holds the semantic information for a builtin function.
class Builtin final : public Castable<Builtin, CallTarget> {
@@ -87,7 +87,7 @@
/// @param supported_stages the pipeline stages that this builtin can be used in
/// @param is_deprecated true if the particular overload is considered deprecated
/// @param must_use true if the builtin was annotated with `@must_use`
- Builtin(BuiltinType type,
+ Builtin(builtin::Function type,
const type::Type* return_type,
utils::VectorRef<Parameter*> parameters,
EvaluationStage eval_stage,
@@ -99,7 +99,7 @@
~Builtin() override;
/// @return the type of the builtin
- BuiltinType Type() const { return type_; }
+ builtin::Function Type() const { return type_; }
/// @return the pipeline stages that this builtin can be used in
PipelineStageSet SupportedStages() const { return supported_stages_; }
@@ -151,7 +151,7 @@
builtin::Extension RequiredExtension() const;
private:
- const BuiltinType type_;
+ const builtin::Function type_;
const PipelineStageSet supported_stages_;
const bool is_deprecated_;
};
diff --git a/src/tint/sem/builtin_test.cc b/src/tint/sem/builtin_test.cc
index ff66e1b..ef63dc6 100644
--- a/src/tint/sem/builtin_test.cc
+++ b/src/tint/sem/builtin_test.cc
@@ -21,7 +21,7 @@
struct BuiltinData {
const char* name;
- BuiltinType builtin;
+ builtin::Function builtin;
};
inline std::ostream& operator<<(std::ostream& out, BuiltinData data) {
@@ -29,98 +29,98 @@
return out;
}
-using BuiltinTypeTest = testing::TestWithParam<BuiltinData>;
+using BuiltinFunctionTest = testing::TestWithParam<BuiltinData>;
-TEST_P(BuiltinTypeTest, Parse) {
+TEST_P(BuiltinFunctionTest, Parse) {
auto param = GetParam();
- EXPECT_EQ(ParseBuiltinType(param.name), param.builtin);
+ EXPECT_EQ(builtin::ParseFunction(param.name), param.builtin);
}
INSTANTIATE_TEST_SUITE_P(
- BuiltinTypeTest,
- BuiltinTypeTest,
- testing::Values(BuiltinData{"abs", BuiltinType::kAbs},
- BuiltinData{"acos", BuiltinType::kAcos},
- BuiltinData{"all", BuiltinType::kAll},
- BuiltinData{"any", BuiltinType::kAny},
- BuiltinData{"arrayLength", BuiltinType::kArrayLength},
- BuiltinData{"asin", BuiltinType::kAsin},
- BuiltinData{"atan", BuiltinType::kAtan},
- BuiltinData{"atan2", BuiltinType::kAtan2},
- BuiltinData{"ceil", BuiltinType::kCeil},
- BuiltinData{"clamp", BuiltinType::kClamp},
- BuiltinData{"cos", BuiltinType::kCos},
- BuiltinData{"cosh", BuiltinType::kCosh},
- BuiltinData{"countOneBits", BuiltinType::kCountOneBits},
- BuiltinData{"cross", BuiltinType::kCross},
- BuiltinData{"determinant", BuiltinType::kDeterminant},
- BuiltinData{"distance", BuiltinType::kDistance},
- BuiltinData{"dot", BuiltinType::kDot},
- BuiltinData{"dot4I8Packed", BuiltinType::kDot4I8Packed},
- BuiltinData{"dot4U8Packed", BuiltinType::kDot4U8Packed},
- BuiltinData{"dpdx", BuiltinType::kDpdx},
- BuiltinData{"dpdxCoarse", BuiltinType::kDpdxCoarse},
- BuiltinData{"dpdxFine", BuiltinType::kDpdxFine},
- BuiltinData{"dpdy", BuiltinType::kDpdy},
- BuiltinData{"dpdyCoarse", BuiltinType::kDpdyCoarse},
- BuiltinData{"dpdyFine", BuiltinType::kDpdyFine},
- BuiltinData{"exp", BuiltinType::kExp},
- BuiltinData{"exp2", BuiltinType::kExp2},
- BuiltinData{"faceForward", BuiltinType::kFaceForward},
- BuiltinData{"floor", BuiltinType::kFloor},
- BuiltinData{"fma", BuiltinType::kFma},
- BuiltinData{"fract", BuiltinType::kFract},
- BuiltinData{"frexp", BuiltinType::kFrexp},
- BuiltinData{"fwidth", BuiltinType::kFwidth},
- BuiltinData{"fwidthCoarse", BuiltinType::kFwidthCoarse},
- BuiltinData{"fwidthFine", BuiltinType::kFwidthFine},
- BuiltinData{"inverseSqrt", BuiltinType::kInverseSqrt},
- BuiltinData{"ldexp", BuiltinType::kLdexp},
- BuiltinData{"length", BuiltinType::kLength},
- BuiltinData{"log", BuiltinType::kLog},
- BuiltinData{"log2", BuiltinType::kLog2},
- BuiltinData{"max", BuiltinType::kMax},
- BuiltinData{"min", BuiltinType::kMin},
- BuiltinData{"mix", BuiltinType::kMix},
- BuiltinData{"modf", BuiltinType::kModf},
- BuiltinData{"normalize", BuiltinType::kNormalize},
- BuiltinData{"pow", BuiltinType::kPow},
- BuiltinData{"reflect", BuiltinType::kReflect},
- BuiltinData{"reverseBits", BuiltinType::kReverseBits},
- BuiltinData{"round", BuiltinType::kRound},
- BuiltinData{"select", BuiltinType::kSelect},
- BuiltinData{"sign", BuiltinType::kSign},
- BuiltinData{"sin", BuiltinType::kSin},
- BuiltinData{"sinh", BuiltinType::kSinh},
- BuiltinData{"smoothstep", BuiltinType::kSmoothstep},
- BuiltinData{"sqrt", BuiltinType::kSqrt},
- BuiltinData{"step", BuiltinType::kStep},
- BuiltinData{"storageBarrier", BuiltinType::kStorageBarrier},
- BuiltinData{"tan", BuiltinType::kTan},
- BuiltinData{"tanh", BuiltinType::kTanh},
- BuiltinData{"textureDimensions", BuiltinType::kTextureDimensions},
- BuiltinData{"textureLoad", BuiltinType::kTextureLoad},
- BuiltinData{"textureNumLayers", BuiltinType::kTextureNumLayers},
- BuiltinData{"textureNumLevels", BuiltinType::kTextureNumLevels},
- BuiltinData{"textureNumSamples", BuiltinType::kTextureNumSamples},
- BuiltinData{"textureSample", BuiltinType::kTextureSample},
- BuiltinData{"textureSampleBias", BuiltinType::kTextureSampleBias},
- BuiltinData{"textureSampleCompare", BuiltinType::kTextureSampleCompare},
+ BuiltinFunctionTest,
+ BuiltinFunctionTest,
+ testing::Values(BuiltinData{"abs", builtin::Function::kAbs},
+ BuiltinData{"acos", builtin::Function::kAcos},
+ BuiltinData{"all", builtin::Function::kAll},
+ BuiltinData{"any", builtin::Function::kAny},
+ BuiltinData{"arrayLength", builtin::Function::kArrayLength},
+ BuiltinData{"asin", builtin::Function::kAsin},
+ BuiltinData{"atan", builtin::Function::kAtan},
+ BuiltinData{"atan2", builtin::Function::kAtan2},
+ BuiltinData{"ceil", builtin::Function::kCeil},
+ BuiltinData{"clamp", builtin::Function::kClamp},
+ BuiltinData{"cos", builtin::Function::kCos},
+ BuiltinData{"cosh", builtin::Function::kCosh},
+ BuiltinData{"countOneBits", builtin::Function::kCountOneBits},
+ BuiltinData{"cross", builtin::Function::kCross},
+ BuiltinData{"determinant", builtin::Function::kDeterminant},
+ BuiltinData{"distance", builtin::Function::kDistance},
+ BuiltinData{"dot", builtin::Function::kDot},
+ BuiltinData{"dot4I8Packed", builtin::Function::kDot4I8Packed},
+ BuiltinData{"dot4U8Packed", builtin::Function::kDot4U8Packed},
+ BuiltinData{"dpdx", builtin::Function::kDpdx},
+ BuiltinData{"dpdxCoarse", builtin::Function::kDpdxCoarse},
+ BuiltinData{"dpdxFine", builtin::Function::kDpdxFine},
+ BuiltinData{"dpdy", builtin::Function::kDpdy},
+ BuiltinData{"dpdyCoarse", builtin::Function::kDpdyCoarse},
+ BuiltinData{"dpdyFine", builtin::Function::kDpdyFine},
+ BuiltinData{"exp", builtin::Function::kExp},
+ BuiltinData{"exp2", builtin::Function::kExp2},
+ BuiltinData{"faceForward", builtin::Function::kFaceForward},
+ BuiltinData{"floor", builtin::Function::kFloor},
+ BuiltinData{"fma", builtin::Function::kFma},
+ BuiltinData{"fract", builtin::Function::kFract},
+ BuiltinData{"frexp", builtin::Function::kFrexp},
+ BuiltinData{"fwidth", builtin::Function::kFwidth},
+ BuiltinData{"fwidthCoarse", builtin::Function::kFwidthCoarse},
+ BuiltinData{"fwidthFine", builtin::Function::kFwidthFine},
+ BuiltinData{"inverseSqrt", builtin::Function::kInverseSqrt},
+ BuiltinData{"ldexp", builtin::Function::kLdexp},
+ BuiltinData{"length", builtin::Function::kLength},
+ BuiltinData{"log", builtin::Function::kLog},
+ BuiltinData{"log2", builtin::Function::kLog2},
+ BuiltinData{"max", builtin::Function::kMax},
+ BuiltinData{"min", builtin::Function::kMin},
+ BuiltinData{"mix", builtin::Function::kMix},
+ BuiltinData{"modf", builtin::Function::kModf},
+ BuiltinData{"normalize", builtin::Function::kNormalize},
+ BuiltinData{"pow", builtin::Function::kPow},
+ BuiltinData{"reflect", builtin::Function::kReflect},
+ BuiltinData{"reverseBits", builtin::Function::kReverseBits},
+ BuiltinData{"round", builtin::Function::kRound},
+ BuiltinData{"select", builtin::Function::kSelect},
+ BuiltinData{"sign", builtin::Function::kSign},
+ BuiltinData{"sin", builtin::Function::kSin},
+ BuiltinData{"sinh", builtin::Function::kSinh},
+ BuiltinData{"smoothstep", builtin::Function::kSmoothstep},
+ BuiltinData{"sqrt", builtin::Function::kSqrt},
+ BuiltinData{"step", builtin::Function::kStep},
+ BuiltinData{"storageBarrier", builtin::Function::kStorageBarrier},
+ BuiltinData{"tan", builtin::Function::kTan},
+ BuiltinData{"tanh", builtin::Function::kTanh},
+ BuiltinData{"textureDimensions", builtin::Function::kTextureDimensions},
+ BuiltinData{"textureLoad", builtin::Function::kTextureLoad},
+ BuiltinData{"textureNumLayers", builtin::Function::kTextureNumLayers},
+ BuiltinData{"textureNumLevels", builtin::Function::kTextureNumLevels},
+ BuiltinData{"textureNumSamples", builtin::Function::kTextureNumSamples},
+ BuiltinData{"textureSample", builtin::Function::kTextureSample},
+ BuiltinData{"textureSampleBias", builtin::Function::kTextureSampleBias},
+ BuiltinData{"textureSampleCompare", builtin::Function::kTextureSampleCompare},
BuiltinData{"textureSampleCompareLevel",
- BuiltinType::kTextureSampleCompareLevel},
- BuiltinData{"textureSampleGrad", BuiltinType::kTextureSampleGrad},
- BuiltinData{"textureSampleLevel", BuiltinType::kTextureSampleLevel},
- BuiltinData{"trunc", BuiltinType::kTrunc},
- BuiltinData{"unpack2x16float", BuiltinType::kUnpack2X16Float},
- BuiltinData{"unpack2x16snorm", BuiltinType::kUnpack2X16Snorm},
- BuiltinData{"unpack2x16unorm", BuiltinType::kUnpack2X16Unorm},
- BuiltinData{"unpack4x8snorm", BuiltinType::kUnpack4X8Snorm},
- BuiltinData{"unpack4x8unorm", BuiltinType::kUnpack4X8Unorm},
- BuiltinData{"workgroupBarrier", BuiltinType::kWorkgroupBarrier},
- BuiltinData{"workgroupUniformLoad", BuiltinType::kWorkgroupUniformLoad}));
+ builtin::Function::kTextureSampleCompareLevel},
+ BuiltinData{"textureSampleGrad", builtin::Function::kTextureSampleGrad},
+ BuiltinData{"textureSampleLevel", builtin::Function::kTextureSampleLevel},
+ BuiltinData{"trunc", builtin::Function::kTrunc},
+ BuiltinData{"unpack2x16float", builtin::Function::kUnpack2X16Float},
+ BuiltinData{"unpack2x16snorm", builtin::Function::kUnpack2X16Snorm},
+ BuiltinData{"unpack2x16unorm", builtin::Function::kUnpack2X16Unorm},
+ BuiltinData{"unpack4x8snorm", builtin::Function::kUnpack4X8Snorm},
+ BuiltinData{"unpack4x8unorm", builtin::Function::kUnpack4X8Unorm},
+ BuiltinData{"workgroupBarrier", builtin::Function::kWorkgroupBarrier},
+ BuiltinData{"workgroupUniformLoad", builtin::Function::kWorkgroupUniformLoad}));
-TEST_F(BuiltinTypeTest, ParseNoMatch) {
- EXPECT_EQ(ParseBuiltinType("not_builtin"), BuiltinType::kNone);
+TEST_F(BuiltinFunctionTest, ParseNoMatch) {
+ EXPECT_EQ(builtin::ParseFunction("not_builtin"), builtin::Function::kNone);
}
} // namespace
diff --git a/src/tint/sem/builtin_type.cc b/src/tint/sem/builtin_type.cc
deleted file mode 100644
index 8abcec0..0000000
--- a/src/tint/sem/builtin_type.cc
+++ /dev/null
@@ -1,614 +0,0 @@
-// Copyright 2021 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/sem/builtin_type.cc.tmpl
-//
-// Do not modify this file directly
-////////////////////////////////////////////////////////////////////////////////
-
-#include "src/tint/sem/builtin_type.h"
-
-namespace tint::sem {
-
-BuiltinType ParseBuiltinType(const std::string& name) {
- if (name == "abs") {
- return BuiltinType::kAbs;
- }
- if (name == "acos") {
- return BuiltinType::kAcos;
- }
- if (name == "acosh") {
- return BuiltinType::kAcosh;
- }
- if (name == "all") {
- return BuiltinType::kAll;
- }
- if (name == "any") {
- return BuiltinType::kAny;
- }
- if (name == "arrayLength") {
- return BuiltinType::kArrayLength;
- }
- if (name == "asin") {
- return BuiltinType::kAsin;
- }
- if (name == "asinh") {
- return BuiltinType::kAsinh;
- }
- if (name == "atan") {
- return BuiltinType::kAtan;
- }
- if (name == "atan2") {
- return BuiltinType::kAtan2;
- }
- if (name == "atanh") {
- return BuiltinType::kAtanh;
- }
- if (name == "ceil") {
- return BuiltinType::kCeil;
- }
- if (name == "clamp") {
- return BuiltinType::kClamp;
- }
- if (name == "cos") {
- return BuiltinType::kCos;
- }
- if (name == "cosh") {
- return BuiltinType::kCosh;
- }
- if (name == "countLeadingZeros") {
- return BuiltinType::kCountLeadingZeros;
- }
- if (name == "countOneBits") {
- return BuiltinType::kCountOneBits;
- }
- if (name == "countTrailingZeros") {
- return BuiltinType::kCountTrailingZeros;
- }
- if (name == "cross") {
- return BuiltinType::kCross;
- }
- if (name == "degrees") {
- return BuiltinType::kDegrees;
- }
- if (name == "determinant") {
- return BuiltinType::kDeterminant;
- }
- if (name == "distance") {
- return BuiltinType::kDistance;
- }
- if (name == "dot") {
- return BuiltinType::kDot;
- }
- if (name == "dot4I8Packed") {
- return BuiltinType::kDot4I8Packed;
- }
- if (name == "dot4U8Packed") {
- return BuiltinType::kDot4U8Packed;
- }
- if (name == "dpdx") {
- return BuiltinType::kDpdx;
- }
- if (name == "dpdxCoarse") {
- return BuiltinType::kDpdxCoarse;
- }
- if (name == "dpdxFine") {
- return BuiltinType::kDpdxFine;
- }
- if (name == "dpdy") {
- return BuiltinType::kDpdy;
- }
- if (name == "dpdyCoarse") {
- return BuiltinType::kDpdyCoarse;
- }
- if (name == "dpdyFine") {
- return BuiltinType::kDpdyFine;
- }
- if (name == "exp") {
- return BuiltinType::kExp;
- }
- if (name == "exp2") {
- return BuiltinType::kExp2;
- }
- if (name == "extractBits") {
- return BuiltinType::kExtractBits;
- }
- if (name == "faceForward") {
- return BuiltinType::kFaceForward;
- }
- if (name == "firstLeadingBit") {
- return BuiltinType::kFirstLeadingBit;
- }
- if (name == "firstTrailingBit") {
- return BuiltinType::kFirstTrailingBit;
- }
- if (name == "floor") {
- return BuiltinType::kFloor;
- }
- if (name == "fma") {
- return BuiltinType::kFma;
- }
- if (name == "fract") {
- return BuiltinType::kFract;
- }
- if (name == "frexp") {
- return BuiltinType::kFrexp;
- }
- if (name == "fwidth") {
- return BuiltinType::kFwidth;
- }
- if (name == "fwidthCoarse") {
- return BuiltinType::kFwidthCoarse;
- }
- if (name == "fwidthFine") {
- return BuiltinType::kFwidthFine;
- }
- if (name == "insertBits") {
- return BuiltinType::kInsertBits;
- }
- if (name == "inverseSqrt") {
- return BuiltinType::kInverseSqrt;
- }
- if (name == "ldexp") {
- return BuiltinType::kLdexp;
- }
- if (name == "length") {
- return BuiltinType::kLength;
- }
- if (name == "log") {
- return BuiltinType::kLog;
- }
- if (name == "log2") {
- return BuiltinType::kLog2;
- }
- if (name == "max") {
- return BuiltinType::kMax;
- }
- if (name == "min") {
- return BuiltinType::kMin;
- }
- if (name == "mix") {
- return BuiltinType::kMix;
- }
- if (name == "modf") {
- return BuiltinType::kModf;
- }
- if (name == "normalize") {
- return BuiltinType::kNormalize;
- }
- if (name == "pack2x16float") {
- return BuiltinType::kPack2X16Float;
- }
- if (name == "pack2x16snorm") {
- return BuiltinType::kPack2X16Snorm;
- }
- if (name == "pack2x16unorm") {
- return BuiltinType::kPack2X16Unorm;
- }
- if (name == "pack4x8snorm") {
- return BuiltinType::kPack4X8Snorm;
- }
- if (name == "pack4x8unorm") {
- return BuiltinType::kPack4X8Unorm;
- }
- if (name == "pow") {
- return BuiltinType::kPow;
- }
- if (name == "quantizeToF16") {
- return BuiltinType::kQuantizeToF16;
- }
- if (name == "radians") {
- return BuiltinType::kRadians;
- }
- if (name == "reflect") {
- return BuiltinType::kReflect;
- }
- if (name == "refract") {
- return BuiltinType::kRefract;
- }
- if (name == "reverseBits") {
- return BuiltinType::kReverseBits;
- }
- if (name == "round") {
- return BuiltinType::kRound;
- }
- if (name == "saturate") {
- return BuiltinType::kSaturate;
- }
- if (name == "select") {
- return BuiltinType::kSelect;
- }
- if (name == "sign") {
- return BuiltinType::kSign;
- }
- if (name == "sin") {
- return BuiltinType::kSin;
- }
- if (name == "sinh") {
- return BuiltinType::kSinh;
- }
- if (name == "smoothstep") {
- return BuiltinType::kSmoothstep;
- }
- if (name == "sqrt") {
- return BuiltinType::kSqrt;
- }
- if (name == "step") {
- return BuiltinType::kStep;
- }
- if (name == "storageBarrier") {
- return BuiltinType::kStorageBarrier;
- }
- if (name == "tan") {
- return BuiltinType::kTan;
- }
- if (name == "tanh") {
- return BuiltinType::kTanh;
- }
- if (name == "transpose") {
- return BuiltinType::kTranspose;
- }
- if (name == "trunc") {
- return BuiltinType::kTrunc;
- }
- if (name == "unpack2x16float") {
- return BuiltinType::kUnpack2X16Float;
- }
- if (name == "unpack2x16snorm") {
- return BuiltinType::kUnpack2X16Snorm;
- }
- if (name == "unpack2x16unorm") {
- return BuiltinType::kUnpack2X16Unorm;
- }
- if (name == "unpack4x8snorm") {
- return BuiltinType::kUnpack4X8Snorm;
- }
- if (name == "unpack4x8unorm") {
- return BuiltinType::kUnpack4X8Unorm;
- }
- if (name == "workgroupBarrier") {
- return BuiltinType::kWorkgroupBarrier;
- }
- if (name == "workgroupUniformLoad") {
- return BuiltinType::kWorkgroupUniformLoad;
- }
- if (name == "textureDimensions") {
- return BuiltinType::kTextureDimensions;
- }
- if (name == "textureGather") {
- return BuiltinType::kTextureGather;
- }
- if (name == "textureGatherCompare") {
- return BuiltinType::kTextureGatherCompare;
- }
- if (name == "textureNumLayers") {
- return BuiltinType::kTextureNumLayers;
- }
- if (name == "textureNumLevels") {
- return BuiltinType::kTextureNumLevels;
- }
- if (name == "textureNumSamples") {
- return BuiltinType::kTextureNumSamples;
- }
- if (name == "textureSample") {
- return BuiltinType::kTextureSample;
- }
- if (name == "textureSampleBias") {
- return BuiltinType::kTextureSampleBias;
- }
- if (name == "textureSampleCompare") {
- return BuiltinType::kTextureSampleCompare;
- }
- if (name == "textureSampleCompareLevel") {
- return BuiltinType::kTextureSampleCompareLevel;
- }
- if (name == "textureSampleGrad") {
- return BuiltinType::kTextureSampleGrad;
- }
- if (name == "textureSampleLevel") {
- return BuiltinType::kTextureSampleLevel;
- }
- if (name == "textureSampleBaseClampToEdge") {
- return BuiltinType::kTextureSampleBaseClampToEdge;
- }
- if (name == "textureStore") {
- return BuiltinType::kTextureStore;
- }
- if (name == "textureLoad") {
- return BuiltinType::kTextureLoad;
- }
- if (name == "atomicLoad") {
- return BuiltinType::kAtomicLoad;
- }
- if (name == "atomicStore") {
- return BuiltinType::kAtomicStore;
- }
- if (name == "atomicAdd") {
- return BuiltinType::kAtomicAdd;
- }
- if (name == "atomicSub") {
- return BuiltinType::kAtomicSub;
- }
- if (name == "atomicMax") {
- return BuiltinType::kAtomicMax;
- }
- if (name == "atomicMin") {
- return BuiltinType::kAtomicMin;
- }
- if (name == "atomicAnd") {
- return BuiltinType::kAtomicAnd;
- }
- if (name == "atomicOr") {
- return BuiltinType::kAtomicOr;
- }
- if (name == "atomicXor") {
- return BuiltinType::kAtomicXor;
- }
- if (name == "atomicExchange") {
- return BuiltinType::kAtomicExchange;
- }
- if (name == "atomicCompareExchangeWeak") {
- return BuiltinType::kAtomicCompareExchangeWeak;
- }
- if (name == "_tint_materialize") {
- return BuiltinType::kTintMaterialize;
- }
- return BuiltinType::kNone;
-}
-
-const char* str(BuiltinType i) {
- switch (i) {
- case BuiltinType::kNone:
- return "<none>";
- case BuiltinType::kAbs:
- return "abs";
- case BuiltinType::kAcos:
- return "acos";
- case BuiltinType::kAcosh:
- return "acosh";
- case BuiltinType::kAll:
- return "all";
- case BuiltinType::kAny:
- return "any";
- case BuiltinType::kArrayLength:
- return "arrayLength";
- case BuiltinType::kAsin:
- return "asin";
- case BuiltinType::kAsinh:
- return "asinh";
- case BuiltinType::kAtan:
- return "atan";
- case BuiltinType::kAtan2:
- return "atan2";
- case BuiltinType::kAtanh:
- return "atanh";
- case BuiltinType::kCeil:
- return "ceil";
- case BuiltinType::kClamp:
- return "clamp";
- case BuiltinType::kCos:
- return "cos";
- case BuiltinType::kCosh:
- return "cosh";
- case BuiltinType::kCountLeadingZeros:
- return "countLeadingZeros";
- case BuiltinType::kCountOneBits:
- return "countOneBits";
- case BuiltinType::kCountTrailingZeros:
- return "countTrailingZeros";
- case BuiltinType::kCross:
- return "cross";
- case BuiltinType::kDegrees:
- return "degrees";
- case BuiltinType::kDeterminant:
- return "determinant";
- case BuiltinType::kDistance:
- return "distance";
- case BuiltinType::kDot:
- return "dot";
- case BuiltinType::kDot4I8Packed:
- return "dot4I8Packed";
- case BuiltinType::kDot4U8Packed:
- return "dot4U8Packed";
- case BuiltinType::kDpdx:
- return "dpdx";
- case BuiltinType::kDpdxCoarse:
- return "dpdxCoarse";
- case BuiltinType::kDpdxFine:
- return "dpdxFine";
- case BuiltinType::kDpdy:
- return "dpdy";
- case BuiltinType::kDpdyCoarse:
- return "dpdyCoarse";
- case BuiltinType::kDpdyFine:
- return "dpdyFine";
- case BuiltinType::kExp:
- return "exp";
- case BuiltinType::kExp2:
- return "exp2";
- case BuiltinType::kExtractBits:
- return "extractBits";
- case BuiltinType::kFaceForward:
- return "faceForward";
- case BuiltinType::kFirstLeadingBit:
- return "firstLeadingBit";
- case BuiltinType::kFirstTrailingBit:
- return "firstTrailingBit";
- case BuiltinType::kFloor:
- return "floor";
- case BuiltinType::kFma:
- return "fma";
- case BuiltinType::kFract:
- return "fract";
- case BuiltinType::kFrexp:
- return "frexp";
- case BuiltinType::kFwidth:
- return "fwidth";
- case BuiltinType::kFwidthCoarse:
- return "fwidthCoarse";
- case BuiltinType::kFwidthFine:
- return "fwidthFine";
- case BuiltinType::kInsertBits:
- return "insertBits";
- case BuiltinType::kInverseSqrt:
- return "inverseSqrt";
- case BuiltinType::kLdexp:
- return "ldexp";
- case BuiltinType::kLength:
- return "length";
- case BuiltinType::kLog:
- return "log";
- case BuiltinType::kLog2:
- return "log2";
- case BuiltinType::kMax:
- return "max";
- case BuiltinType::kMin:
- return "min";
- case BuiltinType::kMix:
- return "mix";
- case BuiltinType::kModf:
- return "modf";
- case BuiltinType::kNormalize:
- return "normalize";
- case BuiltinType::kPack2X16Float:
- return "pack2x16float";
- case BuiltinType::kPack2X16Snorm:
- return "pack2x16snorm";
- case BuiltinType::kPack2X16Unorm:
- return "pack2x16unorm";
- case BuiltinType::kPack4X8Snorm:
- return "pack4x8snorm";
- case BuiltinType::kPack4X8Unorm:
- return "pack4x8unorm";
- case BuiltinType::kPow:
- return "pow";
- case BuiltinType::kQuantizeToF16:
- return "quantizeToF16";
- case BuiltinType::kRadians:
- return "radians";
- case BuiltinType::kReflect:
- return "reflect";
- case BuiltinType::kRefract:
- return "refract";
- case BuiltinType::kReverseBits:
- return "reverseBits";
- case BuiltinType::kRound:
- return "round";
- case BuiltinType::kSaturate:
- return "saturate";
- case BuiltinType::kSelect:
- return "select";
- case BuiltinType::kSign:
- return "sign";
- case BuiltinType::kSin:
- return "sin";
- case BuiltinType::kSinh:
- return "sinh";
- case BuiltinType::kSmoothstep:
- return "smoothstep";
- case BuiltinType::kSqrt:
- return "sqrt";
- case BuiltinType::kStep:
- return "step";
- case BuiltinType::kStorageBarrier:
- return "storageBarrier";
- case BuiltinType::kTan:
- return "tan";
- case BuiltinType::kTanh:
- return "tanh";
- case BuiltinType::kTranspose:
- return "transpose";
- case BuiltinType::kTrunc:
- return "trunc";
- case BuiltinType::kUnpack2X16Float:
- return "unpack2x16float";
- case BuiltinType::kUnpack2X16Snorm:
- return "unpack2x16snorm";
- case BuiltinType::kUnpack2X16Unorm:
- return "unpack2x16unorm";
- case BuiltinType::kUnpack4X8Snorm:
- return "unpack4x8snorm";
- case BuiltinType::kUnpack4X8Unorm:
- return "unpack4x8unorm";
- case BuiltinType::kWorkgroupBarrier:
- return "workgroupBarrier";
- case BuiltinType::kWorkgroupUniformLoad:
- return "workgroupUniformLoad";
- case BuiltinType::kTextureDimensions:
- return "textureDimensions";
- case BuiltinType::kTextureGather:
- return "textureGather";
- case BuiltinType::kTextureGatherCompare:
- return "textureGatherCompare";
- case BuiltinType::kTextureNumLayers:
- return "textureNumLayers";
- case BuiltinType::kTextureNumLevels:
- return "textureNumLevels";
- case BuiltinType::kTextureNumSamples:
- return "textureNumSamples";
- case BuiltinType::kTextureSample:
- return "textureSample";
- case BuiltinType::kTextureSampleBias:
- return "textureSampleBias";
- case BuiltinType::kTextureSampleCompare:
- return "textureSampleCompare";
- case BuiltinType::kTextureSampleCompareLevel:
- return "textureSampleCompareLevel";
- case BuiltinType::kTextureSampleGrad:
- return "textureSampleGrad";
- case BuiltinType::kTextureSampleLevel:
- return "textureSampleLevel";
- case BuiltinType::kTextureSampleBaseClampToEdge:
- return "textureSampleBaseClampToEdge";
- case BuiltinType::kTextureStore:
- return "textureStore";
- case BuiltinType::kTextureLoad:
- return "textureLoad";
- case BuiltinType::kAtomicLoad:
- return "atomicLoad";
- case BuiltinType::kAtomicStore:
- return "atomicStore";
- case BuiltinType::kAtomicAdd:
- return "atomicAdd";
- case BuiltinType::kAtomicSub:
- return "atomicSub";
- case BuiltinType::kAtomicMax:
- return "atomicMax";
- case BuiltinType::kAtomicMin:
- return "atomicMin";
- case BuiltinType::kAtomicAnd:
- return "atomicAnd";
- case BuiltinType::kAtomicOr:
- return "atomicOr";
- case BuiltinType::kAtomicXor:
- return "atomicXor";
- case BuiltinType::kAtomicExchange:
- return "atomicExchange";
- case BuiltinType::kAtomicCompareExchangeWeak:
- return "atomicCompareExchangeWeak";
- case BuiltinType::kTintMaterialize:
- return "_tint_materialize";
- }
- return "<unknown>";
-}
-
-utils::StringStream& operator<<(utils::StringStream& out, BuiltinType i) {
- out << str(i);
- return out;
-}
-
-} // namespace tint::sem
diff --git a/src/tint/sem/builtin_type.cc.tmpl b/src/tint/sem/builtin_type.cc.tmpl
deleted file mode 100644
index 86a8623..0000000
--- a/src/tint/sem/builtin_type.cc.tmpl
+++ /dev/null
@@ -1,44 +0,0 @@
-{{- /*
---------------------------------------------------------------------------------
-Template file for use with tools/src/cmd/gen to generate builtin_type.cc
-
-To update the generated file, run:
- ./tools/run gen
-
-See:
-* tools/src/cmd/gen for structures used by this template
-* https://golang.org/pkg/text/template/ for documentation on the template syntax
---------------------------------------------------------------------------------
-*/ -}}
-
-#include "src/tint/sem/builtin_type.h"
-
-namespace tint::sem {
-
-BuiltinType ParseBuiltinType(const std::string& name) {
-{{- range Sem.Builtins }}
- if (name == "{{.Name}}") {
- return BuiltinType::k{{PascalCase .Name}};
- }
-{{- end }}
- return BuiltinType::kNone;
-}
-
-const char* str(BuiltinType i) {
- switch (i) {
- case BuiltinType::kNone:
- return "<none>";
-{{- range Sem.Builtins }}
- case BuiltinType::k{{PascalCase .Name}}:
- return "{{.Name}}";
-{{- end }}
- }
- return "<unknown>";
-}
-
-utils::StringStream& operator<<(utils::StringStream& out, BuiltinType i) {
- out << str(i);
- return out;
-}
-
-} // namespace tint::sem
diff --git a/src/tint/sem/builtin_type.h b/src/tint/sem/builtin_type.h
deleted file mode 100644
index 23f3749..0000000
--- a/src/tint/sem/builtin_type.h
+++ /dev/null
@@ -1,403 +0,0 @@
-// Copyright 2021 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/sem/builtin_type.h.tmpl
-//
-// Do not modify this file directly
-////////////////////////////////////////////////////////////////////////////////
-
-#ifndef SRC_TINT_SEM_BUILTIN_TYPE_H_
-#define SRC_TINT_SEM_BUILTIN_TYPE_H_
-
-#include <string>
-
-#include "src/tint/utils/string_stream.h"
-
-namespace tint::sem {
-
-/// Enumerator of all builtin functions
-enum class BuiltinType {
- kNone = -1,
- kAbs,
- kAcos,
- kAcosh,
- kAll,
- kAny,
- kArrayLength,
- kAsin,
- kAsinh,
- kAtan,
- kAtan2,
- kAtanh,
- kCeil,
- kClamp,
- kCos,
- kCosh,
- kCountLeadingZeros,
- kCountOneBits,
- kCountTrailingZeros,
- kCross,
- kDegrees,
- kDeterminant,
- kDistance,
- kDot,
- kDot4I8Packed,
- kDot4U8Packed,
- kDpdx,
- kDpdxCoarse,
- kDpdxFine,
- kDpdy,
- kDpdyCoarse,
- kDpdyFine,
- kExp,
- kExp2,
- kExtractBits,
- kFaceForward,
- kFirstLeadingBit,
- kFirstTrailingBit,
- kFloor,
- kFma,
- kFract,
- kFrexp,
- kFwidth,
- kFwidthCoarse,
- kFwidthFine,
- kInsertBits,
- kInverseSqrt,
- kLdexp,
- kLength,
- kLog,
- kLog2,
- kMax,
- kMin,
- kMix,
- kModf,
- kNormalize,
- kPack2X16Float,
- kPack2X16Snorm,
- kPack2X16Unorm,
- kPack4X8Snorm,
- kPack4X8Unorm,
- kPow,
- kQuantizeToF16,
- kRadians,
- kReflect,
- kRefract,
- kReverseBits,
- kRound,
- kSaturate,
- kSelect,
- kSign,
- kSin,
- kSinh,
- kSmoothstep,
- kSqrt,
- kStep,
- kStorageBarrier,
- kTan,
- kTanh,
- kTranspose,
- kTrunc,
- kUnpack2X16Float,
- kUnpack2X16Snorm,
- kUnpack2X16Unorm,
- kUnpack4X8Snorm,
- kUnpack4X8Unorm,
- kWorkgroupBarrier,
- kWorkgroupUniformLoad,
- kTextureDimensions,
- kTextureGather,
- kTextureGatherCompare,
- kTextureNumLayers,
- kTextureNumLevels,
- kTextureNumSamples,
- kTextureSample,
- kTextureSampleBias,
- kTextureSampleCompare,
- kTextureSampleCompareLevel,
- kTextureSampleGrad,
- kTextureSampleLevel,
- kTextureSampleBaseClampToEdge,
- kTextureStore,
- kTextureLoad,
- kAtomicLoad,
- kAtomicStore,
- kAtomicAdd,
- kAtomicSub,
- kAtomicMax,
- kAtomicMin,
- kAtomicAnd,
- kAtomicOr,
- kAtomicXor,
- kAtomicExchange,
- kAtomicCompareExchangeWeak,
- kTintMaterialize,
-};
-
-/// Matches the BuiltinType by name
-/// @param name the builtin name to parse
-/// @returns the parsed BuiltinType, or BuiltinType::kNone if `name` did not
-/// match any builtin.
-BuiltinType ParseBuiltinType(const std::string& name);
-
-/// @returns the name of the builtin function type. The spelling, including
-/// case, matches the name in the WGSL spec.
-const char* str(BuiltinType i);
-
-/// Emits the name of the builtin function type. The spelling, including case,
-/// matches the name in the WGSL spec.
-utils::StringStream& operator<<(utils::StringStream& out, BuiltinType i);
-
-/// All builtin function
-constexpr BuiltinType kBuiltinTypes[] = {
- BuiltinType::kAbs,
- BuiltinType::kAcos,
- BuiltinType::kAcosh,
- BuiltinType::kAll,
- BuiltinType::kAny,
- BuiltinType::kArrayLength,
- BuiltinType::kAsin,
- BuiltinType::kAsinh,
- BuiltinType::kAtan,
- BuiltinType::kAtan2,
- BuiltinType::kAtanh,
- BuiltinType::kCeil,
- BuiltinType::kClamp,
- BuiltinType::kCos,
- BuiltinType::kCosh,
- BuiltinType::kCountLeadingZeros,
- BuiltinType::kCountOneBits,
- BuiltinType::kCountTrailingZeros,
- BuiltinType::kCross,
- BuiltinType::kDegrees,
- BuiltinType::kDeterminant,
- BuiltinType::kDistance,
- BuiltinType::kDot,
- BuiltinType::kDot4I8Packed,
- BuiltinType::kDot4U8Packed,
- BuiltinType::kDpdx,
- BuiltinType::kDpdxCoarse,
- BuiltinType::kDpdxFine,
- BuiltinType::kDpdy,
- BuiltinType::kDpdyCoarse,
- BuiltinType::kDpdyFine,
- BuiltinType::kExp,
- BuiltinType::kExp2,
- BuiltinType::kExtractBits,
- BuiltinType::kFaceForward,
- BuiltinType::kFirstLeadingBit,
- BuiltinType::kFirstTrailingBit,
- BuiltinType::kFloor,
- BuiltinType::kFma,
- BuiltinType::kFract,
- BuiltinType::kFrexp,
- BuiltinType::kFwidth,
- BuiltinType::kFwidthCoarse,
- BuiltinType::kFwidthFine,
- BuiltinType::kInsertBits,
- BuiltinType::kInverseSqrt,
- BuiltinType::kLdexp,
- BuiltinType::kLength,
- BuiltinType::kLog,
- BuiltinType::kLog2,
- BuiltinType::kMax,
- BuiltinType::kMin,
- BuiltinType::kMix,
- BuiltinType::kModf,
- BuiltinType::kNormalize,
- BuiltinType::kPack2X16Float,
- BuiltinType::kPack2X16Snorm,
- BuiltinType::kPack2X16Unorm,
- BuiltinType::kPack4X8Snorm,
- BuiltinType::kPack4X8Unorm,
- BuiltinType::kPow,
- BuiltinType::kQuantizeToF16,
- BuiltinType::kRadians,
- BuiltinType::kReflect,
- BuiltinType::kRefract,
- BuiltinType::kReverseBits,
- BuiltinType::kRound,
- BuiltinType::kSaturate,
- BuiltinType::kSelect,
- BuiltinType::kSign,
- BuiltinType::kSin,
- BuiltinType::kSinh,
- BuiltinType::kSmoothstep,
- BuiltinType::kSqrt,
- BuiltinType::kStep,
- BuiltinType::kStorageBarrier,
- BuiltinType::kTan,
- BuiltinType::kTanh,
- BuiltinType::kTranspose,
- BuiltinType::kTrunc,
- BuiltinType::kUnpack2X16Float,
- BuiltinType::kUnpack2X16Snorm,
- BuiltinType::kUnpack2X16Unorm,
- BuiltinType::kUnpack4X8Snorm,
- BuiltinType::kUnpack4X8Unorm,
- BuiltinType::kWorkgroupBarrier,
- BuiltinType::kWorkgroupUniformLoad,
- BuiltinType::kTextureDimensions,
- BuiltinType::kTextureGather,
- BuiltinType::kTextureGatherCompare,
- BuiltinType::kTextureNumLayers,
- BuiltinType::kTextureNumLevels,
- BuiltinType::kTextureNumSamples,
- BuiltinType::kTextureSample,
- BuiltinType::kTextureSampleBias,
- BuiltinType::kTextureSampleCompare,
- BuiltinType::kTextureSampleCompareLevel,
- BuiltinType::kTextureSampleGrad,
- BuiltinType::kTextureSampleLevel,
- BuiltinType::kTextureSampleBaseClampToEdge,
- BuiltinType::kTextureStore,
- BuiltinType::kTextureLoad,
- BuiltinType::kAtomicLoad,
- BuiltinType::kAtomicStore,
- BuiltinType::kAtomicAdd,
- BuiltinType::kAtomicSub,
- BuiltinType::kAtomicMax,
- BuiltinType::kAtomicMin,
- BuiltinType::kAtomicAnd,
- BuiltinType::kAtomicOr,
- BuiltinType::kAtomicXor,
- BuiltinType::kAtomicExchange,
- BuiltinType::kAtomicCompareExchangeWeak,
- BuiltinType::kTintMaterialize,
-};
-
-/// All builtin function names
-constexpr const char* kBuiltinStrings[] = {
- "abs",
- "acos",
- "acosh",
- "all",
- "any",
- "arrayLength",
- "asin",
- "asinh",
- "atan",
- "atan2",
- "atanh",
- "ceil",
- "clamp",
- "cos",
- "cosh",
- "countLeadingZeros",
- "countOneBits",
- "countTrailingZeros",
- "cross",
- "degrees",
- "determinant",
- "distance",
- "dot",
- "dot4I8Packed",
- "dot4U8Packed",
- "dpdx",
- "dpdxCoarse",
- "dpdxFine",
- "dpdy",
- "dpdyCoarse",
- "dpdyFine",
- "exp",
- "exp2",
- "extractBits",
- "faceForward",
- "firstLeadingBit",
- "firstTrailingBit",
- "floor",
- "fma",
- "fract",
- "frexp",
- "fwidth",
- "fwidthCoarse",
- "fwidthFine",
- "insertBits",
- "inverseSqrt",
- "ldexp",
- "length",
- "log",
- "log2",
- "max",
- "min",
- "mix",
- "modf",
- "normalize",
- "pack2x16float",
- "pack2x16snorm",
- "pack2x16unorm",
- "pack4x8snorm",
- "pack4x8unorm",
- "pow",
- "quantizeToF16",
- "radians",
- "reflect",
- "refract",
- "reverseBits",
- "round",
- "saturate",
- "select",
- "sign",
- "sin",
- "sinh",
- "smoothstep",
- "sqrt",
- "step",
- "storageBarrier",
- "tan",
- "tanh",
- "transpose",
- "trunc",
- "unpack2x16float",
- "unpack2x16snorm",
- "unpack2x16unorm",
- "unpack4x8snorm",
- "unpack4x8unorm",
- "workgroupBarrier",
- "workgroupUniformLoad",
- "textureDimensions",
- "textureGather",
- "textureGatherCompare",
- "textureNumLayers",
- "textureNumLevels",
- "textureNumSamples",
- "textureSample",
- "textureSampleBias",
- "textureSampleCompare",
- "textureSampleCompareLevel",
- "textureSampleGrad",
- "textureSampleLevel",
- "textureSampleBaseClampToEdge",
- "textureStore",
- "textureLoad",
- "atomicLoad",
- "atomicStore",
- "atomicAdd",
- "atomicSub",
- "atomicMax",
- "atomicMin",
- "atomicAnd",
- "atomicOr",
- "atomicXor",
- "atomicExchange",
- "atomicCompareExchangeWeak",
- "_tint_materialize",
-};
-
-} // namespace tint::sem
-
-#endif // SRC_TINT_SEM_BUILTIN_TYPE_H_
diff --git a/src/tint/sem/builtin_type.h.tmpl b/src/tint/sem/builtin_type.h.tmpl
deleted file mode 100644
index 366db95..0000000
--- a/src/tint/sem/builtin_type.h.tmpl
+++ /dev/null
@@ -1,61 +0,0 @@
-{{- /*
---------------------------------------------------------------------------------
-Template file for use with tools/src/cmd/gen to generate builtin_type.h
-
-To update the generated file, run:
- ./tools/run gen
-
-See:
-* tools/src/cmd/gen for structures used by this template
-* https://golang.org/pkg/text/template/ for documentation on the template syntax
---------------------------------------------------------------------------------
-*/ -}}
-
-#ifndef SRC_TINT_SEM_BUILTIN_TYPE_H_
-#define SRC_TINT_SEM_BUILTIN_TYPE_H_
-
-#include <string>
-
-#include "src/tint/utils/string_stream.h"
-
-namespace tint::sem {
-
-/// Enumerator of all builtin functions
-enum class BuiltinType {
- kNone = -1,
-{{- range Sem.Builtins }}
- k{{PascalCase .Name}},
-{{- end }}
-};
-
-/// Matches the BuiltinType by name
-/// @param name the builtin name to parse
-/// @returns the parsed BuiltinType, or BuiltinType::kNone if `name` did not
-/// match any builtin.
-BuiltinType ParseBuiltinType(const std::string& name);
-
-/// @returns the name of the builtin function type. The spelling, including
-/// case, matches the name in the WGSL spec.
-const char* str(BuiltinType i);
-
-/// Emits the name of the builtin function type. The spelling, including case,
-/// matches the name in the WGSL spec.
-utils::StringStream& operator<<(utils::StringStream& out, BuiltinType i);
-
-/// All builtin function
-constexpr BuiltinType kBuiltinTypes[] = {
-{{- range Sem.Builtins }}
- BuiltinType::k{{PascalCase .Name}},
-{{- end }}
-};
-
-/// All builtin function names
-constexpr const char* kBuiltinStrings[] = {
-{{- range Sem.Builtins }}
- "{{.Name}}",
-{{- end }}
-};
-
-} // namespace tint::sem
-
-#endif // SRC_TINT_SEM_BUILTIN_TYPE_H_
diff --git a/src/tint/transform/array_length_from_uniform.cc b/src/tint/transform/array_length_from_uniform.cc
index 78535f1..a396965 100644
--- a/src/tint/transform/array_length_from_uniform.cc
+++ b/src/tint/transform/array_length_from_uniform.cc
@@ -37,7 +37,7 @@
for (auto* fn : program->AST().Functions()) {
if (auto* sem_fn = program->Sem().Get(fn)) {
for (auto* builtin : sem_fn->DirectlyCalledBuiltins()) {
- if (builtin->Type() == sem::BuiltinType::kArrayLength) {
+ if (builtin->Type() == builtin::Function::kArrayLength) {
return true;
}
}
@@ -199,7 +199,7 @@
auto* call = sem.Get(call_expr)->UnwrapMaterialize()->As<sem::Call>();
auto* builtin = call->Target()->As<sem::Builtin>();
- if (!builtin || builtin->Type() != sem::BuiltinType::kArrayLength) {
+ if (!builtin || builtin->Type() != builtin::Function::kArrayLength) {
continue;
}
diff --git a/src/tint/transform/builtin_polyfill.cc b/src/tint/transform/builtin_polyfill.cc
index 587dcf0..f66025c 100644
--- a/src/tint/transform/builtin_polyfill.cc
+++ b/src/tint/transform/builtin_polyfill.cc
@@ -1030,28 +1030,28 @@
call->Target(), //
[&](const sem::Builtin* builtin) {
switch (builtin->Type()) {
- case sem::BuiltinType::kAcosh:
+ case builtin::Function::kAcosh:
if (cfg.builtins.acosh != Level::kNone) {
return builtin_polyfills.GetOrCreate(
builtin, [&] { return acosh(builtin->ReturnType()); });
}
return Symbol{};
- case sem::BuiltinType::kAsinh:
+ case builtin::Function::kAsinh:
if (cfg.builtins.asinh) {
return builtin_polyfills.GetOrCreate(
builtin, [&] { return asinh(builtin->ReturnType()); });
}
return Symbol{};
- case sem::BuiltinType::kAtanh:
+ case builtin::Function::kAtanh:
if (cfg.builtins.atanh != Level::kNone) {
return builtin_polyfills.GetOrCreate(
builtin, [&] { return atanh(builtin->ReturnType()); });
}
return Symbol{};
- case sem::BuiltinType::kClamp:
+ case builtin::Function::kClamp:
if (cfg.builtins.clamp_int) {
auto& sig = builtin->Signature();
if (sig.parameters[0]->Type()->is_integer_scalar_or_vector()) {
@@ -1061,49 +1061,49 @@
}
return Symbol{};
- case sem::BuiltinType::kCountLeadingZeros:
+ case builtin::Function::kCountLeadingZeros:
if (cfg.builtins.count_leading_zeros) {
return builtin_polyfills.GetOrCreate(
builtin, [&] { return countLeadingZeros(builtin->ReturnType()); });
}
return Symbol{};
- case sem::BuiltinType::kCountTrailingZeros:
+ case builtin::Function::kCountTrailingZeros:
if (cfg.builtins.count_trailing_zeros) {
return builtin_polyfills.GetOrCreate(
builtin, [&] { return countTrailingZeros(builtin->ReturnType()); });
}
return Symbol{};
- case sem::BuiltinType::kExtractBits:
+ case builtin::Function::kExtractBits:
if (cfg.builtins.extract_bits != Level::kNone) {
return builtin_polyfills.GetOrCreate(
builtin, [&] { return extractBits(builtin->ReturnType()); });
}
return Symbol{};
- case sem::BuiltinType::kFirstLeadingBit:
+ case builtin::Function::kFirstLeadingBit:
if (cfg.builtins.first_leading_bit) {
return builtin_polyfills.GetOrCreate(
builtin, [&] { return firstLeadingBit(builtin->ReturnType()); });
}
return Symbol{};
- case sem::BuiltinType::kFirstTrailingBit:
+ case builtin::Function::kFirstTrailingBit:
if (cfg.builtins.first_trailing_bit) {
return builtin_polyfills.GetOrCreate(
builtin, [&] { return firstTrailingBit(builtin->ReturnType()); });
}
return Symbol{};
- case sem::BuiltinType::kInsertBits:
+ case builtin::Function::kInsertBits:
if (cfg.builtins.insert_bits != Level::kNone) {
return builtin_polyfills.GetOrCreate(
builtin, [&] { return insertBits(builtin->ReturnType()); });
}
return Symbol{};
- case sem::BuiltinType::kReflect:
+ case builtin::Function::kReflect:
// Only polyfill for vec2<f32>. See https://crbug.com/tint/1798 for
// more details.
if (cfg.builtins.reflect_vec2_f32) {
@@ -1116,14 +1116,14 @@
}
return Symbol{};
- case sem::BuiltinType::kSaturate:
+ case builtin::Function::kSaturate:
if (cfg.builtins.saturate) {
return builtin_polyfills.GetOrCreate(
builtin, [&] { return saturate(builtin->ReturnType()); });
}
return Symbol{};
- case sem::BuiltinType::kSign:
+ case builtin::Function::kSign:
if (cfg.builtins.sign_int) {
auto* ty = builtin->ReturnType();
if (ty->is_signed_integer_scalar_or_vector()) {
@@ -1133,7 +1133,7 @@
}
return Symbol{};
- case sem::BuiltinType::kTextureSampleBaseClampToEdge:
+ case builtin::Function::kTextureSampleBaseClampToEdge:
if (cfg.builtins.texture_sample_base_clamp_to_edge_2d_f32) {
auto& sig = builtin->Signature();
auto* tex = sig.Parameter(sem::ParameterUsage::kTexture);
@@ -1147,7 +1147,7 @@
}
return Symbol{};
- case sem::BuiltinType::kTextureStore:
+ case builtin::Function::kTextureStore:
if (cfg.builtins.bgra8unorm) {
auto& sig = builtin->Signature();
auto* tex = sig.Parameter(sem::ParameterUsage::kTexture);
@@ -1165,7 +1165,7 @@
args.Push(arg);
}
return ctx.dst->Call(
- utils::ToString(sem::BuiltinType::kTextureStore),
+ utils::ToString(builtin::Function::kTextureStore),
std::move(args));
});
made_changes = true;
@@ -1174,7 +1174,7 @@
}
return Symbol{};
- case sem::BuiltinType::kQuantizeToF16:
+ case builtin::Function::kQuantizeToF16:
if (cfg.builtins.quantize_to_vec_f16) {
if (auto* vec = builtin->ReturnType()->As<type::Vector>()) {
return builtin_polyfills.GetOrCreate(
@@ -1183,7 +1183,7 @@
}
return Symbol{};
- case sem::BuiltinType::kWorkgroupUniformLoad:
+ case builtin::Function::kWorkgroupUniformLoad:
if (cfg.builtins.workgroup_uniform_load) {
return builtin_polyfills.GetOrCreate(builtin, [&] {
return workgroupUniformLoad(builtin->ReturnType());
diff --git a/src/tint/transform/calculate_array_length.cc b/src/tint/transform/calculate_array_length.cc
index 9f5b659..36ad192 100644
--- a/src/tint/transform/calculate_array_length.cc
+++ b/src/tint/transform/calculate_array_length.cc
@@ -44,7 +44,7 @@
for (auto* fn : program->AST().Functions()) {
if (auto* sem_fn = program->Sem().Get(fn)) {
for (auto* builtin : sem_fn->DirectlyCalledBuiltins()) {
- if (builtin->Type() == sem::BuiltinType::kArrayLength) {
+ if (builtin->Type() == builtin::Function::kArrayLength) {
return true;
}
}
@@ -130,7 +130,7 @@
if (auto* call_expr = node->As<ast::CallExpression>()) {
auto* call = sem.Get(call_expr)->UnwrapMaterialize()->As<sem::Call>();
if (auto* builtin = call->Target()->As<sem::Builtin>()) {
- if (builtin->Type() == sem::BuiltinType::kArrayLength) {
+ if (builtin->Type() == builtin::Function::kArrayLength) {
// We're dealing with an arrayLength() call
if (auto* call_stmt = call->Stmt()->Declaration()->As<ast::CallStatement>()) {
diff --git a/src/tint/transform/combine_samplers.cc b/src/tint/transform/combine_samplers.cc
index 7b9f9fd..ca8111c 100644
--- a/src/tint/transform/combine_samplers.cc
+++ b/src/tint/transform/combine_samplers.cc
@@ -276,7 +276,7 @@
}
}
const ast::Expression* value = ctx.dst->Call(ctx.Clone(expr->target), args);
- if (builtin->Type() == sem::BuiltinType::kTextureLoad &&
+ if (builtin->Type() == builtin::Function::kTextureLoad &&
texture_var->Type()->UnwrapRef()->Is<type::DepthTexture>() &&
!call->Stmt()->Declaration()->Is<ast::CallStatement>()) {
value = ctx.dst->MemberAccessor(value, "x");
diff --git a/src/tint/transform/decompose_memory_access.cc b/src/tint/transform/decompose_memory_access.cc
index f3d92c5..2ff62b4 100644
--- a/src/tint/transform/decompose_memory_access.cc
+++ b/src/tint/transform/decompose_memory_access.cc
@@ -124,7 +124,7 @@
/// AtomicKey is the unordered map key to an atomic intrinsic.
struct AtomicKey {
type::Type const* el_ty = nullptr; // element type
- sem::BuiltinType const op; // atomic op
+ builtin::Function const op; // atomic op
Symbol const buffer; // buffer name
bool operator==(const AtomicKey& rhs) const {
return el_ty == rhs.el_ty && op == rhs.op && buffer == rhs.buffer;
@@ -248,42 +248,42 @@
/// @returns a DecomposeMemoryAccess::Intrinsic attribute that can be applied to a stub function for
/// the atomic op and the type @p ty.
DecomposeMemoryAccess::Intrinsic* IntrinsicAtomicFor(ProgramBuilder* builder,
- sem::BuiltinType ity,
+ builtin::Function ity,
const type::Type* ty,
const Symbol& buffer) {
auto op = DecomposeMemoryAccess::Intrinsic::Op::kAtomicLoad;
switch (ity) {
- case sem::BuiltinType::kAtomicLoad:
+ case builtin::Function::kAtomicLoad:
op = DecomposeMemoryAccess::Intrinsic::Op::kAtomicLoad;
break;
- case sem::BuiltinType::kAtomicStore:
+ case builtin::Function::kAtomicStore:
op = DecomposeMemoryAccess::Intrinsic::Op::kAtomicStore;
break;
- case sem::BuiltinType::kAtomicAdd:
+ case builtin::Function::kAtomicAdd:
op = DecomposeMemoryAccess::Intrinsic::Op::kAtomicAdd;
break;
- case sem::BuiltinType::kAtomicSub:
+ case builtin::Function::kAtomicSub:
op = DecomposeMemoryAccess::Intrinsic::Op::kAtomicSub;
break;
- case sem::BuiltinType::kAtomicMax:
+ case builtin::Function::kAtomicMax:
op = DecomposeMemoryAccess::Intrinsic::Op::kAtomicMax;
break;
- case sem::BuiltinType::kAtomicMin:
+ case builtin::Function::kAtomicMin:
op = DecomposeMemoryAccess::Intrinsic::Op::kAtomicMin;
break;
- case sem::BuiltinType::kAtomicAnd:
+ case builtin::Function::kAtomicAnd:
op = DecomposeMemoryAccess::Intrinsic::Op::kAtomicAnd;
break;
- case sem::BuiltinType::kAtomicOr:
+ case builtin::Function::kAtomicOr:
op = DecomposeMemoryAccess::Intrinsic::Op::kAtomicOr;
break;
- case sem::BuiltinType::kAtomicXor:
+ case builtin::Function::kAtomicXor:
op = DecomposeMemoryAccess::Intrinsic::Op::kAtomicXor;
break;
- case sem::BuiltinType::kAtomicExchange:
+ case builtin::Function::kAtomicExchange:
op = DecomposeMemoryAccess::Intrinsic::Op::kAtomicExchange;
break;
- case sem::BuiltinType::kAtomicCompareExchangeWeak:
+ case builtin::Function::kAtomicCompareExchangeWeak:
op = DecomposeMemoryAccess::Intrinsic::Op::kAtomicCompareExchangeWeak;
break;
default:
@@ -658,7 +658,7 @@
ast::Type ret_ty;
// For intrinsics that return a struct, there is no AST node for it, so create one now.
- if (intrinsic->Type() == sem::BuiltinType::kAtomicCompareExchangeWeak) {
+ if (intrinsic->Type() == builtin::Function::kAtomicCompareExchangeWeak) {
auto* str = intrinsic->ReturnType()->As<sem::Struct>();
TINT_ASSERT(Transform, str && str->Declaration() == nullptr);
@@ -937,7 +937,7 @@
if (auto* call_expr = node->As<ast::CallExpression>()) {
auto* call = sem.Get(call_expr)->UnwrapMaterialize()->As<sem::Call>();
if (auto* builtin = call->Target()->As<sem::Builtin>()) {
- if (builtin->Type() == sem::BuiltinType::kArrayLength) {
+ if (builtin->Type() == builtin::Function::kArrayLength) {
// arrayLength(X)
// Don't convert X into a load, this builtin actually requires the real pointer.
state.TakeAccess(call_expr->args[0]);
diff --git a/src/tint/transform/demote_to_helper.cc b/src/tint/transform/demote_to_helper.cc
index ac3c15e..1cb6f96 100644
--- a/src/tint/transform/demote_to_helper.cc
+++ b/src/tint/transform/demote_to_helper.cc
@@ -152,13 +152,13 @@
return;
}
- if (builtin->Type() == sem::BuiltinType::kTextureStore) {
+ if (builtin->Type() == builtin::Function::kTextureStore) {
// A call to textureStore() will always be a statement.
// Wrap it inside a conditional block.
auto* masked_call = b.If(b.Not(flag), b.Block(ctx.Clone(stmt->Declaration())));
ctx.Replace(stmt->Declaration(), masked_call);
} else if (builtin->IsAtomic() &&
- builtin->Type() != sem::BuiltinType::kAtomicLoad) {
+ builtin->Type() != builtin::Function::kAtomicLoad) {
// A call to an atomic builtin can be a statement or an expression.
if (auto* call_stmt = stmt->Declaration()->As<ast::CallStatement>();
call_stmt && call_stmt->expr == call) {
@@ -179,7 +179,7 @@
auto result = b.Sym();
ast::Type result_ty;
const ast::Statement* masked_call = nullptr;
- if (builtin->Type() == sem::BuiltinType::kAtomicCompareExchangeWeak) {
+ if (builtin->Type() == builtin::Function::kAtomicCompareExchangeWeak) {
// Special case for atomicCompareExchangeWeak as we cannot name its
// result type. We have to declare an equivalent struct and copy the
// original member values over to it.
diff --git a/src/tint/transform/multiplanar_external_texture.cc b/src/tint/transform/multiplanar_external_texture.cc
index 800a057..310bc46 100644
--- a/src/tint/transform/multiplanar_external_texture.cc
+++ b/src/tint/transform/multiplanar_external_texture.cc
@@ -196,7 +196,7 @@
if (builtin && !builtin->Parameters().IsEmpty() &&
builtin->Parameters()[0]->Type()->Is<type::ExternalTexture>() &&
- builtin->Type() != sem::BuiltinType::kTextureDimensions) {
+ builtin->Type() != builtin::Function::kTextureDimensions) {
if (auto* var_user =
sem.GetVal(expr->args[0])->UnwrapLoad()->As<sem::VariableUser>()) {
auto it = new_binding_symbols.find(var_user->Variable());
@@ -210,9 +210,9 @@
auto& syms = it->second;
switch (builtin->Type()) {
- case sem::BuiltinType::kTextureLoad:
+ case builtin::Function::kTextureLoad:
return createTextureLoad(call, syms);
- case sem::BuiltinType::kTextureSampleBaseClampToEdge:
+ case builtin::Function::kTextureSampleBaseClampToEdge:
return createTextureSampleBaseClampToEdge(expr, syms);
default:
break;
@@ -310,13 +310,13 @@
/// builtin function.
/// @param call_type determines which function body to generate
/// @returns a statement list that makes of the body of the chosen function
- auto buildTextureBuiltinBody(sem::BuiltinType call_type) {
+ auto buildTextureBuiltinBody(builtin::Function call_type) {
utils::Vector<const ast::Statement*, 16> stmts;
const ast::CallExpression* single_plane_call = nullptr;
const ast::CallExpression* plane_0_call = nullptr;
const ast::CallExpression* plane_1_call = nullptr;
switch (call_type) {
- case sem::BuiltinType::kTextureSampleBaseClampToEdge:
+ case builtin::Function::kTextureSampleBaseClampToEdge:
stmts.Push(b.Decl(b.Let(
"modifiedCoords", b.Mul(b.MemberAccessor("params", "coordTransformationMatrix"),
b.vec3<f32>("coord", 1_a)))));
@@ -346,7 +346,7 @@
// textureSampleLevel(plane1, smp, plane1_clamped, 0.0);
plane_1_call = b.Call("textureSampleLevel", "plane1", "smp", "plane1_clamped", 0_a);
break;
- case sem::BuiltinType::kTextureLoad:
+ case builtin::Function::kTextureLoad:
// textureLoad(plane0, coord, 0);
single_plane_call = b.Call("textureLoad", "plane0", "coord", 0_a);
// textureLoad(plane0, coord, 0);
@@ -433,7 +433,7 @@
b.Param("params", b.ty(params_struct_sym)),
},
b.ty.vec4(b.ty.f32()),
- buildTextureBuiltinBody(sem::BuiltinType::kTextureSampleBaseClampToEdge));
+ buildTextureBuiltinBody(builtin::Function::kTextureSampleBaseClampToEdge));
}
return b.Call(texture_sample_external_sym, utils::Vector{
@@ -480,7 +480,7 @@
b.Param("params", b.ty(params_struct_sym)),
},
b.ty.vec4(b.ty.f32()), //
- buildTextureBuiltinBody(sem::BuiltinType::kTextureLoad));
+ buildTextureBuiltinBody(builtin::Function::kTextureLoad));
return name;
});
diff --git a/src/tint/transform/multiplanar_external_texture.h b/src/tint/transform/multiplanar_external_texture.h
index 2e6f99f..625c756 100644
--- a/src/tint/transform/multiplanar_external_texture.h
+++ b/src/tint/transform/multiplanar_external_texture.h
@@ -19,8 +19,8 @@
#include <utility>
#include "src/tint/ast/struct_member.h"
+#include "src/tint/builtin/function.h"
#include "src/tint/sem/binding_point.h"
-#include "src/tint/sem/builtin_type.h"
#include "src/tint/transform/transform.h"
namespace tint::transform {
diff --git a/src/tint/transform/robustness.cc b/src/tint/transform/robustness.cc
index b79a029..b7a46f5 100644
--- a/src/tint/transform/robustness.cc
+++ b/src/tint/transform/robustness.cc
@@ -231,7 +231,7 @@
// Must clamp, even if the index is constant.
auto* arr_ptr = b.AddressOf(ctx.Clone(expr->Object()->Declaration()));
- return b.Sub(b.Call(sem::BuiltinType::kArrayLength, arr_ptr), 1_u);
+ return b.Sub(b.Call(builtin::Function::kArrayLength, arr_ptr), 1_u);
}
if (auto count = arr->ConstantCount()) {
if (expr->Index()->ConstantValue()) {
@@ -343,7 +343,7 @@
if (expr_sem->Index()->Type()->is_signed_integer_scalar()) {
idx = b.Call<u32>(idx); // u32(idx)
}
- auto* clamped_idx = b.Call(sem::BuiltinType::kMin, idx, max);
+ auto* clamped_idx = b.Call(builtin::Function::kMin, idx, max);
ctx.Replace(expr->Declaration()->index, clamped_idx);
}
@@ -358,14 +358,14 @@
}
if (predicate) {
- if (builtin->Type() == sem::BuiltinType::kWorkgroupUniformLoad) {
+ if (builtin->Type() == builtin::Function::kWorkgroupUniformLoad) {
// https://www.w3.org/TR/WGSL/#workgroupUniformLoad-builtin:
// "Executes a control barrier synchronization function that affects memory and
// atomic operations in the workgroup address space."
// Because the call acts like a control barrier, we need to make sure that we still
// trigger a workgroup barrier if the predicate fails.
PredicateCall(call, predicate,
- b.Block(b.CallStmt(b.Call(sem::BuiltinType::kWorkgroupBarrier))));
+ b.Block(b.CallStmt(b.Call(builtin::Function::kWorkgroupBarrier))));
} else {
PredicateCall(call, predicate);
}
@@ -408,7 +408,7 @@
// let num_levels = textureNumLevels(texture-arg);
num_levels = b.Symbols().New("num_levels");
hoist.InsertBefore(
- stmt, b.Decl(b.Let(num_levels, b.Call(sem::BuiltinType::kTextureNumLevels,
+ stmt, b.Decl(b.Let(num_levels, b.Call(builtin::Function::kTextureNumLevels,
ctx.Clone(texture_arg)))));
// predicate: level_idx < num_levels
@@ -433,12 +433,12 @@
// predicate: all(coords < textureDimensions(texture))
auto* dimensions =
level_idx.IsValid()
- ? b.Call(sem::BuiltinType::kTextureDimensions, ctx.Clone(texture_arg),
- b.Call(sem::BuiltinType::kMin, b.Expr(level_idx),
+ ? b.Call(builtin::Function::kTextureDimensions, ctx.Clone(texture_arg),
+ b.Call(builtin::Function::kMin, b.Expr(level_idx),
b.Sub(num_levels, 1_a)))
- : b.Call(sem::BuiltinType::kTextureDimensions, ctx.Clone(texture_arg));
+ : b.Call(builtin::Function::kTextureDimensions, ctx.Clone(texture_arg));
predicate =
- And(predicate, b.Call(sem::BuiltinType::kAll, b.LessThan(coords, dimensions)));
+ And(predicate, b.Call(builtin::Function::kAll, b.LessThan(coords, dimensions)));
// Replace the level argument with `coord`
ctx.Replace(arg, b.Expr(coords));
@@ -448,7 +448,7 @@
if (array_arg_idx >= 0) {
// let array_idx = u32(array-arg)
auto* arg = expr->args[static_cast<size_t>(array_arg_idx)];
- auto* num_layers = b.Call(sem::BuiltinType::kTextureNumLayers, ctx.Clone(texture_arg));
+ auto* num_layers = b.Call(builtin::Function::kTextureNumLayers, ctx.Clone(texture_arg));
auto array_idx = b.Symbols().New("array_idx");
hoist.InsertBefore(stmt, b.Decl(b.Let(array_idx, CastToUnsigned(ctx.Clone(arg), 1u))));
@@ -493,10 +493,10 @@
const auto* arg = expr->args[static_cast<size_t>(level_arg_idx)];
level_idx = b.Symbols().New("level_idx");
const auto* num_levels =
- b.Call(sem::BuiltinType::kTextureNumLevels, ctx.Clone(texture_arg));
+ b.Call(builtin::Function::kTextureNumLevels, ctx.Clone(texture_arg));
const auto* max = b.Sub(num_levels, 1_a);
hoist.InsertBefore(
- stmt, b.Decl(b.Let(level_idx, b.Call(sem::BuiltinType::kMin,
+ stmt, b.Decl(b.Let(level_idx, b.Call(builtin::Function::kMin,
b.Call<u32>(ctx.Clone(arg)), max))));
ctx.Replace(arg, b.Expr(level_idx));
}
@@ -510,19 +510,19 @@
const auto width = WidthOf(param->Type());
const auto* dimensions =
level_idx.IsValid()
- ? b.Call(sem::BuiltinType::kTextureDimensions, ctx.Clone(texture_arg),
+ ? b.Call(builtin::Function::kTextureDimensions, ctx.Clone(texture_arg),
level_idx)
- : b.Call(sem::BuiltinType::kTextureDimensions, ctx.Clone(texture_arg));
+ : b.Call(builtin::Function::kTextureDimensions, ctx.Clone(texture_arg));
// dimensions is u32 or vecN<u32>
const auto* unsigned_max = b.Sub(dimensions, ScalarOrVec(b.Expr(1_a), width));
if (param->Type()->is_signed_integer_scalar_or_vector()) {
const auto* zero = ScalarOrVec(b.Expr(0_a), width);
const auto* signed_max = CastToSigned(unsigned_max, width);
- ctx.Replace(arg,
- b.Call(sem::BuiltinType::kClamp, ctx.Clone(arg), zero, signed_max));
+ ctx.Replace(
+ arg, b.Call(builtin::Function::kClamp, ctx.Clone(arg), zero, signed_max));
} else {
- ctx.Replace(arg, b.Call(sem::BuiltinType::kMin, ctx.Clone(arg), unsigned_max));
+ ctx.Replace(arg, b.Call(builtin::Function::kMin, ctx.Clone(arg), unsigned_max));
}
}
}
@@ -531,14 +531,15 @@
if (array_arg_idx >= 0) {
auto* param = builtin->Parameters()[static_cast<size_t>(array_arg_idx)];
auto* arg = expr->args[static_cast<size_t>(array_arg_idx)];
- auto* num_layers = b.Call(sem::BuiltinType::kTextureNumLayers, ctx.Clone(texture_arg));
+ auto* num_layers = b.Call(builtin::Function::kTextureNumLayers, ctx.Clone(texture_arg));
const auto* unsigned_max = b.Sub(num_layers, 1_a);
if (param->Type()->is_signed_integer_scalar()) {
const auto* signed_max = CastToSigned(unsigned_max, 1u);
- ctx.Replace(arg, b.Call(sem::BuiltinType::kClamp, ctx.Clone(arg), 0_a, signed_max));
+ ctx.Replace(arg,
+ b.Call(builtin::Function::kClamp, ctx.Clone(arg), 0_a, signed_max));
} else {
- ctx.Replace(arg, b.Call(sem::BuiltinType::kMin, ctx.Clone(arg), unsigned_max));
+ ctx.Replace(arg, b.Call(builtin::Function::kMin, ctx.Clone(arg), unsigned_max));
}
}
}
@@ -546,9 +547,10 @@
/// @param type builtin type
/// @returns true if the given builtin is a texture function that requires predication or
/// clamping of arguments.
- bool TextureBuiltinNeedsRobustness(sem::BuiltinType type) {
- return type == sem::BuiltinType::kTextureLoad || type == sem::BuiltinType::kTextureStore ||
- type == sem::BuiltinType::kTextureDimensions;
+ bool TextureBuiltinNeedsRobustness(builtin::Function type) {
+ return type == builtin::Function::kTextureLoad ||
+ type == builtin::Function::kTextureStore ||
+ type == builtin::Function::kTextureDimensions;
}
/// @returns a bitwise and of the two expressions, or the other expression if one is null.
diff --git a/src/tint/transform/spirv_atomic.cc b/src/tint/transform/spirv_atomic.cc
index 043861b..73c2ae2 100644
--- a/src/tint/transform/spirv_atomic.cc
+++ b/src/tint/transform/spirv_atomic.cc
@@ -81,22 +81,22 @@
out_args[0] = b.AddressOf(out_args[0]);
// Replace all callsites of this stub to a call to the real builtin
- if (stub->builtin == sem::BuiltinType::kAtomicCompareExchangeWeak) {
+ if (stub->builtin == builtin::Function::kAtomicCompareExchangeWeak) {
// atomicCompareExchangeWeak returns a struct, so insert a call to it above
// the current statement, and replace the current call with the struct's
// `old_value` member.
auto* block = call->Stmt()->Block()->Declaration();
auto old_value = b.Symbols().New("old_value");
auto old_value_decl = b.Decl(b.Let(
- old_value,
- b.MemberAccessor(b.Call(sem::str(stub->builtin), std::move(out_args)),
- "old_value")));
+ old_value, b.MemberAccessor(
+ b.Call(builtin::str(stub->builtin), std::move(out_args)),
+ "old_value")));
ctx.InsertBefore(block->statements, call->Stmt()->Declaration(),
old_value_decl);
ctx.Replace(call->Declaration(), b.Expr(old_value));
} else {
ctx.Replace(call->Declaration(),
- b.Call(sem::str(stub->builtin), std::move(out_args)));
+ b.Call(builtin::str(stub->builtin), std::move(out_args)));
}
// Keep track of this expression. We'll need to modify the root identifier /
@@ -255,7 +255,7 @@
ctx.Replace(assign, [=] {
auto* lhs = ctx.CloneWithoutTransform(assign->lhs);
auto* rhs = ctx.CloneWithoutTransform(assign->rhs);
- auto* call = b.Call(sem::str(sem::BuiltinType::kAtomicStore),
+ auto* call = b.Call(builtin::str(builtin::Function::kAtomicStore),
b.AddressOf(lhs), rhs);
return b.CallStmt(call);
});
@@ -266,7 +266,7 @@
if (is_ref_to_atomic_var(sem_rhs->UnwrapLoad())) {
ctx.Replace(assign->rhs, [=] {
auto* rhs = ctx.CloneWithoutTransform(assign->rhs);
- return b.Call(sem::str(sem::BuiltinType::kAtomicLoad),
+ return b.Call(builtin::str(builtin::Function::kAtomicLoad),
b.AddressOf(rhs));
});
return;
@@ -278,7 +278,7 @@
if (is_ref_to_atomic_var(sem_init->UnwrapLoad())) {
ctx.Replace(var->initializer, [=] {
auto* rhs = ctx.CloneWithoutTransform(var->initializer);
- return b.Call(sem::str(sem::BuiltinType::kAtomicLoad),
+ return b.Call(builtin::str(builtin::Function::kAtomicLoad),
b.AddressOf(rhs));
});
return;
@@ -293,11 +293,11 @@
SpirvAtomic::SpirvAtomic() = default;
SpirvAtomic::~SpirvAtomic() = default;
-SpirvAtomic::Stub::Stub(ProgramID pid, ast::NodeID nid, sem::BuiltinType b)
+SpirvAtomic::Stub::Stub(ProgramID pid, ast::NodeID nid, builtin::Function b)
: Base(pid, nid, utils::Empty), builtin(b) {}
SpirvAtomic::Stub::~Stub() = default;
std::string SpirvAtomic::Stub::InternalName() const {
- return "@internal(spirv-atomic " + std::string(sem::str(builtin)) + ")";
+ return "@internal(spirv-atomic " + std::string(builtin::str(builtin)) + ")";
}
const SpirvAtomic::Stub* SpirvAtomic::Stub::Clone(CloneContext* ctx) const {
diff --git a/src/tint/transform/spirv_atomic.h b/src/tint/transform/spirv_atomic.h
index 0f99dba..b524200 100644
--- a/src/tint/transform/spirv_atomic.h
+++ b/src/tint/transform/spirv_atomic.h
@@ -18,7 +18,7 @@
#include <string>
#include "src/tint/ast/internal_attribute.h"
-#include "src/tint/sem/builtin_type.h"
+#include "src/tint/builtin/function.h"
#include "src/tint/transform/transform.h"
// Forward declarations
@@ -46,7 +46,7 @@
/// @param pid the identifier of the program that owns this node
/// @param nid the unique node identifier
/// @param builtin the atomic builtin this stub represents
- Stub(ProgramID pid, ast::NodeID nid, sem::BuiltinType builtin);
+ Stub(ProgramID pid, ast::NodeID nid, builtin::Function builtin);
/// Destructor
~Stub() override;
@@ -60,7 +60,7 @@
const Stub* Clone(CloneContext* ctx) const override;
/// The type of the intrinsic
- const sem::BuiltinType builtin;
+ const builtin::Function builtin;
};
/// @copydoc Transform::Apply
diff --git a/src/tint/transform/spirv_atomic_test.cc b/src/tint/transform/spirv_atomic_test.cc
index 7bb9f2a..29976b5 100644
--- a/src/tint/transform/spirv_atomic_test.cc
+++ b/src/tint/transform/spirv_atomic_test.cc
@@ -36,14 +36,14 @@
auto& b = parser.builder();
- sem::BuiltinType two_params[] = {
- sem::BuiltinType::kAtomicExchange, sem::BuiltinType::kAtomicAdd,
- sem::BuiltinType::kAtomicSub, sem::BuiltinType::kAtomicMin,
- sem::BuiltinType::kAtomicMax, sem::BuiltinType::kAtomicAnd,
- sem::BuiltinType::kAtomicOr, sem::BuiltinType::kAtomicXor,
+ builtin::Function two_params[] = {
+ builtin::Function::kAtomicExchange, builtin::Function::kAtomicAdd,
+ builtin::Function::kAtomicSub, builtin::Function::kAtomicMin,
+ builtin::Function::kAtomicMax, builtin::Function::kAtomicAnd,
+ builtin::Function::kAtomicOr, builtin::Function::kAtomicXor,
};
for (auto& a : two_params) {
- b.Func(std::string{"stub_"} + sem::str(a) + "_u32",
+ b.Func(std::string{"stub_"} + builtin::str(a) + "_u32",
utils::Vector{
b.Param("p0", b.ty.u32()),
b.Param("p1", b.ty.u32()),
@@ -55,7 +55,7 @@
utils::Vector{
b.ASTNodes().Create<SpirvAtomic::Stub>(b.ID(), b.AllocateNodeID(), a),
});
- b.Func(std::string{"stub_"} + sem::str(a) + "_i32",
+ b.Func(std::string{"stub_"} + builtin::str(a) + "_i32",
utils::Vector{
b.Param("p0", b.ty.i32()),
b.Param("p1", b.ty.i32()),
@@ -79,7 +79,7 @@
},
utils::Vector{
b.ASTNodes().Create<SpirvAtomic::Stub>(b.ID(), b.AllocateNodeID(),
- sem::BuiltinType::kAtomicLoad),
+ builtin::Function::kAtomicLoad),
});
b.Func("stub_atomicLoad_i32",
utils::Vector{
@@ -91,7 +91,7 @@
},
utils::Vector{
b.ASTNodes().Create<SpirvAtomic::Stub>(b.ID(), b.AllocateNodeID(),
- sem::BuiltinType::kAtomicLoad),
+ builtin::Function::kAtomicLoad),
});
b.Func("stub_atomicStore_u32",
@@ -102,7 +102,7 @@
b.ty.void_(), utils::Empty,
utils::Vector{
b.ASTNodes().Create<SpirvAtomic::Stub>(b.ID(), b.AllocateNodeID(),
- sem::BuiltinType::kAtomicStore),
+ builtin::Function::kAtomicStore),
});
b.Func("stub_atomicStore_i32",
utils::Vector{
@@ -112,7 +112,7 @@
b.ty.void_(), utils::Empty,
utils::Vector{
b.ASTNodes().Create<SpirvAtomic::Stub>(b.ID(), b.AllocateNodeID(),
- sem::BuiltinType::kAtomicStore),
+ builtin::Function::kAtomicStore),
});
b.Func("stub_atomic_compare_exchange_weak_u32",
@@ -127,7 +127,7 @@
},
utils::Vector{
b.ASTNodes().Create<SpirvAtomic::Stub>(
- b.ID(), b.AllocateNodeID(), sem::BuiltinType::kAtomicCompareExchangeWeak),
+ b.ID(), b.AllocateNodeID(), builtin::Function::kAtomicCompareExchangeWeak),
});
b.Func("stub_atomic_compare_exchange_weak_i32",
utils::Vector{b.Param("p0", b.ty.i32()), b.Param("p1", b.ty.i32()),
@@ -138,7 +138,7 @@
},
utils::Vector{
b.ASTNodes().Create<SpirvAtomic::Stub>(
- b.ID(), b.AllocateNodeID(), sem::BuiltinType::kAtomicCompareExchangeWeak),
+ b.ID(), b.AllocateNodeID(), builtin::Function::kAtomicCompareExchangeWeak),
});
// Keep this pointer alive after Transform() returns
diff --git a/src/tint/transform/substitute_override.cc b/src/tint/transform/substitute_override.cc
index 2d6b995..e4b2d7b 100644
--- a/src/tint/transform/substitute_override.cc
+++ b/src/tint/transform/substitute_override.cc
@@ -17,6 +17,7 @@
#include <functional>
#include <utility>
+#include "src/tint/builtin/function.h"
#include "src/tint/program_builder.h"
#include "src/tint/sem/builtin.h"
#include "src/tint/sem/index_accessor_expression.h"
@@ -105,7 +106,7 @@
if (auto* access = sem->UnwrapMaterialize()->As<sem::IndexAccessorExpression>()) {
if (access->Object()->UnwrapMaterialize()->Type()->HoldsAbstract() &&
access->Index()->Stage() == sem::EvaluationStage::kOverride) {
- auto* obj = b.Call(sem::str(sem::BuiltinType::kTintMaterialize),
+ auto* obj = b.Call(builtin::str(builtin::Function::kTintMaterialize),
ctx.Clone(expr->object));
return b.IndexAccessor(obj, ctx.Clone(expr->index));
}
diff --git a/src/tint/transform/texture_1d_to_2d.cc b/src/tint/transform/texture_1d_to_2d.cc
index d1caaab..5050aa0 100644
--- a/src/tint/transform/texture_1d_to_2d.cc
+++ b/src/tint/transform/texture_1d_to_2d.cc
@@ -137,7 +137,7 @@
return nullptr;
}
- if (builtin->Type() == sem::BuiltinType::kTextureDimensions) {
+ if (builtin->Type() == builtin::Function::kTextureDimensions) {
// If this textureDimensions() call is in a CallStatement, we can leave it
// unmodified since the return value will be dropped on the floor anyway.
if (call->Stmt()->Declaration()->Is<ast::CallStatement>()) {
diff --git a/src/tint/writer/glsl/generator_impl.cc b/src/tint/writer/glsl/generator_impl.cc
index 5e06902..61b281f 100644
--- a/src/tint/writer/glsl/generator_impl.cc
+++ b/src/tint/writer/glsl/generator_impl.cc
@@ -776,48 +776,49 @@
if (builtin->IsTexture()) {
return EmitTextureCall(out, call, builtin);
}
- if (builtin->Type() == sem::BuiltinType::kCountOneBits) {
+ if (builtin->Type() == builtin::Function::kCountOneBits) {
return EmitCountOneBitsCall(out, expr);
}
- if (builtin->Type() == sem::BuiltinType::kSelect) {
+ if (builtin->Type() == builtin::Function::kSelect) {
return EmitSelectCall(out, expr, builtin);
}
- if (builtin->Type() == sem::BuiltinType::kDot) {
+ if (builtin->Type() == builtin::Function::kDot) {
return EmitDotCall(out, expr, builtin);
}
- if (builtin->Type() == sem::BuiltinType::kModf) {
+ if (builtin->Type() == builtin::Function::kModf) {
return EmitModfCall(out, expr, builtin);
}
- if (builtin->Type() == sem::BuiltinType::kFrexp) {
+ if (builtin->Type() == builtin::Function::kFrexp) {
return EmitFrexpCall(out, expr, builtin);
}
- if (builtin->Type() == sem::BuiltinType::kDegrees) {
+ if (builtin->Type() == builtin::Function::kDegrees) {
return EmitDegreesCall(out, expr, builtin);
}
- if (builtin->Type() == sem::BuiltinType::kRadians) {
+ if (builtin->Type() == builtin::Function::kRadians) {
return EmitRadiansCall(out, expr, builtin);
}
- if (builtin->Type() == sem::BuiltinType::kQuantizeToF16) {
+ if (builtin->Type() == builtin::Function::kQuantizeToF16) {
return EmitQuantizeToF16Call(out, expr, builtin);
}
- if (builtin->Type() == sem::BuiltinType::kArrayLength) {
+ if (builtin->Type() == builtin::Function::kArrayLength) {
return EmitArrayLength(out, expr);
}
- if (builtin->Type() == sem::BuiltinType::kExtractBits) {
+ if (builtin->Type() == builtin::Function::kExtractBits) {
return EmitExtractBits(out, expr);
}
- if (builtin->Type() == sem::BuiltinType::kInsertBits) {
+ if (builtin->Type() == builtin::Function::kInsertBits) {
return EmitInsertBits(out, expr);
}
- if (builtin->Type() == sem::BuiltinType::kFma && version_.IsES()) {
+ if (builtin->Type() == builtin::Function::kFma && version_.IsES()) {
return EmitEmulatedFMA(out, expr);
}
- if (builtin->Type() == sem::BuiltinType::kAbs &&
+ if (builtin->Type() == builtin::Function::kAbs &&
TypeOf(expr->args[0])->UnwrapRef()->is_unsigned_integer_scalar_or_vector()) {
// GLSL does not support abs() on unsigned arguments. However, it's a no-op.
return EmitExpression(out, expr->args[0]);
}
- if ((builtin->Type() == sem::BuiltinType::kAny || builtin->Type() == sem::BuiltinType::kAll) &&
+ if ((builtin->Type() == builtin::Function::kAny ||
+ builtin->Type() == builtin::Function::kAll) &&
TypeOf(expr->args[0])->UnwrapRef()->is_scalar()) {
// GLSL does not support any() or all() on scalar arguments. It's a no-op.
return EmitExpression(out, expr->args[0]);
@@ -919,7 +920,7 @@
};
switch (builtin->Type()) {
- case sem::BuiltinType::kAtomicLoad: {
+ case builtin::Function::kAtomicLoad: {
// GLSL does not have an atomicLoad, so we emulate it with
// atomicOr using 0 as the OR value
out << "atomicOr";
@@ -935,7 +936,7 @@
}
return true;
}
- case sem::BuiltinType::kAtomicCompareExchangeWeak: {
+ case builtin::Function::kAtomicCompareExchangeWeak: {
if (!EmitStructType(&helpers_, builtin->ReturnType()->As<sem::Struct>())) {
return false;
}
@@ -986,27 +987,27 @@
return true;
}
- case sem::BuiltinType::kAtomicAdd:
- case sem::BuiltinType::kAtomicSub:
+ case builtin::Function::kAtomicAdd:
+ case builtin::Function::kAtomicSub:
return call("atomicAdd");
- case sem::BuiltinType::kAtomicMax:
+ case builtin::Function::kAtomicMax:
return call("atomicMax");
- case sem::BuiltinType::kAtomicMin:
+ case builtin::Function::kAtomicMin:
return call("atomicMin");
- case sem::BuiltinType::kAtomicAnd:
+ case builtin::Function::kAtomicAnd:
return call("atomicAnd");
- case sem::BuiltinType::kAtomicOr:
+ case builtin::Function::kAtomicOr:
return call("atomicOr");
- case sem::BuiltinType::kAtomicXor:
+ case builtin::Function::kAtomicXor:
return call("atomicXor");
- case sem::BuiltinType::kAtomicExchange:
- case sem::BuiltinType::kAtomicStore:
+ case builtin::Function::kAtomicExchange:
+ case builtin::Function::kAtomicStore:
// GLSL does not have an atomicStore, so we emulate it with
// atomicExchange.
return call("atomicExchange");
@@ -1339,13 +1340,13 @@
bool GeneratorImpl::EmitBarrierCall(utils::StringStream& out, const sem::Builtin* builtin) {
// TODO(crbug.com/tint/661): Combine sequential barriers to a single
// instruction.
- if (builtin->Type() == sem::BuiltinType::kWorkgroupBarrier) {
+ if (builtin->Type() == builtin::Function::kWorkgroupBarrier) {
out << "barrier()";
- } else if (builtin->Type() == sem::BuiltinType::kStorageBarrier) {
+ } else if (builtin->Type() == builtin::Function::kStorageBarrier) {
out << "{ barrier(); memoryBarrierBuffer(); }";
} else {
TINT_UNREACHABLE(Writer, diagnostics_)
- << "unexpected barrier builtin type " << sem::str(builtin->Type());
+ << "unexpected barrier builtin type " << builtin::str(builtin->Type());
return false;
}
return true;
@@ -1415,7 +1416,7 @@
};
switch (builtin->Type()) {
- case sem::BuiltinType::kTextureDimensions: {
+ case builtin::Function::kTextureDimensions: {
// textureDimensions() returns an unsigned scalar / vector in WGSL.
// textureSize() / imageSize() returns a signed scalar / vector in GLSL.
// Cast.
@@ -1454,7 +1455,7 @@
}
return true;
}
- case sem::BuiltinType::kTextureNumLayers: {
+ case builtin::Function::kTextureNumLayers: {
// textureNumLayers() returns an unsigned scalar in WGSL.
// textureSize() / imageSize() returns a signed scalar / vector in GLSL.
// Cast.
@@ -1488,7 +1489,7 @@
out << ").z";
return true;
}
- case sem::BuiltinType::kTextureNumLevels: {
+ case builtin::Function::kTextureNumLevels: {
// textureNumLevels() returns an unsigned scalar in WGSL.
// textureQueryLevels() returns a signed scalar in GLSL.
// Cast.
@@ -1502,7 +1503,7 @@
out << ")";
return true;
}
- case sem::BuiltinType::kTextureNumSamples: {
+ case builtin::Function::kTextureNumSamples: {
// textureNumSamples() returns an unsigned scalar in WGSL.
// textureSamples() returns a signed scalar in GLSL.
// Cast.
@@ -1525,36 +1526,36 @@
bool is_depth = texture_type->Is<type::DepthTexture>();
switch (builtin->Type()) {
- case sem::BuiltinType::kTextureSample:
- case sem::BuiltinType::kTextureSampleBias:
+ case builtin::Function::kTextureSample:
+ case builtin::Function::kTextureSampleBias:
out << "texture";
if (is_depth) {
glsl_ret_width = 1u;
}
break;
- case sem::BuiltinType::kTextureSampleLevel:
+ case builtin::Function::kTextureSampleLevel:
out << "textureLod";
if (is_depth) {
glsl_ret_width = 1u;
}
break;
- case sem::BuiltinType::kTextureGather:
- case sem::BuiltinType::kTextureGatherCompare:
+ case builtin::Function::kTextureGather:
+ case builtin::Function::kTextureGatherCompare:
out << "textureGather";
append_depth_ref_to_coords = false;
break;
- case sem::BuiltinType::kTextureSampleGrad:
+ case builtin::Function::kTextureSampleGrad:
out << "textureGrad";
break;
- case sem::BuiltinType::kTextureSampleCompare:
- case sem::BuiltinType::kTextureSampleCompareLevel:
+ case builtin::Function::kTextureSampleCompare:
+ case builtin::Function::kTextureSampleCompareLevel:
out << "texture";
glsl_ret_width = 1;
break;
- case sem::BuiltinType::kTextureLoad:
+ case builtin::Function::kTextureLoad:
out << "texelFetch";
break;
- case sem::BuiltinType::kTextureStore:
+ case builtin::Function::kTextureStore:
out << "imageStore";
break;
default:
@@ -1633,7 +1634,7 @@
}
// GLSL's textureGather always requires a refZ parameter.
- if (is_depth && builtin->Type() == sem::BuiltinType::kTextureGather) {
+ if (is_depth && builtin->Type() == builtin::Function::kTextureGather) {
out << ", 0.0";
}
@@ -1644,7 +1645,7 @@
if (!EmitExpression(out, e)) {
return false;
}
- } else if (builtin->Type() == sem::BuiltinType::kTextureSample) {
+ } else if (builtin->Type() == builtin::Function::kTextureSample) {
out << ", 0.0f";
}
}
@@ -1688,114 +1689,114 @@
std::string GeneratorImpl::generate_builtin_name(const sem::Builtin* builtin) {
switch (builtin->Type()) {
- case sem::BuiltinType::kAbs:
- case sem::BuiltinType::kAcos:
- case sem::BuiltinType::kAcosh:
- case sem::BuiltinType::kAll:
- case sem::BuiltinType::kAny:
- case sem::BuiltinType::kAsin:
- case sem::BuiltinType::kAsinh:
- case sem::BuiltinType::kAtan:
- case sem::BuiltinType::kAtanh:
- case sem::BuiltinType::kCeil:
- case sem::BuiltinType::kClamp:
- case sem::BuiltinType::kCos:
- case sem::BuiltinType::kCosh:
- case sem::BuiltinType::kCross:
- case sem::BuiltinType::kDeterminant:
- case sem::BuiltinType::kDistance:
- case sem::BuiltinType::kDot:
- case sem::BuiltinType::kExp:
- case sem::BuiltinType::kExp2:
- case sem::BuiltinType::kFloor:
- case sem::BuiltinType::kFrexp:
- case sem::BuiltinType::kLdexp:
- case sem::BuiltinType::kLength:
- case sem::BuiltinType::kLog:
- case sem::BuiltinType::kLog2:
- case sem::BuiltinType::kMax:
- case sem::BuiltinType::kMin:
- case sem::BuiltinType::kModf:
- case sem::BuiltinType::kNormalize:
- case sem::BuiltinType::kPow:
- case sem::BuiltinType::kReflect:
- case sem::BuiltinType::kRefract:
- case sem::BuiltinType::kRound:
- case sem::BuiltinType::kSign:
- case sem::BuiltinType::kSin:
- case sem::BuiltinType::kSinh:
- case sem::BuiltinType::kSqrt:
- case sem::BuiltinType::kStep:
- case sem::BuiltinType::kTan:
- case sem::BuiltinType::kTanh:
- case sem::BuiltinType::kTranspose:
- case sem::BuiltinType::kTrunc:
+ case builtin::Function::kAbs:
+ case builtin::Function::kAcos:
+ case builtin::Function::kAcosh:
+ case builtin::Function::kAll:
+ case builtin::Function::kAny:
+ case builtin::Function::kAsin:
+ case builtin::Function::kAsinh:
+ case builtin::Function::kAtan:
+ case builtin::Function::kAtanh:
+ case builtin::Function::kCeil:
+ case builtin::Function::kClamp:
+ case builtin::Function::kCos:
+ case builtin::Function::kCosh:
+ case builtin::Function::kCross:
+ case builtin::Function::kDeterminant:
+ case builtin::Function::kDistance:
+ case builtin::Function::kDot:
+ case builtin::Function::kExp:
+ case builtin::Function::kExp2:
+ case builtin::Function::kFloor:
+ case builtin::Function::kFrexp:
+ case builtin::Function::kLdexp:
+ case builtin::Function::kLength:
+ case builtin::Function::kLog:
+ case builtin::Function::kLog2:
+ case builtin::Function::kMax:
+ case builtin::Function::kMin:
+ case builtin::Function::kModf:
+ case builtin::Function::kNormalize:
+ case builtin::Function::kPow:
+ case builtin::Function::kReflect:
+ case builtin::Function::kRefract:
+ case builtin::Function::kRound:
+ case builtin::Function::kSign:
+ case builtin::Function::kSin:
+ case builtin::Function::kSinh:
+ case builtin::Function::kSqrt:
+ case builtin::Function::kStep:
+ case builtin::Function::kTan:
+ case builtin::Function::kTanh:
+ case builtin::Function::kTranspose:
+ case builtin::Function::kTrunc:
return builtin->str();
- case sem::BuiltinType::kAtan2:
+ case builtin::Function::kAtan2:
return "atan";
- case sem::BuiltinType::kCountOneBits:
+ case builtin::Function::kCountOneBits:
return "bitCount";
- case sem::BuiltinType::kDpdx:
+ case builtin::Function::kDpdx:
return "dFdx";
- case sem::BuiltinType::kDpdxCoarse:
+ case builtin::Function::kDpdxCoarse:
if (version_.IsES()) {
return "dFdx";
}
return "dFdxCoarse";
- case sem::BuiltinType::kDpdxFine:
+ case builtin::Function::kDpdxFine:
if (version_.IsES()) {
return "dFdx";
}
return "dFdxFine";
- case sem::BuiltinType::kDpdy:
+ case builtin::Function::kDpdy:
return "dFdy";
- case sem::BuiltinType::kDpdyCoarse:
+ case builtin::Function::kDpdyCoarse:
if (version_.IsES()) {
return "dFdy";
}
return "dFdyCoarse";
- case sem::BuiltinType::kDpdyFine:
+ case builtin::Function::kDpdyFine:
if (version_.IsES()) {
return "dFdy";
}
return "dFdyFine";
- case sem::BuiltinType::kFaceForward:
+ case builtin::Function::kFaceForward:
return "faceforward";
- case sem::BuiltinType::kFract:
+ case builtin::Function::kFract:
return "fract";
- case sem::BuiltinType::kFma:
+ case builtin::Function::kFma:
return "fma";
- case sem::BuiltinType::kFwidth:
- case sem::BuiltinType::kFwidthCoarse:
- case sem::BuiltinType::kFwidthFine:
+ case builtin::Function::kFwidth:
+ case builtin::Function::kFwidthCoarse:
+ case builtin::Function::kFwidthFine:
return "fwidth";
- case sem::BuiltinType::kInverseSqrt:
+ case builtin::Function::kInverseSqrt:
return "inversesqrt";
- case sem::BuiltinType::kMix:
+ case builtin::Function::kMix:
return "mix";
- case sem::BuiltinType::kPack2X16Float:
+ case builtin::Function::kPack2X16Float:
return "packHalf2x16";
- case sem::BuiltinType::kPack2X16Snorm:
+ case builtin::Function::kPack2X16Snorm:
return "packSnorm2x16";
- case sem::BuiltinType::kPack2X16Unorm:
+ case builtin::Function::kPack2X16Unorm:
return "packUnorm2x16";
- case sem::BuiltinType::kPack4X8Snorm:
+ case builtin::Function::kPack4X8Snorm:
return "packSnorm4x8";
- case sem::BuiltinType::kPack4X8Unorm:
+ case builtin::Function::kPack4X8Unorm:
return "packUnorm4x8";
- case sem::BuiltinType::kReverseBits:
+ case builtin::Function::kReverseBits:
return "bitfieldReverse";
- case sem::BuiltinType::kSmoothstep:
+ case builtin::Function::kSmoothstep:
return "smoothstep";
- case sem::BuiltinType::kUnpack2X16Float:
+ case builtin::Function::kUnpack2X16Float:
return "unpackHalf2x16";
- case sem::BuiltinType::kUnpack2X16Snorm:
+ case builtin::Function::kUnpack2X16Snorm:
return "unpackSnorm2x16";
- case sem::BuiltinType::kUnpack2X16Unorm:
+ case builtin::Function::kUnpack2X16Unorm:
return "unpackUnorm2x16";
- case sem::BuiltinType::kUnpack4X8Snorm:
+ case builtin::Function::kUnpack4X8Snorm:
return "unpackSnorm4x8";
- case sem::BuiltinType::kUnpack4X8Unorm:
+ case builtin::Function::kUnpack4X8Unorm:
return "unpackUnorm4x8";
default:
diagnostics_.add_error(diag::System::Writer,
@@ -3236,7 +3237,7 @@
TextBuffer b;
TINT_DEFER(helpers_.Append(b));
- auto fn_name = UniqueIdentifier(std::string("tint_") + sem::str(builtin->Type()));
+ auto fn_name = UniqueIdentifier(std::string("tint_") + builtin::str(builtin->Type()));
std::vector<std::string> parameter_names;
{
auto decl = line(&b);
diff --git a/src/tint/writer/glsl/generator_impl_builtin_test.cc b/src/tint/writer/glsl/generator_impl_builtin_test.cc
index 19bf555..27cd717 100644
--- a/src/tint/writer/glsl/generator_impl_builtin_test.cc
+++ b/src/tint/writer/glsl/generator_impl_builtin_test.cc
@@ -26,8 +26,6 @@
namespace tint::writer::glsl {
namespace {
-using BuiltinType = sem::BuiltinType;
-
using GlslGeneratorImplTest_Builtin = TestHelper;
enum class CallParamType {
@@ -38,7 +36,7 @@
};
struct BuiltinData {
- BuiltinType builtin;
+ builtin::Function builtin;
CallParamType type;
const char* glsl_name;
};
@@ -62,86 +60,86 @@
return out;
}
-const ast::CallExpression* GenerateCall(BuiltinType builtin,
+const ast::CallExpression* GenerateCall(builtin::Function builtin,
CallParamType type,
ProgramBuilder* builder) {
std::string name;
utils::StringStream str;
str << name << builtin;
switch (builtin) {
- case BuiltinType::kAcos:
- case BuiltinType::kAsin:
- case BuiltinType::kAtan:
- case BuiltinType::kCeil:
- case BuiltinType::kCos:
- case BuiltinType::kCosh:
- case BuiltinType::kDpdx:
- case BuiltinType::kDpdxCoarse:
- case BuiltinType::kDpdxFine:
- case BuiltinType::kDpdy:
- case BuiltinType::kDpdyCoarse:
- case BuiltinType::kDpdyFine:
- case BuiltinType::kExp:
- case BuiltinType::kExp2:
- case BuiltinType::kFloor:
- case BuiltinType::kFract:
- case BuiltinType::kFwidth:
- case BuiltinType::kFwidthCoarse:
- case BuiltinType::kFwidthFine:
- case BuiltinType::kInverseSqrt:
- case BuiltinType::kLength:
- case BuiltinType::kLog:
- case BuiltinType::kLog2:
- case BuiltinType::kNormalize:
- case BuiltinType::kRound:
- case BuiltinType::kSin:
- case BuiltinType::kSinh:
- case BuiltinType::kSqrt:
- case BuiltinType::kTan:
- case BuiltinType::kTanh:
- case BuiltinType::kTrunc:
- case BuiltinType::kSign:
+ case builtin::Function::kAcos:
+ case builtin::Function::kAsin:
+ case builtin::Function::kAtan:
+ case builtin::Function::kCeil:
+ case builtin::Function::kCos:
+ case builtin::Function::kCosh:
+ case builtin::Function::kDpdx:
+ case builtin::Function::kDpdxCoarse:
+ case builtin::Function::kDpdxFine:
+ case builtin::Function::kDpdy:
+ case builtin::Function::kDpdyCoarse:
+ case builtin::Function::kDpdyFine:
+ case builtin::Function::kExp:
+ case builtin::Function::kExp2:
+ case builtin::Function::kFloor:
+ case builtin::Function::kFract:
+ case builtin::Function::kFwidth:
+ case builtin::Function::kFwidthCoarse:
+ case builtin::Function::kFwidthFine:
+ case builtin::Function::kInverseSqrt:
+ case builtin::Function::kLength:
+ case builtin::Function::kLog:
+ case builtin::Function::kLog2:
+ case builtin::Function::kNormalize:
+ case builtin::Function::kRound:
+ case builtin::Function::kSin:
+ case builtin::Function::kSinh:
+ case builtin::Function::kSqrt:
+ case builtin::Function::kTan:
+ case builtin::Function::kTanh:
+ case builtin::Function::kTrunc:
+ case builtin::Function::kSign:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "h2");
} else {
return builder->Call(str.str(), "f2");
}
- case BuiltinType::kLdexp:
+ case builtin::Function::kLdexp:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "h2", "i2");
} else {
return builder->Call(str.str(), "f2", "i2");
}
- case BuiltinType::kAtan2:
- case BuiltinType::kDot:
- case BuiltinType::kDistance:
- case BuiltinType::kPow:
- case BuiltinType::kReflect:
- case BuiltinType::kStep:
+ case builtin::Function::kAtan2:
+ case builtin::Function::kDot:
+ case builtin::Function::kDistance:
+ case builtin::Function::kPow:
+ case builtin::Function::kReflect:
+ case builtin::Function::kStep:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "h2", "h2");
} else {
return builder->Call(str.str(), "f2", "f2");
}
- case BuiltinType::kCross:
+ case builtin::Function::kCross:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "h3", "h3");
} else {
return builder->Call(str.str(), "f3", "f3");
}
- case BuiltinType::kFma:
- case BuiltinType::kMix:
- case BuiltinType::kFaceForward:
- case BuiltinType::kSmoothstep:
+ case builtin::Function::kFma:
+ case builtin::Function::kMix:
+ case builtin::Function::kFaceForward:
+ case builtin::Function::kSmoothstep:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "h2", "h2", "h2");
} else {
return builder->Call(str.str(), "f2", "f2", "f2");
}
- case BuiltinType::kAll:
- case BuiltinType::kAny:
+ case builtin::Function::kAll:
+ case builtin::Function::kAny:
return builder->Call(str.str(), "b2");
- case BuiltinType::kAbs:
+ case builtin::Function::kAbs:
if (type == CallParamType::kF32) {
return builder->Call(str.str(), "f2");
} else if (type == CallParamType::kF16) {
@@ -149,11 +147,11 @@
} else {
return builder->Call(str.str(), "u2");
}
- case BuiltinType::kCountOneBits:
- case BuiltinType::kReverseBits:
+ case builtin::Function::kCountOneBits:
+ case builtin::Function::kReverseBits:
return builder->Call(str.str(), "u2");
- case BuiltinType::kMax:
- case BuiltinType::kMin:
+ case builtin::Function::kMax:
+ case builtin::Function::kMin:
if (type == CallParamType::kF32) {
return builder->Call(str.str(), "f2", "f2");
} else if (type == CallParamType::kF16) {
@@ -161,7 +159,7 @@
} else {
return builder->Call(str.str(), "u2", "u2");
}
- case BuiltinType::kClamp:
+ case builtin::Function::kClamp:
if (type == CallParamType::kF32) {
return builder->Call(str.str(), "f2", "f2", "f2");
} else if (type == CallParamType::kF16) {
@@ -169,19 +167,19 @@
} else {
return builder->Call(str.str(), "u2", "u2", "u2");
}
- case BuiltinType::kSelect:
+ case builtin::Function::kSelect:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "h2", "h2", "b2");
} else {
return builder->Call(str.str(), "f2", "f2", "b2");
}
- case BuiltinType::kDeterminant:
+ case builtin::Function::kDeterminant:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "hm2x2");
} else {
return builder->Call(str.str(), "m2x2");
}
- case BuiltinType::kTranspose:
+ case builtin::Function::kTranspose:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "hm3x2");
} else {
@@ -235,110 +233,111 @@
INSTANTIATE_TEST_SUITE_P(
GlslGeneratorImplTest_Builtin,
GlslBuiltinTest,
- testing::Values(/* Logical built-in */
- BuiltinData{BuiltinType::kAll, CallParamType::kBool, "all"},
- BuiltinData{BuiltinType::kAny, CallParamType::kBool, "any"},
- /* Float built-in */
- BuiltinData{BuiltinType::kAbs, CallParamType::kF32, "abs"},
- BuiltinData{BuiltinType::kAbs, CallParamType::kF16, "abs"},
- BuiltinData{BuiltinType::kAcos, CallParamType::kF32, "acos"},
- BuiltinData{BuiltinType::kAcos, CallParamType::kF16, "acos"},
- BuiltinData{BuiltinType::kAsin, CallParamType::kF32, "asin"},
- BuiltinData{BuiltinType::kAsin, CallParamType::kF16, "asin"},
- BuiltinData{BuiltinType::kAtan, CallParamType::kF32, "atan"},
- BuiltinData{BuiltinType::kAtan, CallParamType::kF16, "atan"},
- BuiltinData{BuiltinType::kAtan2, CallParamType::kF32, "atan"},
- BuiltinData{BuiltinType::kAtan2, CallParamType::kF16, "atan"},
- BuiltinData{BuiltinType::kCeil, CallParamType::kF32, "ceil"},
- BuiltinData{BuiltinType::kCeil, CallParamType::kF16, "ceil"},
- BuiltinData{BuiltinType::kClamp, CallParamType::kF32, "clamp"},
- BuiltinData{BuiltinType::kClamp, CallParamType::kF16, "clamp"},
- BuiltinData{BuiltinType::kCos, CallParamType::kF32, "cos"},
- BuiltinData{BuiltinType::kCos, CallParamType::kF16, "cos"},
- BuiltinData{BuiltinType::kCosh, CallParamType::kF32, "cosh"},
- BuiltinData{BuiltinType::kCosh, CallParamType::kF16, "cosh"},
- BuiltinData{BuiltinType::kCross, CallParamType::kF32, "cross"},
- BuiltinData{BuiltinType::kCross, CallParamType::kF16, "cross"},
- BuiltinData{BuiltinType::kDistance, CallParamType::kF32, "distance"},
- BuiltinData{BuiltinType::kDistance, CallParamType::kF16, "distance"},
- BuiltinData{BuiltinType::kExp, CallParamType::kF32, "exp"},
- BuiltinData{BuiltinType::kExp, CallParamType::kF16, "exp"},
- BuiltinData{BuiltinType::kExp2, CallParamType::kF32, "exp2"},
- BuiltinData{BuiltinType::kExp2, CallParamType::kF16, "exp2"},
- BuiltinData{BuiltinType::kFaceForward, CallParamType::kF32, "faceforward"},
- BuiltinData{BuiltinType::kFaceForward, CallParamType::kF16, "faceforward"},
- BuiltinData{BuiltinType::kFloor, CallParamType::kF32, "floor"},
- BuiltinData{BuiltinType::kFloor, CallParamType::kF16, "floor"},
- BuiltinData{BuiltinType::kFma, CallParamType::kF32, "fma"},
- BuiltinData{BuiltinType::kFma, CallParamType::kF16, "fma"},
- BuiltinData{BuiltinType::kFract, CallParamType::kF32, "fract"},
- BuiltinData{BuiltinType::kFract, CallParamType::kF16, "fract"},
- BuiltinData{BuiltinType::kInverseSqrt, CallParamType::kF32, "inversesqrt"},
- BuiltinData{BuiltinType::kInverseSqrt, CallParamType::kF16, "inversesqrt"},
- BuiltinData{BuiltinType::kLdexp, CallParamType::kF32, "ldexp"},
- BuiltinData{BuiltinType::kLdexp, CallParamType::kF16, "ldexp"},
- BuiltinData{BuiltinType::kLength, CallParamType::kF32, "length"},
- BuiltinData{BuiltinType::kLength, CallParamType::kF16, "length"},
- BuiltinData{BuiltinType::kLog, CallParamType::kF32, "log"},
- BuiltinData{BuiltinType::kLog, CallParamType::kF16, "log"},
- BuiltinData{BuiltinType::kLog2, CallParamType::kF32, "log2"},
- BuiltinData{BuiltinType::kLog2, CallParamType::kF16, "log2"},
- BuiltinData{BuiltinType::kMax, CallParamType::kF32, "max"},
- BuiltinData{BuiltinType::kMax, CallParamType::kF16, "max"},
- BuiltinData{BuiltinType::kMin, CallParamType::kF32, "min"},
- BuiltinData{BuiltinType::kMin, CallParamType::kF16, "min"},
- BuiltinData{BuiltinType::kMix, CallParamType::kF32, "mix"},
- BuiltinData{BuiltinType::kMix, CallParamType::kF16, "mix"},
- BuiltinData{BuiltinType::kNormalize, CallParamType::kF32, "normalize"},
- BuiltinData{BuiltinType::kNormalize, CallParamType::kF16, "normalize"},
- BuiltinData{BuiltinType::kPow, CallParamType::kF32, "pow"},
- BuiltinData{BuiltinType::kPow, CallParamType::kF16, "pow"},
- BuiltinData{BuiltinType::kReflect, CallParamType::kF32, "reflect"},
- BuiltinData{BuiltinType::kReflect, CallParamType::kF16, "reflect"},
- BuiltinData{BuiltinType::kSign, CallParamType::kF32, "sign"},
- BuiltinData{BuiltinType::kSign, CallParamType::kF16, "sign"},
- BuiltinData{BuiltinType::kSin, CallParamType::kF32, "sin"},
- BuiltinData{BuiltinType::kSin, CallParamType::kF16, "sin"},
- BuiltinData{BuiltinType::kSinh, CallParamType::kF32, "sinh"},
- BuiltinData{BuiltinType::kSinh, CallParamType::kF16, "sinh"},
- BuiltinData{BuiltinType::kSmoothstep, CallParamType::kF32, "smoothstep"},
- BuiltinData{BuiltinType::kSmoothstep, CallParamType::kF16, "smoothstep"},
- BuiltinData{BuiltinType::kSqrt, CallParamType::kF32, "sqrt"},
- BuiltinData{BuiltinType::kSqrt, CallParamType::kF16, "sqrt"},
- BuiltinData{BuiltinType::kStep, CallParamType::kF32, "step"},
- BuiltinData{BuiltinType::kStep, CallParamType::kF16, "step"},
- BuiltinData{BuiltinType::kTan, CallParamType::kF32, "tan"},
- BuiltinData{BuiltinType::kTan, CallParamType::kF16, "tan"},
- BuiltinData{BuiltinType::kTanh, CallParamType::kF32, "tanh"},
- BuiltinData{BuiltinType::kTanh, CallParamType::kF16, "tanh"},
- BuiltinData{BuiltinType::kTrunc, CallParamType::kF32, "trunc"},
- BuiltinData{BuiltinType::kTrunc, CallParamType::kF16, "trunc"},
- /* Integer built-in */
- BuiltinData{BuiltinType::kAbs, CallParamType::kU32, "abs"},
- BuiltinData{BuiltinType::kClamp, CallParamType::kU32, "clamp"},
- BuiltinData{BuiltinType::kCountOneBits, CallParamType::kU32, "bitCount"},
- BuiltinData{BuiltinType::kMax, CallParamType::kU32, "max"},
- BuiltinData{BuiltinType::kMin, CallParamType::kU32, "min"},
- BuiltinData{BuiltinType::kReverseBits, CallParamType::kU32, "bitfieldReverse"},
- BuiltinData{BuiltinType::kRound, CallParamType::kU32, "round"},
- /* Matrix built-in */
- BuiltinData{BuiltinType::kDeterminant, CallParamType::kF32, "determinant"},
- BuiltinData{BuiltinType::kDeterminant, CallParamType::kF16, "determinant"},
- BuiltinData{BuiltinType::kTranspose, CallParamType::kF32, "transpose"},
- BuiltinData{BuiltinType::kTranspose, CallParamType::kF16, "transpose"},
- /* Vector built-in */
- BuiltinData{BuiltinType::kDot, CallParamType::kF32, "dot"},
- BuiltinData{BuiltinType::kDot, CallParamType::kF16, "dot"},
- /* Derivate built-in */
- BuiltinData{BuiltinType::kDpdx, CallParamType::kF32, "dFdx"},
- BuiltinData{BuiltinType::kDpdxCoarse, CallParamType::kF32, "dFdx"},
- BuiltinData{BuiltinType::kDpdxFine, CallParamType::kF32, "dFdx"},
- BuiltinData{BuiltinType::kDpdy, CallParamType::kF32, "dFdy"},
- BuiltinData{BuiltinType::kDpdyCoarse, CallParamType::kF32, "dFdy"},
- BuiltinData{BuiltinType::kDpdyFine, CallParamType::kF32, "dFdy"},
- BuiltinData{BuiltinType::kFwidth, CallParamType::kF32, "fwidth"},
- BuiltinData{BuiltinType::kFwidthCoarse, CallParamType::kF32, "fwidth"},
- BuiltinData{BuiltinType::kFwidthFine, CallParamType::kF32, "fwidth"}));
+ testing::
+ Values(/* Logical built-in */
+ BuiltinData{builtin::Function::kAll, CallParamType::kBool, "all"},
+ BuiltinData{builtin::Function::kAny, CallParamType::kBool, "any"},
+ /* Float built-in */
+ BuiltinData{builtin::Function::kAbs, CallParamType::kF32, "abs"},
+ BuiltinData{builtin::Function::kAbs, CallParamType::kF16, "abs"},
+ BuiltinData{builtin::Function::kAcos, CallParamType::kF32, "acos"},
+ BuiltinData{builtin::Function::kAcos, CallParamType::kF16, "acos"},
+ BuiltinData{builtin::Function::kAsin, CallParamType::kF32, "asin"},
+ BuiltinData{builtin::Function::kAsin, CallParamType::kF16, "asin"},
+ BuiltinData{builtin::Function::kAtan, CallParamType::kF32, "atan"},
+ BuiltinData{builtin::Function::kAtan, CallParamType::kF16, "atan"},
+ BuiltinData{builtin::Function::kAtan2, CallParamType::kF32, "atan"},
+ BuiltinData{builtin::Function::kAtan2, CallParamType::kF16, "atan"},
+ BuiltinData{builtin::Function::kCeil, CallParamType::kF32, "ceil"},
+ BuiltinData{builtin::Function::kCeil, CallParamType::kF16, "ceil"},
+ BuiltinData{builtin::Function::kClamp, CallParamType::kF32, "clamp"},
+ BuiltinData{builtin::Function::kClamp, CallParamType::kF16, "clamp"},
+ BuiltinData{builtin::Function::kCos, CallParamType::kF32, "cos"},
+ BuiltinData{builtin::Function::kCos, CallParamType::kF16, "cos"},
+ BuiltinData{builtin::Function::kCosh, CallParamType::kF32, "cosh"},
+ BuiltinData{builtin::Function::kCosh, CallParamType::kF16, "cosh"},
+ BuiltinData{builtin::Function::kCross, CallParamType::kF32, "cross"},
+ BuiltinData{builtin::Function::kCross, CallParamType::kF16, "cross"},
+ BuiltinData{builtin::Function::kDistance, CallParamType::kF32, "distance"},
+ BuiltinData{builtin::Function::kDistance, CallParamType::kF16, "distance"},
+ BuiltinData{builtin::Function::kExp, CallParamType::kF32, "exp"},
+ BuiltinData{builtin::Function::kExp, CallParamType::kF16, "exp"},
+ BuiltinData{builtin::Function::kExp2, CallParamType::kF32, "exp2"},
+ BuiltinData{builtin::Function::kExp2, CallParamType::kF16, "exp2"},
+ BuiltinData{builtin::Function::kFaceForward, CallParamType::kF32, "faceforward"},
+ BuiltinData{builtin::Function::kFaceForward, CallParamType::kF16, "faceforward"},
+ BuiltinData{builtin::Function::kFloor, CallParamType::kF32, "floor"},
+ BuiltinData{builtin::Function::kFloor, CallParamType::kF16, "floor"},
+ BuiltinData{builtin::Function::kFma, CallParamType::kF32, "fma"},
+ BuiltinData{builtin::Function::kFma, CallParamType::kF16, "fma"},
+ BuiltinData{builtin::Function::kFract, CallParamType::kF32, "fract"},
+ BuiltinData{builtin::Function::kFract, CallParamType::kF16, "fract"},
+ BuiltinData{builtin::Function::kInverseSqrt, CallParamType::kF32, "inversesqrt"},
+ BuiltinData{builtin::Function::kInverseSqrt, CallParamType::kF16, "inversesqrt"},
+ BuiltinData{builtin::Function::kLdexp, CallParamType::kF32, "ldexp"},
+ BuiltinData{builtin::Function::kLdexp, CallParamType::kF16, "ldexp"},
+ BuiltinData{builtin::Function::kLength, CallParamType::kF32, "length"},
+ BuiltinData{builtin::Function::kLength, CallParamType::kF16, "length"},
+ BuiltinData{builtin::Function::kLog, CallParamType::kF32, "log"},
+ BuiltinData{builtin::Function::kLog, CallParamType::kF16, "log"},
+ BuiltinData{builtin::Function::kLog2, CallParamType::kF32, "log2"},
+ BuiltinData{builtin::Function::kLog2, CallParamType::kF16, "log2"},
+ BuiltinData{builtin::Function::kMax, CallParamType::kF32, "max"},
+ BuiltinData{builtin::Function::kMax, CallParamType::kF16, "max"},
+ BuiltinData{builtin::Function::kMin, CallParamType::kF32, "min"},
+ BuiltinData{builtin::Function::kMin, CallParamType::kF16, "min"},
+ BuiltinData{builtin::Function::kMix, CallParamType::kF32, "mix"},
+ BuiltinData{builtin::Function::kMix, CallParamType::kF16, "mix"},
+ BuiltinData{builtin::Function::kNormalize, CallParamType::kF32, "normalize"},
+ BuiltinData{builtin::Function::kNormalize, CallParamType::kF16, "normalize"},
+ BuiltinData{builtin::Function::kPow, CallParamType::kF32, "pow"},
+ BuiltinData{builtin::Function::kPow, CallParamType::kF16, "pow"},
+ BuiltinData{builtin::Function::kReflect, CallParamType::kF32, "reflect"},
+ BuiltinData{builtin::Function::kReflect, CallParamType::kF16, "reflect"},
+ BuiltinData{builtin::Function::kSign, CallParamType::kF32, "sign"},
+ BuiltinData{builtin::Function::kSign, CallParamType::kF16, "sign"},
+ BuiltinData{builtin::Function::kSin, CallParamType::kF32, "sin"},
+ BuiltinData{builtin::Function::kSin, CallParamType::kF16, "sin"},
+ BuiltinData{builtin::Function::kSinh, CallParamType::kF32, "sinh"},
+ BuiltinData{builtin::Function::kSinh, CallParamType::kF16, "sinh"},
+ BuiltinData{builtin::Function::kSmoothstep, CallParamType::kF32, "smoothstep"},
+ BuiltinData{builtin::Function::kSmoothstep, CallParamType::kF16, "smoothstep"},
+ BuiltinData{builtin::Function::kSqrt, CallParamType::kF32, "sqrt"},
+ BuiltinData{builtin::Function::kSqrt, CallParamType::kF16, "sqrt"},
+ BuiltinData{builtin::Function::kStep, CallParamType::kF32, "step"},
+ BuiltinData{builtin::Function::kStep, CallParamType::kF16, "step"},
+ BuiltinData{builtin::Function::kTan, CallParamType::kF32, "tan"},
+ BuiltinData{builtin::Function::kTan, CallParamType::kF16, "tan"},
+ BuiltinData{builtin::Function::kTanh, CallParamType::kF32, "tanh"},
+ BuiltinData{builtin::Function::kTanh, CallParamType::kF16, "tanh"},
+ BuiltinData{builtin::Function::kTrunc, CallParamType::kF32, "trunc"},
+ BuiltinData{builtin::Function::kTrunc, CallParamType::kF16, "trunc"},
+ /* Integer built-in */
+ BuiltinData{builtin::Function::kAbs, CallParamType::kU32, "abs"},
+ BuiltinData{builtin::Function::kClamp, CallParamType::kU32, "clamp"},
+ BuiltinData{builtin::Function::kCountOneBits, CallParamType::kU32, "bitCount"},
+ BuiltinData{builtin::Function::kMax, CallParamType::kU32, "max"},
+ BuiltinData{builtin::Function::kMin, CallParamType::kU32, "min"},
+ BuiltinData{builtin::Function::kReverseBits, CallParamType::kU32, "bitfieldReverse"},
+ BuiltinData{builtin::Function::kRound, CallParamType::kU32, "round"},
+ /* Matrix built-in */
+ BuiltinData{builtin::Function::kDeterminant, CallParamType::kF32, "determinant"},
+ BuiltinData{builtin::Function::kDeterminant, CallParamType::kF16, "determinant"},
+ BuiltinData{builtin::Function::kTranspose, CallParamType::kF32, "transpose"},
+ BuiltinData{builtin::Function::kTranspose, CallParamType::kF16, "transpose"},
+ /* Vector built-in */
+ BuiltinData{builtin::Function::kDot, CallParamType::kF32, "dot"},
+ BuiltinData{builtin::Function::kDot, CallParamType::kF16, "dot"},
+ /* Derivate built-in */
+ BuiltinData{builtin::Function::kDpdx, CallParamType::kF32, "dFdx"},
+ BuiltinData{builtin::Function::kDpdxCoarse, CallParamType::kF32, "dFdx"},
+ BuiltinData{builtin::Function::kDpdxFine, CallParamType::kF32, "dFdx"},
+ BuiltinData{builtin::Function::kDpdy, CallParamType::kF32, "dFdy"},
+ BuiltinData{builtin::Function::kDpdyCoarse, CallParamType::kF32, "dFdy"},
+ BuiltinData{builtin::Function::kDpdyFine, CallParamType::kF32, "dFdy"},
+ BuiltinData{builtin::Function::kFwidth, CallParamType::kF32, "fwidth"},
+ BuiltinData{builtin::Function::kFwidthCoarse, CallParamType::kF32, "fwidth"},
+ BuiltinData{builtin::Function::kFwidthFine, CallParamType::kF32, "fwidth"}));
TEST_F(GlslGeneratorImplTest_Builtin, Builtin_Call) {
auto* call = Call("dot", "param1", "param2");
diff --git a/src/tint/writer/hlsl/generator_impl.cc b/src/tint/writer/hlsl/generator_impl.cc
index 3acafe1..ada0399 100644
--- a/src/tint/writer/hlsl/generator_impl.cc
+++ b/src/tint/writer/hlsl/generator_impl.cc
@@ -966,25 +966,25 @@
if (builtin->IsTexture()) {
return EmitTextureCall(out, call, builtin);
}
- if (type == sem::BuiltinType::kSelect) {
+ if (type == builtin::Function::kSelect) {
return EmitSelectCall(out, expr);
}
- if (type == sem::BuiltinType::kModf) {
+ if (type == builtin::Function::kModf) {
return EmitModfCall(out, expr, builtin);
}
- if (type == sem::BuiltinType::kFrexp) {
+ if (type == builtin::Function::kFrexp) {
return EmitFrexpCall(out, expr, builtin);
}
- if (type == sem::BuiltinType::kDegrees) {
+ if (type == builtin::Function::kDegrees) {
return EmitDegreesCall(out, expr, builtin);
}
- if (type == sem::BuiltinType::kRadians) {
+ if (type == builtin::Function::kRadians) {
return EmitRadiansCall(out, expr, builtin);
}
- if (type == sem::BuiltinType::kSign) {
+ if (type == builtin::Function::kSign) {
return EmitSignCall(out, call, builtin);
}
- if (type == sem::BuiltinType::kQuantizeToF16) {
+ if (type == builtin::Function::kQuantizeToF16) {
return EmitQuantizeToF16Call(out, expr, builtin);
}
if (builtin->IsDataPacking()) {
@@ -1011,7 +1011,7 @@
// Handle single argument builtins that only accept and return uint (not int overload). We need
// to explicitly cast the return value (we also cast the arg for good measure). See
// crbug.com/tint/1550
- if (type == sem::BuiltinType::kCountOneBits || type == sem::BuiltinType::kReverseBits) {
+ if (type == builtin::Function::kCountOneBits || type == builtin::Function::kReverseBits) {
auto* arg = call->Arguments()[0];
if (arg->Type()->UnwrapRef()->is_signed_integer_scalar_or_vector()) {
out << "asint(" << name << "(asuint(";
@@ -1805,7 +1805,7 @@
if (i > 0) {
pre << ", ";
}
- if (i == 1 && builtin->Type() == sem::BuiltinType::kAtomicSub) {
+ if (i == 1 && builtin->Type() == builtin::Function::kAtomicSub) {
// Sub uses InterlockedAdd with the operand negated.
pre << "-";
}
@@ -1824,7 +1824,7 @@
};
switch (builtin->Type()) {
- case sem::BuiltinType::kAtomicLoad: {
+ case builtin::Function::kAtomicLoad: {
// HLSL does not have an InterlockedLoad, so we emulate it with
// InterlockedOr using 0 as the OR value
auto pre = line();
@@ -1841,7 +1841,7 @@
out << result;
return true;
}
- case sem::BuiltinType::kAtomicStore: {
+ case builtin::Function::kAtomicStore: {
// HLSL does not have an InterlockedStore, so we emulate it with
// InterlockedExchange and discard the returned value
{ // T result = 0;
@@ -1872,7 +1872,7 @@
}
return true;
}
- case sem::BuiltinType::kAtomicCompareExchangeWeak: {
+ case builtin::Function::kAtomicCompareExchangeWeak: {
if (!EmitStructType(&helpers_, builtin->ReturnType()->As<sem::Struct>())) {
return false;
}
@@ -1921,26 +1921,26 @@
return true;
}
- case sem::BuiltinType::kAtomicAdd:
- case sem::BuiltinType::kAtomicSub:
+ case builtin::Function::kAtomicAdd:
+ case builtin::Function::kAtomicSub:
return call("InterlockedAdd");
- case sem::BuiltinType::kAtomicMax:
+ case builtin::Function::kAtomicMax:
return call("InterlockedMax");
- case sem::BuiltinType::kAtomicMin:
+ case builtin::Function::kAtomicMin:
return call("InterlockedMin");
- case sem::BuiltinType::kAtomicAnd:
+ case builtin::Function::kAtomicAnd:
return call("InterlockedAnd");
- case sem::BuiltinType::kAtomicOr:
+ case builtin::Function::kAtomicOr:
return call("InterlockedOr");
- case sem::BuiltinType::kAtomicXor:
+ case builtin::Function::kAtomicXor:
return call("InterlockedXor");
- case sem::BuiltinType::kAtomicExchange:
+ case builtin::Function::kAtomicExchange:
return call("InterlockedExchange");
default:
@@ -2114,21 +2114,21 @@
uint32_t dims = 2;
bool is_signed = false;
uint32_t scale = 65535;
- if (builtin->Type() == sem::BuiltinType::kPack4X8Snorm ||
- builtin->Type() == sem::BuiltinType::kPack4X8Unorm) {
+ if (builtin->Type() == builtin::Function::kPack4X8Snorm ||
+ builtin->Type() == builtin::Function::kPack4X8Unorm) {
dims = 4;
scale = 255;
}
- if (builtin->Type() == sem::BuiltinType::kPack4X8Snorm ||
- builtin->Type() == sem::BuiltinType::kPack2X16Snorm) {
+ if (builtin->Type() == builtin::Function::kPack4X8Snorm ||
+ builtin->Type() == builtin::Function::kPack2X16Snorm) {
is_signed = true;
scale = (scale - 1) / 2;
}
switch (builtin->Type()) {
- case sem::BuiltinType::kPack4X8Snorm:
- case sem::BuiltinType::kPack4X8Unorm:
- case sem::BuiltinType::kPack2X16Snorm:
- case sem::BuiltinType::kPack2X16Unorm: {
+ case builtin::Function::kPack4X8Snorm:
+ case builtin::Function::kPack4X8Unorm:
+ case builtin::Function::kPack2X16Snorm:
+ case builtin::Function::kPack2X16Unorm: {
{
auto l = line(b);
l << (is_signed ? "" : "u") << "int" << dims
@@ -2154,7 +2154,7 @@
}
break;
}
- case sem::BuiltinType::kPack2X16Float: {
+ case builtin::Function::kPack2X16Float: {
line(b) << "uint2 i = f32tof16(" << params[0] << ");";
line(b) << "return i.x | (i.y << 16);";
break;
@@ -2177,19 +2177,19 @@
uint32_t dims = 2;
bool is_signed = false;
uint32_t scale = 65535;
- if (builtin->Type() == sem::BuiltinType::kUnpack4X8Snorm ||
- builtin->Type() == sem::BuiltinType::kUnpack4X8Unorm) {
+ if (builtin->Type() == builtin::Function::kUnpack4X8Snorm ||
+ builtin->Type() == builtin::Function::kUnpack4X8Unorm) {
dims = 4;
scale = 255;
}
- if (builtin->Type() == sem::BuiltinType::kUnpack4X8Snorm ||
- builtin->Type() == sem::BuiltinType::kUnpack2X16Snorm) {
+ if (builtin->Type() == builtin::Function::kUnpack4X8Snorm ||
+ builtin->Type() == builtin::Function::kUnpack2X16Snorm) {
is_signed = true;
scale = (scale - 1) / 2;
}
switch (builtin->Type()) {
- case sem::BuiltinType::kUnpack4X8Snorm:
- case sem::BuiltinType::kUnpack2X16Snorm: {
+ case builtin::Function::kUnpack4X8Snorm:
+ case builtin::Function::kUnpack2X16Snorm: {
line(b) << "int j = int(" << params[0] << ");";
{ // Perform sign extension on the converted values.
auto l = line(b);
@@ -2205,8 +2205,8 @@
<< (is_signed ? "-1.0" : "0.0") << ", 1.0);";
break;
}
- case sem::BuiltinType::kUnpack4X8Unorm:
- case sem::BuiltinType::kUnpack2X16Unorm: {
+ case builtin::Function::kUnpack4X8Unorm:
+ case builtin::Function::kUnpack2X16Unorm: {
line(b) << "uint j = " << params[0] << ";";
{
auto l = line(b);
@@ -2222,7 +2222,7 @@
line(b) << "return float" << dims << "(i) / " << scale << ".0;";
break;
}
- case sem::BuiltinType::kUnpack2X16Float:
+ case builtin::Function::kUnpack2X16Float:
line(b) << "uint i = " << params[0] << ";";
line(b) << "return f16tof32(uint2(i & 0xffff, i >> 16));";
break;
@@ -2244,11 +2244,11 @@
out, expr, builtin, [&](TextBuffer* b, const std::vector<std::string>& params) {
std::string functionName;
switch (builtin->Type()) {
- case sem::BuiltinType::kDot4I8Packed:
+ case builtin::Function::kDot4I8Packed:
line(b) << "int accumulator = 0;";
functionName = "dot4add_i8packed";
break;
- case sem::BuiltinType::kDot4U8Packed:
+ case builtin::Function::kDot4U8Packed:
line(b) << "uint accumulator = 0u;";
functionName = "dot4add_u8packed";
break;
@@ -2267,13 +2267,13 @@
bool GeneratorImpl::EmitBarrierCall(utils::StringStream& out, const sem::Builtin* builtin) {
// TODO(crbug.com/tint/661): Combine sequential barriers to a single
// instruction.
- if (builtin->Type() == sem::BuiltinType::kWorkgroupBarrier) {
+ if (builtin->Type() == builtin::Function::kWorkgroupBarrier) {
out << "GroupMemoryBarrierWithGroupSync()";
- } else if (builtin->Type() == sem::BuiltinType::kStorageBarrier) {
+ } else if (builtin->Type() == builtin::Function::kStorageBarrier) {
out << "DeviceMemoryBarrierWithGroupSync()";
} else {
TINT_UNREACHABLE(Writer, diagnostics_)
- << "unexpected barrier builtin type " << sem::str(builtin->Type());
+ << "unexpected barrier builtin type " << builtin::str(builtin->Type());
return false;
}
return true;
@@ -2303,10 +2303,10 @@
auto* texture_type = TypeOf(texture)->UnwrapRef()->As<type::Texture>();
switch (builtin->Type()) {
- case sem::BuiltinType::kTextureDimensions:
- case sem::BuiltinType::kTextureNumLayers:
- case sem::BuiltinType::kTextureNumLevels:
- case sem::BuiltinType::kTextureNumSamples: {
+ case builtin::Function::kTextureDimensions:
+ case builtin::Function::kTextureNumLayers:
+ case builtin::Function::kTextureNumLevels:
+ case builtin::Function::kTextureNumSamples: {
// All of these builtins use the GetDimensions() method on the texture
bool is_ms =
texture_type->IsAnyOf<type::MultisampledTexture, type::DepthMultisampledTexture>();
@@ -2314,7 +2314,7 @@
std::string swizzle;
switch (builtin->Type()) {
- case sem::BuiltinType::kTextureDimensions:
+ case builtin::Function::kTextureDimensions:
switch (texture_type->dim()) {
case type::TextureDimension::kNone:
TINT_ICE(Writer, diagnostics_) << "texture dimension is kNone";
@@ -2342,7 +2342,7 @@
break;
}
break;
- case sem::BuiltinType::kTextureNumLayers:
+ case builtin::Function::kTextureNumLayers:
switch (texture_type->dim()) {
default:
TINT_ICE(Writer, diagnostics_) << "texture dimension is not arrayed";
@@ -2357,7 +2357,7 @@
break;
}
break;
- case sem::BuiltinType::kTextureNumLevels:
+ case builtin::Function::kTextureNumLevels:
switch (texture_type->dim()) {
default:
TINT_ICE(Writer, diagnostics_)
@@ -2380,7 +2380,7 @@
break;
}
break;
- case sem::BuiltinType::kTextureNumSamples:
+ case builtin::Function::kTextureNumSamples:
switch (texture_type->dim()) {
default:
TINT_ICE(Writer, diagnostics_)
@@ -2444,7 +2444,7 @@
return false;
}
pre << ", ";
- } else if (builtin->Type() == sem::BuiltinType::kTextureNumLevels) {
+ } else if (builtin->Type() == builtin::Function::kTextureNumLevels) {
pre << "0, ";
}
@@ -2491,34 +2491,34 @@
uint32_t hlsl_ret_width = 4u;
switch (builtin->Type()) {
- case sem::BuiltinType::kTextureSample:
+ case builtin::Function::kTextureSample:
out << ".Sample(";
break;
- case sem::BuiltinType::kTextureSampleBias:
+ case builtin::Function::kTextureSampleBias:
out << ".SampleBias(";
break;
- case sem::BuiltinType::kTextureSampleLevel:
+ case builtin::Function::kTextureSampleLevel:
out << ".SampleLevel(";
break;
- case sem::BuiltinType::kTextureSampleGrad:
+ case builtin::Function::kTextureSampleGrad:
out << ".SampleGrad(";
break;
- case sem::BuiltinType::kTextureSampleCompare:
+ case builtin::Function::kTextureSampleCompare:
out << ".SampleCmp(";
hlsl_ret_width = 1;
break;
- case sem::BuiltinType::kTextureSampleCompareLevel:
+ case builtin::Function::kTextureSampleCompareLevel:
out << ".SampleCmpLevelZero(";
hlsl_ret_width = 1;
break;
- case sem::BuiltinType::kTextureLoad:
+ case builtin::Function::kTextureLoad:
out << ".Load(";
// Multisampled textures do not support mip-levels.
if (!texture_type->Is<type::MultisampledTexture>()) {
pack_level_in_coords = true;
}
break;
- case sem::BuiltinType::kTextureGather:
+ case builtin::Function::kTextureGather:
out << ".Gather";
if (builtin->Parameters()[0]->Usage() == sem::ParameterUsage::kComponent) {
switch (call->Arguments()[0]->ConstantValue()->ValueAs<AInt>()) {
@@ -2538,10 +2538,10 @@
}
out << "(";
break;
- case sem::BuiltinType::kTextureGatherCompare:
+ case builtin::Function::kTextureGatherCompare:
out << ".GatherCmp(";
break;
- case sem::BuiltinType::kTextureStore:
+ case builtin::Function::kTextureStore:
out << "[";
break;
default:
@@ -2621,7 +2621,7 @@
}
}
- if (builtin->Type() == sem::BuiltinType::kTextureStore) {
+ if (builtin->Type() == builtin::Function::kTextureStore) {
out << "] = ";
if (!EmitExpression(out, arg(Usage::kValue))) {
return false;
@@ -2655,78 +2655,78 @@
std::string GeneratorImpl::generate_builtin_name(const sem::Builtin* builtin) {
switch (builtin->Type()) {
- case sem::BuiltinType::kAbs:
- case sem::BuiltinType::kAcos:
- case sem::BuiltinType::kAll:
- case sem::BuiltinType::kAny:
- case sem::BuiltinType::kAsin:
- case sem::BuiltinType::kAtan:
- case sem::BuiltinType::kAtan2:
- case sem::BuiltinType::kCeil:
- case sem::BuiltinType::kClamp:
- case sem::BuiltinType::kCos:
- case sem::BuiltinType::kCosh:
- case sem::BuiltinType::kCross:
- case sem::BuiltinType::kDeterminant:
- case sem::BuiltinType::kDistance:
- case sem::BuiltinType::kDot:
- case sem::BuiltinType::kExp:
- case sem::BuiltinType::kExp2:
- case sem::BuiltinType::kFloor:
- case sem::BuiltinType::kFrexp:
- case sem::BuiltinType::kLdexp:
- case sem::BuiltinType::kLength:
- case sem::BuiltinType::kLog:
- case sem::BuiltinType::kLog2:
- case sem::BuiltinType::kMax:
- case sem::BuiltinType::kMin:
- case sem::BuiltinType::kModf:
- case sem::BuiltinType::kNormalize:
- case sem::BuiltinType::kPow:
- case sem::BuiltinType::kReflect:
- case sem::BuiltinType::kRefract:
- case sem::BuiltinType::kRound:
- case sem::BuiltinType::kSaturate:
- case sem::BuiltinType::kSin:
- case sem::BuiltinType::kSinh:
- case sem::BuiltinType::kSqrt:
- case sem::BuiltinType::kStep:
- case sem::BuiltinType::kTan:
- case sem::BuiltinType::kTanh:
- case sem::BuiltinType::kTranspose:
- case sem::BuiltinType::kTrunc:
+ case builtin::Function::kAbs:
+ case builtin::Function::kAcos:
+ case builtin::Function::kAll:
+ case builtin::Function::kAny:
+ case builtin::Function::kAsin:
+ case builtin::Function::kAtan:
+ case builtin::Function::kAtan2:
+ case builtin::Function::kCeil:
+ case builtin::Function::kClamp:
+ case builtin::Function::kCos:
+ case builtin::Function::kCosh:
+ case builtin::Function::kCross:
+ case builtin::Function::kDeterminant:
+ case builtin::Function::kDistance:
+ case builtin::Function::kDot:
+ case builtin::Function::kExp:
+ case builtin::Function::kExp2:
+ case builtin::Function::kFloor:
+ case builtin::Function::kFrexp:
+ case builtin::Function::kLdexp:
+ case builtin::Function::kLength:
+ case builtin::Function::kLog:
+ case builtin::Function::kLog2:
+ case builtin::Function::kMax:
+ case builtin::Function::kMin:
+ case builtin::Function::kModf:
+ case builtin::Function::kNormalize:
+ case builtin::Function::kPow:
+ case builtin::Function::kReflect:
+ case builtin::Function::kRefract:
+ case builtin::Function::kRound:
+ case builtin::Function::kSaturate:
+ case builtin::Function::kSin:
+ case builtin::Function::kSinh:
+ case builtin::Function::kSqrt:
+ case builtin::Function::kStep:
+ case builtin::Function::kTan:
+ case builtin::Function::kTanh:
+ case builtin::Function::kTranspose:
+ case builtin::Function::kTrunc:
return builtin->str();
- case sem::BuiltinType::kCountOneBits: // uint
+ case builtin::Function::kCountOneBits: // uint
return "countbits";
- case sem::BuiltinType::kDpdx:
+ case builtin::Function::kDpdx:
return "ddx";
- case sem::BuiltinType::kDpdxCoarse:
+ case builtin::Function::kDpdxCoarse:
return "ddx_coarse";
- case sem::BuiltinType::kDpdxFine:
+ case builtin::Function::kDpdxFine:
return "ddx_fine";
- case sem::BuiltinType::kDpdy:
+ case builtin::Function::kDpdy:
return "ddy";
- case sem::BuiltinType::kDpdyCoarse:
+ case builtin::Function::kDpdyCoarse:
return "ddy_coarse";
- case sem::BuiltinType::kDpdyFine:
+ case builtin::Function::kDpdyFine:
return "ddy_fine";
- case sem::BuiltinType::kFaceForward:
+ case builtin::Function::kFaceForward:
return "faceforward";
- case sem::BuiltinType::kFract:
+ case builtin::Function::kFract:
return "frac";
- case sem::BuiltinType::kFma:
+ case builtin::Function::kFma:
return "mad";
- case sem::BuiltinType::kFwidth:
- case sem::BuiltinType::kFwidthCoarse:
- case sem::BuiltinType::kFwidthFine:
+ case builtin::Function::kFwidth:
+ case builtin::Function::kFwidthCoarse:
+ case builtin::Function::kFwidthFine:
return "fwidth";
- case sem::BuiltinType::kInverseSqrt:
+ case builtin::Function::kInverseSqrt:
return "rsqrt";
- case sem::BuiltinType::kMix:
+ case builtin::Function::kMix:
return "lerp";
- case sem::BuiltinType::kReverseBits: // uint
+ case builtin::Function::kReverseBits: // uint
return "reversebits";
- case sem::BuiltinType::kSmoothstep:
+ case builtin::Function::kSmoothstep:
return "smoothstep";
default:
diagnostics_.add_error(diag::System::Writer,
@@ -4346,7 +4346,7 @@
TextBuffer b;
TINT_DEFER(helpers_.Append(b));
- auto fn_name = UniqueIdentifier(std::string("tint_") + sem::str(builtin->Type()));
+ auto fn_name = UniqueIdentifier(std::string("tint_") + builtin::str(builtin->Type()));
std::vector<std::string> parameter_names;
{
auto decl = line(&b);
diff --git a/src/tint/writer/hlsl/generator_impl_builtin_test.cc b/src/tint/writer/hlsl/generator_impl_builtin_test.cc
index 5054327..f473ac8 100644
--- a/src/tint/writer/hlsl/generator_impl_builtin_test.cc
+++ b/src/tint/writer/hlsl/generator_impl_builtin_test.cc
@@ -26,7 +26,6 @@
namespace tint::writer::hlsl {
namespace {
-using BuiltinType = sem::BuiltinType;
using HlslGeneratorImplTest_Builtin = TestHelper;
enum class CallParamType {
@@ -37,7 +36,7 @@
};
struct BuiltinData {
- BuiltinType builtin;
+ builtin::Function builtin;
CallParamType type;
const char* hlsl_name;
};
@@ -61,85 +60,85 @@
return out;
}
-const ast::CallExpression* GenerateCall(BuiltinType builtin,
+const ast::CallExpression* GenerateCall(builtin::Function builtin,
CallParamType type,
ProgramBuilder* builder) {
std::string name;
utils::StringStream str;
str << name << builtin;
switch (builtin) {
- case BuiltinType::kAcos:
- case BuiltinType::kAsin:
- case BuiltinType::kAtan:
- case BuiltinType::kCeil:
- case BuiltinType::kCos:
- case BuiltinType::kCosh:
- case BuiltinType::kDpdx:
- case BuiltinType::kDpdxCoarse:
- case BuiltinType::kDpdxFine:
- case BuiltinType::kDpdy:
- case BuiltinType::kDpdyCoarse:
- case BuiltinType::kDpdyFine:
- case BuiltinType::kExp:
- case BuiltinType::kExp2:
- case BuiltinType::kFloor:
- case BuiltinType::kFract:
- case BuiltinType::kFwidth:
- case BuiltinType::kFwidthCoarse:
- case BuiltinType::kFwidthFine:
- case BuiltinType::kInverseSqrt:
- case BuiltinType::kLength:
- case BuiltinType::kLog:
- case BuiltinType::kLog2:
- case BuiltinType::kNormalize:
- case BuiltinType::kRound:
- case BuiltinType::kSin:
- case BuiltinType::kSinh:
- case BuiltinType::kSqrt:
- case BuiltinType::kTan:
- case BuiltinType::kTanh:
- case BuiltinType::kTrunc:
+ case builtin::Function::kAcos:
+ case builtin::Function::kAsin:
+ case builtin::Function::kAtan:
+ case builtin::Function::kCeil:
+ case builtin::Function::kCos:
+ case builtin::Function::kCosh:
+ case builtin::Function::kDpdx:
+ case builtin::Function::kDpdxCoarse:
+ case builtin::Function::kDpdxFine:
+ case builtin::Function::kDpdy:
+ case builtin::Function::kDpdyCoarse:
+ case builtin::Function::kDpdyFine:
+ case builtin::Function::kExp:
+ case builtin::Function::kExp2:
+ case builtin::Function::kFloor:
+ case builtin::Function::kFract:
+ case builtin::Function::kFwidth:
+ case builtin::Function::kFwidthCoarse:
+ case builtin::Function::kFwidthFine:
+ case builtin::Function::kInverseSqrt:
+ case builtin::Function::kLength:
+ case builtin::Function::kLog:
+ case builtin::Function::kLog2:
+ case builtin::Function::kNormalize:
+ case builtin::Function::kRound:
+ case builtin::Function::kSin:
+ case builtin::Function::kSinh:
+ case builtin::Function::kSqrt:
+ case builtin::Function::kTan:
+ case builtin::Function::kTanh:
+ case builtin::Function::kTrunc:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "h2");
} else {
return builder->Call(str.str(), "f2");
}
- case BuiltinType::kLdexp:
+ case builtin::Function::kLdexp:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "h2", "i2");
} else {
return builder->Call(str.str(), "f2", "i2");
}
- case BuiltinType::kAtan2:
- case BuiltinType::kDot:
- case BuiltinType::kDistance:
- case BuiltinType::kPow:
- case BuiltinType::kReflect:
- case BuiltinType::kStep:
+ case builtin::Function::kAtan2:
+ case builtin::Function::kDot:
+ case builtin::Function::kDistance:
+ case builtin::Function::kPow:
+ case builtin::Function::kReflect:
+ case builtin::Function::kStep:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "h2", "h2");
} else {
return builder->Call(str.str(), "f2", "f2");
}
- case BuiltinType::kCross:
+ case builtin::Function::kCross:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "h3", "h3");
} else {
return builder->Call(str.str(), "f3", "f3");
}
- case BuiltinType::kFma:
- case BuiltinType::kMix:
- case BuiltinType::kFaceForward:
- case BuiltinType::kSmoothstep:
+ case builtin::Function::kFma:
+ case builtin::Function::kMix:
+ case builtin::Function::kFaceForward:
+ case builtin::Function::kSmoothstep:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "h2", "h2", "h2");
} else {
return builder->Call(str.str(), "f2", "f2", "f2");
}
- case BuiltinType::kAll:
- case BuiltinType::kAny:
+ case builtin::Function::kAll:
+ case builtin::Function::kAny:
return builder->Call(str.str(), "b2");
- case BuiltinType::kAbs:
+ case builtin::Function::kAbs:
if (type == CallParamType::kF32) {
return builder->Call(str.str(), "f2");
} else if (type == CallParamType::kF16) {
@@ -147,11 +146,11 @@
} else {
return builder->Call(str.str(), "u2");
}
- case BuiltinType::kCountOneBits:
- case BuiltinType::kReverseBits:
+ case builtin::Function::kCountOneBits:
+ case builtin::Function::kReverseBits:
return builder->Call(str.str(), "u2");
- case BuiltinType::kMax:
- case BuiltinType::kMin:
+ case builtin::Function::kMax:
+ case builtin::Function::kMin:
if (type == CallParamType::kF32) {
return builder->Call(str.str(), "f2", "f2");
} else if (type == CallParamType::kF16) {
@@ -159,7 +158,7 @@
} else {
return builder->Call(str.str(), "u2", "u2");
}
- case BuiltinType::kClamp:
+ case builtin::Function::kClamp:
if (type == CallParamType::kF32) {
return builder->Call(str.str(), "f2", "f2", "f2");
} else if (type == CallParamType::kF16) {
@@ -167,19 +166,19 @@
} else {
return builder->Call(str.str(), "u2", "u2", "u2");
}
- case BuiltinType::kSelect:
+ case builtin::Function::kSelect:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "h2", "h2", "b2");
} else {
return builder->Call(str.str(), "f2", "f2", "b2");
}
- case BuiltinType::kDeterminant:
+ case builtin::Function::kDeterminant:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "hm2x2");
} else {
return builder->Call(str.str(), "m2x2");
}
- case BuiltinType::kTranspose:
+ case builtin::Function::kTranspose:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "hm3x2");
} else {
@@ -235,107 +234,112 @@
HlslGeneratorImplTest_Builtin,
HlslBuiltinTest,
testing::Values(/* Logical built-in */
- BuiltinData{BuiltinType::kAll, CallParamType::kBool, "all"},
- BuiltinData{BuiltinType::kAny, CallParamType::kBool, "any"},
+ BuiltinData{builtin::Function::kAll, CallParamType::kBool, "all"},
+ BuiltinData{builtin::Function::kAny, CallParamType::kBool, "any"},
/* Float built-in */
- BuiltinData{BuiltinType::kAbs, CallParamType::kF32, "abs"},
- BuiltinData{BuiltinType::kAbs, CallParamType::kF16, "abs"},
- BuiltinData{BuiltinType::kAcos, CallParamType::kF32, "acos"},
- BuiltinData{BuiltinType::kAcos, CallParamType::kF16, "acos"},
- BuiltinData{BuiltinType::kAsin, CallParamType::kF32, "asin"},
- BuiltinData{BuiltinType::kAsin, CallParamType::kF16, "asin"},
- BuiltinData{BuiltinType::kAtan, CallParamType::kF32, "atan"},
- BuiltinData{BuiltinType::kAtan, CallParamType::kF16, "atan"},
- BuiltinData{BuiltinType::kAtan2, CallParamType::kF32, "atan2"},
- BuiltinData{BuiltinType::kAtan2, CallParamType::kF16, "atan2"},
- BuiltinData{BuiltinType::kCeil, CallParamType::kF32, "ceil"},
- BuiltinData{BuiltinType::kCeil, CallParamType::kF16, "ceil"},
- BuiltinData{BuiltinType::kClamp, CallParamType::kF32, "clamp"},
- BuiltinData{BuiltinType::kClamp, CallParamType::kF16, "clamp"},
- BuiltinData{BuiltinType::kCos, CallParamType::kF32, "cos"},
- BuiltinData{BuiltinType::kCos, CallParamType::kF16, "cos"},
- BuiltinData{BuiltinType::kCosh, CallParamType::kF32, "cosh"},
- BuiltinData{BuiltinType::kCosh, CallParamType::kF16, "cosh"},
- BuiltinData{BuiltinType::kCross, CallParamType::kF32, "cross"},
- BuiltinData{BuiltinType::kCross, CallParamType::kF16, "cross"},
- BuiltinData{BuiltinType::kDistance, CallParamType::kF32, "distance"},
- BuiltinData{BuiltinType::kDistance, CallParamType::kF16, "distance"},
- BuiltinData{BuiltinType::kExp, CallParamType::kF32, "exp"},
- BuiltinData{BuiltinType::kExp, CallParamType::kF16, "exp"},
- BuiltinData{BuiltinType::kExp2, CallParamType::kF32, "exp2"},
- BuiltinData{BuiltinType::kExp2, CallParamType::kF16, "exp2"},
- BuiltinData{BuiltinType::kFaceForward, CallParamType::kF32, "faceforward"},
- BuiltinData{BuiltinType::kFaceForward, CallParamType::kF16, "faceforward"},
- BuiltinData{BuiltinType::kFloor, CallParamType::kF32, "floor"},
- BuiltinData{BuiltinType::kFloor, CallParamType::kF16, "floor"},
- BuiltinData{BuiltinType::kFma, CallParamType::kF32, "mad"},
- BuiltinData{BuiltinType::kFma, CallParamType::kF16, "mad"},
- BuiltinData{BuiltinType::kFract, CallParamType::kF32, "frac"},
- BuiltinData{BuiltinType::kFract, CallParamType::kF16, "frac"},
- BuiltinData{BuiltinType::kInverseSqrt, CallParamType::kF32, "rsqrt"},
- BuiltinData{BuiltinType::kInverseSqrt, CallParamType::kF16, "rsqrt"},
- BuiltinData{BuiltinType::kLdexp, CallParamType::kF32, "ldexp"},
- BuiltinData{BuiltinType::kLdexp, CallParamType::kF16, "ldexp"},
- BuiltinData{BuiltinType::kLength, CallParamType::kF32, "length"},
- BuiltinData{BuiltinType::kLength, CallParamType::kF16, "length"},
- BuiltinData{BuiltinType::kLog, CallParamType::kF32, "log"},
- BuiltinData{BuiltinType::kLog, CallParamType::kF16, "log"},
- BuiltinData{BuiltinType::kLog2, CallParamType::kF32, "log2"},
- BuiltinData{BuiltinType::kLog2, CallParamType::kF16, "log2"},
- BuiltinData{BuiltinType::kMax, CallParamType::kF32, "max"},
- BuiltinData{BuiltinType::kMax, CallParamType::kF16, "max"},
- BuiltinData{BuiltinType::kMin, CallParamType::kF32, "min"},
- BuiltinData{BuiltinType::kMin, CallParamType::kF16, "min"},
- BuiltinData{BuiltinType::kMix, CallParamType::kF32, "lerp"},
- BuiltinData{BuiltinType::kMix, CallParamType::kF16, "lerp"},
- BuiltinData{BuiltinType::kNormalize, CallParamType::kF32, "normalize"},
- BuiltinData{BuiltinType::kNormalize, CallParamType::kF16, "normalize"},
- BuiltinData{BuiltinType::kPow, CallParamType::kF32, "pow"},
- BuiltinData{BuiltinType::kPow, CallParamType::kF16, "pow"},
- BuiltinData{BuiltinType::kReflect, CallParamType::kF32, "reflect"},
- BuiltinData{BuiltinType::kReflect, CallParamType::kF16, "reflect"},
- BuiltinData{BuiltinType::kSin, CallParamType::kF32, "sin"},
- BuiltinData{BuiltinType::kSin, CallParamType::kF16, "sin"},
- BuiltinData{BuiltinType::kSinh, CallParamType::kF32, "sinh"},
- BuiltinData{BuiltinType::kSinh, CallParamType::kF16, "sinh"},
- BuiltinData{BuiltinType::kSmoothstep, CallParamType::kF32, "smoothstep"},
- BuiltinData{BuiltinType::kSmoothstep, CallParamType::kF16, "smoothstep"},
- BuiltinData{BuiltinType::kSqrt, CallParamType::kF32, "sqrt"},
- BuiltinData{BuiltinType::kSqrt, CallParamType::kF16, "sqrt"},
- BuiltinData{BuiltinType::kStep, CallParamType::kF32, "step"},
- BuiltinData{BuiltinType::kStep, CallParamType::kF16, "step"},
- BuiltinData{BuiltinType::kTan, CallParamType::kF32, "tan"},
- BuiltinData{BuiltinType::kTan, CallParamType::kF16, "tan"},
- BuiltinData{BuiltinType::kTanh, CallParamType::kF32, "tanh"},
- BuiltinData{BuiltinType::kTanh, CallParamType::kF16, "tanh"},
- BuiltinData{BuiltinType::kTrunc, CallParamType::kF32, "trunc"},
- BuiltinData{BuiltinType::kTrunc, CallParamType::kF16, "trunc"},
+ BuiltinData{builtin::Function::kAbs, CallParamType::kF32, "abs"},
+ BuiltinData{builtin::Function::kAbs, CallParamType::kF16, "abs"},
+ BuiltinData{builtin::Function::kAcos, CallParamType::kF32, "acos"},
+ BuiltinData{builtin::Function::kAcos, CallParamType::kF16, "acos"},
+ BuiltinData{builtin::Function::kAsin, CallParamType::kF32, "asin"},
+ BuiltinData{builtin::Function::kAsin, CallParamType::kF16, "asin"},
+ BuiltinData{builtin::Function::kAtan, CallParamType::kF32, "atan"},
+ BuiltinData{builtin::Function::kAtan, CallParamType::kF16, "atan"},
+ BuiltinData{builtin::Function::kAtan2, CallParamType::kF32, "atan2"},
+ BuiltinData{builtin::Function::kAtan2, CallParamType::kF16, "atan2"},
+ BuiltinData{builtin::Function::kCeil, CallParamType::kF32, "ceil"},
+ BuiltinData{builtin::Function::kCeil, CallParamType::kF16, "ceil"},
+ BuiltinData{builtin::Function::kClamp, CallParamType::kF32, "clamp"},
+ BuiltinData{builtin::Function::kClamp, CallParamType::kF16, "clamp"},
+ BuiltinData{builtin::Function::kCos, CallParamType::kF32, "cos"},
+ BuiltinData{builtin::Function::kCos, CallParamType::kF16, "cos"},
+ BuiltinData{builtin::Function::kCosh, CallParamType::kF32, "cosh"},
+ BuiltinData{builtin::Function::kCosh, CallParamType::kF16, "cosh"},
+ BuiltinData{builtin::Function::kCross, CallParamType::kF32, "cross"},
+ BuiltinData{builtin::Function::kCross, CallParamType::kF16, "cross"},
+ BuiltinData{builtin::Function::kDistance, CallParamType::kF32, "distance"},
+ BuiltinData{builtin::Function::kDistance, CallParamType::kF16, "distance"},
+ BuiltinData{builtin::Function::kExp, CallParamType::kF32, "exp"},
+ BuiltinData{builtin::Function::kExp, CallParamType::kF16, "exp"},
+ BuiltinData{builtin::Function::kExp2, CallParamType::kF32, "exp2"},
+ BuiltinData{builtin::Function::kExp2, CallParamType::kF16, "exp2"},
+ BuiltinData{builtin::Function::kFaceForward, CallParamType::kF32,
+ "faceforward"},
+ BuiltinData{builtin::Function::kFaceForward, CallParamType::kF16,
+ "faceforward"},
+ BuiltinData{builtin::Function::kFloor, CallParamType::kF32, "floor"},
+ BuiltinData{builtin::Function::kFloor, CallParamType::kF16, "floor"},
+ BuiltinData{builtin::Function::kFma, CallParamType::kF32, "mad"},
+ BuiltinData{builtin::Function::kFma, CallParamType::kF16, "mad"},
+ BuiltinData{builtin::Function::kFract, CallParamType::kF32, "frac"},
+ BuiltinData{builtin::Function::kFract, CallParamType::kF16, "frac"},
+ BuiltinData{builtin::Function::kInverseSqrt, CallParamType::kF32, "rsqrt"},
+ BuiltinData{builtin::Function::kInverseSqrt, CallParamType::kF16, "rsqrt"},
+ BuiltinData{builtin::Function::kLdexp, CallParamType::kF32, "ldexp"},
+ BuiltinData{builtin::Function::kLdexp, CallParamType::kF16, "ldexp"},
+ BuiltinData{builtin::Function::kLength, CallParamType::kF32, "length"},
+ BuiltinData{builtin::Function::kLength, CallParamType::kF16, "length"},
+ BuiltinData{builtin::Function::kLog, CallParamType::kF32, "log"},
+ BuiltinData{builtin::Function::kLog, CallParamType::kF16, "log"},
+ BuiltinData{builtin::Function::kLog2, CallParamType::kF32, "log2"},
+ BuiltinData{builtin::Function::kLog2, CallParamType::kF16, "log2"},
+ BuiltinData{builtin::Function::kMax, CallParamType::kF32, "max"},
+ BuiltinData{builtin::Function::kMax, CallParamType::kF16, "max"},
+ BuiltinData{builtin::Function::kMin, CallParamType::kF32, "min"},
+ BuiltinData{builtin::Function::kMin, CallParamType::kF16, "min"},
+ BuiltinData{builtin::Function::kMix, CallParamType::kF32, "lerp"},
+ BuiltinData{builtin::Function::kMix, CallParamType::kF16, "lerp"},
+ BuiltinData{builtin::Function::kNormalize, CallParamType::kF32, "normalize"},
+ BuiltinData{builtin::Function::kNormalize, CallParamType::kF16, "normalize"},
+ BuiltinData{builtin::Function::kPow, CallParamType::kF32, "pow"},
+ BuiltinData{builtin::Function::kPow, CallParamType::kF16, "pow"},
+ BuiltinData{builtin::Function::kReflect, CallParamType::kF32, "reflect"},
+ BuiltinData{builtin::Function::kReflect, CallParamType::kF16, "reflect"},
+ BuiltinData{builtin::Function::kSin, CallParamType::kF32, "sin"},
+ BuiltinData{builtin::Function::kSin, CallParamType::kF16, "sin"},
+ BuiltinData{builtin::Function::kSinh, CallParamType::kF32, "sinh"},
+ BuiltinData{builtin::Function::kSinh, CallParamType::kF16, "sinh"},
+ BuiltinData{builtin::Function::kSmoothstep, CallParamType::kF32, "smoothstep"},
+ BuiltinData{builtin::Function::kSmoothstep, CallParamType::kF16, "smoothstep"},
+ BuiltinData{builtin::Function::kSqrt, CallParamType::kF32, "sqrt"},
+ BuiltinData{builtin::Function::kSqrt, CallParamType::kF16, "sqrt"},
+ BuiltinData{builtin::Function::kStep, CallParamType::kF32, "step"},
+ BuiltinData{builtin::Function::kStep, CallParamType::kF16, "step"},
+ BuiltinData{builtin::Function::kTan, CallParamType::kF32, "tan"},
+ BuiltinData{builtin::Function::kTan, CallParamType::kF16, "tan"},
+ BuiltinData{builtin::Function::kTanh, CallParamType::kF32, "tanh"},
+ BuiltinData{builtin::Function::kTanh, CallParamType::kF16, "tanh"},
+ BuiltinData{builtin::Function::kTrunc, CallParamType::kF32, "trunc"},
+ BuiltinData{builtin::Function::kTrunc, CallParamType::kF16, "trunc"},
/* Integer built-in */
- BuiltinData{BuiltinType::kAbs, CallParamType::kU32, "abs"},
- BuiltinData{BuiltinType::kClamp, CallParamType::kU32, "clamp"},
- BuiltinData{BuiltinType::kCountOneBits, CallParamType::kU32, "countbits"},
- BuiltinData{BuiltinType::kMax, CallParamType::kU32, "max"},
- BuiltinData{BuiltinType::kMin, CallParamType::kU32, "min"},
- BuiltinData{BuiltinType::kReverseBits, CallParamType::kU32, "reversebits"},
- BuiltinData{BuiltinType::kRound, CallParamType::kU32, "round"},
+ BuiltinData{builtin::Function::kAbs, CallParamType::kU32, "abs"},
+ BuiltinData{builtin::Function::kClamp, CallParamType::kU32, "clamp"},
+ BuiltinData{builtin::Function::kCountOneBits, CallParamType::kU32, "countbits"},
+ BuiltinData{builtin::Function::kMax, CallParamType::kU32, "max"},
+ BuiltinData{builtin::Function::kMin, CallParamType::kU32, "min"},
+ BuiltinData{builtin::Function::kReverseBits, CallParamType::kU32,
+ "reversebits"},
+ BuiltinData{builtin::Function::kRound, CallParamType::kU32, "round"},
/* Matrix built-in */
- BuiltinData{BuiltinType::kDeterminant, CallParamType::kF32, "determinant"},
- BuiltinData{BuiltinType::kDeterminant, CallParamType::kF16, "determinant"},
- BuiltinData{BuiltinType::kTranspose, CallParamType::kF32, "transpose"},
- BuiltinData{BuiltinType::kTranspose, CallParamType::kF16, "transpose"},
+ BuiltinData{builtin::Function::kDeterminant, CallParamType::kF32,
+ "determinant"},
+ BuiltinData{builtin::Function::kDeterminant, CallParamType::kF16,
+ "determinant"},
+ BuiltinData{builtin::Function::kTranspose, CallParamType::kF32, "transpose"},
+ BuiltinData{builtin::Function::kTranspose, CallParamType::kF16, "transpose"},
/* Vector built-in */
- BuiltinData{BuiltinType::kDot, CallParamType::kF32, "dot"},
- BuiltinData{BuiltinType::kDot, CallParamType::kF16, "dot"},
+ BuiltinData{builtin::Function::kDot, CallParamType::kF32, "dot"},
+ BuiltinData{builtin::Function::kDot, CallParamType::kF16, "dot"},
/* Derivate built-in */
- BuiltinData{BuiltinType::kDpdx, CallParamType::kF32, "ddx"},
- BuiltinData{BuiltinType::kDpdxCoarse, CallParamType::kF32, "ddx_coarse"},
- BuiltinData{BuiltinType::kDpdxFine, CallParamType::kF32, "ddx_fine"},
- BuiltinData{BuiltinType::kDpdy, CallParamType::kF32, "ddy"},
- BuiltinData{BuiltinType::kDpdyCoarse, CallParamType::kF32, "ddy_coarse"},
- BuiltinData{BuiltinType::kDpdyFine, CallParamType::kF32, "ddy_fine"},
- BuiltinData{BuiltinType::kFwidth, CallParamType::kF32, "fwidth"},
- BuiltinData{BuiltinType::kFwidthCoarse, CallParamType::kF32, "fwidth"},
- BuiltinData{BuiltinType::kFwidthFine, CallParamType::kF32, "fwidth"}));
+ BuiltinData{builtin::Function::kDpdx, CallParamType::kF32, "ddx"},
+ BuiltinData{builtin::Function::kDpdxCoarse, CallParamType::kF32, "ddx_coarse"},
+ BuiltinData{builtin::Function::kDpdxFine, CallParamType::kF32, "ddx_fine"},
+ BuiltinData{builtin::Function::kDpdy, CallParamType::kF32, "ddy"},
+ BuiltinData{builtin::Function::kDpdyCoarse, CallParamType::kF32, "ddy_coarse"},
+ BuiltinData{builtin::Function::kDpdyFine, CallParamType::kF32, "ddy_fine"},
+ BuiltinData{builtin::Function::kFwidth, CallParamType::kF32, "fwidth"},
+ BuiltinData{builtin::Function::kFwidthCoarse, CallParamType::kF32, "fwidth"},
+ BuiltinData{builtin::Function::kFwidthFine, CallParamType::kF32, "fwidth"}));
TEST_F(HlslGeneratorImplTest_Builtin, Builtin_Call) {
auto* call = Call("dot", "param1", "param2");
diff --git a/src/tint/writer/msl/generator_impl.cc b/src/tint/writer/msl/generator_impl.cc
index 5c9e11b..92bdb96 100644
--- a/src/tint/writer/msl/generator_impl.cc
+++ b/src/tint/writer/msl/generator_impl.cc
@@ -699,20 +699,20 @@
auto name = generate_builtin_name(builtin);
switch (builtin->Type()) {
- case sem::BuiltinType::kDot:
+ case builtin::Function::kDot:
return EmitDotCall(out, expr, builtin);
- case sem::BuiltinType::kModf:
+ case builtin::Function::kModf:
return EmitModfCall(out, expr, builtin);
- case sem::BuiltinType::kFrexp:
+ case builtin::Function::kFrexp:
return EmitFrexpCall(out, expr, builtin);
- case sem::BuiltinType::kDegrees:
+ case builtin::Function::kDegrees:
return EmitDegreesCall(out, expr, builtin);
- case sem::BuiltinType::kRadians:
+ case builtin::Function::kRadians:
return EmitRadiansCall(out, expr, builtin);
- case sem::BuiltinType::kPack2X16Float:
- case sem::BuiltinType::kUnpack2X16Float: {
- if (builtin->Type() == sem::BuiltinType::kPack2X16Float) {
+ case builtin::Function::kPack2X16Float:
+ case builtin::Function::kUnpack2X16Float: {
+ if (builtin->Type() == builtin::Function::kPack2X16Float) {
out << "as_type<uint>(half2(";
} else {
out << "float2(as_type<half2>(";
@@ -723,7 +723,7 @@
out << "))";
return true;
}
- case sem::BuiltinType::kQuantizeToF16: {
+ case builtin::Function::kQuantizeToF16: {
std::string width = "";
if (auto* vec = builtin->ReturnType()->As<type::Vector>()) {
width = std::to_string(vec->Width());
@@ -737,16 +737,16 @@
}
// TODO(crbug.com/tint/661): Combine sequential barriers to a single
// instruction.
- case sem::BuiltinType::kStorageBarrier: {
+ case builtin::Function::kStorageBarrier: {
out << "threadgroup_barrier(mem_flags::mem_device)";
return true;
}
- case sem::BuiltinType::kWorkgroupBarrier: {
+ case builtin::Function::kWorkgroupBarrier: {
out << "threadgroup_barrier(mem_flags::mem_threadgroup)";
return true;
}
- case sem::BuiltinType::kLength: {
+ case builtin::Function::kLength: {
auto* sem = builder_.Sem().GetVal(expr->args[0]);
if (sem->Type()->UnwrapRef()->is_scalar()) {
// Emulate scalar overload using fabs(x).
@@ -755,7 +755,7 @@
break;
}
- case sem::BuiltinType::kDistance: {
+ case builtin::Function::kDistance: {
auto* sem = builder_.Sem().GetVal(expr->args[0]);
if (sem->Type()->UnwrapRef()->is_scalar()) {
// Emulate scalar overload using fabs(x - y);
@@ -896,37 +896,37 @@
};
switch (builtin->Type()) {
- case sem::BuiltinType::kAtomicLoad:
+ case builtin::Function::kAtomicLoad:
return call("atomic_load_explicit", true);
- case sem::BuiltinType::kAtomicStore:
+ case builtin::Function::kAtomicStore:
return call("atomic_store_explicit", true);
- case sem::BuiltinType::kAtomicAdd:
+ case builtin::Function::kAtomicAdd:
return call("atomic_fetch_add_explicit", true);
- case sem::BuiltinType::kAtomicSub:
+ case builtin::Function::kAtomicSub:
return call("atomic_fetch_sub_explicit", true);
- case sem::BuiltinType::kAtomicMax:
+ case builtin::Function::kAtomicMax:
return call("atomic_fetch_max_explicit", true);
- case sem::BuiltinType::kAtomicMin:
+ case builtin::Function::kAtomicMin:
return call("atomic_fetch_min_explicit", true);
- case sem::BuiltinType::kAtomicAnd:
+ case builtin::Function::kAtomicAnd:
return call("atomic_fetch_and_explicit", true);
- case sem::BuiltinType::kAtomicOr:
+ case builtin::Function::kAtomicOr:
return call("atomic_fetch_or_explicit", true);
- case sem::BuiltinType::kAtomicXor:
+ case builtin::Function::kAtomicXor:
return call("atomic_fetch_xor_explicit", true);
- case sem::BuiltinType::kAtomicExchange:
+ case builtin::Function::kAtomicExchange:
return call("atomic_exchange_explicit", true);
- case sem::BuiltinType::kAtomicCompareExchangeWeak: {
+ case builtin::Function::kAtomicCompareExchangeWeak: {
auto* ptr_ty = TypeOf(expr->args[0])->UnwrapRef()->As<type::Pointer>();
auto sc = ptr_ty->AddressSpace();
auto* str = builtin->ReturnType()->As<sem::Struct>();
@@ -1041,7 +1041,7 @@
bool level_is_constant_zero = texture_type->dim() == type::TextureDimension::k1d;
switch (builtin->Type()) {
- case sem::BuiltinType::kTextureDimensions: {
+ case builtin::Function::kTextureDimensions: {
std::vector<const char*> dims;
switch (texture_type->dim()) {
case type::TextureDimension::kNone:
@@ -1094,21 +1094,21 @@
}
return true;
}
- case sem::BuiltinType::kTextureNumLayers: {
+ case builtin::Function::kTextureNumLayers: {
if (!texture_expr()) {
return false;
}
out << ".get_array_size()";
return true;
}
- case sem::BuiltinType::kTextureNumLevels: {
+ case builtin::Function::kTextureNumLevels: {
if (!texture_expr()) {
return false;
}
out << ".get_num_mip_levels()";
return true;
}
- case sem::BuiltinType::kTextureNumSamples: {
+ case builtin::Function::kTextureNumSamples: {
if (!texture_expr()) {
return false;
}
@@ -1126,27 +1126,27 @@
bool lod_param_is_named = true;
switch (builtin->Type()) {
- case sem::BuiltinType::kTextureSample:
- case sem::BuiltinType::kTextureSampleBias:
- case sem::BuiltinType::kTextureSampleLevel:
- case sem::BuiltinType::kTextureSampleGrad:
+ case builtin::Function::kTextureSample:
+ case builtin::Function::kTextureSampleBias:
+ case builtin::Function::kTextureSampleLevel:
+ case builtin::Function::kTextureSampleGrad:
out << ".sample(";
break;
- case sem::BuiltinType::kTextureSampleCompare:
- case sem::BuiltinType::kTextureSampleCompareLevel:
+ case builtin::Function::kTextureSampleCompare:
+ case builtin::Function::kTextureSampleCompareLevel:
out << ".sample_compare(";
break;
- case sem::BuiltinType::kTextureGather:
+ case builtin::Function::kTextureGather:
out << ".gather(";
break;
- case sem::BuiltinType::kTextureGatherCompare:
+ case builtin::Function::kTextureGatherCompare:
out << ".gather_compare(";
break;
- case sem::BuiltinType::kTextureLoad:
+ case builtin::Function::kTextureLoad:
out << ".read(";
lod_param_is_named = false;
break;
- case sem::BuiltinType::kTextureStore:
+ case builtin::Function::kTextureStore:
out << ".write(";
break;
default:
@@ -1223,7 +1223,7 @@
out << ")";
}
}
- if (builtin->Type() == sem::BuiltinType::kTextureSampleCompareLevel) {
+ if (builtin->Type() == builtin::Function::kTextureSampleCompareLevel) {
maybe_write_comma();
out << "level(0)";
}
@@ -1430,143 +1430,143 @@
std::string GeneratorImpl::generate_builtin_name(const sem::Builtin* builtin) {
std::string out = "";
switch (builtin->Type()) {
- case sem::BuiltinType::kAcos:
- case sem::BuiltinType::kAcosh:
- case sem::BuiltinType::kAll:
- case sem::BuiltinType::kAny:
- case sem::BuiltinType::kAsin:
- case sem::BuiltinType::kAsinh:
- case sem::BuiltinType::kAtanh:
- case sem::BuiltinType::kAtan:
- case sem::BuiltinType::kAtan2:
- case sem::BuiltinType::kCeil:
- case sem::BuiltinType::kCos:
- case sem::BuiltinType::kCosh:
- case sem::BuiltinType::kCross:
- case sem::BuiltinType::kDeterminant:
- case sem::BuiltinType::kDistance:
- case sem::BuiltinType::kDot:
- case sem::BuiltinType::kExp:
- case sem::BuiltinType::kExp2:
- case sem::BuiltinType::kFloor:
- case sem::BuiltinType::kFma:
- case sem::BuiltinType::kFract:
- case sem::BuiltinType::kFrexp:
- case sem::BuiltinType::kLength:
- case sem::BuiltinType::kLdexp:
- case sem::BuiltinType::kLog:
- case sem::BuiltinType::kLog2:
- case sem::BuiltinType::kMix:
- case sem::BuiltinType::kModf:
- case sem::BuiltinType::kNormalize:
- case sem::BuiltinType::kPow:
- case sem::BuiltinType::kReflect:
- case sem::BuiltinType::kRefract:
- case sem::BuiltinType::kSaturate:
- case sem::BuiltinType::kSelect:
- case sem::BuiltinType::kSin:
- case sem::BuiltinType::kSinh:
- case sem::BuiltinType::kSqrt:
- case sem::BuiltinType::kStep:
- case sem::BuiltinType::kTan:
- case sem::BuiltinType::kTanh:
- case sem::BuiltinType::kTranspose:
- case sem::BuiltinType::kTrunc:
- case sem::BuiltinType::kSign:
- case sem::BuiltinType::kClamp:
+ case builtin::Function::kAcos:
+ case builtin::Function::kAcosh:
+ case builtin::Function::kAll:
+ case builtin::Function::kAny:
+ case builtin::Function::kAsin:
+ case builtin::Function::kAsinh:
+ case builtin::Function::kAtanh:
+ case builtin::Function::kAtan:
+ case builtin::Function::kAtan2:
+ case builtin::Function::kCeil:
+ case builtin::Function::kCos:
+ case builtin::Function::kCosh:
+ case builtin::Function::kCross:
+ case builtin::Function::kDeterminant:
+ case builtin::Function::kDistance:
+ case builtin::Function::kDot:
+ case builtin::Function::kExp:
+ case builtin::Function::kExp2:
+ case builtin::Function::kFloor:
+ case builtin::Function::kFma:
+ case builtin::Function::kFract:
+ case builtin::Function::kFrexp:
+ case builtin::Function::kLength:
+ case builtin::Function::kLdexp:
+ case builtin::Function::kLog:
+ case builtin::Function::kLog2:
+ case builtin::Function::kMix:
+ case builtin::Function::kModf:
+ case builtin::Function::kNormalize:
+ case builtin::Function::kPow:
+ case builtin::Function::kReflect:
+ case builtin::Function::kRefract:
+ case builtin::Function::kSaturate:
+ case builtin::Function::kSelect:
+ case builtin::Function::kSin:
+ case builtin::Function::kSinh:
+ case builtin::Function::kSqrt:
+ case builtin::Function::kStep:
+ case builtin::Function::kTan:
+ case builtin::Function::kTanh:
+ case builtin::Function::kTranspose:
+ case builtin::Function::kTrunc:
+ case builtin::Function::kSign:
+ case builtin::Function::kClamp:
out += builtin->str();
break;
- case sem::BuiltinType::kAbs:
+ case builtin::Function::kAbs:
if (builtin->ReturnType()->is_float_scalar_or_vector()) {
out += "fabs";
} else {
out += "abs";
}
break;
- case sem::BuiltinType::kCountLeadingZeros:
+ case builtin::Function::kCountLeadingZeros:
out += "clz";
break;
- case sem::BuiltinType::kCountOneBits:
+ case builtin::Function::kCountOneBits:
out += "popcount";
break;
- case sem::BuiltinType::kCountTrailingZeros:
+ case builtin::Function::kCountTrailingZeros:
out += "ctz";
break;
- case sem::BuiltinType::kDpdx:
- case sem::BuiltinType::kDpdxCoarse:
- case sem::BuiltinType::kDpdxFine:
+ case builtin::Function::kDpdx:
+ case builtin::Function::kDpdxCoarse:
+ case builtin::Function::kDpdxFine:
out += "dfdx";
break;
- case sem::BuiltinType::kDpdy:
- case sem::BuiltinType::kDpdyCoarse:
- case sem::BuiltinType::kDpdyFine:
+ case builtin::Function::kDpdy:
+ case builtin::Function::kDpdyCoarse:
+ case builtin::Function::kDpdyFine:
out += "dfdy";
break;
- case sem::BuiltinType::kExtractBits:
+ case builtin::Function::kExtractBits:
out += "extract_bits";
break;
- case sem::BuiltinType::kInsertBits:
+ case builtin::Function::kInsertBits:
out += "insert_bits";
break;
- case sem::BuiltinType::kFwidth:
- case sem::BuiltinType::kFwidthCoarse:
- case sem::BuiltinType::kFwidthFine:
+ case builtin::Function::kFwidth:
+ case builtin::Function::kFwidthCoarse:
+ case builtin::Function::kFwidthFine:
out += "fwidth";
break;
- case sem::BuiltinType::kMax:
+ case builtin::Function::kMax:
if (builtin->ReturnType()->is_float_scalar_or_vector()) {
out += "fmax";
} else {
out += "max";
}
break;
- case sem::BuiltinType::kMin:
+ case builtin::Function::kMin:
if (builtin->ReturnType()->is_float_scalar_or_vector()) {
out += "fmin";
} else {
out += "min";
}
break;
- case sem::BuiltinType::kFaceForward:
+ case builtin::Function::kFaceForward:
out += "faceforward";
break;
- case sem::BuiltinType::kPack4X8Snorm:
+ case builtin::Function::kPack4X8Snorm:
out += "pack_float_to_snorm4x8";
break;
- case sem::BuiltinType::kPack4X8Unorm:
+ case builtin::Function::kPack4X8Unorm:
out += "pack_float_to_unorm4x8";
break;
- case sem::BuiltinType::kPack2X16Snorm:
+ case builtin::Function::kPack2X16Snorm:
out += "pack_float_to_snorm2x16";
break;
- case sem::BuiltinType::kPack2X16Unorm:
+ case builtin::Function::kPack2X16Unorm:
out += "pack_float_to_unorm2x16";
break;
- case sem::BuiltinType::kReverseBits:
+ case builtin::Function::kReverseBits:
out += "reverse_bits";
break;
- case sem::BuiltinType::kRound:
+ case builtin::Function::kRound:
out += "rint";
break;
- case sem::BuiltinType::kSmoothstep:
+ case builtin::Function::kSmoothstep:
out += "smoothstep";
break;
- case sem::BuiltinType::kInverseSqrt:
+ case builtin::Function::kInverseSqrt:
out += "rsqrt";
break;
- case sem::BuiltinType::kUnpack4X8Snorm:
+ case builtin::Function::kUnpack4X8Snorm:
out += "unpack_snorm4x8_to_float";
break;
- case sem::BuiltinType::kUnpack4X8Unorm:
+ case builtin::Function::kUnpack4X8Unorm:
out += "unpack_unorm4x8_to_float";
break;
- case sem::BuiltinType::kUnpack2X16Snorm:
+ case builtin::Function::kUnpack2X16Snorm:
out += "unpack_snorm2x16_to_float";
break;
- case sem::BuiltinType::kUnpack2X16Unorm:
+ case builtin::Function::kUnpack2X16Unorm:
out += "unpack_unorm2x16_to_float";
break;
- case sem::BuiltinType::kArrayLength:
+ case builtin::Function::kArrayLength:
diagnostics_.add_error(
diag::System::Writer,
"Unable to translate builtin: " + std::string(builtin->str()) +
@@ -3258,7 +3258,7 @@
TextBuffer b;
TINT_DEFER(helpers_.Append(b));
- auto fn_name = UniqueIdentifier(std::string("tint_") + sem::str(builtin->Type()));
+ auto fn_name = UniqueIdentifier(std::string("tint_") + builtin::str(builtin->Type()));
std::vector<std::string> parameter_names;
{
auto decl = line(&b);
diff --git a/src/tint/writer/msl/generator_impl_builtin_test.cc b/src/tint/writer/msl/generator_impl_builtin_test.cc
index 08a2d25..6c70abe 100644
--- a/src/tint/writer/msl/generator_impl_builtin_test.cc
+++ b/src/tint/writer/msl/generator_impl_builtin_test.cc
@@ -22,8 +22,6 @@
namespace tint::writer::msl {
namespace {
-using BuiltinType = sem::BuiltinType;
-
using MslGeneratorImplTest = TestHelper;
enum class CallParamType {
@@ -34,7 +32,7 @@
};
struct BuiltinData {
- BuiltinType builtin;
+ builtin::Function builtin;
CallParamType type;
const char* msl_name;
};
@@ -58,88 +56,88 @@
return out;
}
-const ast::CallExpression* GenerateCall(BuiltinType builtin,
+const ast::CallExpression* GenerateCall(builtin::Function builtin,
CallParamType type,
ProgramBuilder* builder) {
std::string name;
utils::StringStream str;
str << name << builtin;
switch (builtin) {
- case BuiltinType::kAcos:
- case BuiltinType::kAsin:
- case BuiltinType::kAtan:
- case BuiltinType::kCeil:
- case BuiltinType::kCos:
- case BuiltinType::kCosh:
- case BuiltinType::kDpdx:
- case BuiltinType::kDpdxCoarse:
- case BuiltinType::kDpdxFine:
- case BuiltinType::kDpdy:
- case BuiltinType::kDpdyCoarse:
- case BuiltinType::kDpdyFine:
- case BuiltinType::kExp:
- case BuiltinType::kExp2:
- case BuiltinType::kFloor:
- case BuiltinType::kFract:
- case BuiltinType::kFwidth:
- case BuiltinType::kFwidthCoarse:
- case BuiltinType::kFwidthFine:
- case BuiltinType::kInverseSqrt:
- case BuiltinType::kLength:
- case BuiltinType::kLog:
- case BuiltinType::kLog2:
- case BuiltinType::kNormalize:
- case BuiltinType::kRound:
- case BuiltinType::kSin:
- case BuiltinType::kSinh:
- case BuiltinType::kSqrt:
- case BuiltinType::kTan:
- case BuiltinType::kTanh:
- case BuiltinType::kTrunc:
- case BuiltinType::kSign:
+ case builtin::Function::kAcos:
+ case builtin::Function::kAsin:
+ case builtin::Function::kAtan:
+ case builtin::Function::kCeil:
+ case builtin::Function::kCos:
+ case builtin::Function::kCosh:
+ case builtin::Function::kDpdx:
+ case builtin::Function::kDpdxCoarse:
+ case builtin::Function::kDpdxFine:
+ case builtin::Function::kDpdy:
+ case builtin::Function::kDpdyCoarse:
+ case builtin::Function::kDpdyFine:
+ case builtin::Function::kExp:
+ case builtin::Function::kExp2:
+ case builtin::Function::kFloor:
+ case builtin::Function::kFract:
+ case builtin::Function::kFwidth:
+ case builtin::Function::kFwidthCoarse:
+ case builtin::Function::kFwidthFine:
+ case builtin::Function::kInverseSqrt:
+ case builtin::Function::kLength:
+ case builtin::Function::kLog:
+ case builtin::Function::kLog2:
+ case builtin::Function::kNormalize:
+ case builtin::Function::kRound:
+ case builtin::Function::kSin:
+ case builtin::Function::kSinh:
+ case builtin::Function::kSqrt:
+ case builtin::Function::kTan:
+ case builtin::Function::kTanh:
+ case builtin::Function::kTrunc:
+ case builtin::Function::kSign:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "h2");
} else {
return builder->Call(str.str(), "f2");
}
- case BuiltinType::kLdexp:
+ case builtin::Function::kLdexp:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "h2", "i2");
} else {
return builder->Call(str.str(), "f2", "i2");
}
- case BuiltinType::kAtan2:
- case BuiltinType::kDot:
- case BuiltinType::kDistance:
- case BuiltinType::kPow:
- case BuiltinType::kReflect:
- case BuiltinType::kStep:
+ case builtin::Function::kAtan2:
+ case builtin::Function::kDot:
+ case builtin::Function::kDistance:
+ case builtin::Function::kPow:
+ case builtin::Function::kReflect:
+ case builtin::Function::kStep:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "h2", "h2");
} else {
return builder->Call(str.str(), "f2", "f2");
}
- case BuiltinType::kStorageBarrier:
+ case builtin::Function::kStorageBarrier:
return builder->Call(str.str());
- case BuiltinType::kCross:
+ case builtin::Function::kCross:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "h3", "h3");
} else {
return builder->Call(str.str(), "f3", "f3");
}
- case BuiltinType::kFma:
- case BuiltinType::kMix:
- case BuiltinType::kFaceForward:
- case BuiltinType::kSmoothstep:
+ case builtin::Function::kFma:
+ case builtin::Function::kMix:
+ case builtin::Function::kFaceForward:
+ case builtin::Function::kSmoothstep:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "h2", "h2", "h2");
} else {
return builder->Call(str.str(), "f2", "f2", "f2");
}
- case BuiltinType::kAll:
- case BuiltinType::kAny:
+ case builtin::Function::kAll:
+ case builtin::Function::kAny:
return builder->Call(str.str(), "b2");
- case BuiltinType::kAbs:
+ case builtin::Function::kAbs:
if (type == CallParamType::kF32) {
return builder->Call(str.str(), "f2");
} else if (type == CallParamType::kF16) {
@@ -147,17 +145,17 @@
} else {
return builder->Call(str.str(), "u2");
}
- case BuiltinType::kCountLeadingZeros:
- case BuiltinType::kCountOneBits:
- case BuiltinType::kCountTrailingZeros:
- case BuiltinType::kReverseBits:
+ case builtin::Function::kCountLeadingZeros:
+ case builtin::Function::kCountOneBits:
+ case builtin::Function::kCountTrailingZeros:
+ case builtin::Function::kReverseBits:
return builder->Call(str.str(), "u2");
- case BuiltinType::kExtractBits:
+ case builtin::Function::kExtractBits:
return builder->Call(str.str(), "u2", "u1", "u1");
- case BuiltinType::kInsertBits:
+ case builtin::Function::kInsertBits:
return builder->Call(str.str(), "u2", "u2", "u1", "u1");
- case BuiltinType::kMax:
- case BuiltinType::kMin:
+ case builtin::Function::kMax:
+ case builtin::Function::kMin:
if (type == CallParamType::kF32) {
return builder->Call(str.str(), "f2", "f2");
} else if (type == CallParamType::kF16) {
@@ -165,7 +163,7 @@
} else {
return builder->Call(str.str(), "u2", "u2");
}
- case BuiltinType::kClamp:
+ case builtin::Function::kClamp:
if (type == CallParamType::kF32) {
return builder->Call(str.str(), "f2", "f2", "f2");
} else if (type == CallParamType::kF16) {
@@ -173,32 +171,32 @@
} else {
return builder->Call(str.str(), "u2", "u2", "u2");
}
- case BuiltinType::kSelect:
+ case builtin::Function::kSelect:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "h2", "h2", "b2");
} else {
return builder->Call(str.str(), "f2", "f2", "b2");
}
- case BuiltinType::kDeterminant:
+ case builtin::Function::kDeterminant:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "hm2x2");
} else {
return builder->Call(str.str(), "m2x2");
}
- case BuiltinType::kPack2X16Snorm:
- case BuiltinType::kPack2X16Unorm:
+ case builtin::Function::kPack2X16Snorm:
+ case builtin::Function::kPack2X16Unorm:
return builder->Call(str.str(), "f2");
- case BuiltinType::kPack4X8Snorm:
- case BuiltinType::kPack4X8Unorm:
+ case builtin::Function::kPack4X8Snorm:
+ case builtin::Function::kPack4X8Unorm:
return builder->Call(str.str(), "f4");
- case BuiltinType::kUnpack4X8Snorm:
- case BuiltinType::kUnpack4X8Unorm:
- case BuiltinType::kUnpack2X16Snorm:
- case BuiltinType::kUnpack2X16Unorm:
+ case builtin::Function::kUnpack4X8Snorm:
+ case builtin::Function::kUnpack4X8Unorm:
+ case builtin::Function::kUnpack2X16Snorm:
+ case builtin::Function::kUnpack2X16Unorm:
return builder->Call(str.str(), "u1");
- case BuiltinType::kWorkgroupBarrier:
+ case builtin::Function::kWorkgroupBarrier:
return builder->Call(str.str());
- case BuiltinType::kTranspose:
+ case builtin::Function::kTranspose:
if (type == CallParamType::kF16) {
return builder->Call(str.str(), "hm3x2");
} else {
@@ -254,120 +252,126 @@
MslBuiltinTest,
testing::Values(
/* Logical built-in */
- BuiltinData{BuiltinType::kAll, CallParamType::kBool, "all"},
- BuiltinData{BuiltinType::kAny, CallParamType::kBool, "any"},
- BuiltinData{BuiltinType::kSelect, CallParamType::kF32, "select"},
+ BuiltinData{builtin::Function::kAll, CallParamType::kBool, "all"},
+ BuiltinData{builtin::Function::kAny, CallParamType::kBool, "any"},
+ BuiltinData{builtin::Function::kSelect, CallParamType::kF32, "select"},
/* Float built-in */
- BuiltinData{BuiltinType::kAbs, CallParamType::kF32, "fabs"},
- BuiltinData{BuiltinType::kAbs, CallParamType::kF16, "fabs"},
- BuiltinData{BuiltinType::kAcos, CallParamType::kF32, "acos"},
- BuiltinData{BuiltinType::kAcos, CallParamType::kF16, "acos"},
- BuiltinData{BuiltinType::kAsin, CallParamType::kF32, "asin"},
- BuiltinData{BuiltinType::kAsin, CallParamType::kF16, "asin"},
- BuiltinData{BuiltinType::kAtan, CallParamType::kF32, "atan"},
- BuiltinData{BuiltinType::kAtan, CallParamType::kF16, "atan"},
- BuiltinData{BuiltinType::kAtan2, CallParamType::kF32, "atan2"},
- BuiltinData{BuiltinType::kAtan2, CallParamType::kF16, "atan2"},
- BuiltinData{BuiltinType::kCeil, CallParamType::kF32, "ceil"},
- BuiltinData{BuiltinType::kCeil, CallParamType::kF16, "ceil"},
- BuiltinData{BuiltinType::kClamp, CallParamType::kF32, "clamp"},
- BuiltinData{BuiltinType::kClamp, CallParamType::kF16, "clamp"},
- BuiltinData{BuiltinType::kCos, CallParamType::kF32, "cos"},
- BuiltinData{BuiltinType::kCos, CallParamType::kF16, "cos"},
- BuiltinData{BuiltinType::kCosh, CallParamType::kF32, "cosh"},
- BuiltinData{BuiltinType::kCosh, CallParamType::kF16, "cosh"},
- BuiltinData{BuiltinType::kCross, CallParamType::kF32, "cross"},
- BuiltinData{BuiltinType::kCross, CallParamType::kF16, "cross"},
- BuiltinData{BuiltinType::kDistance, CallParamType::kF32, "distance"},
- BuiltinData{BuiltinType::kDistance, CallParamType::kF16, "distance"},
- BuiltinData{BuiltinType::kExp, CallParamType::kF32, "exp"},
- BuiltinData{BuiltinType::kExp, CallParamType::kF16, "exp"},
- BuiltinData{BuiltinType::kExp2, CallParamType::kF32, "exp2"},
- BuiltinData{BuiltinType::kExp2, CallParamType::kF16, "exp2"},
- BuiltinData{BuiltinType::kFaceForward, CallParamType::kF32, "faceforward"},
- BuiltinData{BuiltinType::kFaceForward, CallParamType::kF16, "faceforward"},
- BuiltinData{BuiltinType::kFloor, CallParamType::kF32, "floor"},
- BuiltinData{BuiltinType::kFloor, CallParamType::kF16, "floor"},
- BuiltinData{BuiltinType::kFma, CallParamType::kF32, "fma"},
- BuiltinData{BuiltinType::kFma, CallParamType::kF16, "fma"},
- BuiltinData{BuiltinType::kFract, CallParamType::kF32, "fract"},
- BuiltinData{BuiltinType::kFract, CallParamType::kF16, "fract"},
- BuiltinData{BuiltinType::kInverseSqrt, CallParamType::kF32, "rsqrt"},
- BuiltinData{BuiltinType::kInverseSqrt, CallParamType::kF16, "rsqrt"},
- BuiltinData{BuiltinType::kLdexp, CallParamType::kF32, "ldexp"},
- BuiltinData{BuiltinType::kLdexp, CallParamType::kF16, "ldexp"},
- BuiltinData{BuiltinType::kLength, CallParamType::kF32, "length"},
- BuiltinData{BuiltinType::kLength, CallParamType::kF16, "length"},
- BuiltinData{BuiltinType::kLog, CallParamType::kF32, "log"},
- BuiltinData{BuiltinType::kLog, CallParamType::kF16, "log"},
- BuiltinData{BuiltinType::kLog2, CallParamType::kF32, "log2"},
- BuiltinData{BuiltinType::kLog2, CallParamType::kF16, "log2"},
- BuiltinData{BuiltinType::kMax, CallParamType::kF32, "fmax"},
- BuiltinData{BuiltinType::kMax, CallParamType::kF16, "fmax"},
- BuiltinData{BuiltinType::kMin, CallParamType::kF32, "fmin"},
- BuiltinData{BuiltinType::kMin, CallParamType::kF16, "fmin"},
- BuiltinData{BuiltinType::kNormalize, CallParamType::kF32, "normalize"},
- BuiltinData{BuiltinType::kNormalize, CallParamType::kF16, "normalize"},
- BuiltinData{BuiltinType::kPow, CallParamType::kF32, "pow"},
- BuiltinData{BuiltinType::kPow, CallParamType::kF16, "pow"},
- BuiltinData{BuiltinType::kReflect, CallParamType::kF32, "reflect"},
- BuiltinData{BuiltinType::kReflect, CallParamType::kF16, "reflect"},
- BuiltinData{BuiltinType::kSign, CallParamType::kF32, "sign"},
- BuiltinData{BuiltinType::kSign, CallParamType::kF16, "sign"},
- BuiltinData{BuiltinType::kSin, CallParamType::kF32, "sin"},
- BuiltinData{BuiltinType::kSin, CallParamType::kF16, "sin"},
- BuiltinData{BuiltinType::kSinh, CallParamType::kF32, "sinh"},
- BuiltinData{BuiltinType::kSinh, CallParamType::kF16, "sinh"},
- BuiltinData{BuiltinType::kSmoothstep, CallParamType::kF32, "smoothstep"},
- BuiltinData{BuiltinType::kSmoothstep, CallParamType::kF16, "smoothstep"},
- BuiltinData{BuiltinType::kSqrt, CallParamType::kF32, "sqrt"},
- BuiltinData{BuiltinType::kSqrt, CallParamType::kF16, "sqrt"},
- BuiltinData{BuiltinType::kStep, CallParamType::kF32, "step"},
- BuiltinData{BuiltinType::kStep, CallParamType::kF16, "step"},
- BuiltinData{BuiltinType::kTan, CallParamType::kF32, "tan"},
- BuiltinData{BuiltinType::kTan, CallParamType::kF16, "tan"},
- BuiltinData{BuiltinType::kTanh, CallParamType::kF32, "tanh"},
- BuiltinData{BuiltinType::kTanh, CallParamType::kF16, "tanh"},
- BuiltinData{BuiltinType::kTrunc, CallParamType::kF32, "trunc"},
- BuiltinData{BuiltinType::kTrunc, CallParamType::kF16, "trunc"},
+ BuiltinData{builtin::Function::kAbs, CallParamType::kF32, "fabs"},
+ BuiltinData{builtin::Function::kAbs, CallParamType::kF16, "fabs"},
+ BuiltinData{builtin::Function::kAcos, CallParamType::kF32, "acos"},
+ BuiltinData{builtin::Function::kAcos, CallParamType::kF16, "acos"},
+ BuiltinData{builtin::Function::kAsin, CallParamType::kF32, "asin"},
+ BuiltinData{builtin::Function::kAsin, CallParamType::kF16, "asin"},
+ BuiltinData{builtin::Function::kAtan, CallParamType::kF32, "atan"},
+ BuiltinData{builtin::Function::kAtan, CallParamType::kF16, "atan"},
+ BuiltinData{builtin::Function::kAtan2, CallParamType::kF32, "atan2"},
+ BuiltinData{builtin::Function::kAtan2, CallParamType::kF16, "atan2"},
+ BuiltinData{builtin::Function::kCeil, CallParamType::kF32, "ceil"},
+ BuiltinData{builtin::Function::kCeil, CallParamType::kF16, "ceil"},
+ BuiltinData{builtin::Function::kClamp, CallParamType::kF32, "clamp"},
+ BuiltinData{builtin::Function::kClamp, CallParamType::kF16, "clamp"},
+ BuiltinData{builtin::Function::kCos, CallParamType::kF32, "cos"},
+ BuiltinData{builtin::Function::kCos, CallParamType::kF16, "cos"},
+ BuiltinData{builtin::Function::kCosh, CallParamType::kF32, "cosh"},
+ BuiltinData{builtin::Function::kCosh, CallParamType::kF16, "cosh"},
+ BuiltinData{builtin::Function::kCross, CallParamType::kF32, "cross"},
+ BuiltinData{builtin::Function::kCross, CallParamType::kF16, "cross"},
+ BuiltinData{builtin::Function::kDistance, CallParamType::kF32, "distance"},
+ BuiltinData{builtin::Function::kDistance, CallParamType::kF16, "distance"},
+ BuiltinData{builtin::Function::kExp, CallParamType::kF32, "exp"},
+ BuiltinData{builtin::Function::kExp, CallParamType::kF16, "exp"},
+ BuiltinData{builtin::Function::kExp2, CallParamType::kF32, "exp2"},
+ BuiltinData{builtin::Function::kExp2, CallParamType::kF16, "exp2"},
+ BuiltinData{builtin::Function::kFaceForward, CallParamType::kF32, "faceforward"},
+ BuiltinData{builtin::Function::kFaceForward, CallParamType::kF16, "faceforward"},
+ BuiltinData{builtin::Function::kFloor, CallParamType::kF32, "floor"},
+ BuiltinData{builtin::Function::kFloor, CallParamType::kF16, "floor"},
+ BuiltinData{builtin::Function::kFma, CallParamType::kF32, "fma"},
+ BuiltinData{builtin::Function::kFma, CallParamType::kF16, "fma"},
+ BuiltinData{builtin::Function::kFract, CallParamType::kF32, "fract"},
+ BuiltinData{builtin::Function::kFract, CallParamType::kF16, "fract"},
+ BuiltinData{builtin::Function::kInverseSqrt, CallParamType::kF32, "rsqrt"},
+ BuiltinData{builtin::Function::kInverseSqrt, CallParamType::kF16, "rsqrt"},
+ BuiltinData{builtin::Function::kLdexp, CallParamType::kF32, "ldexp"},
+ BuiltinData{builtin::Function::kLdexp, CallParamType::kF16, "ldexp"},
+ BuiltinData{builtin::Function::kLength, CallParamType::kF32, "length"},
+ BuiltinData{builtin::Function::kLength, CallParamType::kF16, "length"},
+ BuiltinData{builtin::Function::kLog, CallParamType::kF32, "log"},
+ BuiltinData{builtin::Function::kLog, CallParamType::kF16, "log"},
+ BuiltinData{builtin::Function::kLog2, CallParamType::kF32, "log2"},
+ BuiltinData{builtin::Function::kLog2, CallParamType::kF16, "log2"},
+ BuiltinData{builtin::Function::kMax, CallParamType::kF32, "fmax"},
+ BuiltinData{builtin::Function::kMax, CallParamType::kF16, "fmax"},
+ BuiltinData{builtin::Function::kMin, CallParamType::kF32, "fmin"},
+ BuiltinData{builtin::Function::kMin, CallParamType::kF16, "fmin"},
+ BuiltinData{builtin::Function::kNormalize, CallParamType::kF32, "normalize"},
+ BuiltinData{builtin::Function::kNormalize, CallParamType::kF16, "normalize"},
+ BuiltinData{builtin::Function::kPow, CallParamType::kF32, "pow"},
+ BuiltinData{builtin::Function::kPow, CallParamType::kF16, "pow"},
+ BuiltinData{builtin::Function::kReflect, CallParamType::kF32, "reflect"},
+ BuiltinData{builtin::Function::kReflect, CallParamType::kF16, "reflect"},
+ BuiltinData{builtin::Function::kSign, CallParamType::kF32, "sign"},
+ BuiltinData{builtin::Function::kSign, CallParamType::kF16, "sign"},
+ BuiltinData{builtin::Function::kSin, CallParamType::kF32, "sin"},
+ BuiltinData{builtin::Function::kSin, CallParamType::kF16, "sin"},
+ BuiltinData{builtin::Function::kSinh, CallParamType::kF32, "sinh"},
+ BuiltinData{builtin::Function::kSinh, CallParamType::kF16, "sinh"},
+ BuiltinData{builtin::Function::kSmoothstep, CallParamType::kF32, "smoothstep"},
+ BuiltinData{builtin::Function::kSmoothstep, CallParamType::kF16, "smoothstep"},
+ BuiltinData{builtin::Function::kSqrt, CallParamType::kF32, "sqrt"},
+ BuiltinData{builtin::Function::kSqrt, CallParamType::kF16, "sqrt"},
+ BuiltinData{builtin::Function::kStep, CallParamType::kF32, "step"},
+ BuiltinData{builtin::Function::kStep, CallParamType::kF16, "step"},
+ BuiltinData{builtin::Function::kTan, CallParamType::kF32, "tan"},
+ BuiltinData{builtin::Function::kTan, CallParamType::kF16, "tan"},
+ BuiltinData{builtin::Function::kTanh, CallParamType::kF32, "tanh"},
+ BuiltinData{builtin::Function::kTanh, CallParamType::kF16, "tanh"},
+ BuiltinData{builtin::Function::kTrunc, CallParamType::kF32, "trunc"},
+ BuiltinData{builtin::Function::kTrunc, CallParamType::kF16, "trunc"},
/* Integer built-in */
- BuiltinData{BuiltinType::kAbs, CallParamType::kU32, "abs"},
- BuiltinData{BuiltinType::kClamp, CallParamType::kU32, "clamp"},
- BuiltinData{BuiltinType::kCountLeadingZeros, CallParamType::kU32, "clz"},
- BuiltinData{BuiltinType::kCountOneBits, CallParamType::kU32, "popcount"},
- BuiltinData{BuiltinType::kCountTrailingZeros, CallParamType::kU32, "ctz"},
- BuiltinData{BuiltinType::kExtractBits, CallParamType::kU32, "extract_bits"},
- BuiltinData{BuiltinType::kInsertBits, CallParamType::kU32, "insert_bits"},
- BuiltinData{BuiltinType::kMax, CallParamType::kU32, "max"},
- BuiltinData{BuiltinType::kMin, CallParamType::kU32, "min"},
- BuiltinData{BuiltinType::kReverseBits, CallParamType::kU32, "reverse_bits"},
- BuiltinData{BuiltinType::kRound, CallParamType::kU32, "rint"},
+ BuiltinData{builtin::Function::kAbs, CallParamType::kU32, "abs"},
+ BuiltinData{builtin::Function::kClamp, CallParamType::kU32, "clamp"},
+ BuiltinData{builtin::Function::kCountLeadingZeros, CallParamType::kU32, "clz"},
+ BuiltinData{builtin::Function::kCountOneBits, CallParamType::kU32, "popcount"},
+ BuiltinData{builtin::Function::kCountTrailingZeros, CallParamType::kU32, "ctz"},
+ BuiltinData{builtin::Function::kExtractBits, CallParamType::kU32, "extract_bits"},
+ BuiltinData{builtin::Function::kInsertBits, CallParamType::kU32, "insert_bits"},
+ BuiltinData{builtin::Function::kMax, CallParamType::kU32, "max"},
+ BuiltinData{builtin::Function::kMin, CallParamType::kU32, "min"},
+ BuiltinData{builtin::Function::kReverseBits, CallParamType::kU32, "reverse_bits"},
+ BuiltinData{builtin::Function::kRound, CallParamType::kU32, "rint"},
/* Matrix built-in */
- BuiltinData{BuiltinType::kDeterminant, CallParamType::kF32, "determinant"},
- BuiltinData{BuiltinType::kTranspose, CallParamType::kF32, "transpose"},
+ BuiltinData{builtin::Function::kDeterminant, CallParamType::kF32, "determinant"},
+ BuiltinData{builtin::Function::kTranspose, CallParamType::kF32, "transpose"},
/* Vector built-in */
- BuiltinData{BuiltinType::kDot, CallParamType::kF32, "dot"},
+ BuiltinData{builtin::Function::kDot, CallParamType::kF32, "dot"},
/* Derivate built-in */
- BuiltinData{BuiltinType::kDpdx, CallParamType::kF32, "dfdx"},
- BuiltinData{BuiltinType::kDpdxCoarse, CallParamType::kF32, "dfdx"},
- BuiltinData{BuiltinType::kDpdxFine, CallParamType::kF32, "dfdx"},
- BuiltinData{BuiltinType::kDpdy, CallParamType::kF32, "dfdy"},
- BuiltinData{BuiltinType::kDpdyCoarse, CallParamType::kF32, "dfdy"},
- BuiltinData{BuiltinType::kDpdyFine, CallParamType::kF32, "dfdy"},
- BuiltinData{BuiltinType::kFwidth, CallParamType::kF32, "fwidth"},
- BuiltinData{BuiltinType::kFwidthCoarse, CallParamType::kF32, "fwidth"},
- BuiltinData{BuiltinType::kFwidthFine, CallParamType::kF32, "fwidth"},
+ BuiltinData{builtin::Function::kDpdx, CallParamType::kF32, "dfdx"},
+ BuiltinData{builtin::Function::kDpdxCoarse, CallParamType::kF32, "dfdx"},
+ BuiltinData{builtin::Function::kDpdxFine, CallParamType::kF32, "dfdx"},
+ BuiltinData{builtin::Function::kDpdy, CallParamType::kF32, "dfdy"},
+ BuiltinData{builtin::Function::kDpdyCoarse, CallParamType::kF32, "dfdy"},
+ BuiltinData{builtin::Function::kDpdyFine, CallParamType::kF32, "dfdy"},
+ BuiltinData{builtin::Function::kFwidth, CallParamType::kF32, "fwidth"},
+ BuiltinData{builtin::Function::kFwidthCoarse, CallParamType::kF32, "fwidth"},
+ BuiltinData{builtin::Function::kFwidthFine, CallParamType::kF32, "fwidth"},
/* Data packing builtin */
- BuiltinData{BuiltinType::kPack4X8Snorm, CallParamType::kF32, "pack_float_to_snorm4x8"},
- BuiltinData{BuiltinType::kPack4X8Unorm, CallParamType::kF32, "pack_float_to_unorm4x8"},
- BuiltinData{BuiltinType::kPack2X16Snorm, CallParamType::kF32, "pack_float_to_snorm2x16"},
- BuiltinData{BuiltinType::kPack2X16Unorm, CallParamType::kF32, "pack_float_to_unorm2x16"},
+ BuiltinData{builtin::Function::kPack4X8Snorm, CallParamType::kF32,
+ "pack_float_to_snorm4x8"},
+ BuiltinData{builtin::Function::kPack4X8Unorm, CallParamType::kF32,
+ "pack_float_to_unorm4x8"},
+ BuiltinData{builtin::Function::kPack2X16Snorm, CallParamType::kF32,
+ "pack_float_to_snorm2x16"},
+ BuiltinData{builtin::Function::kPack2X16Unorm, CallParamType::kF32,
+ "pack_float_to_unorm2x16"},
/* Data unpacking builtin */
- BuiltinData{BuiltinType::kUnpack4X8Snorm, CallParamType::kU32, "unpack_snorm4x8_to_float"},
- BuiltinData{BuiltinType::kUnpack4X8Unorm, CallParamType::kU32, "unpack_unorm4x8_to_float"},
- BuiltinData{BuiltinType::kUnpack2X16Snorm, CallParamType::kU32,
+ BuiltinData{builtin::Function::kUnpack4X8Snorm, CallParamType::kU32,
+ "unpack_snorm4x8_to_float"},
+ BuiltinData{builtin::Function::kUnpack4X8Unorm, CallParamType::kU32,
+ "unpack_unorm4x8_to_float"},
+ BuiltinData{builtin::Function::kUnpack2X16Snorm, CallParamType::kU32,
"unpack_snorm2x16_to_float"},
- BuiltinData{BuiltinType::kUnpack2X16Unorm, CallParamType::kU32,
+ BuiltinData{builtin::Function::kUnpack2X16Unorm, CallParamType::kU32,
"unpack_unorm2x16_to_float"}));
TEST_F(MslGeneratorImplTest, Builtin_Call) {
diff --git a/src/tint/writer/spirv/builder.cc b/src/tint/writer/spirv/builder.cc
index 40f98d8..ae14acd 100644
--- a/src/tint/writer/spirv/builder.cc
+++ b/src/tint/writer/spirv/builder.cc
@@ -56,8 +56,6 @@
namespace tint::writer::spirv {
namespace {
-using BuiltinType = sem::BuiltinType;
-
const char kGLSLstd450[] = "GLSL.std.450";
uint32_t size_of(const InstructionList& instructions) {
@@ -102,23 +100,23 @@
uint32_t builtin_to_glsl_method(const sem::Builtin* builtin) {
switch (builtin->Type()) {
- case BuiltinType::kAcos:
+ case builtin::Function::kAcos:
return GLSLstd450Acos;
- case BuiltinType::kAcosh:
+ case builtin::Function::kAcosh:
return GLSLstd450Acosh;
- case BuiltinType::kAsin:
+ case builtin::Function::kAsin:
return GLSLstd450Asin;
- case BuiltinType::kAsinh:
+ case builtin::Function::kAsinh:
return GLSLstd450Asinh;
- case BuiltinType::kAtan:
+ case builtin::Function::kAtan:
return GLSLstd450Atan;
- case BuiltinType::kAtan2:
+ case builtin::Function::kAtan2:
return GLSLstd450Atan2;
- case BuiltinType::kAtanh:
+ case builtin::Function::kAtanh:
return GLSLstd450Atanh;
- case BuiltinType::kCeil:
+ case builtin::Function::kCeil:
return GLSLstd450Ceil;
- case BuiltinType::kClamp:
+ case builtin::Function::kClamp:
if (builtin->ReturnType()->is_float_scalar_or_vector()) {
return GLSLstd450NClamp;
} else if (builtin->ReturnType()->is_unsigned_integer_scalar_or_vector()) {
@@ -126,43 +124,43 @@
} else {
return GLSLstd450SClamp;
}
- case BuiltinType::kCos:
+ case builtin::Function::kCos:
return GLSLstd450Cos;
- case BuiltinType::kCosh:
+ case builtin::Function::kCosh:
return GLSLstd450Cosh;
- case BuiltinType::kCross:
+ case builtin::Function::kCross:
return GLSLstd450Cross;
- case BuiltinType::kDegrees:
+ case builtin::Function::kDegrees:
return GLSLstd450Degrees;
- case BuiltinType::kDeterminant:
+ case builtin::Function::kDeterminant:
return GLSLstd450Determinant;
- case BuiltinType::kDistance:
+ case builtin::Function::kDistance:
return GLSLstd450Distance;
- case BuiltinType::kExp:
+ case builtin::Function::kExp:
return GLSLstd450Exp;
- case BuiltinType::kExp2:
+ case builtin::Function::kExp2:
return GLSLstd450Exp2;
- case BuiltinType::kFaceForward:
+ case builtin::Function::kFaceForward:
return GLSLstd450FaceForward;
- case BuiltinType::kFloor:
+ case builtin::Function::kFloor:
return GLSLstd450Floor;
- case BuiltinType::kFma:
+ case builtin::Function::kFma:
return GLSLstd450Fma;
- case BuiltinType::kFract:
+ case builtin::Function::kFract:
return GLSLstd450Fract;
- case BuiltinType::kFrexp:
+ case builtin::Function::kFrexp:
return GLSLstd450FrexpStruct;
- case BuiltinType::kInverseSqrt:
+ case builtin::Function::kInverseSqrt:
return GLSLstd450InverseSqrt;
- case BuiltinType::kLdexp:
+ case builtin::Function::kLdexp:
return GLSLstd450Ldexp;
- case BuiltinType::kLength:
+ case builtin::Function::kLength:
return GLSLstd450Length;
- case BuiltinType::kLog:
+ case builtin::Function::kLog:
return GLSLstd450Log;
- case BuiltinType::kLog2:
+ case builtin::Function::kLog2:
return GLSLstd450Log2;
- case BuiltinType::kMax:
+ case builtin::Function::kMax:
if (builtin->ReturnType()->is_float_scalar_or_vector()) {
return GLSLstd450NMax;
} else if (builtin->ReturnType()->is_unsigned_integer_scalar_or_vector()) {
@@ -170,7 +168,7 @@
} else {
return GLSLstd450SMax;
}
- case BuiltinType::kMin:
+ case builtin::Function::kMin:
if (builtin->ReturnType()->is_float_scalar_or_vector()) {
return GLSLstd450NMin;
} else if (builtin->ReturnType()->is_unsigned_integer_scalar_or_vector()) {
@@ -178,63 +176,63 @@
} else {
return GLSLstd450SMin;
}
- case BuiltinType::kMix:
+ case builtin::Function::kMix:
return GLSLstd450FMix;
- case BuiltinType::kModf:
+ case builtin::Function::kModf:
return GLSLstd450ModfStruct;
- case BuiltinType::kNormalize:
+ case builtin::Function::kNormalize:
return GLSLstd450Normalize;
- case BuiltinType::kPack4X8Snorm:
+ case builtin::Function::kPack4X8Snorm:
return GLSLstd450PackSnorm4x8;
- case BuiltinType::kPack4X8Unorm:
+ case builtin::Function::kPack4X8Unorm:
return GLSLstd450PackUnorm4x8;
- case BuiltinType::kPack2X16Snorm:
+ case builtin::Function::kPack2X16Snorm:
return GLSLstd450PackSnorm2x16;
- case BuiltinType::kPack2X16Unorm:
+ case builtin::Function::kPack2X16Unorm:
return GLSLstd450PackUnorm2x16;
- case BuiltinType::kPack2X16Float:
+ case builtin::Function::kPack2X16Float:
return GLSLstd450PackHalf2x16;
- case BuiltinType::kPow:
+ case builtin::Function::kPow:
return GLSLstd450Pow;
- case BuiltinType::kRadians:
+ case builtin::Function::kRadians:
return GLSLstd450Radians;
- case BuiltinType::kReflect:
+ case builtin::Function::kReflect:
return GLSLstd450Reflect;
- case BuiltinType::kRefract:
+ case builtin::Function::kRefract:
return GLSLstd450Refract;
- case BuiltinType::kRound:
+ case builtin::Function::kRound:
return GLSLstd450RoundEven;
- case BuiltinType::kSign:
+ case builtin::Function::kSign:
if (builtin->ReturnType()->is_signed_integer_scalar_or_vector()) {
return GLSLstd450SSign;
} else {
return GLSLstd450FSign;
}
- case BuiltinType::kSin:
+ case builtin::Function::kSin:
return GLSLstd450Sin;
- case BuiltinType::kSinh:
+ case builtin::Function::kSinh:
return GLSLstd450Sinh;
- case BuiltinType::kSmoothstep:
+ case builtin::Function::kSmoothstep:
return GLSLstd450SmoothStep;
- case BuiltinType::kSqrt:
+ case builtin::Function::kSqrt:
return GLSLstd450Sqrt;
- case BuiltinType::kStep:
+ case builtin::Function::kStep:
return GLSLstd450Step;
- case BuiltinType::kTan:
+ case builtin::Function::kTan:
return GLSLstd450Tan;
- case BuiltinType::kTanh:
+ case builtin::Function::kTanh:
return GLSLstd450Tanh;
- case BuiltinType::kTrunc:
+ case builtin::Function::kTrunc:
return GLSLstd450Trunc;
- case BuiltinType::kUnpack4X8Snorm:
+ case builtin::Function::kUnpack4X8Snorm:
return GLSLstd450UnpackSnorm4x8;
- case BuiltinType::kUnpack4X8Unorm:
+ case builtin::Function::kUnpack4X8Unorm:
return GLSLstd450UnpackUnorm4x8;
- case BuiltinType::kUnpack2X16Snorm:
+ case builtin::Function::kUnpack2X16Snorm:
return GLSLstd450UnpackSnorm2x16;
- case BuiltinType::kUnpack2X16Unorm:
+ case builtin::Function::kUnpack2X16Unorm:
return GLSLstd450UnpackUnorm2x16;
- case BuiltinType::kUnpack2X16Float:
+ case builtin::Function::kUnpack2X16Float:
return GLSLstd450UnpackHalf2x16;
default:
break;
@@ -2363,21 +2361,21 @@
};
switch (builtin->Type()) {
- case BuiltinType::kAny:
+ case builtin::Function::kAny:
if (builtin->Parameters()[0]->Type()->Is<type::Bool>()) {
// any(v: bool) just resolves to v.
return get_arg_as_value_id(0);
}
op = spv::Op::OpAny;
break;
- case BuiltinType::kAll:
+ case builtin::Function::kAll:
if (builtin->Parameters()[0]->Type()->Is<type::Bool>()) {
// all(v: bool) just resolves to v.
return get_arg_as_value_id(0);
}
op = spv::Op::OpAll;
break;
- case BuiltinType::kArrayLength: {
+ case builtin::Function::kArrayLength: {
auto* address_of = call->Arguments()[0]->Declaration()->As<ast::UnaryOpExpression>();
if (!address_of || address_of->op != ast::UnaryOp::kAddressOf) {
error_ = "arrayLength() expected pointer to member access, got " +
@@ -2414,10 +2412,10 @@
}
return result_id;
}
- case BuiltinType::kCountOneBits:
+ case builtin::Function::kCountOneBits:
op = spv::Op::OpBitCount;
break;
- case BuiltinType::kDot: {
+ case builtin::Function::kDot: {
op = spv::Op::OpDot;
auto* vec_ty = builtin->Parameters()[0]->Type()->As<type::Vector>();
if (vec_ty->type()->is_integer_scalar()) {
@@ -2458,42 +2456,42 @@
}
break;
}
- case BuiltinType::kDpdx:
+ case builtin::Function::kDpdx:
op = spv::Op::OpDPdx;
break;
- case BuiltinType::kDpdxCoarse:
+ case builtin::Function::kDpdxCoarse:
op = spv::Op::OpDPdxCoarse;
break;
- case BuiltinType::kDpdxFine:
+ case builtin::Function::kDpdxFine:
op = spv::Op::OpDPdxFine;
break;
- case BuiltinType::kDpdy:
+ case builtin::Function::kDpdy:
op = spv::Op::OpDPdy;
break;
- case BuiltinType::kDpdyCoarse:
+ case builtin::Function::kDpdyCoarse:
op = spv::Op::OpDPdyCoarse;
break;
- case BuiltinType::kDpdyFine:
+ case builtin::Function::kDpdyFine:
op = spv::Op::OpDPdyFine;
break;
- case BuiltinType::kExtractBits:
+ case builtin::Function::kExtractBits:
op = builtin->Parameters()[0]->Type()->is_unsigned_integer_scalar_or_vector()
? spv::Op::OpBitFieldUExtract
: spv::Op::OpBitFieldSExtract;
break;
- case BuiltinType::kFwidth:
+ case builtin::Function::kFwidth:
op = spv::Op::OpFwidth;
break;
- case BuiltinType::kFwidthCoarse:
+ case builtin::Function::kFwidthCoarse:
op = spv::Op::OpFwidthCoarse;
break;
- case BuiltinType::kFwidthFine:
+ case builtin::Function::kFwidthFine:
op = spv::Op::OpFwidthFine;
break;
- case BuiltinType::kInsertBits:
+ case builtin::Function::kInsertBits:
op = spv::Op::OpBitFieldInsert;
break;
- case BuiltinType::kMix: {
+ case builtin::Function::kMix: {
auto std450 = Operand(GetGLSLstd450Import());
auto a_id = get_arg_as_value_id(0);
@@ -2520,13 +2518,13 @@
}
return result_id;
}
- case BuiltinType::kQuantizeToF16:
+ case builtin::Function::kQuantizeToF16:
op = spv::Op::OpQuantizeToF16;
break;
- case BuiltinType::kReverseBits:
+ case builtin::Function::kReverseBits:
op = spv::Op::OpBitReverse;
break;
- case BuiltinType::kSelect: {
+ case builtin::Function::kSelect: {
// Note: Argument order is different in WGSL and SPIR-V
auto cond_id = get_arg_as_value_id(2);
auto true_id = get_arg_as_value_id(1);
@@ -2558,10 +2556,10 @@
}
return result_id;
}
- case BuiltinType::kTranspose:
+ case builtin::Function::kTranspose:
op = spv::Op::OpTranspose;
break;
- case BuiltinType::kAbs:
+ case builtin::Function::kAbs:
if (builtin->ReturnType()->is_unsigned_integer_scalar_or_vector()) {
// abs() only operates on *signed* integers.
// This is a no-op for unsigned integers.
@@ -2573,7 +2571,7 @@
glsl_std450(GLSLstd450SAbs);
}
break;
- case BuiltinType::kDot4I8Packed: {
+ case builtin::Function::kDot4I8Packed: {
auto first_param_id = get_arg_as_value_id(0);
auto second_param_id = get_arg_as_value_id(1);
if (!push_function_inst(spv::Op::OpSDotKHR,
@@ -2585,7 +2583,7 @@
}
return result_id;
}
- case BuiltinType::kDot4U8Packed: {
+ case builtin::Function::kDot4U8Packed: {
auto first_param_id = get_arg_as_value_id(0);
auto second_param_id = get_arg_as_value_id(1);
if (!push_function_inst(spv::Op::OpUDotKHR,
@@ -2788,7 +2786,7 @@
};
switch (builtin->Type()) {
- case BuiltinType::kTextureDimensions: {
+ case builtin::Function::kTextureDimensions: {
// Number of returned elements from OpImageQuerySize[Lod] may not match
// those of textureDimensions().
// This might be due to an extra vector scalar describing the number of
@@ -2833,7 +2831,7 @@
}
break;
}
- case BuiltinType::kTextureNumLayers: {
+ case builtin::Function::kTextureNumLayers: {
uint32_t spirv_dims = 0;
switch (texture_type->dim()) {
default:
@@ -2863,19 +2861,19 @@
}
break;
}
- case BuiltinType::kTextureNumLevels: {
+ case builtin::Function::kTextureNumLevels: {
op = spv::Op::OpImageQueryLevels;
append_result_type_and_id_to_spirv_params();
spirv_params.emplace_back(gen_arg(Usage::kTexture));
break;
}
- case BuiltinType::kTextureNumSamples: {
+ case builtin::Function::kTextureNumSamples: {
op = spv::Op::OpImageQuerySamples;
append_result_type_and_id_to_spirv_params();
spirv_params.emplace_back(gen_arg(Usage::kTexture));
break;
}
- case BuiltinType::kTextureLoad: {
+ case builtin::Function::kTextureLoad: {
op = texture_type->Is<type::StorageTexture>() ? spv::Op::OpImageRead
: spv::Op::OpImageFetch;
append_result_type_and_id_to_spirv_params_for_read();
@@ -2895,7 +2893,7 @@
break;
}
- case BuiltinType::kTextureStore: {
+ case builtin::Function::kTextureStore: {
op = spv::Op::OpImageWrite;
spirv_params.emplace_back(gen_arg(Usage::kTexture));
if (!append_coords_to_spirv_params()) {
@@ -2904,7 +2902,7 @@
spirv_params.emplace_back(gen_arg(Usage::kValue));
break;
}
- case BuiltinType::kTextureGather: {
+ case builtin::Function::kTextureGather: {
op = spv::Op::OpImageGather;
append_result_type_and_id_to_spirv_params();
if (!append_image_and_coords_to_spirv_params()) {
@@ -2918,7 +2916,7 @@
}
break;
}
- case BuiltinType::kTextureGatherCompare: {
+ case builtin::Function::kTextureGatherCompare: {
op = spv::Op::OpImageDrefGather;
append_result_type_and_id_to_spirv_params();
if (!append_image_and_coords_to_spirv_params()) {
@@ -2927,7 +2925,7 @@
spirv_params.emplace_back(gen_arg(Usage::kDepthRef));
break;
}
- case BuiltinType::kTextureSample: {
+ case builtin::Function::kTextureSample: {
op = spv::Op::OpImageSampleImplicitLod;
append_result_type_and_id_to_spirv_params_for_read();
if (!append_image_and_coords_to_spirv_params()) {
@@ -2935,7 +2933,7 @@
}
break;
}
- case BuiltinType::kTextureSampleBias: {
+ case builtin::Function::kTextureSampleBias: {
op = spv::Op::OpImageSampleImplicitLod;
append_result_type_and_id_to_spirv_params_for_read();
if (!append_image_and_coords_to_spirv_params()) {
@@ -2945,7 +2943,7 @@
ImageOperand{SpvImageOperandsBiasMask, gen_arg(Usage::kBias)});
break;
}
- case BuiltinType::kTextureSampleLevel: {
+ case builtin::Function::kTextureSampleLevel: {
op = spv::Op::OpImageSampleExplicitLod;
append_result_type_and_id_to_spirv_params_for_read();
if (!append_image_and_coords_to_spirv_params()) {
@@ -2970,7 +2968,7 @@
image_operands.emplace_back(ImageOperand{SpvImageOperandsLodMask, level});
break;
}
- case BuiltinType::kTextureSampleGrad: {
+ case builtin::Function::kTextureSampleGrad: {
op = spv::Op::OpImageSampleExplicitLod;
append_result_type_and_id_to_spirv_params_for_read();
if (!append_image_and_coords_to_spirv_params()) {
@@ -2982,7 +2980,7 @@
ImageOperand{SpvImageOperandsGradMask, gen_arg(Usage::kDdy)});
break;
}
- case BuiltinType::kTextureSampleCompare: {
+ case builtin::Function::kTextureSampleCompare: {
op = spv::Op::OpImageSampleDrefImplicitLod;
append_result_type_and_id_to_spirv_params();
if (!append_image_and_coords_to_spirv_params()) {
@@ -2991,7 +2989,7 @@
spirv_params.emplace_back(gen_arg(Usage::kDepthRef));
break;
}
- case BuiltinType::kTextureSampleCompareLevel: {
+ case builtin::Function::kTextureSampleCompareLevel: {
op = spv::Op::OpImageSampleDrefExplicitLod;
append_result_type_and_id_to_spirv_params();
if (!append_image_and_coords_to_spirv_params()) {
@@ -3046,19 +3044,19 @@
// TODO(crbug.com/tint/661): Combine sequential barriers to a single
// instruction.
- if (builtin->Type() == sem::BuiltinType::kWorkgroupBarrier) {
+ if (builtin->Type() == builtin::Function::kWorkgroupBarrier) {
execution = static_cast<uint32_t>(spv::Scope::Workgroup);
memory = static_cast<uint32_t>(spv::Scope::Workgroup);
semantics = static_cast<uint32_t>(spv::MemorySemanticsMask::AcquireRelease) |
static_cast<uint32_t>(spv::MemorySemanticsMask::WorkgroupMemory);
- } else if (builtin->Type() == sem::BuiltinType::kStorageBarrier) {
+ } else if (builtin->Type() == builtin::Function::kStorageBarrier) {
execution = static_cast<uint32_t>(spv::Scope::Workgroup);
memory = static_cast<uint32_t>(spv::Scope::Workgroup);
semantics = static_cast<uint32_t>(spv::MemorySemanticsMask::AcquireRelease) |
static_cast<uint32_t>(spv::MemorySemanticsMask::UniformMemory);
} else {
error_ = "unexpected barrier builtin type ";
- error_ += sem::str(builtin->Type());
+ error_ += builtin::str(builtin->Type());
return false;
}
@@ -3128,7 +3126,7 @@
Operand semantics = Operand(semantics_id);
switch (builtin->Type()) {
- case sem::BuiltinType::kAtomicLoad:
+ case builtin::Function::kAtomicLoad:
return push_function_inst(spv::Op::OpAtomicLoad, {
result_type,
result_id,
@@ -3136,14 +3134,14 @@
memory,
semantics,
});
- case sem::BuiltinType::kAtomicStore:
+ case builtin::Function::kAtomicStore:
return push_function_inst(spv::Op::OpAtomicStore, {
pointer,
memory,
semantics,
value,
});
- case sem::BuiltinType::kAtomicAdd:
+ case builtin::Function::kAtomicAdd:
return push_function_inst(spv::Op::OpAtomicIAdd, {
result_type,
result_id,
@@ -3152,7 +3150,7 @@
semantics,
value,
});
- case sem::BuiltinType::kAtomicSub:
+ case builtin::Function::kAtomicSub:
return push_function_inst(spv::Op::OpAtomicISub, {
result_type,
result_id,
@@ -3161,7 +3159,7 @@
semantics,
value,
});
- case sem::BuiltinType::kAtomicMax:
+ case builtin::Function::kAtomicMax:
return push_function_inst(
is_value_signed() ? spv::Op::OpAtomicSMax : spv::Op::OpAtomicUMax, {
result_type,
@@ -3171,7 +3169,7 @@
semantics,
value,
});
- case sem::BuiltinType::kAtomicMin:
+ case builtin::Function::kAtomicMin:
return push_function_inst(
is_value_signed() ? spv::Op::OpAtomicSMin : spv::Op::OpAtomicUMin, {
result_type,
@@ -3181,7 +3179,7 @@
semantics,
value,
});
- case sem::BuiltinType::kAtomicAnd:
+ case builtin::Function::kAtomicAnd:
return push_function_inst(spv::Op::OpAtomicAnd, {
result_type,
result_id,
@@ -3190,7 +3188,7 @@
semantics,
value,
});
- case sem::BuiltinType::kAtomicOr:
+ case builtin::Function::kAtomicOr:
return push_function_inst(spv::Op::OpAtomicOr, {
result_type,
result_id,
@@ -3199,7 +3197,7 @@
semantics,
value,
});
- case sem::BuiltinType::kAtomicXor:
+ case builtin::Function::kAtomicXor:
return push_function_inst(spv::Op::OpAtomicXor, {
result_type,
result_id,
@@ -3208,7 +3206,7 @@
semantics,
value,
});
- case sem::BuiltinType::kAtomicExchange:
+ case builtin::Function::kAtomicExchange:
return push_function_inst(spv::Op::OpAtomicExchange, {
result_type,
result_id,
@@ -3217,7 +3215,7 @@
semantics,
value,
});
- case sem::BuiltinType::kAtomicCompareExchangeWeak: {
+ case builtin::Function::kAtomicCompareExchangeWeak: {
auto comparator = GenerateExpression(call->Arguments()[1]);
if (comparator == 0) {
return false;
